]> 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
Regenerate to add the new file toucan.png.
[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 /* for raw pointers */
989 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
990 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
991 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
992 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
993 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
994 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
995 #define swig_owntype int
996
997 /* for raw packed data */
998 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
999 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1000
1001 /* for class or struct pointers */
1002 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1003 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1004
1005 /* for C or C++ function pointers */
1006 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1007 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
1008
1009 /* for C++ member pointers, ie, member methods */
1010 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1011 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1012
1013
1014 /* Runtime API */
1015
1016 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1017 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1018 #define SWIG_NewClientData(obj) PySwigClientData_New(obj)
1019
1020 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1021 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1022 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1023 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1024 #define SWIG_fail goto fail
1025
1026
1027 /* Runtime API implementation */
1028
1029 /* Error manipulation */
1030
1031 SWIGINTERN void
1032 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1033 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1034 PyErr_SetObject(errtype, obj);
1035 Py_DECREF(obj);
1036 SWIG_PYTHON_THREAD_END_BLOCK;
1037 }
1038
1039 SWIGINTERN void
1040 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1041 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1042 PyErr_SetString(errtype, (char *) msg);
1043 SWIG_PYTHON_THREAD_END_BLOCK;
1044 }
1045
1046 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1047
1048 /* Set a constant value */
1049
1050 SWIGINTERN void
1051 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1052 PyDict_SetItemString(d, (char*) name, obj);
1053 Py_DECREF(obj);
1054 }
1055
1056 /* Append a value to the result obj */
1057
1058 SWIGINTERN PyObject*
1059 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1060 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1061 if (!result) {
1062 result = obj;
1063 } else if (result == Py_None) {
1064 Py_DECREF(result);
1065 result = obj;
1066 } else {
1067 if (!PyList_Check(result)) {
1068 PyObject *o2 = result;
1069 result = PyList_New(1);
1070 PyList_SetItem(result, 0, o2);
1071 }
1072 PyList_Append(result,obj);
1073 Py_DECREF(obj);
1074 }
1075 return result;
1076 #else
1077 PyObject* o2;
1078 PyObject* o3;
1079 if (!result) {
1080 result = obj;
1081 } else if (result == Py_None) {
1082 Py_DECREF(result);
1083 result = obj;
1084 } else {
1085 if (!PyTuple_Check(result)) {
1086 o2 = result;
1087 result = PyTuple_New(1);
1088 PyTuple_SET_ITEM(result, 0, o2);
1089 }
1090 o3 = PyTuple_New(1);
1091 PyTuple_SET_ITEM(o3, 0, obj);
1092 o2 = result;
1093 result = PySequence_Concat(o2, o3);
1094 Py_DECREF(o2);
1095 Py_DECREF(o3);
1096 }
1097 return result;
1098 #endif
1099 }
1100
1101 /* Unpack the argument tuple */
1102
1103 SWIGINTERN int
1104 SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs)
1105 {
1106 if (!args) {
1107 if (!min && !max) {
1108 return 1;
1109 } else {
1110 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1111 name, (min == max ? "" : "at least "), min);
1112 return 0;
1113 }
1114 }
1115 if (!PyTuple_Check(args)) {
1116 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1117 return 0;
1118 } else {
1119 register int l = PyTuple_GET_SIZE(args);
1120 if (l < min) {
1121 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1122 name, (min == max ? "" : "at least "), min, l);
1123 return 0;
1124 } else if (l > max) {
1125 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1126 name, (min == max ? "" : "at most "), max, l);
1127 return 0;
1128 } else {
1129 register int i;
1130 for (i = 0; i < l; ++i) {
1131 objs[i] = PyTuple_GET_ITEM(args, i);
1132 }
1133 for (; l < max; ++l) {
1134 objs[l] = 0;
1135 }
1136 return i + 1;
1137 }
1138 }
1139 }
1140
1141 /* A functor is a function object with one single object argument */
1142 #if PY_VERSION_HEX >= 0x02020000
1143 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1144 #else
1145 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1146 #endif
1147
1148 /*
1149 Helper for static pointer initialization for both C and C++ code, for example
1150 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1151 */
1152 #ifdef __cplusplus
1153 #define SWIG_STATIC_POINTER(var) var
1154 #else
1155 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1156 #endif
1157
1158 /* -----------------------------------------------------------------------------
1159 * Pointer declarations
1160 * ----------------------------------------------------------------------------- */
1161
1162 /* Flags for new pointer objects */
1163 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1164 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1165
1166 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1167
1168 #ifdef __cplusplus
1169 extern "C" {
1170 #if 0
1171 } /* cc-mode */
1172 #endif
1173 #endif
1174
1175 /* How to access Py_None */
1176 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1177 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1178 # ifndef SWIG_PYTHON_BUILD_NONE
1179 # define SWIG_PYTHON_BUILD_NONE
1180 # endif
1181 # endif
1182 #endif
1183
1184 #ifdef SWIG_PYTHON_BUILD_NONE
1185 # ifdef Py_None
1186 # undef Py_None
1187 # define Py_None SWIG_Py_None()
1188 # endif
1189 SWIGRUNTIMEINLINE PyObject *
1190 _SWIG_Py_None(void)
1191 {
1192 PyObject *none = Py_BuildValue("");
1193 Py_DECREF(none);
1194 return none;
1195 }
1196 SWIGRUNTIME PyObject *
1197 SWIG_Py_None(void)
1198 {
1199 static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1200 return none;
1201 }
1202 #endif
1203
1204 /* The python void return value */
1205
1206 SWIGRUNTIMEINLINE PyObject *
1207 SWIG_Py_Void(void)
1208 {
1209 PyObject *none = Py_None;
1210 Py_INCREF(none);
1211 return none;
1212 }
1213
1214 /* PySwigClientData */
1215
1216 typedef struct {
1217 PyObject *klass;
1218 PyObject *newraw;
1219 PyObject *newargs;
1220 PyObject *destroy;
1221 int delargs;
1222 int implicitconv;
1223 } PySwigClientData;
1224
1225 SWIGRUNTIMEINLINE int
1226 SWIG_Python_CheckImplicit(swig_type_info *ty)
1227 {
1228 PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1229 return data ? data->implicitconv : 0;
1230 }
1231
1232 SWIGRUNTIMEINLINE PyObject *
1233 SWIG_Python_ExceptionType(swig_type_info *desc) {
1234 PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1235 PyObject *klass = data ? data->klass : 0;
1236 return (klass ? klass : PyExc_RuntimeError);
1237 }
1238
1239
1240 SWIGRUNTIME PySwigClientData *
1241 PySwigClientData_New(PyObject* obj)
1242 {
1243 if (!obj) {
1244 return 0;
1245 } else {
1246 PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1247 /* the klass element */
1248 data->klass = obj;
1249 Py_INCREF(data->klass);
1250 /* the newraw method and newargs arguments used to create a new raw instance */
1251 if (PyClass_Check(obj)) {
1252 data->newraw = 0;
1253 data->newargs = obj;
1254 Py_INCREF(obj);
1255 } else {
1256 #if (PY_VERSION_HEX < 0x02020000)
1257 data->newraw = 0;
1258 #else
1259 data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1260 #endif
1261 if (data->newraw) {
1262 Py_INCREF(data->newraw);
1263 data->newargs = PyTuple_New(1);
1264 PyTuple_SetItem(data->newargs, 0, obj);
1265 } else {
1266 data->newargs = obj;
1267 }
1268 Py_INCREF(data->newargs);
1269 }
1270 /* the destroy method, aka as the C++ delete method */
1271 data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1272 if (PyErr_Occurred()) {
1273 PyErr_Clear();
1274 data->destroy = 0;
1275 }
1276 if (data->destroy) {
1277 int flags;
1278 Py_INCREF(data->destroy);
1279 flags = PyCFunction_GET_FLAGS(data->destroy);
1280 #ifdef METH_O
1281 data->delargs = !(flags & (METH_O));
1282 #else
1283 data->delargs = 0;
1284 #endif
1285 } else {
1286 data->delargs = 0;
1287 }
1288 data->implicitconv = 0;
1289 return data;
1290 }
1291 }
1292
1293 SWIGRUNTIME void
1294 PySwigClientData_Del(PySwigClientData* data)
1295 {
1296 Py_XDECREF(data->newraw);
1297 Py_XDECREF(data->newargs);
1298 Py_XDECREF(data->destroy);
1299 }
1300
1301 /* =============== PySwigObject =====================*/
1302
1303 typedef struct {
1304 PyObject_HEAD
1305 void *ptr;
1306 swig_type_info *ty;
1307 int own;
1308 PyObject *next;
1309 } PySwigObject;
1310
1311 SWIGRUNTIME PyObject *
1312 PySwigObject_long(PySwigObject *v)
1313 {
1314 return PyLong_FromVoidPtr(v->ptr);
1315 }
1316
1317 SWIGRUNTIME PyObject *
1318 PySwigObject_format(const char* fmt, PySwigObject *v)
1319 {
1320 PyObject *res = NULL;
1321 PyObject *args = PyTuple_New(1);
1322 if (args) {
1323 if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1324 PyObject *ofmt = PyString_FromString(fmt);
1325 if (ofmt) {
1326 res = PyString_Format(ofmt,args);
1327 Py_DECREF(ofmt);
1328 }
1329 Py_DECREF(args);
1330 }
1331 }
1332 return res;
1333 }
1334
1335 SWIGRUNTIME PyObject *
1336 PySwigObject_oct(PySwigObject *v)
1337 {
1338 return PySwigObject_format("%o",v);
1339 }
1340
1341 SWIGRUNTIME PyObject *
1342 PySwigObject_hex(PySwigObject *v)
1343 {
1344 return PySwigObject_format("%x",v);
1345 }
1346
1347 SWIGRUNTIME PyObject *
1348 #ifdef METH_NOARGS
1349 PySwigObject_repr(PySwigObject *v)
1350 #else
1351 PySwigObject_repr(PySwigObject *v, PyObject *args)
1352 #endif
1353 {
1354 const char *name = SWIG_TypePrettyName(v->ty);
1355 PyObject *hex = PySwigObject_hex(v);
1356 PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1357 Py_DECREF(hex);
1358 if (v->next) {
1359 #ifdef METH_NOARGS
1360 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1361 #else
1362 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1363 #endif
1364 PyString_ConcatAndDel(&repr,nrep);
1365 }
1366 return repr;
1367 }
1368
1369 SWIGRUNTIME int
1370 PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1371 {
1372 #ifdef METH_NOARGS
1373 PyObject *repr = PySwigObject_repr(v);
1374 #else
1375 PyObject *repr = PySwigObject_repr(v, NULL);
1376 #endif
1377 if (repr) {
1378 fputs(PyString_AsString(repr), fp);
1379 Py_DECREF(repr);
1380 return 0;
1381 } else {
1382 return 1;
1383 }
1384 }
1385
1386 SWIGRUNTIME PyObject *
1387 PySwigObject_str(PySwigObject *v)
1388 {
1389 char result[SWIG_BUFFER_SIZE];
1390 return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1391 PyString_FromString(result) : 0;
1392 }
1393
1394 SWIGRUNTIME int
1395 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1396 {
1397 void *i = v->ptr;
1398 void *j = w->ptr;
1399 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1400 }
1401
1402 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1403
1404 SWIGRUNTIME PyTypeObject*
1405 PySwigObject_type(void) {
1406 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1407 return type;
1408 }
1409
1410 SWIGRUNTIMEINLINE int
1411 PySwigObject_Check(PyObject *op) {
1412 return ((op)->ob_type == PySwigObject_type())
1413 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1414 }
1415
1416 SWIGRUNTIME PyObject *
1417 PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1418
1419 SWIGRUNTIME void
1420 PySwigObject_dealloc(PyObject *v)
1421 {
1422 PySwigObject *sobj = (PySwigObject *) v;
1423 PyObject *next = sobj->next;
1424 if (sobj->own) {
1425 swig_type_info *ty = sobj->ty;
1426 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1427 PyObject *destroy = data ? data->destroy : 0;
1428 if (destroy) {
1429 /* destroy is always a VARARGS method */
1430 PyObject *res;
1431 if (data->delargs) {
1432 /* we need to create a temporal object to carry the destroy operation */
1433 PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1434 res = SWIG_Python_CallFunctor(destroy, tmp);
1435 Py_DECREF(tmp);
1436 } else {
1437 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1438 PyObject *mself = PyCFunction_GET_SELF(destroy);
1439 res = ((*meth)(mself, v));
1440 }
1441 Py_XDECREF(res);
1442 } else {
1443 const char *name = SWIG_TypePrettyName(ty);
1444 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1445 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
1446 #endif
1447 }
1448 }
1449 Py_XDECREF(next);
1450 PyObject_DEL(v);
1451 }
1452
1453 SWIGRUNTIME PyObject*
1454 PySwigObject_append(PyObject* v, PyObject* next)
1455 {
1456 PySwigObject *sobj = (PySwigObject *) v;
1457 #ifndef METH_O
1458 PyObject *tmp = 0;
1459 if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1460 next = tmp;
1461 #endif
1462 if (!PySwigObject_Check(next)) {
1463 return NULL;
1464 }
1465 sobj->next = next;
1466 Py_INCREF(next);
1467 return SWIG_Py_Void();
1468 }
1469
1470 SWIGRUNTIME PyObject*
1471 #ifdef METH_NOARGS
1472 PySwigObject_next(PyObject* v)
1473 #else
1474 PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1475 #endif
1476 {
1477 PySwigObject *sobj = (PySwigObject *) v;
1478 if (sobj->next) {
1479 Py_INCREF(sobj->next);
1480 return sobj->next;
1481 } else {
1482 return SWIG_Py_Void();
1483 }
1484 }
1485
1486 SWIGINTERN PyObject*
1487 #ifdef METH_NOARGS
1488 PySwigObject_disown(PyObject *v)
1489 #else
1490 PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1491 #endif
1492 {
1493 PySwigObject *sobj = (PySwigObject *)v;
1494 sobj->own = 0;
1495 return SWIG_Py_Void();
1496 }
1497
1498 SWIGINTERN PyObject*
1499 #ifdef METH_NOARGS
1500 PySwigObject_acquire(PyObject *v)
1501 #else
1502 PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1503 #endif
1504 {
1505 PySwigObject *sobj = (PySwigObject *)v;
1506 sobj->own = SWIG_POINTER_OWN;
1507 return SWIG_Py_Void();
1508 }
1509
1510 SWIGINTERN PyObject*
1511 PySwigObject_own(PyObject *v, PyObject *args)
1512 {
1513 PyObject *val = 0;
1514 #if (PY_VERSION_HEX < 0x02020000)
1515 if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1516 #else
1517 if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1518 #endif
1519 {
1520 return NULL;
1521 }
1522 else
1523 {
1524 PySwigObject *sobj = (PySwigObject *)v;
1525 PyObject *obj = PyBool_FromLong(sobj->own);
1526 if (val) {
1527 #ifdef METH_NOARGS
1528 if (PyObject_IsTrue(val)) {
1529 PySwigObject_acquire(v);
1530 } else {
1531 PySwigObject_disown(v);
1532 }
1533 #else
1534 if (PyObject_IsTrue(val)) {
1535 PySwigObject_acquire(v,args);
1536 } else {
1537 PySwigObject_disown(v,args);
1538 }
1539 #endif
1540 }
1541 return obj;
1542 }
1543 }
1544
1545 #ifdef METH_O
1546 static PyMethodDef
1547 swigobject_methods[] = {
1548 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1549 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
1550 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1551 {(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"},
1552 {(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1553 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"},
1554 {0, 0, 0, 0}
1555 };
1556 #else
1557 static PyMethodDef
1558 swigobject_methods[] = {
1559 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1560 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1561 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1562 {(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1563 {(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1564 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"},
1565 {0, 0, 0, 0}
1566 };
1567 #endif
1568
1569 #if PY_VERSION_HEX < 0x02020000
1570 SWIGINTERN PyObject *
1571 PySwigObject_getattr(PySwigObject *sobj,char *name)
1572 {
1573 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1574 }
1575 #endif
1576
1577 SWIGRUNTIME PyTypeObject*
1578 _PySwigObject_type(void) {
1579 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1580
1581 static PyNumberMethods PySwigObject_as_number = {
1582 (binaryfunc)0, /*nb_add*/
1583 (binaryfunc)0, /*nb_subtract*/
1584 (binaryfunc)0, /*nb_multiply*/
1585 (binaryfunc)0, /*nb_divide*/
1586 (binaryfunc)0, /*nb_remainder*/
1587 (binaryfunc)0, /*nb_divmod*/
1588 (ternaryfunc)0,/*nb_power*/
1589 (unaryfunc)0, /*nb_negative*/
1590 (unaryfunc)0, /*nb_positive*/
1591 (unaryfunc)0, /*nb_absolute*/
1592 (inquiry)0, /*nb_nonzero*/
1593 0, /*nb_invert*/
1594 0, /*nb_lshift*/
1595 0, /*nb_rshift*/
1596 0, /*nb_and*/
1597 0, /*nb_xor*/
1598 0, /*nb_or*/
1599 (coercion)0, /*nb_coerce*/
1600 (unaryfunc)PySwigObject_long, /*nb_int*/
1601 (unaryfunc)PySwigObject_long, /*nb_long*/
1602 (unaryfunc)0, /*nb_float*/
1603 (unaryfunc)PySwigObject_oct, /*nb_oct*/
1604 (unaryfunc)PySwigObject_hex, /*nb_hex*/
1605 #if PY_VERSION_HEX >= 0x02020000
1606 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1607 #elif PY_VERSION_HEX >= 0x02000000
1608 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1609 #endif
1610 };
1611
1612 static PyTypeObject pyswigobject_type;
1613 static int type_init = 0;
1614 if (!type_init) {
1615 const PyTypeObject tmp
1616 = {
1617 PyObject_HEAD_INIT(NULL)
1618 0, /* ob_size */
1619 (char *)"PySwigObject", /* tp_name */
1620 sizeof(PySwigObject), /* tp_basicsize */
1621 0, /* tp_itemsize */
1622 (destructor)PySwigObject_dealloc, /* tp_dealloc */
1623 (printfunc)PySwigObject_print, /* tp_print */
1624 #if PY_VERSION_HEX < 0x02020000
1625 (getattrfunc)PySwigObject_getattr, /* tp_getattr */
1626 #else
1627 (getattrfunc)0, /* tp_getattr */
1628 #endif
1629 (setattrfunc)0, /* tp_setattr */
1630 (cmpfunc)PySwigObject_compare, /* tp_compare */
1631 (reprfunc)PySwigObject_repr, /* tp_repr */
1632 &PySwigObject_as_number, /* tp_as_number */
1633 0, /* tp_as_sequence */
1634 0, /* tp_as_mapping */
1635 (hashfunc)0, /* tp_hash */
1636 (ternaryfunc)0, /* tp_call */
1637 (reprfunc)PySwigObject_str, /* tp_str */
1638 PyObject_GenericGetAttr, /* tp_getattro */
1639 0, /* tp_setattro */
1640 0, /* tp_as_buffer */
1641 Py_TPFLAGS_DEFAULT, /* tp_flags */
1642 swigobject_doc, /* tp_doc */
1643 0, /* tp_traverse */
1644 0, /* tp_clear */
1645 0, /* tp_richcompare */
1646 0, /* tp_weaklistoffset */
1647 #if PY_VERSION_HEX >= 0x02020000
1648 0, /* tp_iter */
1649 0, /* tp_iternext */
1650 swigobject_methods, /* tp_methods */
1651 0, /* tp_members */
1652 0, /* tp_getset */
1653 0, /* tp_base */
1654 0, /* tp_dict */
1655 0, /* tp_descr_get */
1656 0, /* tp_descr_set */
1657 0, /* tp_dictoffset */
1658 0, /* tp_init */
1659 0, /* tp_alloc */
1660 0, /* tp_new */
1661 0, /* tp_free */
1662 0, /* tp_is_gc */
1663 0, /* tp_bases */
1664 0, /* tp_mro */
1665 0, /* tp_cache */
1666 0, /* tp_subclasses */
1667 0, /* tp_weaklist */
1668 #endif
1669 #if PY_VERSION_HEX >= 0x02030000
1670 0, /* tp_del */
1671 #endif
1672 #ifdef COUNT_ALLOCS
1673 0,0,0,0 /* tp_alloc -> tp_next */
1674 #endif
1675 };
1676 pyswigobject_type = tmp;
1677 pyswigobject_type.ob_type = &PyType_Type;
1678 type_init = 1;
1679 }
1680 return &pyswigobject_type;
1681 }
1682
1683 SWIGRUNTIME PyObject *
1684 PySwigObject_New(void *ptr, swig_type_info *ty, int own)
1685 {
1686 PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1687 if (sobj) {
1688 sobj->ptr = ptr;
1689 sobj->ty = ty;
1690 sobj->own = own;
1691 sobj->next = 0;
1692 }
1693 return (PyObject *)sobj;
1694 }
1695
1696 /* -----------------------------------------------------------------------------
1697 * Implements a simple Swig Packed type, and use it instead of string
1698 * ----------------------------------------------------------------------------- */
1699
1700 typedef struct {
1701 PyObject_HEAD
1702 void *pack;
1703 swig_type_info *ty;
1704 size_t size;
1705 } PySwigPacked;
1706
1707 SWIGRUNTIME int
1708 PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1709 {
1710 char result[SWIG_BUFFER_SIZE];
1711 fputs("<Swig Packed ", fp);
1712 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1713 fputs("at ", fp);
1714 fputs(result, fp);
1715 }
1716 fputs(v->ty->name,fp);
1717 fputs(">", fp);
1718 return 0;
1719 }
1720
1721 SWIGRUNTIME PyObject *
1722 PySwigPacked_repr(PySwigPacked *v)
1723 {
1724 char result[SWIG_BUFFER_SIZE];
1725 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1726 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1727 } else {
1728 return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
1729 }
1730 }
1731
1732 SWIGRUNTIME PyObject *
1733 PySwigPacked_str(PySwigPacked *v)
1734 {
1735 char result[SWIG_BUFFER_SIZE];
1736 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1737 return PyString_FromFormat("%s%s", result, v->ty->name);
1738 } else {
1739 return PyString_FromString(v->ty->name);
1740 }
1741 }
1742
1743 SWIGRUNTIME int
1744 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
1745 {
1746 size_t i = v->size;
1747 size_t j = w->size;
1748 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1749 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1750 }
1751
1752 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1753
1754 SWIGRUNTIME PyTypeObject*
1755 PySwigPacked_type(void) {
1756 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1757 return type;
1758 }
1759
1760 SWIGRUNTIMEINLINE int
1761 PySwigPacked_Check(PyObject *op) {
1762 return ((op)->ob_type == _PySwigPacked_type())
1763 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1764 }
1765
1766 SWIGRUNTIME void
1767 PySwigPacked_dealloc(PyObject *v)
1768 {
1769 if (PySwigPacked_Check(v)) {
1770 PySwigPacked *sobj = (PySwigPacked *) v;
1771 free(sobj->pack);
1772 }
1773 PyObject_DEL(v);
1774 }
1775
1776 SWIGRUNTIME PyTypeObject*
1777 _PySwigPacked_type(void) {
1778 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1779 static PyTypeObject pyswigpacked_type;
1780 static int type_init = 0;
1781 if (!type_init) {
1782 const PyTypeObject tmp
1783 = {
1784 PyObject_HEAD_INIT(NULL)
1785 0, /* ob_size */
1786 (char *)"PySwigPacked", /* tp_name */
1787 sizeof(PySwigPacked), /* tp_basicsize */
1788 0, /* tp_itemsize */
1789 (destructor)PySwigPacked_dealloc, /* tp_dealloc */
1790 (printfunc)PySwigPacked_print, /* tp_print */
1791 (getattrfunc)0, /* tp_getattr */
1792 (setattrfunc)0, /* tp_setattr */
1793 (cmpfunc)PySwigPacked_compare, /* tp_compare */
1794 (reprfunc)PySwigPacked_repr, /* tp_repr */
1795 0, /* tp_as_number */
1796 0, /* tp_as_sequence */
1797 0, /* tp_as_mapping */
1798 (hashfunc)0, /* tp_hash */
1799 (ternaryfunc)0, /* tp_call */
1800 (reprfunc)PySwigPacked_str, /* tp_str */
1801 PyObject_GenericGetAttr, /* tp_getattro */
1802 0, /* tp_setattro */
1803 0, /* tp_as_buffer */
1804 Py_TPFLAGS_DEFAULT, /* tp_flags */
1805 swigpacked_doc, /* tp_doc */
1806 0, /* tp_traverse */
1807 0, /* tp_clear */
1808 0, /* tp_richcompare */
1809 0, /* tp_weaklistoffset */
1810 #if PY_VERSION_HEX >= 0x02020000
1811 0, /* tp_iter */
1812 0, /* tp_iternext */
1813 0, /* tp_methods */
1814 0, /* tp_members */
1815 0, /* tp_getset */
1816 0, /* tp_base */
1817 0, /* tp_dict */
1818 0, /* tp_descr_get */
1819 0, /* tp_descr_set */
1820 0, /* tp_dictoffset */
1821 0, /* tp_init */
1822 0, /* tp_alloc */
1823 0, /* tp_new */
1824 0, /* tp_free */
1825 0, /* tp_is_gc */
1826 0, /* tp_bases */
1827 0, /* tp_mro */
1828 0, /* tp_cache */
1829 0, /* tp_subclasses */
1830 0, /* tp_weaklist */
1831 #endif
1832 #if PY_VERSION_HEX >= 0x02030000
1833 0, /* tp_del */
1834 #endif
1835 #ifdef COUNT_ALLOCS
1836 0,0,0,0 /* tp_alloc -> tp_next */
1837 #endif
1838 };
1839 pyswigpacked_type = tmp;
1840 pyswigpacked_type.ob_type = &PyType_Type;
1841 type_init = 1;
1842 }
1843 return &pyswigpacked_type;
1844 }
1845
1846 SWIGRUNTIME PyObject *
1847 PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
1848 {
1849 PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1850 if (sobj) {
1851 void *pack = malloc(size);
1852 if (pack) {
1853 memcpy(pack, ptr, size);
1854 sobj->pack = pack;
1855 sobj->ty = ty;
1856 sobj->size = size;
1857 } else {
1858 PyObject_DEL((PyObject *) sobj);
1859 sobj = 0;
1860 }
1861 }
1862 return (PyObject *) sobj;
1863 }
1864
1865 SWIGRUNTIME swig_type_info *
1866 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1867 {
1868 if (PySwigPacked_Check(obj)) {
1869 PySwigPacked *sobj = (PySwigPacked *)obj;
1870 if (sobj->size != size) return 0;
1871 memcpy(ptr, sobj->pack, size);
1872 return sobj->ty;
1873 } else {
1874 return 0;
1875 }
1876 }
1877
1878 /* -----------------------------------------------------------------------------
1879 * pointers/data manipulation
1880 * ----------------------------------------------------------------------------- */
1881
1882 SWIGRUNTIMEINLINE PyObject *
1883 _SWIG_This(void)
1884 {
1885 return PyString_FromString("this");
1886 }
1887
1888 SWIGRUNTIME PyObject *
1889 SWIG_This(void)
1890 {
1891 static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1892 return swig_this;
1893 }
1894
1895 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1896
1897 SWIGRUNTIME PySwigObject *
1898 SWIG_Python_GetSwigThis(PyObject *pyobj)
1899 {
1900 if (PySwigObject_Check(pyobj)) {
1901 return (PySwigObject *) pyobj;
1902 } else {
1903 PyObject *obj = 0;
1904 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1905 if (PyInstance_Check(pyobj)) {
1906 obj = _PyInstance_Lookup(pyobj, SWIG_This());
1907 } else {
1908 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1909 if (dictptr != NULL) {
1910 PyObject *dict = *dictptr;
1911 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1912 } else {
1913 #ifdef PyWeakref_CheckProxy
1914 if (PyWeakref_CheckProxy(pyobj)) {
1915 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1916 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1917 }
1918 #endif
1919 obj = PyObject_GetAttr(pyobj,SWIG_This());
1920 if (obj) {
1921 Py_DECREF(obj);
1922 } else {
1923 if (PyErr_Occurred()) PyErr_Clear();
1924 return 0;
1925 }
1926 }
1927 }
1928 #else
1929 obj = PyObject_GetAttr(pyobj,SWIG_This());
1930 if (obj) {
1931 Py_DECREF(obj);
1932 } else {
1933 if (PyErr_Occurred()) PyErr_Clear();
1934 return 0;
1935 }
1936 #endif
1937 if (obj && !PySwigObject_Check(obj)) {
1938 /* a PyObject is called 'this', try to get the 'real this'
1939 PySwigObject from it */
1940 return SWIG_Python_GetSwigThis(obj);
1941 }
1942 return (PySwigObject *)obj;
1943 }
1944 }
1945
1946 /* Acquire a pointer value */
1947
1948 SWIGRUNTIME int
1949 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1950 if (own) {
1951 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1952 if (sobj) {
1953 int oldown = sobj->own;
1954 sobj->own = own;
1955 return oldown;
1956 }
1957 }
1958 return 0;
1959 }
1960
1961 /* Convert a pointer value */
1962
1963 SWIGRUNTIME int
1964 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1965 if (!obj) return SWIG_ERROR;
1966 if (obj == Py_None) {
1967 if (ptr) *ptr = 0;
1968 return SWIG_OK;
1969 } else {
1970 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1971 while (sobj) {
1972 void *vptr = sobj->ptr;
1973 if (ty) {
1974 swig_type_info *to = sobj->ty;
1975 if (to == ty) {
1976 /* no type cast needed */
1977 if (ptr) *ptr = vptr;
1978 break;
1979 } else {
1980 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1981 if (!tc) {
1982 sobj = (PySwigObject *)sobj->next;
1983 } else {
1984 if (ptr) *ptr = SWIG_TypeCast(tc,vptr);
1985 break;
1986 }
1987 }
1988 } else {
1989 if (ptr) *ptr = vptr;
1990 break;
1991 }
1992 }
1993 if (sobj) {
1994 if (own) *own = sobj->own;
1995 if (flags & SWIG_POINTER_DISOWN) {
1996 sobj->own = 0;
1997 }
1998 return SWIG_OK;
1999 } else {
2000 int res = SWIG_ERROR;
2001 if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2002 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2003 if (data && !data->implicitconv) {
2004 PyObject *klass = data->klass;
2005 if (klass) {
2006 PyObject *impconv;
2007 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2008 impconv = SWIG_Python_CallFunctor(klass, obj);
2009 data->implicitconv = 0;
2010 if (PyErr_Occurred()) {
2011 PyErr_Clear();
2012 impconv = 0;
2013 }
2014 if (impconv) {
2015 PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2016 if (iobj) {
2017 void *vptr;
2018 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2019 if (SWIG_IsOK(res)) {
2020 if (ptr) {
2021 *ptr = vptr;
2022 /* transfer the ownership to 'ptr' */
2023 iobj->own = 0;
2024 res = SWIG_AddCast(res);
2025 res = SWIG_AddNewMask(res);
2026 } else {
2027 res = SWIG_AddCast(res);
2028 }
2029 }
2030 }
2031 Py_DECREF(impconv);
2032 }
2033 }
2034 }
2035 }
2036 return res;
2037 }
2038 }
2039 }
2040
2041 /* Convert a function ptr value */
2042
2043 SWIGRUNTIME int
2044 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2045 if (!PyCFunction_Check(obj)) {
2046 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2047 } else {
2048 void *vptr = 0;
2049
2050 /* here we get the method pointer for callbacks */
2051 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2052 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2053 if (desc) {
2054 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2055 if (!desc) return SWIG_ERROR;
2056 }
2057 if (ty) {
2058 swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2059 if (!tc) return SWIG_ERROR;
2060 *ptr = SWIG_TypeCast(tc,vptr);
2061 } else {
2062 *ptr = vptr;
2063 }
2064 return SWIG_OK;
2065 }
2066 }
2067
2068 /* Convert a packed value value */
2069
2070 SWIGRUNTIME int
2071 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2072 swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2073 if (!to) return SWIG_ERROR;
2074 if (ty) {
2075 if (to != ty) {
2076 /* check type cast? */
2077 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2078 if (!tc) return SWIG_ERROR;
2079 }
2080 }
2081 return SWIG_OK;
2082 }
2083
2084 /* -----------------------------------------------------------------------------
2085 * Create a new pointer object
2086 * ----------------------------------------------------------------------------- */
2087
2088 /*
2089 Create a new instance object, whitout calling __init__, and set the
2090 'this' attribute.
2091 */
2092
2093 SWIGRUNTIME PyObject*
2094 SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2095 {
2096 #if (PY_VERSION_HEX >= 0x02020000)
2097 PyObject *inst = 0;
2098 PyObject *newraw = data->newraw;
2099 if (newraw) {
2100 inst = PyObject_Call(newraw, data->newargs, NULL);
2101 if (inst) {
2102 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2103 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2104 if (dictptr != NULL) {
2105 PyObject *dict = *dictptr;
2106 if (dict == NULL) {
2107 dict = PyDict_New();
2108 *dictptr = dict;
2109 PyDict_SetItem(dict, SWIG_This(), swig_this);
2110 }
2111 }
2112 #else
2113 PyObject *key = SWIG_This();
2114 PyObject_SetAttr(inst, key, swig_this);
2115 #endif
2116 }
2117 } else {
2118 PyObject *dict = PyDict_New();
2119 PyDict_SetItem(dict, SWIG_This(), swig_this);
2120 inst = PyInstance_NewRaw(data->newargs, dict);
2121 Py_DECREF(dict);
2122 }
2123 return inst;
2124 #else
2125 #if (PY_VERSION_HEX >= 0x02010000)
2126 PyObject *inst;
2127 PyObject *dict = PyDict_New();
2128 PyDict_SetItem(dict, SWIG_This(), swig_this);
2129 inst = PyInstance_NewRaw(data->newargs, dict);
2130 Py_DECREF(dict);
2131 return (PyObject *) inst;
2132 #else
2133 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2134 if (inst == NULL) {
2135 return NULL;
2136 }
2137 inst->in_class = (PyClassObject *)data->newargs;
2138 Py_INCREF(inst->in_class);
2139 inst->in_dict = PyDict_New();
2140 if (inst->in_dict == NULL) {
2141 Py_DECREF(inst);
2142 return NULL;
2143 }
2144 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2145 inst->in_weakreflist = NULL;
2146 #endif
2147 #ifdef Py_TPFLAGS_GC
2148 PyObject_GC_Init(inst);
2149 #endif
2150 PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2151 return (PyObject *) inst;
2152 #endif
2153 #endif
2154 }
2155
2156 SWIGRUNTIME void
2157 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2158 {
2159 PyObject *dict;
2160 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2161 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2162 if (dictptr != NULL) {
2163 dict = *dictptr;
2164 if (dict == NULL) {
2165 dict = PyDict_New();
2166 *dictptr = dict;
2167 }
2168 PyDict_SetItem(dict, SWIG_This(), swig_this);
2169 return;
2170 }
2171 #endif
2172 dict = PyObject_GetAttrString(inst, "__dict__");
2173 PyDict_SetItem(dict, SWIG_This(), swig_this);
2174 Py_DECREF(dict);
2175 }
2176
2177
2178 SWIGINTERN PyObject *
2179 SWIG_Python_InitShadowInstance(PyObject *args) {
2180 PyObject *obj[2];
2181 if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2182 return NULL;
2183 } else {
2184 PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2185 if (sthis) {
2186 PySwigObject_append((PyObject*) sthis, obj[1]);
2187 } else {
2188 SWIG_Python_SetSwigThis(obj[0], obj[1]);
2189 }
2190 return SWIG_Py_Void();
2191 }
2192 }
2193
2194 /* Create a new pointer object */
2195
2196 SWIGRUNTIME PyObject *
2197 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2198 if (!ptr) {
2199 return SWIG_Py_Void();
2200 } else {
2201 int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2202 PyObject *robj = PySwigObject_New(ptr, type, own);
2203 PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2204 if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2205 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2206 if (inst) {
2207 Py_DECREF(robj);
2208 robj = inst;
2209 }
2210 }
2211 return robj;
2212 }
2213 }
2214
2215 /* Create a new packed object */
2216
2217 SWIGRUNTIMEINLINE PyObject *
2218 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2219 return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2220 }
2221
2222 /* -----------------------------------------------------------------------------*
2223 * Get type list
2224 * -----------------------------------------------------------------------------*/
2225
2226 #ifdef SWIG_LINK_RUNTIME
2227 void *SWIG_ReturnGlobalTypeList(void *);
2228 #endif
2229
2230 SWIGRUNTIME swig_module_info *
2231 SWIG_Python_GetModule(void) {
2232 static void *type_pointer = (void *)0;
2233 /* first check if module already created */
2234 if (!type_pointer) {
2235 #ifdef SWIG_LINK_RUNTIME
2236 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2237 #else
2238 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2239 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2240 if (PyErr_Occurred()) {
2241 PyErr_Clear();
2242 type_pointer = (void *)0;
2243 }
2244 #endif
2245 }
2246 return (swig_module_info *) type_pointer;
2247 }
2248
2249 #if PY_MAJOR_VERSION < 2
2250 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2251 is copied out of Python/modsupport.c in python version 2.3.4 */
2252 SWIGINTERN int
2253 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2254 {
2255 PyObject *dict;
2256 if (!PyModule_Check(m)) {
2257 PyErr_SetString(PyExc_TypeError,
2258 "PyModule_AddObject() needs module as first arg");
2259 return SWIG_ERROR;
2260 }
2261 if (!o) {
2262 PyErr_SetString(PyExc_TypeError,
2263 "PyModule_AddObject() needs non-NULL value");
2264 return SWIG_ERROR;
2265 }
2266
2267 dict = PyModule_GetDict(m);
2268 if (dict == NULL) {
2269 /* Internal error -- modules must have a dict! */
2270 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2271 PyModule_GetName(m));
2272 return SWIG_ERROR;
2273 }
2274 if (PyDict_SetItemString(dict, name, o))
2275 return SWIG_ERROR;
2276 Py_DECREF(o);
2277 return SWIG_OK;
2278 }
2279 #endif
2280
2281 SWIGRUNTIME void
2282 SWIG_Python_DestroyModule(void *vptr)
2283 {
2284 swig_module_info *swig_module = (swig_module_info *) vptr;
2285 swig_type_info **types = swig_module->types;
2286 size_t i;
2287 for (i =0; i < swig_module->size; ++i) {
2288 swig_type_info *ty = types[i];
2289 if (ty->owndata) {
2290 PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2291 if (data) PySwigClientData_Del(data);
2292 }
2293 }
2294 Py_DECREF(SWIG_This());
2295 }
2296
2297 SWIGRUNTIME void
2298 SWIG_Python_SetModule(swig_module_info *swig_module) {
2299 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2300
2301 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2302 swig_empty_runtime_method_table);
2303 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2304 if (pointer && module) {
2305 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2306 } else {
2307 Py_XDECREF(pointer);
2308 }
2309 }
2310
2311 /* The python cached type query */
2312 SWIGRUNTIME PyObject *
2313 SWIG_Python_TypeCache() {
2314 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2315 return cache;
2316 }
2317
2318 SWIGRUNTIME swig_type_info *
2319 SWIG_Python_TypeQuery(const char *type)
2320 {
2321 PyObject *cache = SWIG_Python_TypeCache();
2322 PyObject *key = PyString_FromString(type);
2323 PyObject *obj = PyDict_GetItem(cache, key);
2324 swig_type_info *descriptor;
2325 if (obj) {
2326 descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2327 } else {
2328 swig_module_info *swig_module = SWIG_Python_GetModule();
2329 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2330 if (descriptor) {
2331 obj = PyCObject_FromVoidPtr(descriptor, NULL);
2332 PyDict_SetItem(cache, key, obj);
2333 Py_DECREF(obj);
2334 }
2335 }
2336 Py_DECREF(key);
2337 return descriptor;
2338 }
2339
2340 /*
2341 For backward compatibility only
2342 */
2343 #define SWIG_POINTER_EXCEPTION 0
2344 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2345 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2346
2347 SWIGRUNTIME int
2348 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2349 {
2350 if (PyErr_Occurred()) {
2351 PyObject *type = 0;
2352 PyObject *value = 0;
2353 PyObject *traceback = 0;
2354 PyErr_Fetch(&type, &value, &traceback);
2355 if (value) {
2356 PyObject *old_str = PyObject_Str(value);
2357 Py_XINCREF(type);
2358 PyErr_Clear();
2359 if (infront) {
2360 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2361 } else {
2362 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2363 }
2364 Py_DECREF(old_str);
2365 }
2366 return 1;
2367 } else {
2368 return 0;
2369 }
2370 }
2371
2372 SWIGRUNTIME int
2373 SWIG_Python_ArgFail(int argnum)
2374 {
2375 if (PyErr_Occurred()) {
2376 /* add information about failing argument */
2377 char mesg[256];
2378 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2379 return SWIG_Python_AddErrMesg(mesg, 1);
2380 } else {
2381 return 0;
2382 }
2383 }
2384
2385 SWIGRUNTIMEINLINE const char *
2386 PySwigObject_GetDesc(PyObject *self)
2387 {
2388 PySwigObject *v = (PySwigObject *)self;
2389 swig_type_info *ty = v ? v->ty : 0;
2390 return ty ? ty->str : (char*)"";
2391 }
2392
2393 SWIGRUNTIME void
2394 SWIG_Python_TypeError(const char *type, PyObject *obj)
2395 {
2396 if (type) {
2397 #if defined(SWIG_COBJECT_TYPES)
2398 if (obj && PySwigObject_Check(obj)) {
2399 const char *otype = (const char *) PySwigObject_GetDesc(obj);
2400 if (otype) {
2401 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2402 type, otype);
2403 return;
2404 }
2405 } else
2406 #endif
2407 {
2408 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2409 if (otype) {
2410 PyObject *str = PyObject_Str(obj);
2411 const char *cstr = str ? PyString_AsString(str) : 0;
2412 if (cstr) {
2413 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2414 type, otype, cstr);
2415 } else {
2416 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2417 type, otype);
2418 }
2419 Py_XDECREF(str);
2420 return;
2421 }
2422 }
2423 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2424 } else {
2425 PyErr_Format(PyExc_TypeError, "unexpected type is received");
2426 }
2427 }
2428
2429
2430 /* Convert a pointer value, signal an exception on a type mismatch */
2431 SWIGRUNTIME void *
2432 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2433 void *result;
2434 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2435 PyErr_Clear();
2436 if (flags & SWIG_POINTER_EXCEPTION) {
2437 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2438 SWIG_Python_ArgFail(argnum);
2439 }
2440 }
2441 return result;
2442 }
2443
2444
2445 #ifdef __cplusplus
2446 #if 0
2447 { /* cc-mode */
2448 #endif
2449 }
2450 #endif
2451
2452
2453
2454 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2455
2456 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2457
2458
2459
2460 /* -------- TYPES TABLE (BEGIN) -------- */
2461
2462 #define SWIGTYPE_p_buffer swig_types[0]
2463 #define SWIGTYPE_p_char swig_types[1]
2464 #define SWIGTYPE_p_form_ops_t swig_types[2]
2465 #define SWIGTYPE_p_int swig_types[3]
2466 #define SWIGTYPE_p_long swig_types[4]
2467 #define SWIGTYPE_p_unsigned_char swig_types[5]
2468 #define SWIGTYPE_p_unsigned_int swig_types[6]
2469 #define SWIGTYPE_p_unsigned_long swig_types[7]
2470 #define SWIGTYPE_p_wxANIHandler swig_types[8]
2471 #define SWIGTYPE_p_wxAcceleratorEntry swig_types[9]
2472 #define SWIGTYPE_p_wxAcceleratorTable swig_types[10]
2473 #define SWIGTYPE_p_wxActivateEvent swig_types[11]
2474 #define SWIGTYPE_p_wxAppTraits swig_types[12]
2475 #define SWIGTYPE_p_wxArrayString swig_types[13]
2476 #define SWIGTYPE_p_wxBMPHandler swig_types[14]
2477 #define SWIGTYPE_p_wxBitmap swig_types[15]
2478 #define SWIGTYPE_p_wxBoxSizer swig_types[16]
2479 #define SWIGTYPE_p_wxButton swig_types[17]
2480 #define SWIGTYPE_p_wxCURHandler swig_types[18]
2481 #define SWIGTYPE_p_wxCaret swig_types[19]
2482 #define SWIGTYPE_p_wxChildFocusEvent swig_types[20]
2483 #define SWIGTYPE_p_wxClipboardTextEvent swig_types[21]
2484 #define SWIGTYPE_p_wxCloseEvent swig_types[22]
2485 #define SWIGTYPE_p_wxColour swig_types[23]
2486 #define SWIGTYPE_p_wxCommandEvent swig_types[24]
2487 #define SWIGTYPE_p_wxContextMenuEvent swig_types[25]
2488 #define SWIGTYPE_p_wxControl swig_types[26]
2489 #define SWIGTYPE_p_wxControlWithItems swig_types[27]
2490 #define SWIGTYPE_p_wxCursor swig_types[28]
2491 #define SWIGTYPE_p_wxDC swig_types[29]
2492 #define SWIGTYPE_p_wxDateEvent swig_types[30]
2493 #define SWIGTYPE_p_wxDateTime swig_types[31]
2494 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[32]
2495 #define SWIGTYPE_p_wxDropFilesEvent swig_types[33]
2496 #define SWIGTYPE_p_wxDuplexMode swig_types[34]
2497 #define SWIGTYPE_p_wxEraseEvent swig_types[35]
2498 #define SWIGTYPE_p_wxEvent swig_types[36]
2499 #define SWIGTYPE_p_wxEventLoop swig_types[37]
2500 #define SWIGTYPE_p_wxEventLoopActivator swig_types[38]
2501 #define SWIGTYPE_p_wxEvtHandler swig_types[39]
2502 #define SWIGTYPE_p_wxFSFile swig_types[40]
2503 #define SWIGTYPE_p_wxFileSystem swig_types[41]
2504 #define SWIGTYPE_p_wxFileSystemHandler swig_types[42]
2505 #define SWIGTYPE_p_wxFlexGridSizer swig_types[43]
2506 #define SWIGTYPE_p_wxFocusEvent swig_types[44]
2507 #define SWIGTYPE_p_wxFont swig_types[45]
2508 #define SWIGTYPE_p_wxFrame swig_types[46]
2509 #define SWIGTYPE_p_wxGBPosition swig_types[47]
2510 #define SWIGTYPE_p_wxGBSizerItem swig_types[48]
2511 #define SWIGTYPE_p_wxGBSpan swig_types[49]
2512 #define SWIGTYPE_p_wxGIFHandler swig_types[50]
2513 #define SWIGTYPE_p_wxGridBagSizer swig_types[51]
2514 #define SWIGTYPE_p_wxGridSizer swig_types[52]
2515 #define SWIGTYPE_p_wxICOHandler swig_types[53]
2516 #define SWIGTYPE_p_wxIconizeEvent swig_types[54]
2517 #define SWIGTYPE_p_wxIdleEvent swig_types[55]
2518 #define SWIGTYPE_p_wxImage swig_types[56]
2519 #define SWIGTYPE_p_wxImageHandler swig_types[57]
2520 #define SWIGTYPE_p_wxImageHistogram swig_types[58]
2521 #define SWIGTYPE_p_wxImage_HSVValue swig_types[59]
2522 #define SWIGTYPE_p_wxImage_RGBValue swig_types[60]
2523 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[61]
2524 #define SWIGTYPE_p_wxInitDialogEvent swig_types[62]
2525 #define SWIGTYPE_p_wxInputStream swig_types[63]
2526 #define SWIGTYPE_p_wxInternetFSHandler swig_types[64]
2527 #define SWIGTYPE_p_wxItemContainer swig_types[65]
2528 #define SWIGTYPE_p_wxJPEGHandler swig_types[66]
2529 #define SWIGTYPE_p_wxKeyEvent swig_types[67]
2530 #define SWIGTYPE_p_wxLayoutConstraints swig_types[68]
2531 #define SWIGTYPE_p_wxMaximizeEvent swig_types[69]
2532 #define SWIGTYPE_p_wxMemoryFSHandler swig_types[70]
2533 #define SWIGTYPE_p_wxMenu swig_types[71]
2534 #define SWIGTYPE_p_wxMenuBar swig_types[72]
2535 #define SWIGTYPE_p_wxMenuBarBase swig_types[73]
2536 #define SWIGTYPE_p_wxMenuEvent swig_types[74]
2537 #define SWIGTYPE_p_wxMenuItem swig_types[75]
2538 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[76]
2539 #define SWIGTYPE_p_wxMouseEvent swig_types[77]
2540 #define SWIGTYPE_p_wxMoveEvent swig_types[78]
2541 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[79]
2542 #define SWIGTYPE_p_wxNcPaintEvent swig_types[80]
2543 #define SWIGTYPE_p_wxNotifyEvent swig_types[81]
2544 #define SWIGTYPE_p_wxObject swig_types[82]
2545 #define SWIGTYPE_p_wxOutputStream swig_types[83]
2546 #define SWIGTYPE_p_wxPCXHandler swig_types[84]
2547 #define SWIGTYPE_p_wxPNGHandler swig_types[85]
2548 #define SWIGTYPE_p_wxPNMHandler swig_types[86]
2549 #define SWIGTYPE_p_wxPaintEvent swig_types[87]
2550 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[88]
2551 #define SWIGTYPE_p_wxPaperSize swig_types[89]
2552 #define SWIGTYPE_p_wxPoint swig_types[90]
2553 #define SWIGTYPE_p_wxPoint2D swig_types[91]
2554 #define SWIGTYPE_p_wxPropagateOnce swig_types[92]
2555 #define SWIGTYPE_p_wxPropagationDisabler swig_types[93]
2556 #define SWIGTYPE_p_wxPyApp swig_types[94]
2557 #define SWIGTYPE_p_wxPyCommandEvent swig_types[95]
2558 #define SWIGTYPE_p_wxPyDropTarget swig_types[96]
2559 #define SWIGTYPE_p_wxPyEvent swig_types[97]
2560 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[98]
2561 #define SWIGTYPE_p_wxPyImageHandler swig_types[99]
2562 #define SWIGTYPE_p_wxPyInputStream swig_types[100]
2563 #define SWIGTYPE_p_wxPySizer swig_types[101]
2564 #define SWIGTYPE_p_wxPyValidator swig_types[102]
2565 #define SWIGTYPE_p_wxQuantize swig_types[103]
2566 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[104]
2567 #define SWIGTYPE_p_wxRealPoint swig_types[105]
2568 #define SWIGTYPE_p_wxRect swig_types[106]
2569 #define SWIGTYPE_p_wxRegion swig_types[107]
2570 #define SWIGTYPE_p_wxScrollEvent swig_types[108]
2571 #define SWIGTYPE_p_wxScrollWinEvent swig_types[109]
2572 #define SWIGTYPE_p_wxSetCursorEvent swig_types[110]
2573 #define SWIGTYPE_p_wxShowEvent swig_types[111]
2574 #define SWIGTYPE_p_wxSize swig_types[112]
2575 #define SWIGTYPE_p_wxSizeEvent swig_types[113]
2576 #define SWIGTYPE_p_wxSizer swig_types[114]
2577 #define SWIGTYPE_p_wxSizerItem swig_types[115]
2578 #define SWIGTYPE_p_wxStaticBox swig_types[116]
2579 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[117]
2580 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[118]
2581 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[119]
2582 #define SWIGTYPE_p_wxTIFFHandler swig_types[120]
2583 #define SWIGTYPE_p_wxToolTip swig_types[121]
2584 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[122]
2585 #define SWIGTYPE_p_wxValidator swig_types[123]
2586 #define SWIGTYPE_p_wxVisualAttributes swig_types[124]
2587 #define SWIGTYPE_p_wxWindow swig_types[125]
2588 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[126]
2589 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[127]
2590 #define SWIGTYPE_p_wxXPMHandler swig_types[128]
2591 #define SWIGTYPE_p_wxZipFSHandler swig_types[129]
2592 static swig_type_info *swig_types[131];
2593 static swig_module_info swig_module = {swig_types, 130, 0, 0, 0, 0};
2594 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2595 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2596
2597 /* -------- TYPES TABLE (END) -------- */
2598
2599 #if (PY_VERSION_HEX <= 0x02000000)
2600 # if !defined(SWIG_PYTHON_CLASSIC)
2601 # error "This python version requires to use swig with the '-classic' option"
2602 # endif
2603 #endif
2604 #if (PY_VERSION_HEX <= 0x02020000)
2605 # error "This python version requires to use swig with the '-nomodern' option"
2606 #endif
2607 #if (PY_VERSION_HEX <= 0x02020000)
2608 # error "This python version requires to use swig with the '-nomodernargs' option"
2609 #endif
2610 #ifndef METH_O
2611 # error "This python version requires to use swig with the '-nofastunpack' option"
2612 #endif
2613
2614 /*-----------------------------------------------
2615 @(target):= _core_.so
2616 ------------------------------------------------*/
2617 #define SWIG_init init_core_
2618
2619 #define SWIG_name "_core_"
2620
2621 #define SWIGVERSION 0x010329
2622
2623
2624 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2625 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2626
2627
2628 #include <stdexcept>
2629
2630
2631 namespace swig {
2632 class PyObject_ptr {
2633 protected:
2634 PyObject *_obj;
2635
2636 public:
2637 PyObject_ptr() :_obj(0)
2638 {
2639 }
2640
2641 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2642 {
2643 Py_XINCREF(_obj);
2644 }
2645
2646 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2647 {
2648 if (initial_ref) Py_XINCREF(_obj);
2649 }
2650
2651 PyObject_ptr & operator=(const PyObject_ptr& item)
2652 {
2653 Py_XINCREF(item._obj);
2654 Py_XDECREF(_obj);
2655 _obj = item._obj;
2656 return *this;
2657 }
2658
2659 ~PyObject_ptr()
2660 {
2661 Py_XDECREF(_obj);
2662 }
2663
2664 operator PyObject *() const
2665 {
2666 return _obj;
2667 }
2668
2669 PyObject *operator->() const
2670 {
2671 return _obj;
2672 }
2673 };
2674 }
2675
2676
2677 namespace swig {
2678 struct PyObject_var : PyObject_ptr {
2679 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2680
2681 PyObject_var & operator = (PyObject* obj)
2682 {
2683 Py_XDECREF(_obj);
2684 _obj = obj;
2685 return *this;
2686 }
2687 };
2688 }
2689
2690
2691 #include "wx/wxPython/wxPython_int.h"
2692 #include "wx/wxPython/pyclasses.h"
2693 #include "wx/wxPython/twoitem.h"
2694
2695
2696 #ifndef wxPyUSE_EXPORT
2697 // Helper functions for dealing with SWIG objects and such. These are
2698 // located here so they know about the SWIG types and functions declared
2699 // in the wrapper code.
2700
2701 #include <wx/hashmap.h>
2702 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
2703
2704
2705 // Maintains a hashmap of className to swig_type_info pointers. Given the
2706 // name of a class either looks up the type info in the cache, or scans the
2707 // SWIG tables for it.
2708 extern PyObject* wxPyPtrTypeMap;
2709 static
2710 swig_type_info* wxPyFindSwigType(const wxChar* className) {
2711
2712 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
2713
2714 if (typeInfoCache == NULL)
2715 typeInfoCache = new wxPyTypeInfoHashMap;
2716
2717 wxString name(className);
2718 swig_type_info* swigType = (*typeInfoCache)[name];
2719
2720 if (! swigType) {
2721 // it wasn't in the cache, so look it up from SWIG
2722 name.Append(wxT(" *"));
2723 swigType = SWIG_TypeQuery(name.mb_str());
2724
2725 // if it still wasn't found, try looking for a mapped name
2726 if (!swigType) {
2727 PyObject* item;
2728 name = className;
2729
2730 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
2731 (char*)(const char*)name.mbc_str())) != NULL) {
2732 name = wxString(PyString_AsString(item), *wxConvCurrent);
2733 name.Append(wxT(" *"));
2734 swigType = SWIG_TypeQuery(name.mb_str());
2735 }
2736 }
2737 if (swigType) {
2738 // and add it to the map if found
2739 (*typeInfoCache)[className] = swigType;
2740 }
2741 }
2742 return swigType;
2743 }
2744
2745
2746 // Check if a class name is a type known to SWIG
2747 bool wxPyCheckSwigType(const wxChar* className) {
2748
2749 swig_type_info* swigType = wxPyFindSwigType(className);
2750 return swigType != NULL;
2751 }
2752
2753
2754 // Given a pointer to a C++ object and a class name, construct a Python proxy
2755 // object for it.
2756 PyObject* wxPyConstructObject(void* ptr,
2757 const wxChar* className,
2758 int setThisOwn) {
2759
2760 swig_type_info* swigType = wxPyFindSwigType(className);
2761 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
2762
2763 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
2764 }
2765
2766
2767 // Extract a pointer to the wrapped C++ object from a Python proxy object.
2768 // Ensures that the proxy object is of the specified (or derived) type. If
2769 // not able to perform the conversion then a Python exception is set and the
2770 // error should be handled properly in the caller. Returns True on success.
2771 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
2772 const wxChar* className) {
2773
2774 swig_type_info* swigType = wxPyFindSwigType(className);
2775 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
2776
2777 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
2778 }
2779
2780
2781
2782 // Make a SWIGified pointer object suitable for a .this attribute
2783 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
2784
2785 PyObject* robj = NULL;
2786
2787 swig_type_info* swigType = wxPyFindSwigType(className);
2788 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyMakeSwigPtr"));
2789
2790 robj = PySwigObject_New(ptr, swigType, 0);
2791 return robj;
2792 }
2793
2794
2795 // Python's PyInstance_Check does not return True for instances of new-style
2796 // classes. This should get close enough for both new and old classes but I
2797 // should re-evaluate the need for doing instance checks...
2798 bool wxPyInstance_Check(PyObject* obj) {
2799 return PyObject_HasAttrString(obj, "__class__") != 0;
2800 }
2801
2802
2803 // This one checks if the object is an instance of a SWIG proxy class (it has
2804 // a .this attribute, and the .this attribute is a PySwigObject.)
2805 bool wxPySwigInstance_Check(PyObject* obj) {
2806 static PyObject* this_str = NULL;
2807 if (this_str == NULL)
2808 this_str = PyString_FromString("this");
2809
2810 PyObject* this_attr = PyObject_GetAttr(obj, this_str);
2811 if (this_attr) {
2812 bool retval = (PySwigObject_Check(this_attr) != 0);
2813 Py_DECREF(this_attr);
2814 return retval;
2815 }
2816
2817 PyErr_Clear();
2818 return false;
2819 }
2820
2821
2822 // Export a C API in a struct. Other modules will be able to load this from
2823 // the wx._core_ module and will then have safe access to these functions,
2824 // even if they are located in another shared library.
2825 static wxPyCoreAPI API = {
2826
2827 wxPyCheckSwigType,
2828 wxPyConstructObject,
2829 wxPyConvertSwigPtr,
2830 wxPyMakeSwigPtr,
2831
2832 wxPyBeginAllowThreads,
2833 wxPyEndAllowThreads,
2834 wxPyBeginBlockThreads,
2835 wxPyEndBlockThreads,
2836
2837 wxPy_ConvertList,
2838
2839 wxString_in_helper,
2840 Py2wxString,
2841 wx2PyString,
2842
2843 byte_LIST_helper,
2844 int_LIST_helper,
2845 long_LIST_helper,
2846 string_LIST_helper,
2847 wxPoint_LIST_helper,
2848 wxBitmap_LIST_helper,
2849 wxString_LIST_helper,
2850 wxAcceleratorEntry_LIST_helper,
2851
2852 wxSize_helper,
2853 wxPoint_helper,
2854 wxRealPoint_helper,
2855 wxRect_helper,
2856 wxColour_helper,
2857 wxPoint2D_helper,
2858
2859 wxPySimple_typecheck,
2860 wxColour_typecheck,
2861
2862 wxPyCBH_setCallbackInfo,
2863 wxPyCBH_findCallback,
2864 wxPyCBH_callCallback,
2865 wxPyCBH_callCallbackObj,
2866 wxPyCBH_delete,
2867
2868 wxPyMake_wxObject,
2869 wxPyMake_wxSizer,
2870 wxPyPtrTypeMap_Add,
2871 wxPy2int_seq_helper,
2872 wxPy4int_seq_helper,
2873 wxArrayString2PyList_helper,
2874 wxArrayInt2PyList_helper,
2875
2876 wxPyClientData_dtor,
2877 wxPyUserData_dtor,
2878 wxPyOORClientData_dtor,
2879
2880 wxPyCBInputStream_create,
2881 wxPyCBInputStream_copy,
2882
2883 wxPyInstance_Check,
2884 wxPySwigInstance_Check,
2885
2886 wxPyCheckForApp
2887
2888 };
2889
2890 #endif
2891
2892
2893 #if !WXWIN_COMPATIBILITY_2_4
2894 #define wxHIDE_READONLY 0
2895 #endif
2896
2897
2898 #define SWIG_From_long PyInt_FromLong
2899
2900
2901 SWIGINTERNINLINE PyObject *
2902 SWIG_From_int (int value)
2903 {
2904 return SWIG_From_long (value);
2905 }
2906
2907 static const wxString wxPyEmptyString(wxEmptyString);
2908 SWIGINTERN wxString wxObject_GetClassName(wxObject *self){
2909 return self->GetClassInfo()->GetClassName();
2910 }
2911 SWIGINTERN void wxObject_Destroy(wxObject *self){
2912 delete self;
2913 }
2914
2915 #ifndef __WXMAC__
2916 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
2917 #endif
2918
2919
2920 #include <limits.h>
2921 #ifndef LLONG_MIN
2922 # define LLONG_MIN LONG_LONG_MIN
2923 #endif
2924 #ifndef LLONG_MAX
2925 # define LLONG_MAX LONG_LONG_MAX
2926 #endif
2927 #ifndef ULLONG_MAX
2928 # define ULLONG_MAX ULONG_LONG_MAX
2929 #endif
2930
2931
2932 SWIGINTERN int
2933 SWIG_AsVal_long (PyObject* obj, long* val)
2934 {
2935 if (PyNumber_Check(obj)) {
2936 if (val) *val = PyInt_AsLong(obj);
2937 return SWIG_OK;
2938 }
2939 return SWIG_TypeError;
2940 }
2941
2942
2943 SWIGINTERN int
2944 SWIG_AsVal_int (PyObject * obj, int *val)
2945 {
2946 long v;
2947 int res = SWIG_AsVal_long (obj, &v);
2948 if (SWIG_IsOK(res)) {
2949 if ((v < INT_MIN || v > INT_MAX)) {
2950 return SWIG_OverflowError;
2951 } else {
2952 if (val) *val = static_cast< int >(v);
2953 }
2954 }
2955 return res;
2956 }
2957
2958 SWIGINTERN bool wxSize___eq__(wxSize *self,PyObject *other){
2959 wxSize temp, *obj = &temp;
2960 if ( other == Py_None ) return false;
2961 if ( ! wxSize_helper(other, &obj) ) {
2962 PyErr_Clear();
2963 return false;
2964 }
2965 return self->operator==(*obj);
2966 }
2967 SWIGINTERN bool wxSize___ne__(wxSize *self,PyObject *other){
2968 wxSize temp, *obj = &temp;
2969 if ( other == Py_None ) return true;
2970 if ( ! wxSize_helper(other, &obj)) {
2971 PyErr_Clear();
2972 return true;
2973 }
2974 return self->operator!=(*obj);
2975 }
2976 SWIGINTERN PyObject *wxSize_Get(wxSize *self){
2977 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2978 PyObject* tup = PyTuple_New(2);
2979 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
2980 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
2981 wxPyEndBlockThreads(blocked);
2982 return tup;
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 #define SWIG_From_double PyFloat_FromDouble
2997
2998 SWIGINTERN bool wxRealPoint___eq__(wxRealPoint *self,PyObject *other){
2999 wxRealPoint temp, *obj = &temp;
3000 if ( other == Py_None ) return false;
3001 if ( ! wxRealPoint_helper(other, &obj) ) {
3002 PyErr_Clear();
3003 return false;
3004 }
3005 return self->operator==(*obj);
3006 }
3007 SWIGINTERN bool wxRealPoint___ne__(wxRealPoint *self,PyObject *other){
3008 wxRealPoint temp, *obj = &temp;
3009 if ( other == Py_None ) return true;
3010 if ( ! wxRealPoint_helper(other, &obj)) {
3011 PyErr_Clear();
3012 return true;
3013 }
3014 return self->operator!=(*obj);
3015 }
3016 SWIGINTERN void wxRealPoint_Set(wxRealPoint *self,double x,double y){
3017 self->x = x;
3018 self->y = y;
3019 }
3020 SWIGINTERN PyObject *wxRealPoint_Get(wxRealPoint *self){
3021 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3022 PyObject* tup = PyTuple_New(2);
3023 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
3024 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
3025 wxPyEndBlockThreads(blocked);
3026 return tup;
3027 }
3028 SWIGINTERN bool wxPoint___eq__(wxPoint *self,PyObject *other){
3029 wxPoint temp, *obj = &temp;
3030 if ( other == Py_None ) return false;
3031 if ( ! wxPoint_helper(other, &obj) ) {
3032 PyErr_Clear();
3033 return false;
3034 }
3035 return self->operator==(*obj);
3036 }
3037 SWIGINTERN bool wxPoint___ne__(wxPoint *self,PyObject *other){
3038 wxPoint temp, *obj = &temp;
3039 if ( other == Py_None ) return true;
3040 if ( ! wxPoint_helper(other, &obj)) {
3041 PyErr_Clear();
3042 return true;
3043 }
3044 return self->operator!=(*obj);
3045 }
3046 SWIGINTERN void wxPoint_Set(wxPoint *self,long x,long y){
3047 self->x = x;
3048 self->y = y;
3049 }
3050 SWIGINTERN PyObject *wxPoint_Get(wxPoint *self){
3051 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3052 PyObject* tup = PyTuple_New(2);
3053 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3054 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3055 wxPyEndBlockThreads(blocked);
3056 return tup;
3057 }
3058 SWIGINTERN bool wxRect___eq__(wxRect *self,PyObject *other){
3059 wxRect temp, *obj = &temp;
3060 if ( other == Py_None ) return false;
3061 if ( ! wxRect_helper(other, &obj) ) {
3062 PyErr_Clear();
3063 return false;
3064 }
3065 return self->operator==(*obj);
3066 }
3067 SWIGINTERN bool wxRect___ne__(wxRect *self,PyObject *other){
3068 wxRect temp, *obj = &temp;
3069 if ( other == Py_None ) return true;
3070 if ( ! wxRect_helper(other, &obj)) {
3071 PyErr_Clear();
3072 return true;
3073 }
3074 return self->operator!=(*obj);
3075 }
3076 SWIGINTERN void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
3077 self->x = x;
3078 self->y = y;
3079 self->width = width;
3080 self->height = height;
3081 }
3082 SWIGINTERN PyObject *wxRect_Get(wxRect *self){
3083 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3084 PyObject* tup = PyTuple_New(4);
3085 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3086 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3087 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
3088 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
3089 wxPyEndBlockThreads(blocked);
3090 return tup;
3091 }
3092
3093 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
3094 wxRegion reg1(*r1);
3095 wxRegion reg2(*r2);
3096 wxRect dest(0,0,0,0);
3097 PyObject* obj;
3098
3099 reg1.Intersect(reg2);
3100 dest = reg1.GetBox();
3101
3102 if (dest != wxRect(0,0,0,0)) {
3103 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3104 wxRect* newRect = new wxRect(dest);
3105 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
3106 wxPyEndBlockThreads(blocked);
3107 return obj;
3108 }
3109 Py_INCREF(Py_None);
3110 return Py_None;
3111 }
3112
3113 SWIGINTERN bool wxPoint2D___eq__(wxPoint2D *self,PyObject *other){
3114 wxPoint2D temp, *obj = &temp;
3115 if ( other == Py_None ) return false;
3116 if ( ! wxPoint2D_helper(other, &obj) ) {
3117 PyErr_Clear();
3118 return false;
3119 }
3120 return self->operator==(*obj);
3121 }
3122 SWIGINTERN bool wxPoint2D___ne__(wxPoint2D *self,PyObject *other){
3123 wxPoint2D temp, *obj = &temp;
3124 if ( other == Py_None ) return true;
3125 if ( ! wxPoint2D_helper(other, &obj)) {
3126 PyErr_Clear();
3127 return true;
3128 }
3129 return self->operator!=(*obj);
3130 }
3131 SWIGINTERN void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
3132 self->m_x = x;
3133 self->m_y = y;
3134 }
3135 SWIGINTERN PyObject *wxPoint2D_Get(wxPoint2D *self){
3136 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3137 PyObject* tup = PyTuple_New(2);
3138 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
3139 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
3140 wxPyEndBlockThreads(blocked);
3141 return tup;
3142 }
3143
3144 #include "wx/wxPython/pyistream.h"
3145
3146 SWIGINTERN wxPyInputStream *new_wxPyInputStream(PyObject *p){
3147 wxInputStream* wxis = wxPyCBInputStream::create(p);
3148 if (wxis)
3149 return new wxPyInputStream(wxis);
3150 else
3151 return NULL;
3152 }
3153
3154 SWIGINTERN swig_type_info*
3155 SWIG_pchar_descriptor()
3156 {
3157 static int init = 0;
3158 static swig_type_info* info = 0;
3159 if (!init) {
3160 info = SWIG_TypeQuery("_p_char");
3161 init = 1;
3162 }
3163 return info;
3164 }
3165
3166
3167 SWIGINTERNINLINE PyObject *
3168 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3169 {
3170 if (carray) {
3171 if (size > INT_MAX) {
3172 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3173 return pchar_descriptor ?
3174 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3175 } else {
3176 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3177 }
3178 } else {
3179 return SWIG_Py_Void();
3180 }
3181 }
3182
3183
3184 SWIGINTERNINLINE PyObject *
3185 SWIG_From_char (char c)
3186 {
3187 return SWIG_FromCharPtrAndSize(&c,1);
3188 }
3189
3190
3191 SWIGINTERNINLINE PyObject*
3192 SWIG_From_unsigned_SS_long (unsigned long value)
3193 {
3194 return (value > LONG_MAX) ?
3195 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
3196 }
3197
3198
3199 SWIGINTERNINLINE PyObject *
3200 SWIG_From_size_t (size_t value)
3201 {
3202 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
3203 }
3204
3205
3206 SWIGINTERN int
3207 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
3208 {
3209 if (PyString_Check(obj)) {
3210 char *cstr; int len;
3211 PyString_AsStringAndSize(obj, &cstr, &len);
3212 if (cptr) {
3213 if (alloc) {
3214 /*
3215 In python the user should not be able to modify the inner
3216 string representation. To warranty that, if you define
3217 SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
3218 buffer is always returned.
3219
3220 The default behavior is just to return the pointer value,
3221 so, be careful.
3222 */
3223 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
3224 if (*alloc != SWIG_OLDOBJ)
3225 #else
3226 if (*alloc == SWIG_NEWOBJ)
3227 #endif
3228 {
3229 *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
3230 *alloc = SWIG_NEWOBJ;
3231 }
3232 else {
3233 *cptr = cstr;
3234 *alloc = SWIG_OLDOBJ;
3235 }
3236 } else {
3237 *cptr = PyString_AsString(obj);
3238 }
3239 }
3240 if (psize) *psize = len + 1;
3241 return SWIG_OK;
3242 } else {
3243 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3244 if (pchar_descriptor) {
3245 void* vptr = 0;
3246 if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3247 if (cptr) *cptr = (char *) vptr;
3248 if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3249 if (alloc) *alloc = SWIG_OLDOBJ;
3250 return SWIG_OK;
3251 }
3252 }
3253 }
3254 return SWIG_TypeError;
3255 }
3256
3257
3258 SWIGINTERN int
3259 SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
3260 {
3261 char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3262 int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3263 if (SWIG_IsOK(res)) {
3264 if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
3265 if (csize <= size) {
3266 if (val) {
3267 if (csize) memcpy(val, cptr, csize*sizeof(char));
3268 if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3269 }
3270 if (alloc == SWIG_NEWOBJ) {
3271 delete[] cptr;
3272 res = SWIG_DelNewMask(res);
3273 }
3274 return res;
3275 }
3276 if (alloc == SWIG_NEWOBJ) delete[] cptr;
3277 }
3278 return SWIG_TypeError;
3279 }
3280
3281
3282 SWIGINTERN int
3283 SWIG_AsVal_char (PyObject * obj, char *val)
3284 {
3285 int res = SWIG_AsCharArray(obj, val, 1);
3286 if (!SWIG_IsOK(res)) {
3287 long v;
3288 res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3289 if (SWIG_IsOK(res)) {
3290 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3291 if (val) *val = static_cast< char >(v);
3292 } else {
3293 res = SWIG_OverflowError;
3294 }
3295 }
3296 }
3297 return res;
3298 }
3299
3300 SWIGINTERN void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
3301 // We use only strings for the streams, not unicode
3302 PyObject* str = PyObject_Str(obj);
3303 if (! str) {
3304 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
3305 return;
3306 }
3307 self->Write(PyString_AS_STRING(str),
3308 PyString_GET_SIZE(str));
3309 Py_DECREF(str);
3310 }
3311
3312 #include "wx/wxPython/pyistream.h"
3313
3314
3315 class wxPyFileSystemHandler : public wxFileSystemHandler
3316 {
3317 public:
3318 wxPyFileSystemHandler() : wxFileSystemHandler() {}
3319
3320 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
3321 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
3322 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
3323 DEC_PYCALLBACK_STRING__pure(FindNext);
3324
3325 wxString GetProtocol(const wxString& location) {
3326 return wxFileSystemHandler::GetProtocol(location);
3327 }
3328
3329 wxString GetLeftLocation(const wxString& location) {
3330 return wxFileSystemHandler::GetLeftLocation(location);
3331 }
3332
3333 wxString GetAnchor(const wxString& location) {
3334 return wxFileSystemHandler::GetAnchor(location);
3335 }
3336
3337 wxString GetRightLocation(const wxString& location) {
3338 return wxFileSystemHandler::GetRightLocation(location);
3339 }
3340
3341 wxString GetMimeTypeFromExt(const wxString& location) {
3342 return wxFileSystemHandler::GetMimeTypeFromExt(location);
3343 }
3344
3345 PYPRIVATE;
3346 };
3347
3348
3349 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
3350 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
3351 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
3352 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
3353
3354
3355 SWIGINTERN int
3356 SWIG_AsVal_bool (PyObject *obj, bool *val)
3357 {
3358 if (obj == Py_True) {
3359 if (val) *val = true;
3360 return SWIG_OK;
3361 } else if (obj == Py_False) {
3362 if (val) *val = false;
3363 return SWIG_OK;
3364 } else {
3365 long v = 0;
3366 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
3367 if (SWIG_IsOK(res) && val) *val = v ? true : false;
3368 return res;
3369 }
3370 }
3371
3372 SWIGINTERN wxString wxFileSystem_URLToFileName(wxString const &url){
3373 wxFileName fname = wxFileSystem::URLToFileName(url);
3374 return fname.GetFullPath();
3375 }
3376
3377 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
3378 wxImage& image,
3379 long type) {
3380 wxMemoryFSHandler::AddFile(filename, image, type);
3381 }
3382
3383 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
3384 const wxBitmap& bitmap,
3385 long type) {
3386 wxMemoryFSHandler::AddFile(filename, bitmap, type);
3387 }
3388
3389 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
3390 PyObject* data) {
3391 if (! PyString_Check(data)) {
3392 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
3393 "Expected string object"));
3394 return;
3395 }
3396
3397 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3398 void* ptr = (void*)PyString_AsString(data);
3399 size_t size = PyString_Size(data);
3400 wxPyEndBlockThreads(blocked);
3401
3402 wxMemoryFSHandler::AddFile(filename, ptr, size);
3403 }
3404
3405
3406 #include "wx/wxPython/pyistream.h"
3407
3408
3409 SWIGINTERN int
3410 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
3411 {
3412 long v = 0;
3413 if (SWIG_AsVal_long(obj, &v) && v < 0) {
3414 return SWIG_TypeError;
3415 }
3416 else if (val)
3417 *val = (unsigned long)v;
3418 return SWIG_OK;
3419 }
3420
3421
3422 SWIGINTERN int
3423 SWIG_AsVal_unsigned_SS_char (PyObject * obj, unsigned char *val)
3424 {
3425 unsigned long v;
3426 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3427 if (SWIG_IsOK(res)) {
3428 if ((v > UCHAR_MAX)) {
3429 return SWIG_OverflowError;
3430 } else {
3431 if (val) *val = static_cast< unsigned char >(v);
3432 }
3433 }
3434 return res;
3435 }
3436
3437
3438 SWIGINTERNINLINE PyObject *
3439 SWIG_From_unsigned_SS_char (unsigned char value)
3440 {
3441 return SWIG_From_unsigned_SS_long (value);
3442 }
3443
3444 SWIGINTERN unsigned long wxImageHistogram_GetCount(wxImageHistogram *self,unsigned long key){
3445 wxImageHistogramEntry e = (*self)[key];
3446 return e.value;
3447 }
3448 SWIGINTERN unsigned long wxImageHistogram_GetCountRGB(wxImageHistogram *self,byte r,byte g,byte b){
3449 unsigned long key = wxImageHistogram::MakeKey(r, g, b);
3450 wxImageHistogramEntry e = (*self)[key];
3451 return e.value;
3452 }
3453 SWIGINTERN unsigned long wxImageHistogram_GetCountColour(wxImageHistogram *self,wxColour const &colour){
3454 unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
3455 colour.Green(),
3456 colour.Blue());
3457 wxImageHistogramEntry e = (*self)[key];
3458 return e.value;
3459 }
3460
3461 typedef unsigned char* buffer;
3462
3463
3464 // Pull the nested class out to the top level for SWIG's sake
3465 #define wxImage_RGBValue wxImage::RGBValue
3466 #define wxImage_HSVValue wxImage::HSVValue
3467
3468 SWIGINTERN wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
3469 if (width > 0 && height > 0)
3470 return new wxImage(width, height, clear);
3471 else
3472 return new wxImage;
3473 }
3474 SWIGINTERN wxImage *new_wxImage(wxBitmap const &bitmap){
3475 return new wxImage(bitmap.ConvertToImage());
3476 }
3477 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE){
3478 if (DATASIZE != width*height*3) {
3479 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3480 return NULL;
3481 }
3482
3483 // Copy the source data so the wxImage can clean it up later
3484 buffer copy = (buffer)malloc(DATASIZE);
3485 if (copy == NULL) {
3486 wxPyBLOCK_THREADS(PyErr_NoMemory());
3487 return NULL;
3488 }
3489 memcpy(copy, data, DATASIZE);
3490 return new wxImage(width, height, copy, false);
3491 }
3492 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE,buffer alpha,int ALPHASIZE){
3493 if (DATASIZE != width*height*3) {
3494 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3495 return NULL;
3496 }
3497 if (ALPHASIZE != width*height) {
3498 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3499 return NULL;
3500 }
3501
3502 // Copy the source data so the wxImage can clean it up later
3503 buffer dcopy = (buffer)malloc(DATASIZE);
3504 if (dcopy == NULL) {
3505 wxPyBLOCK_THREADS(PyErr_NoMemory());
3506 return NULL;
3507 }
3508 memcpy(dcopy, data, DATASIZE);
3509
3510 buffer acopy = (buffer)malloc(ALPHASIZE);
3511 if (acopy == NULL) {
3512 wxPyBLOCK_THREADS(PyErr_NoMemory());
3513 return NULL;
3514 }
3515 memcpy(acopy, alpha, ALPHASIZE);
3516
3517 return new wxImage(width, height, dcopy, acopy, false);
3518 }
3519 SWIGINTERN wxSize wxImage_GetSize(wxImage *self){
3520 wxSize size(self->GetWidth(), self->GetHeight());
3521 return size;
3522 }
3523 SWIGINTERN PyObject *wxImage_GetData(wxImage *self){
3524 buffer data = self->GetData();
3525 int len = self->GetWidth() * self->GetHeight() * 3;
3526 PyObject* rv;
3527 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
3528 return rv;
3529 }
3530 SWIGINTERN void wxImage_SetData(wxImage *self,buffer data,int DATASIZE){
3531 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3532 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3533 return;
3534 }
3535 buffer copy = (buffer)malloc(DATASIZE);
3536 if (copy == NULL) {
3537 wxPyBLOCK_THREADS(PyErr_NoMemory());
3538 return;
3539 }
3540 memcpy(copy, data, DATASIZE);
3541 self->SetData(copy, false);
3542 // wxImage takes ownership of copy...
3543 }
3544 SWIGINTERN PyObject *wxImage_GetDataBuffer(wxImage *self){
3545 buffer data = self->GetData();
3546 int len = self->GetWidth() * self->GetHeight() * 3;
3547 PyObject* rv;
3548 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3549 return rv;
3550 }
3551 SWIGINTERN void wxImage_SetDataBuffer(wxImage *self,buffer data,int DATASIZE){
3552 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3553 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3554 return;
3555 }
3556 self->SetData(data, true);
3557 }
3558 SWIGINTERN PyObject *wxImage_GetAlphaData(wxImage *self){
3559 buffer data = self->GetAlpha();
3560 if (! data) {
3561 RETURN_NONE();
3562 } else {
3563 int len = self->GetWidth() * self->GetHeight();
3564 PyObject* rv;
3565 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
3566 return rv;
3567 }
3568 }
3569 SWIGINTERN void wxImage_SetAlphaData(wxImage *self,buffer alpha,int ALPHASIZE){
3570 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3571 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3572 return;
3573 }
3574 buffer acopy = (buffer)malloc(ALPHASIZE);
3575 if (acopy == NULL) {
3576 wxPyBLOCK_THREADS(PyErr_NoMemory());
3577 return;
3578 }
3579 memcpy(acopy, alpha, ALPHASIZE);
3580 self->SetAlpha(acopy, false);
3581 // wxImage takes ownership of acopy...
3582 }
3583 SWIGINTERN PyObject *wxImage_GetAlphaBuffer(wxImage *self){
3584 buffer data = self->GetAlpha();
3585 int len = self->GetWidth() * self->GetHeight();
3586 PyObject* rv;
3587 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3588 return rv;
3589 }
3590 SWIGINTERN void wxImage_SetAlphaBuffer(wxImage *self,buffer alpha,int ALPHASIZE){
3591 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3592 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3593 return;
3594 }
3595 self->SetAlpha(alpha, true);
3596 }
3597 SWIGINTERN PyObject *wxImage_GetHandlers(){
3598 wxList& list = wxImage::GetHandlers();
3599 return wxPy_ConvertList(&list);
3600 }
3601 SWIGINTERN wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
3602 wxBitmap bitmap(*self, depth);
3603 return bitmap;
3604 }
3605 SWIGINTERN wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,byte red,byte green,byte blue){
3606 wxImage mono = self->ConvertToMono( red, green, blue );
3607 wxBitmap bitmap( mono, 1 );
3608 return bitmap;
3609 }
3610 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
3611 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
3612 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
3613 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
3614 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
3615 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
3616 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
3617 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
3618 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
3619 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
3620 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
3621 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
3622 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
3623 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
3624 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
3625
3626 #include <wx/quantize.h>
3627
3628 SWIGINTERN bool wxQuantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
3629 return wxQuantize::Quantize(src, dest,
3630 //NULL, // palette
3631 desiredNoColours,
3632 NULL, // eightBitData
3633 flags);
3634 }
3635 SWIGINTERN void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
3636 if (PyCallable_Check(func)) {
3637 self->Connect(id, lastId, eventType,
3638 (wxObjectEventFunction) &wxPyCallback::EventThunker,
3639 new wxPyCallback(func));
3640 }
3641 else if (func == Py_None) {
3642 self->Disconnect(id, lastId, eventType,
3643 (wxObjectEventFunction)
3644 &wxPyCallback::EventThunker);
3645 }
3646 else {
3647 wxPyBLOCK_THREADS(
3648 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
3649 }
3650 }
3651 SWIGINTERN bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
3652 return self->Disconnect(id, lastId, eventType,
3653 (wxObjectEventFunction)
3654 &wxPyCallback::EventThunker);
3655 }
3656 SWIGINTERN void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
3657 if (_self && _self != Py_None) {
3658 self->SetClientObject(new wxPyOORClientData(_self, incref));
3659 }
3660 else {
3661 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
3662 if (data) {
3663 self->SetClientObject(NULL); // This will delete it too
3664 }
3665 }
3666 }
3667
3668 #if ! wxUSE_HOTKEY
3669 #define wxEVT_HOTKEY -9999
3670 #endif
3671
3672 SWIGINTERN PyObject *wxCommandEvent_GetClientData(wxCommandEvent *self){
3673 wxPyClientData* data = (wxPyClientData*)self->GetClientObject();
3674 if (data) {
3675 Py_INCREF(data->m_obj);
3676 return data->m_obj;
3677 } else {
3678 Py_INCREF(Py_None);
3679 return Py_None;
3680 }
3681 }
3682 SWIGINTERN void wxCommandEvent_SetClientData(wxCommandEvent *self,PyObject *clientData){
3683 wxPyClientData* data = new wxPyClientData(clientData);
3684 self->SetClientObject(data);
3685 }
3686 SWIGINTERN int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
3687 #if wxUSE_UNICODE
3688 return self->GetUnicodeKey();
3689 #else
3690 return 0;
3691 #endif
3692 }
3693
3694 SWIGINTERNINLINE PyObject *
3695 SWIG_From_unsigned_SS_int (unsigned int value)
3696 {
3697 return SWIG_From_unsigned_SS_long (value);
3698 }
3699
3700
3701 SWIGINTERN int
3702 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3703 {
3704 unsigned long v;
3705 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3706 if (SWIG_IsOK(res)) {
3707 if ((v > UINT_MAX)) {
3708 return SWIG_OverflowError;
3709 } else {
3710 if (val) *val = static_cast< unsigned int >(v);
3711 }
3712 }
3713 return res;
3714 }
3715
3716 SWIGINTERN void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
3717 self->m_size = size;
3718 }
3719 SWIGINTERN PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
3720 int count = self->GetNumberOfFiles();
3721 wxString* files = self->GetFiles();
3722 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3723 PyObject* list = PyList_New(count);
3724
3725 if (!list) {
3726 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
3727 wxPyEndBlockThreads(blocked);
3728 return NULL;
3729 }
3730
3731 for (int i=0; i<count; i++) {
3732 PyList_SetItem(list, i, wx2PyString(files[i]));
3733 }
3734 wxPyEndBlockThreads(blocked);
3735 return list;
3736 }
3737
3738
3739 SWIGINTERN wxPyApp *new_wxPyApp(){
3740 wxPythonApp = new wxPyApp();
3741 return wxPythonApp;
3742 }
3743
3744 void wxApp_CleanUp() {
3745 __wxPyCleanup();
3746 }
3747
3748
3749 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
3750
3751
3752
3753
3754
3755 SWIGINTERNINLINE PyObject *
3756 SWIG_FromCharPtr(const char *cptr)
3757 {
3758 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3759 }
3760
3761
3762 #if 0 // #ifdef __WXMAC__
3763
3764 // A dummy class that raises an exception if used...
3765 class wxEventLoop
3766 {
3767 public:
3768 wxEventLoop() { wxPyRaiseNotImplemented(); }
3769 int Run() { return 0; }
3770 void Exit(int rc = 0) {}
3771 bool Pending() const { return false; }
3772 bool Dispatch() { return false; }
3773 bool IsRunning() const { return false; }
3774 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
3775 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
3776 };
3777
3778 #else
3779
3780 #include <wx/evtloop.h>
3781
3782 #endif
3783
3784
3785
3786 static const wxString wxPyPanelNameStr(wxPanelNameStr);
3787 SWIGINTERN wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
3788 SWIGINTERN void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
3789 SWIGINTERN PyObject *wxWindow_GetChildren(wxWindow *self){
3790 wxWindowList& list = self->GetChildren();
3791 return wxPy_ConvertList(&list);
3792 }
3793 SWIGINTERN bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
3794 #if wxUSE_HOTKEY
3795 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
3796 #else
3797 return false;
3798 #endif
3799 }
3800 SWIGINTERN bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
3801
3802
3803
3804 return false;
3805
3806 }
3807 SWIGINTERN long wxWindow_GetHandle(wxWindow *self){
3808 return wxPyGetWinHandle(self);
3809 }
3810 SWIGINTERN void wxWindow_AssociateHandle(wxWindow *self,long handle){
3811 self->AssociateHandle((WXWidget)handle);
3812 }
3813
3814 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
3815 return wxWindow::FindWindowById(id, parent);
3816 }
3817
3818 wxWindow* wxFindWindowByName( const wxString& name,
3819 const wxWindow *parent = NULL ) {
3820 return wxWindow::FindWindowByName(name, parent);
3821 }
3822
3823 wxWindow* wxFindWindowByLabel( const wxString& label,
3824 const wxWindow *parent = NULL ) {
3825 return wxWindow::FindWindowByLabel(label, parent);
3826 }
3827
3828
3829 #ifdef __WXMSW__
3830 #include <wx/msw/private.h> // to get wxGetWindowId
3831 #endif
3832
3833
3834 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
3835 #ifdef __WXMSW__
3836 WXHWND hWnd = (WXHWND)_hWnd;
3837 long id = wxGetWindowId(hWnd);
3838 wxWindow* win = new wxWindow;
3839 if (parent)
3840 parent->AddChild(win);
3841 win->SetEventHandler(win);
3842 win->SetHWND(hWnd);
3843 win->SetId(id);
3844 win->SubclassWin(hWnd);
3845 win->AdoptAttributesFromHWND();
3846 win->SetupColours();
3847 return win;
3848 #else
3849 wxPyRaiseNotImplemented();
3850 return NULL;
3851 #endif
3852 }
3853
3854
3855 PyObject* GetTopLevelWindows() {
3856 return wxPy_ConvertList(&wxTopLevelWindows);
3857 }
3858
3859
3860 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
3861 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
3862 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
3863
3864 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
3865
3866
3867 SWIGINTERNINLINE int
3868 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3869 {
3870 unsigned long v;
3871 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3872 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3873 return res;
3874 }
3875
3876 SWIGINTERN void wxMenu_Destroy(wxMenu *self){ delete self; }
3877 SWIGINTERN PyObject *wxMenu_GetMenuItems(wxMenu *self){
3878 wxMenuItemList& list = self->GetMenuItems();
3879 return wxPy_ConvertList(&list);
3880 }
3881 SWIGINTERN void wxMenuBar_SetAutoWindowMenu(bool enable){}
3882 SWIGINTERN bool wxMenuBar_GetAutoWindowMenu(){ return false; }
3883 static const wxString wxPyControlNameStr(wxControlNameStr);
3884 SWIGINTERN int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
3885 if (clientData) {
3886 wxPyClientData* data = new wxPyClientData(clientData);
3887 return self->Append(item, data);
3888 } else
3889 return self->Append(item);
3890 }
3891 SWIGINTERN int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,unsigned int pos,PyObject *clientData=NULL){
3892 if (clientData) {
3893 wxPyClientData* data = new wxPyClientData(clientData);
3894 return self->Insert(item, pos, data);
3895 } else
3896 return self->Insert(item, pos);
3897 }
3898 SWIGINTERN PyObject *wxItemContainer_GetClientData(wxItemContainer *self,unsigned int n){
3899 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
3900 if (data) {
3901 Py_INCREF(data->m_obj);
3902 return data->m_obj;
3903 } else {
3904 Py_INCREF(Py_None);
3905 return Py_None;
3906 }
3907 }
3908 SWIGINTERN void wxItemContainer_SetClientData(wxItemContainer *self,unsigned int n,PyObject *clientData){
3909 wxPyClientData* data = new wxPyClientData(clientData);
3910 self->SetClientObject(n, data);
3911 }
3912
3913
3914 SWIGINTERN wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
3915 wxPyUserData* data = NULL;
3916 if ( userData ) {
3917 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3918 data = new wxPyUserData(userData);
3919 wxPyEndBlockThreads(blocked);
3920 }
3921 return new wxSizerItem(window, proportion, flag, border, data);
3922 }
3923 SWIGINTERN wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
3924 wxPyUserData* data = NULL;
3925 if ( userData ) {
3926 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3927 data = new wxPyUserData(userData);
3928 wxPyEndBlockThreads(blocked);
3929 }
3930 return new wxSizerItem(width, height, proportion, flag, border, data);
3931 }
3932 SWIGINTERN wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
3933 wxPyUserData* data = NULL;
3934 if ( userData ) {
3935 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3936 data = new wxPyUserData(userData);
3937 wxPyEndBlockThreads(blocked);
3938 }
3939 return new wxSizerItem(sizer, proportion, flag, border, data);
3940 }
3941
3942 #include <float.h>
3943
3944
3945 SWIGINTERN int
3946 SWIG_AsVal_float (PyObject * obj, float *val)
3947 {
3948 double v;
3949 int res = SWIG_AsVal_double (obj, &v);
3950 if (SWIG_IsOK(res)) {
3951 if ((v < -FLT_MAX || v > FLT_MAX)) {
3952 return SWIG_OverflowError;
3953 } else {
3954 if (val) *val = static_cast< float >(v);
3955 }
3956 }
3957 return res;
3958 }
3959
3960
3961 SWIGINTERNINLINE PyObject *
3962 SWIG_From_float (float value)
3963 {
3964 return SWIG_From_double (value);
3965 }
3966
3967 SWIGINTERN PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
3968 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
3969 if (data) {
3970 Py_INCREF(data->m_obj);
3971 return data->m_obj;
3972 } else {
3973 Py_INCREF(Py_None);
3974 return Py_None;
3975 }
3976 }
3977 SWIGINTERN void wxSizerItem_SetUserData(wxSizerItem *self,PyObject *userData){
3978 wxPyUserData* data = NULL;
3979 if ( userData ) {
3980 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3981 data = new wxPyUserData(userData);
3982 wxPyEndBlockThreads(blocked);
3983 }
3984 self->SetUserData(data);
3985 }
3986
3987 // Figure out the type of the sizer item
3988
3989 struct wxPySizerItemInfo {
3990 wxPySizerItemInfo()
3991 : window(NULL), sizer(NULL), gotSize(false),
3992 size(wxDefaultSize), gotPos(false), pos(-1)
3993 {}
3994
3995 wxWindow* window;
3996 wxSizer* sizer;
3997 bool gotSize;
3998 wxSize size;
3999 bool gotPos;
4000 int pos;
4001 };
4002
4003 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
4004
4005 wxPySizerItemInfo info;
4006 wxSize size;
4007 wxSize* sizePtr = &size;
4008
4009 // Find out what the type of the item is
4010 // try wxWindow
4011 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
4012 PyErr_Clear();
4013 info.window = NULL;
4014
4015 // try wxSizer
4016 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
4017 PyErr_Clear();
4018 info.sizer = NULL;
4019
4020 // try wxSize or (w,h)
4021 if ( checkSize && wxSize_helper(item, &sizePtr)) {
4022 info.size = *sizePtr;
4023 info.gotSize = true;
4024 }
4025
4026 // or a single int
4027 if (checkIdx && PyInt_Check(item)) {
4028 info.pos = PyInt_AsLong(item);
4029 info.gotPos = true;
4030 }
4031 }
4032 }
4033
4034 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
4035 // no expected type, figure out what kind of error message to generate
4036 if ( !checkSize && !checkIdx )
4037 PyErr_SetString(PyExc_TypeError, "wx.Window or wx.Sizer expected for item");
4038 else if ( checkSize && !checkIdx )
4039 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) expected for item");
4040 else if ( !checkSize && checkIdx)
4041 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer or int (position) expected for item");
4042 else
4043 // can this one happen?
4044 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) or int (position) expected for item");
4045 }
4046
4047 return info;
4048 }
4049
4050 SWIGINTERN void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
4051 if (!self->GetClientObject())
4052 self->SetClientObject(new wxPyOORClientData(_self));
4053 }
4054 SWIGINTERN wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4055
4056 wxPyUserData* data = NULL;
4057 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4058 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4059 if ( userData && (info.window || info.sizer || info.gotSize) )
4060 data = new wxPyUserData(userData);
4061 if ( info.sizer )
4062 PyObject_SetAttrString(item,"thisown",Py_False);
4063 wxPyEndBlockThreads(blocked);
4064
4065 // Now call the real Add method if a valid item type was found
4066 if ( info.window )
4067 return self->Add(info.window, proportion, flag, border, data);
4068 else if ( info.sizer )
4069 return self->Add(info.sizer, proportion, flag, border, data);
4070 else if (info.gotSize)
4071 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
4072 proportion, flag, border, data);
4073 else
4074 return NULL;
4075 }
4076 SWIGINTERN wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4077
4078 wxPyUserData* data = NULL;
4079 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4080 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4081 if ( userData && (info.window || info.sizer || info.gotSize) )
4082 data = new wxPyUserData(userData);
4083 if ( info.sizer )
4084 PyObject_SetAttrString(item,"thisown",Py_False);
4085 wxPyEndBlockThreads(blocked);
4086
4087 // Now call the real Insert method if a valid item type was found
4088 if ( info.window )
4089 return self->Insert(before, info.window, proportion, flag, border, data);
4090 else if ( info.sizer )
4091 return self->Insert(before, info.sizer, proportion, flag, border, data);
4092 else if (info.gotSize)
4093 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
4094 proportion, flag, border, data);
4095 else
4096 return NULL;
4097 }
4098 SWIGINTERN wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4099
4100 wxPyUserData* data = NULL;
4101 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4102 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4103 if ( userData && (info.window || info.sizer || info.gotSize) )
4104 data = new wxPyUserData(userData);
4105 if ( info.sizer )
4106 PyObject_SetAttrString(item,"thisown",Py_False);
4107 wxPyEndBlockThreads(blocked);
4108
4109 // Now call the real Prepend method if a valid item type was found
4110 if ( info.window )
4111 return self->Prepend(info.window, proportion, flag, border, data);
4112 else if ( info.sizer )
4113 return self->Prepend(info.sizer, proportion, flag, border, data);
4114 else if (info.gotSize)
4115 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
4116 proportion, flag, border, data);
4117 else
4118 return NULL;
4119 }
4120 SWIGINTERN bool wxSizer_Remove(wxSizer *self,PyObject *item){
4121 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4122 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4123 wxPyEndBlockThreads(blocked);
4124 if ( info.window )
4125 return self->Remove(info.window);
4126 else if ( info.sizer )
4127 return self->Remove(info.sizer);
4128 else if ( info.gotPos )
4129 return self->Remove(info.pos);
4130 else
4131 return false;
4132 }
4133 SWIGINTERN bool wxSizer_Detach(wxSizer *self,PyObject *item){
4134 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4135 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4136 wxPyEndBlockThreads(blocked);
4137 if ( info.window )
4138 return self->Detach(info.window);
4139 else if ( info.sizer )
4140 return self->Detach(info.sizer);
4141 else if ( info.gotPos )
4142 return self->Detach(info.pos);
4143 else
4144 return false;
4145 }
4146 SWIGINTERN wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
4147 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4148 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4149 wxPyEndBlockThreads(blocked);
4150 if ( info.window )
4151 return self->GetItem(info.window);
4152 else if ( info.sizer )
4153 return self->GetItem(info.sizer);
4154 else if ( info.gotPos )
4155 return self->GetItem(info.pos);
4156 else
4157 return NULL;
4158 }
4159 SWIGINTERN void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
4160 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4161 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4162 wxPyEndBlockThreads(blocked);
4163 if ( info.window )
4164 self->SetItemMinSize(info.window, size);
4165 else if ( info.sizer )
4166 self->SetItemMinSize(info.sizer, size);
4167 else if ( info.gotPos )
4168 self->SetItemMinSize(info.pos, size);
4169 }
4170 SWIGINTERN PyObject *wxSizer_GetChildren(wxSizer *self){
4171 wxSizerItemList& list = self->GetChildren();
4172 return wxPy_ConvertList(&list);
4173 }
4174 SWIGINTERN bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
4175 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4176 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4177 wxPyEndBlockThreads(blocked);
4178 if ( info.window )
4179 return self->Show(info.window, show, recursive);
4180 else if ( info.sizer )
4181 return self->Show(info.sizer, show, recursive);
4182 else if ( info.gotPos )
4183 return self->Show(info.pos, show);
4184 else
4185 return false;
4186 }
4187 SWIGINTERN bool wxSizer_IsShown(wxSizer *self,PyObject *item){
4188 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4189 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
4190 wxPyEndBlockThreads(blocked);
4191 if ( info.window )
4192 return self->IsShown(info.window);
4193 else if ( info.sizer )
4194 return self->IsShown(info.sizer);
4195 else if ( info.gotPos )
4196 return self->IsShown(info.pos);
4197 else
4198 return false;
4199 }
4200
4201 // See pyclasses.h
4202 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
4203 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
4204 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
4205
4206
4207
4208
4209 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
4210 {
4211 if (source == Py_None) {
4212 **obj = wxGBPosition(-1,-1);
4213 return true;
4214 }
4215 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
4216 }
4217
4218 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
4219 {
4220 if (source == Py_None) {
4221 **obj = wxGBSpan(-1,-1);
4222 return true;
4223 }
4224 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
4225 }
4226
4227
4228 SWIGINTERN bool wxGBPosition___eq__(wxGBPosition *self,PyObject *other){
4229 wxGBPosition temp, *obj = &temp;
4230 if ( other == Py_None ) return false;
4231 if ( ! wxGBPosition_helper(other, &obj) ) {
4232 PyErr_Clear();
4233 return false;
4234 }
4235 return self->operator==(*obj);
4236 }
4237 SWIGINTERN bool wxGBPosition___ne__(wxGBPosition *self,PyObject *other){
4238 wxGBPosition temp, *obj = &temp;
4239 if ( other == Py_None ) return true;
4240 if ( ! wxGBPosition_helper(other, &obj)) {
4241 PyErr_Clear();
4242 return true;
4243 }
4244 return self->operator!=(*obj);
4245 }
4246 SWIGINTERN void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
4247 self->SetRow(row);
4248 self->SetCol(col);
4249 }
4250 SWIGINTERN PyObject *wxGBPosition_Get(wxGBPosition *self){
4251 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4252 PyObject* tup = PyTuple_New(2);
4253 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
4254 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
4255 wxPyEndBlockThreads(blocked);
4256 return tup;
4257 }
4258 SWIGINTERN bool wxGBSpan___eq__(wxGBSpan *self,PyObject *other){
4259 wxGBSpan temp, *obj = &temp;
4260 if ( other == Py_None ) return false;
4261 if ( ! wxGBSpan_helper(other, &obj) ) {
4262 PyErr_Clear();
4263 return false;
4264 }
4265 return self->operator==(*obj);
4266 }
4267 SWIGINTERN bool wxGBSpan___ne__(wxGBSpan *self,PyObject *other){
4268 wxGBSpan temp, *obj = &temp;
4269 if ( other == Py_None ) return true;
4270 if ( ! wxGBSpan_helper(other, &obj)) {
4271 PyErr_Clear();
4272 return true;
4273 }
4274 return self->operator!=(*obj);
4275 }
4276 SWIGINTERN void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
4277 self->SetRowspan(rowspan);
4278 self->SetColspan(colspan);
4279 }
4280 SWIGINTERN PyObject *wxGBSpan_Get(wxGBSpan *self){
4281 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4282 PyObject* tup = PyTuple_New(2);
4283 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
4284 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
4285 wxPyEndBlockThreads(blocked);
4286 return tup;
4287 }
4288 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4289 wxPyUserData* data = NULL;
4290 if ( userData ) {
4291 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4292 data = new wxPyUserData(userData);
4293 wxPyEndBlockThreads(blocked);
4294 }
4295 return new wxGBSizerItem(window, pos, span, flag, border, data);
4296 }
4297 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4298 wxPyUserData* data = NULL;
4299 if ( userData ) {
4300 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4301 data = new wxPyUserData(userData);
4302 wxPyEndBlockThreads(blocked);
4303 }
4304 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
4305 }
4306 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4307 wxPyUserData* data = NULL;
4308 if ( userData ) {
4309 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4310 data = new wxPyUserData(userData);
4311 wxPyEndBlockThreads(blocked);
4312 }
4313 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
4314 }
4315 SWIGINTERN wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
4316 int row, col;
4317 self->GetEndPos(row, col);
4318 return wxGBPosition(row, col);
4319 }
4320 SWIGINTERN wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
4321
4322 wxPyUserData* data = NULL;
4323 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4324 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4325 if ( userData && (info.window || info.sizer || info.gotSize) )
4326 data = new wxPyUserData(userData);
4327 if ( info.sizer )
4328 PyObject_SetAttrString(item,"thisown",Py_False);
4329 wxPyEndBlockThreads(blocked);
4330
4331 // Now call the real Add method if a valid item type was found
4332 if ( info.window )
4333 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
4334 else if ( info.sizer )
4335 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
4336 else if (info.gotSize)
4337 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
4338 pos, span, flag, border, data);
4339 return NULL;
4340 }
4341
4342
4343 #ifdef __cplusplus
4344 extern "C" {
4345 #endif
4346 SWIGINTERN int EmptyString_set(PyObject *) {
4347 SWIG_Error(SWIG_AttributeError,"Variable EmptyString is read-only.");
4348 return 1;
4349 }
4350
4351
4352 SWIGINTERN PyObject *EmptyString_get(void) {
4353 PyObject *pyobj = 0;
4354
4355 {
4356 #if wxUSE_UNICODE
4357 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4358 #else
4359 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4360 #endif
4361 }
4362 return pyobj;
4363 }
4364
4365
4366 SWIGINTERN PyObject *_wrap_Object_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4367 PyObject *resultobj = 0;
4368 wxObject *arg1 = (wxObject *) 0 ;
4369 wxString result;
4370 void *argp1 = 0 ;
4371 int res1 = 0 ;
4372 PyObject *swig_obj[1] ;
4373
4374 if (!args) SWIG_fail;
4375 swig_obj[0] = args;
4376 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4377 if (!SWIG_IsOK(res1)) {
4378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_GetClassName" "', expected argument " "1"" of type '" "wxObject *""'");
4379 }
4380 arg1 = reinterpret_cast< wxObject * >(argp1);
4381 {
4382 PyThreadState* __tstate = wxPyBeginAllowThreads();
4383 result = wxObject_GetClassName(arg1);
4384 wxPyEndAllowThreads(__tstate);
4385 if (PyErr_Occurred()) SWIG_fail;
4386 }
4387 {
4388 #if wxUSE_UNICODE
4389 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4390 #else
4391 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4392 #endif
4393 }
4394 return resultobj;
4395 fail:
4396 return NULL;
4397 }
4398
4399
4400 SWIGINTERN PyObject *_wrap_Object_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4401 PyObject *resultobj = 0;
4402 wxObject *arg1 = (wxObject *) 0 ;
4403 void *argp1 = 0 ;
4404 int res1 = 0 ;
4405 PyObject *swig_obj[1] ;
4406
4407 if (!args) SWIG_fail;
4408 swig_obj[0] = args;
4409 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4410 if (!SWIG_IsOK(res1)) {
4411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_Destroy" "', expected argument " "1"" of type '" "wxObject *""'");
4412 }
4413 arg1 = reinterpret_cast< wxObject * >(argp1);
4414 {
4415 PyThreadState* __tstate = wxPyBeginAllowThreads();
4416 wxObject_Destroy(arg1);
4417 wxPyEndAllowThreads(__tstate);
4418 if (PyErr_Occurred()) SWIG_fail;
4419 }
4420 resultobj = SWIG_Py_Void();
4421 return resultobj;
4422 fail:
4423 return NULL;
4424 }
4425
4426
4427 SWIGINTERN PyObject *Object_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4428 PyObject *obj;
4429 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4430 SWIG_TypeNewClientData(SWIGTYPE_p_wxObject, SWIG_NewClientData(obj));
4431 return SWIG_Py_Void();
4432 }
4433
4434 SWIGINTERN PyObject *_wrap_Size_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4435 PyObject *resultobj = 0;
4436 wxSize *arg1 = (wxSize *) 0 ;
4437 int arg2 ;
4438 void *argp1 = 0 ;
4439 int res1 = 0 ;
4440 int val2 ;
4441 int ecode2 = 0 ;
4442 PyObject *swig_obj[2] ;
4443
4444 if (!SWIG_Python_UnpackTuple(args,"Size_width_set",2,2,swig_obj)) SWIG_fail;
4445 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4446 if (!SWIG_IsOK(res1)) {
4447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_set" "', expected argument " "1"" of type '" "wxSize *""'");
4448 }
4449 arg1 = reinterpret_cast< wxSize * >(argp1);
4450 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4451 if (!SWIG_IsOK(ecode2)) {
4452 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_width_set" "', expected argument " "2"" of type '" "int""'");
4453 }
4454 arg2 = static_cast< int >(val2);
4455 if (arg1) (arg1)->x = arg2;
4456
4457 resultobj = SWIG_Py_Void();
4458 return resultobj;
4459 fail:
4460 return NULL;
4461 }
4462
4463
4464 SWIGINTERN PyObject *_wrap_Size_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4465 PyObject *resultobj = 0;
4466 wxSize *arg1 = (wxSize *) 0 ;
4467 int result;
4468 void *argp1 = 0 ;
4469 int res1 = 0 ;
4470 PyObject *swig_obj[1] ;
4471
4472 if (!args) SWIG_fail;
4473 swig_obj[0] = args;
4474 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4475 if (!SWIG_IsOK(res1)) {
4476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_get" "', expected argument " "1"" of type '" "wxSize *""'");
4477 }
4478 arg1 = reinterpret_cast< wxSize * >(argp1);
4479 result = (int) ((arg1)->x);
4480 resultobj = SWIG_From_int(static_cast< int >(result));
4481 return resultobj;
4482 fail:
4483 return NULL;
4484 }
4485
4486
4487 SWIGINTERN PyObject *_wrap_Size_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4488 PyObject *resultobj = 0;
4489 wxSize *arg1 = (wxSize *) 0 ;
4490 int arg2 ;
4491 void *argp1 = 0 ;
4492 int res1 = 0 ;
4493 int val2 ;
4494 int ecode2 = 0 ;
4495 PyObject *swig_obj[2] ;
4496
4497 if (!SWIG_Python_UnpackTuple(args,"Size_height_set",2,2,swig_obj)) SWIG_fail;
4498 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4499 if (!SWIG_IsOK(res1)) {
4500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_set" "', expected argument " "1"" of type '" "wxSize *""'");
4501 }
4502 arg1 = reinterpret_cast< wxSize * >(argp1);
4503 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4504 if (!SWIG_IsOK(ecode2)) {
4505 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_height_set" "', expected argument " "2"" of type '" "int""'");
4506 }
4507 arg2 = static_cast< int >(val2);
4508 if (arg1) (arg1)->y = arg2;
4509
4510 resultobj = SWIG_Py_Void();
4511 return resultobj;
4512 fail:
4513 return NULL;
4514 }
4515
4516
4517 SWIGINTERN PyObject *_wrap_Size_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4518 PyObject *resultobj = 0;
4519 wxSize *arg1 = (wxSize *) 0 ;
4520 int result;
4521 void *argp1 = 0 ;
4522 int res1 = 0 ;
4523 PyObject *swig_obj[1] ;
4524
4525 if (!args) SWIG_fail;
4526 swig_obj[0] = args;
4527 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4528 if (!SWIG_IsOK(res1)) {
4529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_get" "', expected argument " "1"" of type '" "wxSize *""'");
4530 }
4531 arg1 = reinterpret_cast< wxSize * >(argp1);
4532 result = (int) ((arg1)->y);
4533 resultobj = SWIG_From_int(static_cast< int >(result));
4534 return resultobj;
4535 fail:
4536 return NULL;
4537 }
4538
4539
4540 SWIGINTERN PyObject *_wrap_new_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4541 PyObject *resultobj = 0;
4542 int arg1 = (int) 0 ;
4543 int arg2 = (int) 0 ;
4544 wxSize *result = 0 ;
4545 int val1 ;
4546 int ecode1 = 0 ;
4547 int val2 ;
4548 int ecode2 = 0 ;
4549 PyObject * obj0 = 0 ;
4550 PyObject * obj1 = 0 ;
4551 char * kwnames[] = {
4552 (char *) "w",(char *) "h", NULL
4553 };
4554
4555 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) SWIG_fail;
4556 if (obj0) {
4557 ecode1 = SWIG_AsVal_int(obj0, &val1);
4558 if (!SWIG_IsOK(ecode1)) {
4559 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Size" "', expected argument " "1"" of type '" "int""'");
4560 }
4561 arg1 = static_cast< int >(val1);
4562 }
4563 if (obj1) {
4564 ecode2 = SWIG_AsVal_int(obj1, &val2);
4565 if (!SWIG_IsOK(ecode2)) {
4566 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Size" "', expected argument " "2"" of type '" "int""'");
4567 }
4568 arg2 = static_cast< int >(val2);
4569 }
4570 {
4571 PyThreadState* __tstate = wxPyBeginAllowThreads();
4572 result = (wxSize *)new wxSize(arg1,arg2);
4573 wxPyEndAllowThreads(__tstate);
4574 if (PyErr_Occurred()) SWIG_fail;
4575 }
4576 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, SWIG_POINTER_NEW | 0 );
4577 return resultobj;
4578 fail:
4579 return NULL;
4580 }
4581
4582
4583 SWIGINTERN PyObject *_wrap_delete_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4584 PyObject *resultobj = 0;
4585 wxSize *arg1 = (wxSize *) 0 ;
4586 void *argp1 = 0 ;
4587 int res1 = 0 ;
4588 PyObject *swig_obj[1] ;
4589
4590 if (!args) SWIG_fail;
4591 swig_obj[0] = args;
4592 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, SWIG_POINTER_DISOWN | 0 );
4593 if (!SWIG_IsOK(res1)) {
4594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Size" "', expected argument " "1"" of type '" "wxSize *""'");
4595 }
4596 arg1 = reinterpret_cast< wxSize * >(argp1);
4597 {
4598 PyThreadState* __tstate = wxPyBeginAllowThreads();
4599 delete arg1;
4600
4601 wxPyEndAllowThreads(__tstate);
4602 if (PyErr_Occurred()) SWIG_fail;
4603 }
4604 resultobj = SWIG_Py_Void();
4605 return resultobj;
4606 fail:
4607 return NULL;
4608 }
4609
4610
4611 SWIGINTERN PyObject *_wrap_Size___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4612 PyObject *resultobj = 0;
4613 wxSize *arg1 = (wxSize *) 0 ;
4614 PyObject *arg2 = (PyObject *) 0 ;
4615 bool result;
4616 void *argp1 = 0 ;
4617 int res1 = 0 ;
4618 PyObject * obj0 = 0 ;
4619 PyObject * obj1 = 0 ;
4620 char * kwnames[] = {
4621 (char *) "self",(char *) "other", NULL
4622 };
4623
4624 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
4625 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4626 if (!SWIG_IsOK(res1)) {
4627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___eq__" "', expected argument " "1"" of type '" "wxSize *""'");
4628 }
4629 arg1 = reinterpret_cast< wxSize * >(argp1);
4630 arg2 = obj1;
4631 {
4632 result = (bool)wxSize___eq__(arg1,arg2);
4633 if (PyErr_Occurred()) SWIG_fail;
4634 }
4635 {
4636 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4637 }
4638 return resultobj;
4639 fail:
4640 return NULL;
4641 }
4642
4643
4644 SWIGINTERN PyObject *_wrap_Size___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4645 PyObject *resultobj = 0;
4646 wxSize *arg1 = (wxSize *) 0 ;
4647 PyObject *arg2 = (PyObject *) 0 ;
4648 bool result;
4649 void *argp1 = 0 ;
4650 int res1 = 0 ;
4651 PyObject * obj0 = 0 ;
4652 PyObject * obj1 = 0 ;
4653 char * kwnames[] = {
4654 (char *) "self",(char *) "other", NULL
4655 };
4656
4657 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
4658 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4659 if (!SWIG_IsOK(res1)) {
4660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___ne__" "', expected argument " "1"" of type '" "wxSize *""'");
4661 }
4662 arg1 = reinterpret_cast< wxSize * >(argp1);
4663 arg2 = obj1;
4664 {
4665 result = (bool)wxSize___ne__(arg1,arg2);
4666 if (PyErr_Occurred()) SWIG_fail;
4667 }
4668 {
4669 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4670 }
4671 return resultobj;
4672 fail:
4673 return NULL;
4674 }
4675
4676
4677 SWIGINTERN PyObject *_wrap_Size___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4678 PyObject *resultobj = 0;
4679 wxSize *arg1 = (wxSize *) 0 ;
4680 wxSize *arg2 = 0 ;
4681 wxSize result;
4682 void *argp1 = 0 ;
4683 int res1 = 0 ;
4684 wxSize temp2 ;
4685 PyObject * obj0 = 0 ;
4686 PyObject * obj1 = 0 ;
4687 char * kwnames[] = {
4688 (char *) "self",(char *) "sz", NULL
4689 };
4690
4691 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) SWIG_fail;
4692 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4693 if (!SWIG_IsOK(res1)) {
4694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___add__" "', expected argument " "1"" of type '" "wxSize *""'");
4695 }
4696 arg1 = reinterpret_cast< wxSize * >(argp1);
4697 {
4698 arg2 = &temp2;
4699 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4700 }
4701 {
4702 PyThreadState* __tstate = wxPyBeginAllowThreads();
4703 result = (arg1)->operator +((wxSize const &)*arg2);
4704 wxPyEndAllowThreads(__tstate);
4705 if (PyErr_Occurred()) SWIG_fail;
4706 }
4707 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4708 return resultobj;
4709 fail:
4710 return NULL;
4711 }
4712
4713
4714 SWIGINTERN PyObject *_wrap_Size___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4715 PyObject *resultobj = 0;
4716 wxSize *arg1 = (wxSize *) 0 ;
4717 wxSize *arg2 = 0 ;
4718 wxSize result;
4719 void *argp1 = 0 ;
4720 int res1 = 0 ;
4721 wxSize temp2 ;
4722 PyObject * obj0 = 0 ;
4723 PyObject * obj1 = 0 ;
4724 char * kwnames[] = {
4725 (char *) "self",(char *) "sz", NULL
4726 };
4727
4728 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
4729 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4730 if (!SWIG_IsOK(res1)) {
4731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___sub__" "', expected argument " "1"" of type '" "wxSize *""'");
4732 }
4733 arg1 = reinterpret_cast< wxSize * >(argp1);
4734 {
4735 arg2 = &temp2;
4736 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4737 }
4738 {
4739 PyThreadState* __tstate = wxPyBeginAllowThreads();
4740 result = (arg1)->operator -((wxSize const &)*arg2);
4741 wxPyEndAllowThreads(__tstate);
4742 if (PyErr_Occurred()) SWIG_fail;
4743 }
4744 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4745 return resultobj;
4746 fail:
4747 return NULL;
4748 }
4749
4750
4751 SWIGINTERN PyObject *_wrap_Size_IncTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4752 PyObject *resultobj = 0;
4753 wxSize *arg1 = (wxSize *) 0 ;
4754 wxSize *arg2 = 0 ;
4755 void *argp1 = 0 ;
4756 int res1 = 0 ;
4757 wxSize temp2 ;
4758 PyObject * obj0 = 0 ;
4759 PyObject * obj1 = 0 ;
4760 char * kwnames[] = {
4761 (char *) "self",(char *) "sz", NULL
4762 };
4763
4764 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) SWIG_fail;
4765 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4766 if (!SWIG_IsOK(res1)) {
4767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncTo" "', expected argument " "1"" of type '" "wxSize *""'");
4768 }
4769 arg1 = reinterpret_cast< wxSize * >(argp1);
4770 {
4771 arg2 = &temp2;
4772 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4773 }
4774 {
4775 PyThreadState* __tstate = wxPyBeginAllowThreads();
4776 (arg1)->IncTo((wxSize const &)*arg2);
4777 wxPyEndAllowThreads(__tstate);
4778 if (PyErr_Occurred()) SWIG_fail;
4779 }
4780 resultobj = SWIG_Py_Void();
4781 return resultobj;
4782 fail:
4783 return NULL;
4784 }
4785
4786
4787 SWIGINTERN PyObject *_wrap_Size_DecTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4788 PyObject *resultobj = 0;
4789 wxSize *arg1 = (wxSize *) 0 ;
4790 wxSize *arg2 = 0 ;
4791 void *argp1 = 0 ;
4792 int res1 = 0 ;
4793 wxSize temp2 ;
4794 PyObject * obj0 = 0 ;
4795 PyObject * obj1 = 0 ;
4796 char * kwnames[] = {
4797 (char *) "self",(char *) "sz", NULL
4798 };
4799
4800 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) SWIG_fail;
4801 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4802 if (!SWIG_IsOK(res1)) {
4803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecTo" "', expected argument " "1"" of type '" "wxSize *""'");
4804 }
4805 arg1 = reinterpret_cast< wxSize * >(argp1);
4806 {
4807 arg2 = &temp2;
4808 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4809 }
4810 {
4811 PyThreadState* __tstate = wxPyBeginAllowThreads();
4812 (arg1)->DecTo((wxSize const &)*arg2);
4813 wxPyEndAllowThreads(__tstate);
4814 if (PyErr_Occurred()) SWIG_fail;
4815 }
4816 resultobj = SWIG_Py_Void();
4817 return resultobj;
4818 fail:
4819 return NULL;
4820 }
4821
4822
4823 SWIGINTERN PyObject *_wrap_Size_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4824 PyObject *resultobj = 0;
4825 wxSize *arg1 = (wxSize *) 0 ;
4826 int arg2 ;
4827 int arg3 ;
4828 void *argp1 = 0 ;
4829 int res1 = 0 ;
4830 int val2 ;
4831 int ecode2 = 0 ;
4832 int val3 ;
4833 int ecode3 = 0 ;
4834 PyObject * obj0 = 0 ;
4835 PyObject * obj1 = 0 ;
4836 PyObject * obj2 = 0 ;
4837 char * kwnames[] = {
4838 (char *) "self",(char *) "w",(char *) "h", NULL
4839 };
4840
4841 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4842 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4843 if (!SWIG_IsOK(res1)) {
4844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Set" "', expected argument " "1"" of type '" "wxSize *""'");
4845 }
4846 arg1 = reinterpret_cast< wxSize * >(argp1);
4847 ecode2 = SWIG_AsVal_int(obj1, &val2);
4848 if (!SWIG_IsOK(ecode2)) {
4849 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Set" "', expected argument " "2"" of type '" "int""'");
4850 }
4851 arg2 = static_cast< int >(val2);
4852 ecode3 = SWIG_AsVal_int(obj2, &val3);
4853 if (!SWIG_IsOK(ecode3)) {
4854 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Set" "', expected argument " "3"" of type '" "int""'");
4855 }
4856 arg3 = static_cast< int >(val3);
4857 {
4858 PyThreadState* __tstate = wxPyBeginAllowThreads();
4859 (arg1)->Set(arg2,arg3);
4860 wxPyEndAllowThreads(__tstate);
4861 if (PyErr_Occurred()) SWIG_fail;
4862 }
4863 resultobj = SWIG_Py_Void();
4864 return resultobj;
4865 fail:
4866 return NULL;
4867 }
4868
4869
4870 SWIGINTERN PyObject *_wrap_Size_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4871 PyObject *resultobj = 0;
4872 wxSize *arg1 = (wxSize *) 0 ;
4873 int arg2 ;
4874 void *argp1 = 0 ;
4875 int res1 = 0 ;
4876 int val2 ;
4877 int ecode2 = 0 ;
4878 PyObject * obj0 = 0 ;
4879 PyObject * obj1 = 0 ;
4880 char * kwnames[] = {
4881 (char *) "self",(char *) "w", NULL
4882 };
4883
4884 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
4885 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4886 if (!SWIG_IsOK(res1)) {
4887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetWidth" "', expected argument " "1"" of type '" "wxSize *""'");
4888 }
4889 arg1 = reinterpret_cast< wxSize * >(argp1);
4890 ecode2 = SWIG_AsVal_int(obj1, &val2);
4891 if (!SWIG_IsOK(ecode2)) {
4892 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetWidth" "', expected argument " "2"" of type '" "int""'");
4893 }
4894 arg2 = static_cast< int >(val2);
4895 {
4896 PyThreadState* __tstate = wxPyBeginAllowThreads();
4897 (arg1)->SetWidth(arg2);
4898 wxPyEndAllowThreads(__tstate);
4899 if (PyErr_Occurred()) SWIG_fail;
4900 }
4901 resultobj = SWIG_Py_Void();
4902 return resultobj;
4903 fail:
4904 return NULL;
4905 }
4906
4907
4908 SWIGINTERN PyObject *_wrap_Size_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4909 PyObject *resultobj = 0;
4910 wxSize *arg1 = (wxSize *) 0 ;
4911 int arg2 ;
4912 void *argp1 = 0 ;
4913 int res1 = 0 ;
4914 int val2 ;
4915 int ecode2 = 0 ;
4916 PyObject * obj0 = 0 ;
4917 PyObject * obj1 = 0 ;
4918 char * kwnames[] = {
4919 (char *) "self",(char *) "h", NULL
4920 };
4921
4922 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
4923 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4924 if (!SWIG_IsOK(res1)) {
4925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetHeight" "', expected argument " "1"" of type '" "wxSize *""'");
4926 }
4927 arg1 = reinterpret_cast< wxSize * >(argp1);
4928 ecode2 = SWIG_AsVal_int(obj1, &val2);
4929 if (!SWIG_IsOK(ecode2)) {
4930 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetHeight" "', expected argument " "2"" of type '" "int""'");
4931 }
4932 arg2 = static_cast< int >(val2);
4933 {
4934 PyThreadState* __tstate = wxPyBeginAllowThreads();
4935 (arg1)->SetHeight(arg2);
4936 wxPyEndAllowThreads(__tstate);
4937 if (PyErr_Occurred()) SWIG_fail;
4938 }
4939 resultobj = SWIG_Py_Void();
4940 return resultobj;
4941 fail:
4942 return NULL;
4943 }
4944
4945
4946 SWIGINTERN PyObject *_wrap_Size_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4947 PyObject *resultobj = 0;
4948 wxSize *arg1 = (wxSize *) 0 ;
4949 int result;
4950 void *argp1 = 0 ;
4951 int res1 = 0 ;
4952 PyObject *swig_obj[1] ;
4953
4954 if (!args) SWIG_fail;
4955 swig_obj[0] = args;
4956 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4957 if (!SWIG_IsOK(res1)) {
4958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetWidth" "', expected argument " "1"" of type '" "wxSize const *""'");
4959 }
4960 arg1 = reinterpret_cast< wxSize * >(argp1);
4961 {
4962 PyThreadState* __tstate = wxPyBeginAllowThreads();
4963 result = (int)((wxSize const *)arg1)->GetWidth();
4964 wxPyEndAllowThreads(__tstate);
4965 if (PyErr_Occurred()) SWIG_fail;
4966 }
4967 resultobj = SWIG_From_int(static_cast< int >(result));
4968 return resultobj;
4969 fail:
4970 return NULL;
4971 }
4972
4973
4974 SWIGINTERN PyObject *_wrap_Size_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4975 PyObject *resultobj = 0;
4976 wxSize *arg1 = (wxSize *) 0 ;
4977 int result;
4978 void *argp1 = 0 ;
4979 int res1 = 0 ;
4980 PyObject *swig_obj[1] ;
4981
4982 if (!args) SWIG_fail;
4983 swig_obj[0] = args;
4984 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4985 if (!SWIG_IsOK(res1)) {
4986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetHeight" "', expected argument " "1"" of type '" "wxSize const *""'");
4987 }
4988 arg1 = reinterpret_cast< wxSize * >(argp1);
4989 {
4990 PyThreadState* __tstate = wxPyBeginAllowThreads();
4991 result = (int)((wxSize const *)arg1)->GetHeight();
4992 wxPyEndAllowThreads(__tstate);
4993 if (PyErr_Occurred()) SWIG_fail;
4994 }
4995 resultobj = SWIG_From_int(static_cast< int >(result));
4996 return resultobj;
4997 fail:
4998 return NULL;
4999 }
5000
5001
5002 SWIGINTERN PyObject *_wrap_Size_IsFullySpecified(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5003 PyObject *resultobj = 0;
5004 wxSize *arg1 = (wxSize *) 0 ;
5005 bool result;
5006 void *argp1 = 0 ;
5007 int res1 = 0 ;
5008 PyObject *swig_obj[1] ;
5009
5010 if (!args) SWIG_fail;
5011 swig_obj[0] = args;
5012 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5013 if (!SWIG_IsOK(res1)) {
5014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IsFullySpecified" "', expected argument " "1"" of type '" "wxSize const *""'");
5015 }
5016 arg1 = reinterpret_cast< wxSize * >(argp1);
5017 {
5018 PyThreadState* __tstate = wxPyBeginAllowThreads();
5019 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
5020 wxPyEndAllowThreads(__tstate);
5021 if (PyErr_Occurred()) SWIG_fail;
5022 }
5023 {
5024 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5025 }
5026 return resultobj;
5027 fail:
5028 return NULL;
5029 }
5030
5031
5032 SWIGINTERN PyObject *_wrap_Size_SetDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5033 PyObject *resultobj = 0;
5034 wxSize *arg1 = (wxSize *) 0 ;
5035 wxSize *arg2 = 0 ;
5036 void *argp1 = 0 ;
5037 int res1 = 0 ;
5038 wxSize temp2 ;
5039 PyObject * obj0 = 0 ;
5040 PyObject * obj1 = 0 ;
5041 char * kwnames[] = {
5042 (char *) "self",(char *) "size", NULL
5043 };
5044
5045 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
5046 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5047 if (!SWIG_IsOK(res1)) {
5048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetDefaults" "', expected argument " "1"" of type '" "wxSize *""'");
5049 }
5050 arg1 = reinterpret_cast< wxSize * >(argp1);
5051 {
5052 arg2 = &temp2;
5053 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5054 }
5055 {
5056 PyThreadState* __tstate = wxPyBeginAllowThreads();
5057 (arg1)->SetDefaults((wxSize const &)*arg2);
5058 wxPyEndAllowThreads(__tstate);
5059 if (PyErr_Occurred()) SWIG_fail;
5060 }
5061 resultobj = SWIG_Py_Void();
5062 return resultobj;
5063 fail:
5064 return NULL;
5065 }
5066
5067
5068 SWIGINTERN PyObject *_wrap_Size_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5069 PyObject *resultobj = 0;
5070 wxSize *arg1 = (wxSize *) 0 ;
5071 PyObject *result = 0 ;
5072 void *argp1 = 0 ;
5073 int res1 = 0 ;
5074 PyObject *swig_obj[1] ;
5075
5076 if (!args) SWIG_fail;
5077 swig_obj[0] = args;
5078 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5079 if (!SWIG_IsOK(res1)) {
5080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Get" "', expected argument " "1"" of type '" "wxSize *""'");
5081 }
5082 arg1 = reinterpret_cast< wxSize * >(argp1);
5083 {
5084 PyThreadState* __tstate = wxPyBeginAllowThreads();
5085 result = (PyObject *)wxSize_Get(arg1);
5086 wxPyEndAllowThreads(__tstate);
5087 if (PyErr_Occurred()) SWIG_fail;
5088 }
5089 resultobj = result;
5090 return resultobj;
5091 fail:
5092 return NULL;
5093 }
5094
5095
5096 SWIGINTERN PyObject *Size_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5097 PyObject *obj;
5098 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5099 SWIG_TypeNewClientData(SWIGTYPE_p_wxSize, SWIG_NewClientData(obj));
5100 return SWIG_Py_Void();
5101 }
5102
5103 SWIGINTERN PyObject *Size_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5104 return SWIG_Python_InitShadowInstance(args);
5105 }
5106
5107 SWIGINTERN PyObject *_wrap_RealPoint_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5108 PyObject *resultobj = 0;
5109 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5110 double arg2 ;
5111 void *argp1 = 0 ;
5112 int res1 = 0 ;
5113 double val2 ;
5114 int ecode2 = 0 ;
5115 PyObject *swig_obj[2] ;
5116
5117 if (!SWIG_Python_UnpackTuple(args,"RealPoint_x_set",2,2,swig_obj)) SWIG_fail;
5118 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5119 if (!SWIG_IsOK(res1)) {
5120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5121 }
5122 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5123 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5124 if (!SWIG_IsOK(ecode2)) {
5125 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_x_set" "', expected argument " "2"" of type '" "double""'");
5126 }
5127 arg2 = static_cast< double >(val2);
5128 if (arg1) (arg1)->x = arg2;
5129
5130 resultobj = SWIG_Py_Void();
5131 return resultobj;
5132 fail:
5133 return NULL;
5134 }
5135
5136
5137 SWIGINTERN PyObject *_wrap_RealPoint_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5138 PyObject *resultobj = 0;
5139 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5140 double result;
5141 void *argp1 = 0 ;
5142 int res1 = 0 ;
5143 PyObject *swig_obj[1] ;
5144
5145 if (!args) SWIG_fail;
5146 swig_obj[0] = args;
5147 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5148 if (!SWIG_IsOK(res1)) {
5149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5150 }
5151 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5152 result = (double) ((arg1)->x);
5153 resultobj = SWIG_From_double(static_cast< double >(result));
5154 return resultobj;
5155 fail:
5156 return NULL;
5157 }
5158
5159
5160 SWIGINTERN PyObject *_wrap_RealPoint_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5161 PyObject *resultobj = 0;
5162 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5163 double arg2 ;
5164 void *argp1 = 0 ;
5165 int res1 = 0 ;
5166 double val2 ;
5167 int ecode2 = 0 ;
5168 PyObject *swig_obj[2] ;
5169
5170 if (!SWIG_Python_UnpackTuple(args,"RealPoint_y_set",2,2,swig_obj)) SWIG_fail;
5171 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5172 if (!SWIG_IsOK(res1)) {
5173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5174 }
5175 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5176 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5177 if (!SWIG_IsOK(ecode2)) {
5178 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_y_set" "', expected argument " "2"" of type '" "double""'");
5179 }
5180 arg2 = static_cast< double >(val2);
5181 if (arg1) (arg1)->y = arg2;
5182
5183 resultobj = SWIG_Py_Void();
5184 return resultobj;
5185 fail:
5186 return NULL;
5187 }
5188
5189
5190 SWIGINTERN PyObject *_wrap_RealPoint_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5191 PyObject *resultobj = 0;
5192 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5193 double result;
5194 void *argp1 = 0 ;
5195 int res1 = 0 ;
5196 PyObject *swig_obj[1] ;
5197
5198 if (!args) SWIG_fail;
5199 swig_obj[0] = args;
5200 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5201 if (!SWIG_IsOK(res1)) {
5202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5203 }
5204 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5205 result = (double) ((arg1)->y);
5206 resultobj = SWIG_From_double(static_cast< double >(result));
5207 return resultobj;
5208 fail:
5209 return NULL;
5210 }
5211
5212
5213 SWIGINTERN PyObject *_wrap_new_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5214 PyObject *resultobj = 0;
5215 double arg1 = (double) 0.0 ;
5216 double arg2 = (double) 0.0 ;
5217 wxRealPoint *result = 0 ;
5218 double val1 ;
5219 int ecode1 = 0 ;
5220 double val2 ;
5221 int ecode2 = 0 ;
5222 PyObject * obj0 = 0 ;
5223 PyObject * obj1 = 0 ;
5224 char * kwnames[] = {
5225 (char *) "x",(char *) "y", NULL
5226 };
5227
5228 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) SWIG_fail;
5229 if (obj0) {
5230 ecode1 = SWIG_AsVal_double(obj0, &val1);
5231 if (!SWIG_IsOK(ecode1)) {
5232 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RealPoint" "', expected argument " "1"" of type '" "double""'");
5233 }
5234 arg1 = static_cast< double >(val1);
5235 }
5236 if (obj1) {
5237 ecode2 = SWIG_AsVal_double(obj1, &val2);
5238 if (!SWIG_IsOK(ecode2)) {
5239 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RealPoint" "', expected argument " "2"" of type '" "double""'");
5240 }
5241 arg2 = static_cast< double >(val2);
5242 }
5243 {
5244 PyThreadState* __tstate = wxPyBeginAllowThreads();
5245 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
5246 wxPyEndAllowThreads(__tstate);
5247 if (PyErr_Occurred()) SWIG_fail;
5248 }
5249 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_NEW | 0 );
5250 return resultobj;
5251 fail:
5252 return NULL;
5253 }
5254
5255
5256 SWIGINTERN PyObject *_wrap_delete_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5257 PyObject *resultobj = 0;
5258 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5259 void *argp1 = 0 ;
5260 int res1 = 0 ;
5261 PyObject *swig_obj[1] ;
5262
5263 if (!args) SWIG_fail;
5264 swig_obj[0] = args;
5265 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, SWIG_POINTER_DISOWN | 0 );
5266 if (!SWIG_IsOK(res1)) {
5267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RealPoint" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5268 }
5269 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5270 {
5271 PyThreadState* __tstate = wxPyBeginAllowThreads();
5272 delete arg1;
5273
5274 wxPyEndAllowThreads(__tstate);
5275 if (PyErr_Occurred()) SWIG_fail;
5276 }
5277 resultobj = SWIG_Py_Void();
5278 return resultobj;
5279 fail:
5280 return NULL;
5281 }
5282
5283
5284 SWIGINTERN PyObject *_wrap_RealPoint___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5285 PyObject *resultobj = 0;
5286 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5287 PyObject *arg2 = (PyObject *) 0 ;
5288 bool result;
5289 void *argp1 = 0 ;
5290 int res1 = 0 ;
5291 PyObject * obj0 = 0 ;
5292 PyObject * obj1 = 0 ;
5293 char * kwnames[] = {
5294 (char *) "self",(char *) "other", NULL
5295 };
5296
5297 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5298 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5299 if (!SWIG_IsOK(res1)) {
5300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___eq__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5301 }
5302 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5303 arg2 = obj1;
5304 {
5305 result = (bool)wxRealPoint___eq__(arg1,arg2);
5306 if (PyErr_Occurred()) SWIG_fail;
5307 }
5308 {
5309 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5310 }
5311 return resultobj;
5312 fail:
5313 return NULL;
5314 }
5315
5316
5317 SWIGINTERN PyObject *_wrap_RealPoint___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5318 PyObject *resultobj = 0;
5319 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5320 PyObject *arg2 = (PyObject *) 0 ;
5321 bool result;
5322 void *argp1 = 0 ;
5323 int res1 = 0 ;
5324 PyObject * obj0 = 0 ;
5325 PyObject * obj1 = 0 ;
5326 char * kwnames[] = {
5327 (char *) "self",(char *) "other", NULL
5328 };
5329
5330 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5331 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5332 if (!SWIG_IsOK(res1)) {
5333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___ne__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5334 }
5335 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5336 arg2 = obj1;
5337 {
5338 result = (bool)wxRealPoint___ne__(arg1,arg2);
5339 if (PyErr_Occurred()) SWIG_fail;
5340 }
5341 {
5342 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5343 }
5344 return resultobj;
5345 fail:
5346 return NULL;
5347 }
5348
5349
5350 SWIGINTERN PyObject *_wrap_RealPoint___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5351 PyObject *resultobj = 0;
5352 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5353 wxRealPoint *arg2 = 0 ;
5354 wxRealPoint result;
5355 void *argp1 = 0 ;
5356 int res1 = 0 ;
5357 wxRealPoint temp2 ;
5358 PyObject * obj0 = 0 ;
5359 PyObject * obj1 = 0 ;
5360 char * kwnames[] = {
5361 (char *) "self",(char *) "pt", NULL
5362 };
5363
5364 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5365 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5366 if (!SWIG_IsOK(res1)) {
5367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___add__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5368 }
5369 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5370 {
5371 arg2 = &temp2;
5372 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5373 }
5374 {
5375 PyThreadState* __tstate = wxPyBeginAllowThreads();
5376 result = (arg1)->operator +((wxRealPoint const &)*arg2);
5377 wxPyEndAllowThreads(__tstate);
5378 if (PyErr_Occurred()) SWIG_fail;
5379 }
5380 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5381 return resultobj;
5382 fail:
5383 return NULL;
5384 }
5385
5386
5387 SWIGINTERN PyObject *_wrap_RealPoint___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5388 PyObject *resultobj = 0;
5389 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5390 wxRealPoint *arg2 = 0 ;
5391 wxRealPoint result;
5392 void *argp1 = 0 ;
5393 int res1 = 0 ;
5394 wxRealPoint temp2 ;
5395 PyObject * obj0 = 0 ;
5396 PyObject * obj1 = 0 ;
5397 char * kwnames[] = {
5398 (char *) "self",(char *) "pt", NULL
5399 };
5400
5401 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5402 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5403 if (!SWIG_IsOK(res1)) {
5404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___sub__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5405 }
5406 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5407 {
5408 arg2 = &temp2;
5409 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5410 }
5411 {
5412 PyThreadState* __tstate = wxPyBeginAllowThreads();
5413 result = (arg1)->operator -((wxRealPoint const &)*arg2);
5414 wxPyEndAllowThreads(__tstate);
5415 if (PyErr_Occurred()) SWIG_fail;
5416 }
5417 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5418 return resultobj;
5419 fail:
5420 return NULL;
5421 }
5422
5423
5424 SWIGINTERN PyObject *_wrap_RealPoint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5425 PyObject *resultobj = 0;
5426 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5427 double arg2 ;
5428 double arg3 ;
5429 void *argp1 = 0 ;
5430 int res1 = 0 ;
5431 double val2 ;
5432 int ecode2 = 0 ;
5433 double val3 ;
5434 int ecode3 = 0 ;
5435 PyObject * obj0 = 0 ;
5436 PyObject * obj1 = 0 ;
5437 PyObject * obj2 = 0 ;
5438 char * kwnames[] = {
5439 (char *) "self",(char *) "x",(char *) "y", NULL
5440 };
5441
5442 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5443 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5444 if (!SWIG_IsOK(res1)) {
5445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5446 }
5447 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5448 ecode2 = SWIG_AsVal_double(obj1, &val2);
5449 if (!SWIG_IsOK(ecode2)) {
5450 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_Set" "', expected argument " "2"" of type '" "double""'");
5451 }
5452 arg2 = static_cast< double >(val2);
5453 ecode3 = SWIG_AsVal_double(obj2, &val3);
5454 if (!SWIG_IsOK(ecode3)) {
5455 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RealPoint_Set" "', expected argument " "3"" of type '" "double""'");
5456 }
5457 arg3 = static_cast< double >(val3);
5458 {
5459 PyThreadState* __tstate = wxPyBeginAllowThreads();
5460 wxRealPoint_Set(arg1,arg2,arg3);
5461 wxPyEndAllowThreads(__tstate);
5462 if (PyErr_Occurred()) SWIG_fail;
5463 }
5464 resultobj = SWIG_Py_Void();
5465 return resultobj;
5466 fail:
5467 return NULL;
5468 }
5469
5470
5471 SWIGINTERN PyObject *_wrap_RealPoint_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5472 PyObject *resultobj = 0;
5473 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5474 PyObject *result = 0 ;
5475 void *argp1 = 0 ;
5476 int res1 = 0 ;
5477 PyObject *swig_obj[1] ;
5478
5479 if (!args) SWIG_fail;
5480 swig_obj[0] = args;
5481 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5482 if (!SWIG_IsOK(res1)) {
5483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5484 }
5485 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5486 {
5487 PyThreadState* __tstate = wxPyBeginAllowThreads();
5488 result = (PyObject *)wxRealPoint_Get(arg1);
5489 wxPyEndAllowThreads(__tstate);
5490 if (PyErr_Occurred()) SWIG_fail;
5491 }
5492 resultobj = result;
5493 return resultobj;
5494 fail:
5495 return NULL;
5496 }
5497
5498
5499 SWIGINTERN PyObject *RealPoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5500 PyObject *obj;
5501 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5502 SWIG_TypeNewClientData(SWIGTYPE_p_wxRealPoint, SWIG_NewClientData(obj));
5503 return SWIG_Py_Void();
5504 }
5505
5506 SWIGINTERN PyObject *RealPoint_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5507 return SWIG_Python_InitShadowInstance(args);
5508 }
5509
5510 SWIGINTERN PyObject *_wrap_Point_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5511 PyObject *resultobj = 0;
5512 wxPoint *arg1 = (wxPoint *) 0 ;
5513 int arg2 ;
5514 void *argp1 = 0 ;
5515 int res1 = 0 ;
5516 int val2 ;
5517 int ecode2 = 0 ;
5518 PyObject *swig_obj[2] ;
5519
5520 if (!SWIG_Python_UnpackTuple(args,"Point_x_set",2,2,swig_obj)) SWIG_fail;
5521 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5522 if (!SWIG_IsOK(res1)) {
5523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5524 }
5525 arg1 = reinterpret_cast< wxPoint * >(argp1);
5526 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5527 if (!SWIG_IsOK(ecode2)) {
5528 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_x_set" "', expected argument " "2"" of type '" "int""'");
5529 }
5530 arg2 = static_cast< int >(val2);
5531 if (arg1) (arg1)->x = arg2;
5532
5533 resultobj = SWIG_Py_Void();
5534 return resultobj;
5535 fail:
5536 return NULL;
5537 }
5538
5539
5540 SWIGINTERN PyObject *_wrap_Point_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5541 PyObject *resultobj = 0;
5542 wxPoint *arg1 = (wxPoint *) 0 ;
5543 int result;
5544 void *argp1 = 0 ;
5545 int res1 = 0 ;
5546 PyObject *swig_obj[1] ;
5547
5548 if (!args) SWIG_fail;
5549 swig_obj[0] = args;
5550 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5551 if (!SWIG_IsOK(res1)) {
5552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5553 }
5554 arg1 = reinterpret_cast< wxPoint * >(argp1);
5555 result = (int) ((arg1)->x);
5556 resultobj = SWIG_From_int(static_cast< int >(result));
5557 return resultobj;
5558 fail:
5559 return NULL;
5560 }
5561
5562
5563 SWIGINTERN PyObject *_wrap_Point_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5564 PyObject *resultobj = 0;
5565 wxPoint *arg1 = (wxPoint *) 0 ;
5566 int arg2 ;
5567 void *argp1 = 0 ;
5568 int res1 = 0 ;
5569 int val2 ;
5570 int ecode2 = 0 ;
5571 PyObject *swig_obj[2] ;
5572
5573 if (!SWIG_Python_UnpackTuple(args,"Point_y_set",2,2,swig_obj)) SWIG_fail;
5574 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5575 if (!SWIG_IsOK(res1)) {
5576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5577 }
5578 arg1 = reinterpret_cast< wxPoint * >(argp1);
5579 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5580 if (!SWIG_IsOK(ecode2)) {
5581 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_y_set" "', expected argument " "2"" of type '" "int""'");
5582 }
5583 arg2 = static_cast< int >(val2);
5584 if (arg1) (arg1)->y = arg2;
5585
5586 resultobj = SWIG_Py_Void();
5587 return resultobj;
5588 fail:
5589 return NULL;
5590 }
5591
5592
5593 SWIGINTERN PyObject *_wrap_Point_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5594 PyObject *resultobj = 0;
5595 wxPoint *arg1 = (wxPoint *) 0 ;
5596 int result;
5597 void *argp1 = 0 ;
5598 int res1 = 0 ;
5599 PyObject *swig_obj[1] ;
5600
5601 if (!args) SWIG_fail;
5602 swig_obj[0] = args;
5603 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5604 if (!SWIG_IsOK(res1)) {
5605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5606 }
5607 arg1 = reinterpret_cast< wxPoint * >(argp1);
5608 result = (int) ((arg1)->y);
5609 resultobj = SWIG_From_int(static_cast< int >(result));
5610 return resultobj;
5611 fail:
5612 return NULL;
5613 }
5614
5615
5616 SWIGINTERN PyObject *_wrap_new_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5617 PyObject *resultobj = 0;
5618 int arg1 = (int) 0 ;
5619 int arg2 = (int) 0 ;
5620 wxPoint *result = 0 ;
5621 int val1 ;
5622 int ecode1 = 0 ;
5623 int val2 ;
5624 int ecode2 = 0 ;
5625 PyObject * obj0 = 0 ;
5626 PyObject * obj1 = 0 ;
5627 char * kwnames[] = {
5628 (char *) "x",(char *) "y", NULL
5629 };
5630
5631 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) SWIG_fail;
5632 if (obj0) {
5633 ecode1 = SWIG_AsVal_int(obj0, &val1);
5634 if (!SWIG_IsOK(ecode1)) {
5635 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point" "', expected argument " "1"" of type '" "int""'");
5636 }
5637 arg1 = static_cast< int >(val1);
5638 }
5639 if (obj1) {
5640 ecode2 = SWIG_AsVal_int(obj1, &val2);
5641 if (!SWIG_IsOK(ecode2)) {
5642 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point" "', expected argument " "2"" of type '" "int""'");
5643 }
5644 arg2 = static_cast< int >(val2);
5645 }
5646 {
5647 PyThreadState* __tstate = wxPyBeginAllowThreads();
5648 result = (wxPoint *)new wxPoint(arg1,arg2);
5649 wxPyEndAllowThreads(__tstate);
5650 if (PyErr_Occurred()) SWIG_fail;
5651 }
5652 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_NEW | 0 );
5653 return resultobj;
5654 fail:
5655 return NULL;
5656 }
5657
5658
5659 SWIGINTERN PyObject *_wrap_delete_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5660 PyObject *resultobj = 0;
5661 wxPoint *arg1 = (wxPoint *) 0 ;
5662 void *argp1 = 0 ;
5663 int res1 = 0 ;
5664 PyObject *swig_obj[1] ;
5665
5666 if (!args) SWIG_fail;
5667 swig_obj[0] = args;
5668 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5669 if (!SWIG_IsOK(res1)) {
5670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point" "', expected argument " "1"" of type '" "wxPoint *""'");
5671 }
5672 arg1 = reinterpret_cast< wxPoint * >(argp1);
5673 {
5674 PyThreadState* __tstate = wxPyBeginAllowThreads();
5675 delete arg1;
5676
5677 wxPyEndAllowThreads(__tstate);
5678 if (PyErr_Occurred()) SWIG_fail;
5679 }
5680 resultobj = SWIG_Py_Void();
5681 return resultobj;
5682 fail:
5683 return NULL;
5684 }
5685
5686
5687 SWIGINTERN PyObject *_wrap_Point___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5688 PyObject *resultobj = 0;
5689 wxPoint *arg1 = (wxPoint *) 0 ;
5690 PyObject *arg2 = (PyObject *) 0 ;
5691 bool result;
5692 void *argp1 = 0 ;
5693 int res1 = 0 ;
5694 PyObject * obj0 = 0 ;
5695 PyObject * obj1 = 0 ;
5696 char * kwnames[] = {
5697 (char *) "self",(char *) "other", NULL
5698 };
5699
5700 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5701 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5702 if (!SWIG_IsOK(res1)) {
5703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___eq__" "', expected argument " "1"" of type '" "wxPoint *""'");
5704 }
5705 arg1 = reinterpret_cast< wxPoint * >(argp1);
5706 arg2 = obj1;
5707 {
5708 result = (bool)wxPoint___eq__(arg1,arg2);
5709 if (PyErr_Occurred()) SWIG_fail;
5710 }
5711 {
5712 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5713 }
5714 return resultobj;
5715 fail:
5716 return NULL;
5717 }
5718
5719
5720 SWIGINTERN PyObject *_wrap_Point___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5721 PyObject *resultobj = 0;
5722 wxPoint *arg1 = (wxPoint *) 0 ;
5723 PyObject *arg2 = (PyObject *) 0 ;
5724 bool result;
5725 void *argp1 = 0 ;
5726 int res1 = 0 ;
5727 PyObject * obj0 = 0 ;
5728 PyObject * obj1 = 0 ;
5729 char * kwnames[] = {
5730 (char *) "self",(char *) "other", NULL
5731 };
5732
5733 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5734 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5735 if (!SWIG_IsOK(res1)) {
5736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___ne__" "', expected argument " "1"" of type '" "wxPoint *""'");
5737 }
5738 arg1 = reinterpret_cast< wxPoint * >(argp1);
5739 arg2 = obj1;
5740 {
5741 result = (bool)wxPoint___ne__(arg1,arg2);
5742 if (PyErr_Occurred()) SWIG_fail;
5743 }
5744 {
5745 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5746 }
5747 return resultobj;
5748 fail:
5749 return NULL;
5750 }
5751
5752
5753 SWIGINTERN PyObject *_wrap_Point___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5754 PyObject *resultobj = 0;
5755 wxPoint *arg1 = (wxPoint *) 0 ;
5756 wxPoint *arg2 = 0 ;
5757 wxPoint result;
5758 void *argp1 = 0 ;
5759 int res1 = 0 ;
5760 wxPoint temp2 ;
5761 PyObject * obj0 = 0 ;
5762 PyObject * obj1 = 0 ;
5763 char * kwnames[] = {
5764 (char *) "self",(char *) "pt", NULL
5765 };
5766
5767 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5768 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5769 if (!SWIG_IsOK(res1)) {
5770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___add__" "', expected argument " "1"" of type '" "wxPoint *""'");
5771 }
5772 arg1 = reinterpret_cast< wxPoint * >(argp1);
5773 {
5774 arg2 = &temp2;
5775 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5776 }
5777 {
5778 PyThreadState* __tstate = wxPyBeginAllowThreads();
5779 result = (arg1)->operator +((wxPoint const &)*arg2);
5780 wxPyEndAllowThreads(__tstate);
5781 if (PyErr_Occurred()) SWIG_fail;
5782 }
5783 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5784 return resultobj;
5785 fail:
5786 return NULL;
5787 }
5788
5789
5790 SWIGINTERN PyObject *_wrap_Point___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5791 PyObject *resultobj = 0;
5792 wxPoint *arg1 = (wxPoint *) 0 ;
5793 wxPoint *arg2 = 0 ;
5794 wxPoint result;
5795 void *argp1 = 0 ;
5796 int res1 = 0 ;
5797 wxPoint temp2 ;
5798 PyObject * obj0 = 0 ;
5799 PyObject * obj1 = 0 ;
5800 char * kwnames[] = {
5801 (char *) "self",(char *) "pt", NULL
5802 };
5803
5804 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5805 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5806 if (!SWIG_IsOK(res1)) {
5807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___sub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5808 }
5809 arg1 = reinterpret_cast< wxPoint * >(argp1);
5810 {
5811 arg2 = &temp2;
5812 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5813 }
5814 {
5815 PyThreadState* __tstate = wxPyBeginAllowThreads();
5816 result = (arg1)->operator -((wxPoint const &)*arg2);
5817 wxPyEndAllowThreads(__tstate);
5818 if (PyErr_Occurred()) SWIG_fail;
5819 }
5820 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5821 return resultobj;
5822 fail:
5823 return NULL;
5824 }
5825
5826
5827 SWIGINTERN PyObject *_wrap_Point___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5828 PyObject *resultobj = 0;
5829 wxPoint *arg1 = (wxPoint *) 0 ;
5830 wxPoint *arg2 = 0 ;
5831 wxPoint *result = 0 ;
5832 void *argp1 = 0 ;
5833 int res1 = 0 ;
5834 wxPoint temp2 ;
5835 PyObject * obj0 = 0 ;
5836 PyObject * obj1 = 0 ;
5837 char * kwnames[] = {
5838 (char *) "self",(char *) "pt", NULL
5839 };
5840
5841 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
5842 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5843 if (!SWIG_IsOK(res1)) {
5844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___iadd__" "', expected argument " "1"" of type '" "wxPoint *""'");
5845 }
5846 arg1 = reinterpret_cast< wxPoint * >(argp1);
5847 {
5848 arg2 = &temp2;
5849 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5850 }
5851 {
5852 PyThreadState* __tstate = wxPyBeginAllowThreads();
5853 {
5854 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
5855 result = (wxPoint *) &_result_ref;
5856 }
5857 wxPyEndAllowThreads(__tstate);
5858 if (PyErr_Occurred()) SWIG_fail;
5859 }
5860 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5861 return resultobj;
5862 fail:
5863 return NULL;
5864 }
5865
5866
5867 SWIGINTERN PyObject *_wrap_Point___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5868 PyObject *resultobj = 0;
5869 wxPoint *arg1 = (wxPoint *) 0 ;
5870 wxPoint *arg2 = 0 ;
5871 wxPoint *result = 0 ;
5872 void *argp1 = 0 ;
5873 int res1 = 0 ;
5874 wxPoint temp2 ;
5875 PyObject * obj0 = 0 ;
5876 PyObject * obj1 = 0 ;
5877 char * kwnames[] = {
5878 (char *) "self",(char *) "pt", NULL
5879 };
5880
5881 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
5882 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5883 if (!SWIG_IsOK(res1)) {
5884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___isub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5885 }
5886 arg1 = reinterpret_cast< wxPoint * >(argp1);
5887 {
5888 arg2 = &temp2;
5889 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5890 }
5891 {
5892 PyThreadState* __tstate = wxPyBeginAllowThreads();
5893 {
5894 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
5895 result = (wxPoint *) &_result_ref;
5896 }
5897 wxPyEndAllowThreads(__tstate);
5898 if (PyErr_Occurred()) SWIG_fail;
5899 }
5900 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5901 return resultobj;
5902 fail:
5903 return NULL;
5904 }
5905
5906
5907 SWIGINTERN PyObject *_wrap_Point_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5908 PyObject *resultobj = 0;
5909 wxPoint *arg1 = (wxPoint *) 0 ;
5910 long arg2 ;
5911 long arg3 ;
5912 void *argp1 = 0 ;
5913 int res1 = 0 ;
5914 long val2 ;
5915 int ecode2 = 0 ;
5916 long val3 ;
5917 int ecode3 = 0 ;
5918 PyObject * obj0 = 0 ;
5919 PyObject * obj1 = 0 ;
5920 PyObject * obj2 = 0 ;
5921 char * kwnames[] = {
5922 (char *) "self",(char *) "x",(char *) "y", NULL
5923 };
5924
5925 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5926 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5927 if (!SWIG_IsOK(res1)) {
5928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Set" "', expected argument " "1"" of type '" "wxPoint *""'");
5929 }
5930 arg1 = reinterpret_cast< wxPoint * >(argp1);
5931 ecode2 = SWIG_AsVal_long(obj1, &val2);
5932 if (!SWIG_IsOK(ecode2)) {
5933 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_Set" "', expected argument " "2"" of type '" "long""'");
5934 }
5935 arg2 = static_cast< long >(val2);
5936 ecode3 = SWIG_AsVal_long(obj2, &val3);
5937 if (!SWIG_IsOK(ecode3)) {
5938 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point_Set" "', expected argument " "3"" of type '" "long""'");
5939 }
5940 arg3 = static_cast< long >(val3);
5941 {
5942 PyThreadState* __tstate = wxPyBeginAllowThreads();
5943 wxPoint_Set(arg1,arg2,arg3);
5944 wxPyEndAllowThreads(__tstate);
5945 if (PyErr_Occurred()) SWIG_fail;
5946 }
5947 resultobj = SWIG_Py_Void();
5948 return resultobj;
5949 fail:
5950 return NULL;
5951 }
5952
5953
5954 SWIGINTERN PyObject *_wrap_Point_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5955 PyObject *resultobj = 0;
5956 wxPoint *arg1 = (wxPoint *) 0 ;
5957 PyObject *result = 0 ;
5958 void *argp1 = 0 ;
5959 int res1 = 0 ;
5960 PyObject *swig_obj[1] ;
5961
5962 if (!args) SWIG_fail;
5963 swig_obj[0] = args;
5964 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5965 if (!SWIG_IsOK(res1)) {
5966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Get" "', expected argument " "1"" of type '" "wxPoint *""'");
5967 }
5968 arg1 = reinterpret_cast< wxPoint * >(argp1);
5969 {
5970 PyThreadState* __tstate = wxPyBeginAllowThreads();
5971 result = (PyObject *)wxPoint_Get(arg1);
5972 wxPyEndAllowThreads(__tstate);
5973 if (PyErr_Occurred()) SWIG_fail;
5974 }
5975 resultobj = result;
5976 return resultobj;
5977 fail:
5978 return NULL;
5979 }
5980
5981
5982 SWIGINTERN PyObject *Point_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5983 PyObject *obj;
5984 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5985 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint, SWIG_NewClientData(obj));
5986 return SWIG_Py_Void();
5987 }
5988
5989 SWIGINTERN PyObject *Point_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5990 return SWIG_Python_InitShadowInstance(args);
5991 }
5992
5993 SWIGINTERN PyObject *_wrap_new_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5994 PyObject *resultobj = 0;
5995 int arg1 = (int) 0 ;
5996 int arg2 = (int) 0 ;
5997 int arg3 = (int) 0 ;
5998 int arg4 = (int) 0 ;
5999 wxRect *result = 0 ;
6000 int val1 ;
6001 int ecode1 = 0 ;
6002 int val2 ;
6003 int ecode2 = 0 ;
6004 int val3 ;
6005 int ecode3 = 0 ;
6006 int val4 ;
6007 int ecode4 = 0 ;
6008 PyObject * obj0 = 0 ;
6009 PyObject * obj1 = 0 ;
6010 PyObject * obj2 = 0 ;
6011 PyObject * obj3 = 0 ;
6012 char * kwnames[] = {
6013 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6014 };
6015
6016 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6017 if (obj0) {
6018 ecode1 = SWIG_AsVal_int(obj0, &val1);
6019 if (!SWIG_IsOK(ecode1)) {
6020 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Rect" "', expected argument " "1"" of type '" "int""'");
6021 }
6022 arg1 = static_cast< int >(val1);
6023 }
6024 if (obj1) {
6025 ecode2 = SWIG_AsVal_int(obj1, &val2);
6026 if (!SWIG_IsOK(ecode2)) {
6027 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Rect" "', expected argument " "2"" of type '" "int""'");
6028 }
6029 arg2 = static_cast< int >(val2);
6030 }
6031 if (obj2) {
6032 ecode3 = SWIG_AsVal_int(obj2, &val3);
6033 if (!SWIG_IsOK(ecode3)) {
6034 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Rect" "', expected argument " "3"" of type '" "int""'");
6035 }
6036 arg3 = static_cast< int >(val3);
6037 }
6038 if (obj3) {
6039 ecode4 = SWIG_AsVal_int(obj3, &val4);
6040 if (!SWIG_IsOK(ecode4)) {
6041 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Rect" "', expected argument " "4"" of type '" "int""'");
6042 }
6043 arg4 = static_cast< int >(val4);
6044 }
6045 {
6046 PyThreadState* __tstate = wxPyBeginAllowThreads();
6047 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
6048 wxPyEndAllowThreads(__tstate);
6049 if (PyErr_Occurred()) SWIG_fail;
6050 }
6051 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_NEW | 0 );
6052 return resultobj;
6053 fail:
6054 return NULL;
6055 }
6056
6057
6058 SWIGINTERN PyObject *_wrap_new_RectPP(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6059 PyObject *resultobj = 0;
6060 wxPoint *arg1 = 0 ;
6061 wxPoint *arg2 = 0 ;
6062 wxRect *result = 0 ;
6063 wxPoint temp1 ;
6064 wxPoint temp2 ;
6065 PyObject * obj0 = 0 ;
6066 PyObject * obj1 = 0 ;
6067 char * kwnames[] = {
6068 (char *) "topLeft",(char *) "bottomRight", NULL
6069 };
6070
6071 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) SWIG_fail;
6072 {
6073 arg1 = &temp1;
6074 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6075 }
6076 {
6077 arg2 = &temp2;
6078 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6079 }
6080 {
6081 PyThreadState* __tstate = wxPyBeginAllowThreads();
6082 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
6083 wxPyEndAllowThreads(__tstate);
6084 if (PyErr_Occurred()) SWIG_fail;
6085 }
6086 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6087 return resultobj;
6088 fail:
6089 return NULL;
6090 }
6091
6092
6093 SWIGINTERN PyObject *_wrap_new_RectPS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6094 PyObject *resultobj = 0;
6095 wxPoint *arg1 = 0 ;
6096 wxSize *arg2 = 0 ;
6097 wxRect *result = 0 ;
6098 wxPoint temp1 ;
6099 wxSize temp2 ;
6100 PyObject * obj0 = 0 ;
6101 PyObject * obj1 = 0 ;
6102 char * kwnames[] = {
6103 (char *) "pos",(char *) "size", NULL
6104 };
6105
6106 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) SWIG_fail;
6107 {
6108 arg1 = &temp1;
6109 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6110 }
6111 {
6112 arg2 = &temp2;
6113 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6114 }
6115 {
6116 PyThreadState* __tstate = wxPyBeginAllowThreads();
6117 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
6118 wxPyEndAllowThreads(__tstate);
6119 if (PyErr_Occurred()) SWIG_fail;
6120 }
6121 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6122 return resultobj;
6123 fail:
6124 return NULL;
6125 }
6126
6127
6128 SWIGINTERN PyObject *_wrap_new_RectS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6129 PyObject *resultobj = 0;
6130 wxSize *arg1 = 0 ;
6131 wxRect *result = 0 ;
6132 wxSize temp1 ;
6133 PyObject * obj0 = 0 ;
6134 char * kwnames[] = {
6135 (char *) "size", NULL
6136 };
6137
6138 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) SWIG_fail;
6139 {
6140 arg1 = &temp1;
6141 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
6142 }
6143 {
6144 PyThreadState* __tstate = wxPyBeginAllowThreads();
6145 result = (wxRect *)new wxRect((wxSize const &)*arg1);
6146 wxPyEndAllowThreads(__tstate);
6147 if (PyErr_Occurred()) SWIG_fail;
6148 }
6149 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6150 return resultobj;
6151 fail:
6152 return NULL;
6153 }
6154
6155
6156 SWIGINTERN PyObject *_wrap_delete_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6157 PyObject *resultobj = 0;
6158 wxRect *arg1 = (wxRect *) 0 ;
6159 void *argp1 = 0 ;
6160 int res1 = 0 ;
6161 PyObject *swig_obj[1] ;
6162
6163 if (!args) SWIG_fail;
6164 swig_obj[0] = args;
6165 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
6166 if (!SWIG_IsOK(res1)) {
6167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect" "', expected argument " "1"" of type '" "wxRect *""'");
6168 }
6169 arg1 = reinterpret_cast< wxRect * >(argp1);
6170 {
6171 PyThreadState* __tstate = wxPyBeginAllowThreads();
6172 delete arg1;
6173
6174 wxPyEndAllowThreads(__tstate);
6175 if (PyErr_Occurred()) SWIG_fail;
6176 }
6177 resultobj = SWIG_Py_Void();
6178 return resultobj;
6179 fail:
6180 return NULL;
6181 }
6182
6183
6184 SWIGINTERN PyObject *_wrap_Rect_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6185 PyObject *resultobj = 0;
6186 wxRect *arg1 = (wxRect *) 0 ;
6187 int result;
6188 void *argp1 = 0 ;
6189 int res1 = 0 ;
6190 PyObject *swig_obj[1] ;
6191
6192 if (!args) SWIG_fail;
6193 swig_obj[0] = args;
6194 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6195 if (!SWIG_IsOK(res1)) {
6196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetX" "', expected argument " "1"" of type '" "wxRect const *""'");
6197 }
6198 arg1 = reinterpret_cast< wxRect * >(argp1);
6199 {
6200 PyThreadState* __tstate = wxPyBeginAllowThreads();
6201 result = (int)((wxRect const *)arg1)->GetX();
6202 wxPyEndAllowThreads(__tstate);
6203 if (PyErr_Occurred()) SWIG_fail;
6204 }
6205 resultobj = SWIG_From_int(static_cast< int >(result));
6206 return resultobj;
6207 fail:
6208 return NULL;
6209 }
6210
6211
6212 SWIGINTERN PyObject *_wrap_Rect_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6213 PyObject *resultobj = 0;
6214 wxRect *arg1 = (wxRect *) 0 ;
6215 int arg2 ;
6216 void *argp1 = 0 ;
6217 int res1 = 0 ;
6218 int val2 ;
6219 int ecode2 = 0 ;
6220 PyObject * obj0 = 0 ;
6221 PyObject * obj1 = 0 ;
6222 char * kwnames[] = {
6223 (char *) "self",(char *) "x", NULL
6224 };
6225
6226 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
6227 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6228 if (!SWIG_IsOK(res1)) {
6229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetX" "', expected argument " "1"" of type '" "wxRect *""'");
6230 }
6231 arg1 = reinterpret_cast< wxRect * >(argp1);
6232 ecode2 = SWIG_AsVal_int(obj1, &val2);
6233 if (!SWIG_IsOK(ecode2)) {
6234 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetX" "', expected argument " "2"" of type '" "int""'");
6235 }
6236 arg2 = static_cast< int >(val2);
6237 {
6238 PyThreadState* __tstate = wxPyBeginAllowThreads();
6239 (arg1)->SetX(arg2);
6240 wxPyEndAllowThreads(__tstate);
6241 if (PyErr_Occurred()) SWIG_fail;
6242 }
6243 resultobj = SWIG_Py_Void();
6244 return resultobj;
6245 fail:
6246 return NULL;
6247 }
6248
6249
6250 SWIGINTERN PyObject *_wrap_Rect_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6251 PyObject *resultobj = 0;
6252 wxRect *arg1 = (wxRect *) 0 ;
6253 int result;
6254 void *argp1 = 0 ;
6255 int res1 = 0 ;
6256 PyObject *swig_obj[1] ;
6257
6258 if (!args) SWIG_fail;
6259 swig_obj[0] = args;
6260 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6261 if (!SWIG_IsOK(res1)) {
6262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetY" "', expected argument " "1"" of type '" "wxRect *""'");
6263 }
6264 arg1 = reinterpret_cast< wxRect * >(argp1);
6265 {
6266 PyThreadState* __tstate = wxPyBeginAllowThreads();
6267 result = (int)(arg1)->GetY();
6268 wxPyEndAllowThreads(__tstate);
6269 if (PyErr_Occurred()) SWIG_fail;
6270 }
6271 resultobj = SWIG_From_int(static_cast< int >(result));
6272 return resultobj;
6273 fail:
6274 return NULL;
6275 }
6276
6277
6278 SWIGINTERN PyObject *_wrap_Rect_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6279 PyObject *resultobj = 0;
6280 wxRect *arg1 = (wxRect *) 0 ;
6281 int arg2 ;
6282 void *argp1 = 0 ;
6283 int res1 = 0 ;
6284 int val2 ;
6285 int ecode2 = 0 ;
6286 PyObject * obj0 = 0 ;
6287 PyObject * obj1 = 0 ;
6288 char * kwnames[] = {
6289 (char *) "self",(char *) "y", NULL
6290 };
6291
6292 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
6293 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6294 if (!SWIG_IsOK(res1)) {
6295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetY" "', expected argument " "1"" of type '" "wxRect *""'");
6296 }
6297 arg1 = reinterpret_cast< wxRect * >(argp1);
6298 ecode2 = SWIG_AsVal_int(obj1, &val2);
6299 if (!SWIG_IsOK(ecode2)) {
6300 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetY" "', expected argument " "2"" of type '" "int""'");
6301 }
6302 arg2 = static_cast< int >(val2);
6303 {
6304 PyThreadState* __tstate = wxPyBeginAllowThreads();
6305 (arg1)->SetY(arg2);
6306 wxPyEndAllowThreads(__tstate);
6307 if (PyErr_Occurred()) SWIG_fail;
6308 }
6309 resultobj = SWIG_Py_Void();
6310 return resultobj;
6311 fail:
6312 return NULL;
6313 }
6314
6315
6316 SWIGINTERN PyObject *_wrap_Rect_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6317 PyObject *resultobj = 0;
6318 wxRect *arg1 = (wxRect *) 0 ;
6319 int result;
6320 void *argp1 = 0 ;
6321 int res1 = 0 ;
6322 PyObject *swig_obj[1] ;
6323
6324 if (!args) SWIG_fail;
6325 swig_obj[0] = args;
6326 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6327 if (!SWIG_IsOK(res1)) {
6328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetWidth" "', expected argument " "1"" of type '" "wxRect const *""'");
6329 }
6330 arg1 = reinterpret_cast< wxRect * >(argp1);
6331 {
6332 PyThreadState* __tstate = wxPyBeginAllowThreads();
6333 result = (int)((wxRect const *)arg1)->GetWidth();
6334 wxPyEndAllowThreads(__tstate);
6335 if (PyErr_Occurred()) SWIG_fail;
6336 }
6337 resultobj = SWIG_From_int(static_cast< int >(result));
6338 return resultobj;
6339 fail:
6340 return NULL;
6341 }
6342
6343
6344 SWIGINTERN PyObject *_wrap_Rect_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6345 PyObject *resultobj = 0;
6346 wxRect *arg1 = (wxRect *) 0 ;
6347 int arg2 ;
6348 void *argp1 = 0 ;
6349 int res1 = 0 ;
6350 int val2 ;
6351 int ecode2 = 0 ;
6352 PyObject * obj0 = 0 ;
6353 PyObject * obj1 = 0 ;
6354 char * kwnames[] = {
6355 (char *) "self",(char *) "w", NULL
6356 };
6357
6358 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
6359 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6360 if (!SWIG_IsOK(res1)) {
6361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetWidth" "', expected argument " "1"" of type '" "wxRect *""'");
6362 }
6363 arg1 = reinterpret_cast< wxRect * >(argp1);
6364 ecode2 = SWIG_AsVal_int(obj1, &val2);
6365 if (!SWIG_IsOK(ecode2)) {
6366 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetWidth" "', expected argument " "2"" of type '" "int""'");
6367 }
6368 arg2 = static_cast< int >(val2);
6369 {
6370 PyThreadState* __tstate = wxPyBeginAllowThreads();
6371 (arg1)->SetWidth(arg2);
6372 wxPyEndAllowThreads(__tstate);
6373 if (PyErr_Occurred()) SWIG_fail;
6374 }
6375 resultobj = SWIG_Py_Void();
6376 return resultobj;
6377 fail:
6378 return NULL;
6379 }
6380
6381
6382 SWIGINTERN PyObject *_wrap_Rect_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6383 PyObject *resultobj = 0;
6384 wxRect *arg1 = (wxRect *) 0 ;
6385 int result;
6386 void *argp1 = 0 ;
6387 int res1 = 0 ;
6388 PyObject *swig_obj[1] ;
6389
6390 if (!args) SWIG_fail;
6391 swig_obj[0] = args;
6392 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6393 if (!SWIG_IsOK(res1)) {
6394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetHeight" "', expected argument " "1"" of type '" "wxRect const *""'");
6395 }
6396 arg1 = reinterpret_cast< wxRect * >(argp1);
6397 {
6398 PyThreadState* __tstate = wxPyBeginAllowThreads();
6399 result = (int)((wxRect const *)arg1)->GetHeight();
6400 wxPyEndAllowThreads(__tstate);
6401 if (PyErr_Occurred()) SWIG_fail;
6402 }
6403 resultobj = SWIG_From_int(static_cast< int >(result));
6404 return resultobj;
6405 fail:
6406 return NULL;
6407 }
6408
6409
6410 SWIGINTERN PyObject *_wrap_Rect_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6411 PyObject *resultobj = 0;
6412 wxRect *arg1 = (wxRect *) 0 ;
6413 int arg2 ;
6414 void *argp1 = 0 ;
6415 int res1 = 0 ;
6416 int val2 ;
6417 int ecode2 = 0 ;
6418 PyObject * obj0 = 0 ;
6419 PyObject * obj1 = 0 ;
6420 char * kwnames[] = {
6421 (char *) "self",(char *) "h", NULL
6422 };
6423
6424 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
6425 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6426 if (!SWIG_IsOK(res1)) {
6427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetHeight" "', expected argument " "1"" of type '" "wxRect *""'");
6428 }
6429 arg1 = reinterpret_cast< wxRect * >(argp1);
6430 ecode2 = SWIG_AsVal_int(obj1, &val2);
6431 if (!SWIG_IsOK(ecode2)) {
6432 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetHeight" "', expected argument " "2"" of type '" "int""'");
6433 }
6434 arg2 = static_cast< int >(val2);
6435 {
6436 PyThreadState* __tstate = wxPyBeginAllowThreads();
6437 (arg1)->SetHeight(arg2);
6438 wxPyEndAllowThreads(__tstate);
6439 if (PyErr_Occurred()) SWIG_fail;
6440 }
6441 resultobj = SWIG_Py_Void();
6442 return resultobj;
6443 fail:
6444 return NULL;
6445 }
6446
6447
6448 SWIGINTERN PyObject *_wrap_Rect_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6449 PyObject *resultobj = 0;
6450 wxRect *arg1 = (wxRect *) 0 ;
6451 wxPoint result;
6452 void *argp1 = 0 ;
6453 int res1 = 0 ;
6454 PyObject *swig_obj[1] ;
6455
6456 if (!args) SWIG_fail;
6457 swig_obj[0] = args;
6458 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6459 if (!SWIG_IsOK(res1)) {
6460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetPosition" "', expected argument " "1"" of type '" "wxRect const *""'");
6461 }
6462 arg1 = reinterpret_cast< wxRect * >(argp1);
6463 {
6464 PyThreadState* __tstate = wxPyBeginAllowThreads();
6465 result = ((wxRect const *)arg1)->GetPosition();
6466 wxPyEndAllowThreads(__tstate);
6467 if (PyErr_Occurred()) SWIG_fail;
6468 }
6469 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6470 return resultobj;
6471 fail:
6472 return NULL;
6473 }
6474
6475
6476 SWIGINTERN PyObject *_wrap_Rect_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6477 PyObject *resultobj = 0;
6478 wxRect *arg1 = (wxRect *) 0 ;
6479 wxPoint *arg2 = 0 ;
6480 void *argp1 = 0 ;
6481 int res1 = 0 ;
6482 wxPoint temp2 ;
6483 PyObject * obj0 = 0 ;
6484 PyObject * obj1 = 0 ;
6485 char * kwnames[] = {
6486 (char *) "self",(char *) "p", NULL
6487 };
6488
6489 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
6490 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6491 if (!SWIG_IsOK(res1)) {
6492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetPosition" "', expected argument " "1"" of type '" "wxRect *""'");
6493 }
6494 arg1 = reinterpret_cast< wxRect * >(argp1);
6495 {
6496 arg2 = &temp2;
6497 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6498 }
6499 {
6500 PyThreadState* __tstate = wxPyBeginAllowThreads();
6501 (arg1)->SetPosition((wxPoint const &)*arg2);
6502 wxPyEndAllowThreads(__tstate);
6503 if (PyErr_Occurred()) SWIG_fail;
6504 }
6505 resultobj = SWIG_Py_Void();
6506 return resultobj;
6507 fail:
6508 return NULL;
6509 }
6510
6511
6512 SWIGINTERN PyObject *_wrap_Rect_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6513 PyObject *resultobj = 0;
6514 wxRect *arg1 = (wxRect *) 0 ;
6515 wxSize result;
6516 void *argp1 = 0 ;
6517 int res1 = 0 ;
6518 PyObject *swig_obj[1] ;
6519
6520 if (!args) SWIG_fail;
6521 swig_obj[0] = args;
6522 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6523 if (!SWIG_IsOK(res1)) {
6524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetSize" "', expected argument " "1"" of type '" "wxRect const *""'");
6525 }
6526 arg1 = reinterpret_cast< wxRect * >(argp1);
6527 {
6528 PyThreadState* __tstate = wxPyBeginAllowThreads();
6529 result = ((wxRect const *)arg1)->GetSize();
6530 wxPyEndAllowThreads(__tstate);
6531 if (PyErr_Occurred()) SWIG_fail;
6532 }
6533 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6534 return resultobj;
6535 fail:
6536 return NULL;
6537 }
6538
6539
6540 SWIGINTERN PyObject *_wrap_Rect_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6541 PyObject *resultobj = 0;
6542 wxRect *arg1 = (wxRect *) 0 ;
6543 wxSize *arg2 = 0 ;
6544 void *argp1 = 0 ;
6545 int res1 = 0 ;
6546 wxSize temp2 ;
6547 PyObject * obj0 = 0 ;
6548 PyObject * obj1 = 0 ;
6549 char * kwnames[] = {
6550 (char *) "self",(char *) "s", NULL
6551 };
6552
6553 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
6554 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6555 if (!SWIG_IsOK(res1)) {
6556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetSize" "', expected argument " "1"" of type '" "wxRect *""'");
6557 }
6558 arg1 = reinterpret_cast< wxRect * >(argp1);
6559 {
6560 arg2 = &temp2;
6561 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6562 }
6563 {
6564 PyThreadState* __tstate = wxPyBeginAllowThreads();
6565 (arg1)->SetSize((wxSize const &)*arg2);
6566 wxPyEndAllowThreads(__tstate);
6567 if (PyErr_Occurred()) SWIG_fail;
6568 }
6569 resultobj = SWIG_Py_Void();
6570 return resultobj;
6571 fail:
6572 return NULL;
6573 }
6574
6575
6576 SWIGINTERN PyObject *_wrap_Rect_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6577 PyObject *resultobj = 0;
6578 wxRect *arg1 = (wxRect *) 0 ;
6579 bool result;
6580 void *argp1 = 0 ;
6581 int res1 = 0 ;
6582 PyObject *swig_obj[1] ;
6583
6584 if (!args) SWIG_fail;
6585 swig_obj[0] = args;
6586 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6587 if (!SWIG_IsOK(res1)) {
6588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_IsEmpty" "', expected argument " "1"" of type '" "wxRect const *""'");
6589 }
6590 arg1 = reinterpret_cast< wxRect * >(argp1);
6591 {
6592 PyThreadState* __tstate = wxPyBeginAllowThreads();
6593 result = (bool)((wxRect const *)arg1)->IsEmpty();
6594 wxPyEndAllowThreads(__tstate);
6595 if (PyErr_Occurred()) SWIG_fail;
6596 }
6597 {
6598 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6599 }
6600 return resultobj;
6601 fail:
6602 return NULL;
6603 }
6604
6605
6606 SWIGINTERN PyObject *_wrap_Rect_GetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6607 PyObject *resultobj = 0;
6608 wxRect *arg1 = (wxRect *) 0 ;
6609 wxPoint result;
6610 void *argp1 = 0 ;
6611 int res1 = 0 ;
6612 PyObject *swig_obj[1] ;
6613
6614 if (!args) SWIG_fail;
6615 swig_obj[0] = args;
6616 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6617 if (!SWIG_IsOK(res1)) {
6618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6619 }
6620 arg1 = reinterpret_cast< wxRect * >(argp1);
6621 {
6622 PyThreadState* __tstate = wxPyBeginAllowThreads();
6623 result = ((wxRect const *)arg1)->GetTopLeft();
6624 wxPyEndAllowThreads(__tstate);
6625 if (PyErr_Occurred()) SWIG_fail;
6626 }
6627 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6628 return resultobj;
6629 fail:
6630 return NULL;
6631 }
6632
6633
6634 SWIGINTERN PyObject *_wrap_Rect_SetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6635 PyObject *resultobj = 0;
6636 wxRect *arg1 = (wxRect *) 0 ;
6637 wxPoint *arg2 = 0 ;
6638 void *argp1 = 0 ;
6639 int res1 = 0 ;
6640 wxPoint temp2 ;
6641 PyObject * obj0 = 0 ;
6642 PyObject * obj1 = 0 ;
6643 char * kwnames[] = {
6644 (char *) "self",(char *) "p", NULL
6645 };
6646
6647 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6648 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6649 if (!SWIG_IsOK(res1)) {
6650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6651 }
6652 arg1 = reinterpret_cast< wxRect * >(argp1);
6653 {
6654 arg2 = &temp2;
6655 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6656 }
6657 {
6658 PyThreadState* __tstate = wxPyBeginAllowThreads();
6659 (arg1)->SetTopLeft((wxPoint const &)*arg2);
6660 wxPyEndAllowThreads(__tstate);
6661 if (PyErr_Occurred()) SWIG_fail;
6662 }
6663 resultobj = SWIG_Py_Void();
6664 return resultobj;
6665 fail:
6666 return NULL;
6667 }
6668
6669
6670 SWIGINTERN PyObject *_wrap_Rect_GetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6671 PyObject *resultobj = 0;
6672 wxRect *arg1 = (wxRect *) 0 ;
6673 wxPoint result;
6674 void *argp1 = 0 ;
6675 int res1 = 0 ;
6676 PyObject *swig_obj[1] ;
6677
6678 if (!args) SWIG_fail;
6679 swig_obj[0] = args;
6680 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6681 if (!SWIG_IsOK(res1)) {
6682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6683 }
6684 arg1 = reinterpret_cast< wxRect * >(argp1);
6685 {
6686 PyThreadState* __tstate = wxPyBeginAllowThreads();
6687 result = ((wxRect const *)arg1)->GetBottomRight();
6688 wxPyEndAllowThreads(__tstate);
6689 if (PyErr_Occurred()) SWIG_fail;
6690 }
6691 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6692 return resultobj;
6693 fail:
6694 return NULL;
6695 }
6696
6697
6698 SWIGINTERN PyObject *_wrap_Rect_SetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6699 PyObject *resultobj = 0;
6700 wxRect *arg1 = (wxRect *) 0 ;
6701 wxPoint *arg2 = 0 ;
6702 void *argp1 = 0 ;
6703 int res1 = 0 ;
6704 wxPoint temp2 ;
6705 PyObject * obj0 = 0 ;
6706 PyObject * obj1 = 0 ;
6707 char * kwnames[] = {
6708 (char *) "self",(char *) "p", NULL
6709 };
6710
6711 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) SWIG_fail;
6712 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6713 if (!SWIG_IsOK(res1)) {
6714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomRight" "', expected argument " "1"" of type '" "wxRect *""'");
6715 }
6716 arg1 = reinterpret_cast< wxRect * >(argp1);
6717 {
6718 arg2 = &temp2;
6719 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6720 }
6721 {
6722 PyThreadState* __tstate = wxPyBeginAllowThreads();
6723 (arg1)->SetBottomRight((wxPoint const &)*arg2);
6724 wxPyEndAllowThreads(__tstate);
6725 if (PyErr_Occurred()) SWIG_fail;
6726 }
6727 resultobj = SWIG_Py_Void();
6728 return resultobj;
6729 fail:
6730 return NULL;
6731 }
6732
6733
6734 SWIGINTERN PyObject *_wrap_Rect_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6735 PyObject *resultobj = 0;
6736 wxRect *arg1 = (wxRect *) 0 ;
6737 int result;
6738 void *argp1 = 0 ;
6739 int res1 = 0 ;
6740 PyObject *swig_obj[1] ;
6741
6742 if (!args) SWIG_fail;
6743 swig_obj[0] = args;
6744 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6745 if (!SWIG_IsOK(res1)) {
6746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6747 }
6748 arg1 = reinterpret_cast< wxRect * >(argp1);
6749 {
6750 PyThreadState* __tstate = wxPyBeginAllowThreads();
6751 result = (int)((wxRect const *)arg1)->GetLeft();
6752 wxPyEndAllowThreads(__tstate);
6753 if (PyErr_Occurred()) SWIG_fail;
6754 }
6755 resultobj = SWIG_From_int(static_cast< int >(result));
6756 return resultobj;
6757 fail:
6758 return NULL;
6759 }
6760
6761
6762 SWIGINTERN PyObject *_wrap_Rect_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6763 PyObject *resultobj = 0;
6764 wxRect *arg1 = (wxRect *) 0 ;
6765 int result;
6766 void *argp1 = 0 ;
6767 int res1 = 0 ;
6768 PyObject *swig_obj[1] ;
6769
6770 if (!args) SWIG_fail;
6771 swig_obj[0] = args;
6772 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6773 if (!SWIG_IsOK(res1)) {
6774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTop" "', expected argument " "1"" of type '" "wxRect const *""'");
6775 }
6776 arg1 = reinterpret_cast< wxRect * >(argp1);
6777 {
6778 PyThreadState* __tstate = wxPyBeginAllowThreads();
6779 result = (int)((wxRect const *)arg1)->GetTop();
6780 wxPyEndAllowThreads(__tstate);
6781 if (PyErr_Occurred()) SWIG_fail;
6782 }
6783 resultobj = SWIG_From_int(static_cast< int >(result));
6784 return resultobj;
6785 fail:
6786 return NULL;
6787 }
6788
6789
6790 SWIGINTERN PyObject *_wrap_Rect_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6791 PyObject *resultobj = 0;
6792 wxRect *arg1 = (wxRect *) 0 ;
6793 int result;
6794 void *argp1 = 0 ;
6795 int res1 = 0 ;
6796 PyObject *swig_obj[1] ;
6797
6798 if (!args) SWIG_fail;
6799 swig_obj[0] = args;
6800 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6801 if (!SWIG_IsOK(res1)) {
6802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottom" "', expected argument " "1"" of type '" "wxRect const *""'");
6803 }
6804 arg1 = reinterpret_cast< wxRect * >(argp1);
6805 {
6806 PyThreadState* __tstate = wxPyBeginAllowThreads();
6807 result = (int)((wxRect const *)arg1)->GetBottom();
6808 wxPyEndAllowThreads(__tstate);
6809 if (PyErr_Occurred()) SWIG_fail;
6810 }
6811 resultobj = SWIG_From_int(static_cast< int >(result));
6812 return resultobj;
6813 fail:
6814 return NULL;
6815 }
6816
6817
6818 SWIGINTERN PyObject *_wrap_Rect_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6819 PyObject *resultobj = 0;
6820 wxRect *arg1 = (wxRect *) 0 ;
6821 int result;
6822 void *argp1 = 0 ;
6823 int res1 = 0 ;
6824 PyObject *swig_obj[1] ;
6825
6826 if (!args) SWIG_fail;
6827 swig_obj[0] = args;
6828 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6829 if (!SWIG_IsOK(res1)) {
6830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6831 }
6832 arg1 = reinterpret_cast< wxRect * >(argp1);
6833 {
6834 PyThreadState* __tstate = wxPyBeginAllowThreads();
6835 result = (int)((wxRect const *)arg1)->GetRight();
6836 wxPyEndAllowThreads(__tstate);
6837 if (PyErr_Occurred()) SWIG_fail;
6838 }
6839 resultobj = SWIG_From_int(static_cast< int >(result));
6840 return resultobj;
6841 fail:
6842 return NULL;
6843 }
6844
6845
6846 SWIGINTERN PyObject *_wrap_Rect_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6847 PyObject *resultobj = 0;
6848 wxRect *arg1 = (wxRect *) 0 ;
6849 int arg2 ;
6850 void *argp1 = 0 ;
6851 int res1 = 0 ;
6852 int val2 ;
6853 int ecode2 = 0 ;
6854 PyObject * obj0 = 0 ;
6855 PyObject * obj1 = 0 ;
6856 char * kwnames[] = {
6857 (char *) "self",(char *) "left", NULL
6858 };
6859
6860 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6861 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6862 if (!SWIG_IsOK(res1)) {
6863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6864 }
6865 arg1 = reinterpret_cast< wxRect * >(argp1);
6866 ecode2 = SWIG_AsVal_int(obj1, &val2);
6867 if (!SWIG_IsOK(ecode2)) {
6868 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetLeft" "', expected argument " "2"" of type '" "int""'");
6869 }
6870 arg2 = static_cast< int >(val2);
6871 {
6872 PyThreadState* __tstate = wxPyBeginAllowThreads();
6873 (arg1)->SetLeft(arg2);
6874 wxPyEndAllowThreads(__tstate);
6875 if (PyErr_Occurred()) SWIG_fail;
6876 }
6877 resultobj = SWIG_Py_Void();
6878 return resultobj;
6879 fail:
6880 return NULL;
6881 }
6882
6883
6884 SWIGINTERN PyObject *_wrap_Rect_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6885 PyObject *resultobj = 0;
6886 wxRect *arg1 = (wxRect *) 0 ;
6887 int arg2 ;
6888 void *argp1 = 0 ;
6889 int res1 = 0 ;
6890 int val2 ;
6891 int ecode2 = 0 ;
6892 PyObject * obj0 = 0 ;
6893 PyObject * obj1 = 0 ;
6894 char * kwnames[] = {
6895 (char *) "self",(char *) "right", NULL
6896 };
6897
6898 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
6899 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6900 if (!SWIG_IsOK(res1)) {
6901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetRight" "', expected argument " "1"" of type '" "wxRect *""'");
6902 }
6903 arg1 = reinterpret_cast< wxRect * >(argp1);
6904 ecode2 = SWIG_AsVal_int(obj1, &val2);
6905 if (!SWIG_IsOK(ecode2)) {
6906 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetRight" "', expected argument " "2"" of type '" "int""'");
6907 }
6908 arg2 = static_cast< int >(val2);
6909 {
6910 PyThreadState* __tstate = wxPyBeginAllowThreads();
6911 (arg1)->SetRight(arg2);
6912 wxPyEndAllowThreads(__tstate);
6913 if (PyErr_Occurred()) SWIG_fail;
6914 }
6915 resultobj = SWIG_Py_Void();
6916 return resultobj;
6917 fail:
6918 return NULL;
6919 }
6920
6921
6922 SWIGINTERN PyObject *_wrap_Rect_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6923 PyObject *resultobj = 0;
6924 wxRect *arg1 = (wxRect *) 0 ;
6925 int arg2 ;
6926 void *argp1 = 0 ;
6927 int res1 = 0 ;
6928 int val2 ;
6929 int ecode2 = 0 ;
6930 PyObject * obj0 = 0 ;
6931 PyObject * obj1 = 0 ;
6932 char * kwnames[] = {
6933 (char *) "self",(char *) "top", NULL
6934 };
6935
6936 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
6937 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6938 if (!SWIG_IsOK(res1)) {
6939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTop" "', expected argument " "1"" of type '" "wxRect *""'");
6940 }
6941 arg1 = reinterpret_cast< wxRect * >(argp1);
6942 ecode2 = SWIG_AsVal_int(obj1, &val2);
6943 if (!SWIG_IsOK(ecode2)) {
6944 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetTop" "', expected argument " "2"" of type '" "int""'");
6945 }
6946 arg2 = static_cast< int >(val2);
6947 {
6948 PyThreadState* __tstate = wxPyBeginAllowThreads();
6949 (arg1)->SetTop(arg2);
6950 wxPyEndAllowThreads(__tstate);
6951 if (PyErr_Occurred()) SWIG_fail;
6952 }
6953 resultobj = SWIG_Py_Void();
6954 return resultobj;
6955 fail:
6956 return NULL;
6957 }
6958
6959
6960 SWIGINTERN PyObject *_wrap_Rect_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6961 PyObject *resultobj = 0;
6962 wxRect *arg1 = (wxRect *) 0 ;
6963 int arg2 ;
6964 void *argp1 = 0 ;
6965 int res1 = 0 ;
6966 int val2 ;
6967 int ecode2 = 0 ;
6968 PyObject * obj0 = 0 ;
6969 PyObject * obj1 = 0 ;
6970 char * kwnames[] = {
6971 (char *) "self",(char *) "bottom", NULL
6972 };
6973
6974 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
6975 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6976 if (!SWIG_IsOK(res1)) {
6977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottom" "', expected argument " "1"" of type '" "wxRect *""'");
6978 }
6979 arg1 = reinterpret_cast< wxRect * >(argp1);
6980 ecode2 = SWIG_AsVal_int(obj1, &val2);
6981 if (!SWIG_IsOK(ecode2)) {
6982 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetBottom" "', expected argument " "2"" of type '" "int""'");
6983 }
6984 arg2 = static_cast< int >(val2);
6985 {
6986 PyThreadState* __tstate = wxPyBeginAllowThreads();
6987 (arg1)->SetBottom(arg2);
6988 wxPyEndAllowThreads(__tstate);
6989 if (PyErr_Occurred()) SWIG_fail;
6990 }
6991 resultobj = SWIG_Py_Void();
6992 return resultobj;
6993 fail:
6994 return NULL;
6995 }
6996
6997
6998 SWIGINTERN PyObject *_wrap_Rect_Inflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6999 PyObject *resultobj = 0;
7000 wxRect *arg1 = (wxRect *) 0 ;
7001 int arg2 ;
7002 int arg3 ;
7003 wxRect *result = 0 ;
7004 void *argp1 = 0 ;
7005 int res1 = 0 ;
7006 int val2 ;
7007 int ecode2 = 0 ;
7008 int val3 ;
7009 int ecode3 = 0 ;
7010 PyObject * obj0 = 0 ;
7011 PyObject * obj1 = 0 ;
7012 PyObject * obj2 = 0 ;
7013 char * kwnames[] = {
7014 (char *) "self",(char *) "dx",(char *) "dy", NULL
7015 };
7016
7017 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7018 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7019 if (!SWIG_IsOK(res1)) {
7020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inflate" "', expected argument " "1"" of type '" "wxRect *""'");
7021 }
7022 arg1 = reinterpret_cast< wxRect * >(argp1);
7023 ecode2 = SWIG_AsVal_int(obj1, &val2);
7024 if (!SWIG_IsOK(ecode2)) {
7025 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Inflate" "', expected argument " "2"" of type '" "int""'");
7026 }
7027 arg2 = static_cast< int >(val2);
7028 ecode3 = SWIG_AsVal_int(obj2, &val3);
7029 if (!SWIG_IsOK(ecode3)) {
7030 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Inflate" "', expected argument " "3"" of type '" "int""'");
7031 }
7032 arg3 = static_cast< int >(val3);
7033 {
7034 PyThreadState* __tstate = wxPyBeginAllowThreads();
7035 {
7036 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
7037 result = (wxRect *) &_result_ref;
7038 }
7039 wxPyEndAllowThreads(__tstate);
7040 if (PyErr_Occurred()) SWIG_fail;
7041 }
7042 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7043 return resultobj;
7044 fail:
7045 return NULL;
7046 }
7047
7048
7049 SWIGINTERN PyObject *_wrap_Rect_Deflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7050 PyObject *resultobj = 0;
7051 wxRect *arg1 = (wxRect *) 0 ;
7052 int arg2 ;
7053 int arg3 ;
7054 wxRect *result = 0 ;
7055 void *argp1 = 0 ;
7056 int res1 = 0 ;
7057 int val2 ;
7058 int ecode2 = 0 ;
7059 int val3 ;
7060 int ecode3 = 0 ;
7061 PyObject * obj0 = 0 ;
7062 PyObject * obj1 = 0 ;
7063 PyObject * obj2 = 0 ;
7064 char * kwnames[] = {
7065 (char *) "self",(char *) "dx",(char *) "dy", NULL
7066 };
7067
7068 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7069 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7070 if (!SWIG_IsOK(res1)) {
7071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Deflate" "', expected argument " "1"" of type '" "wxRect *""'");
7072 }
7073 arg1 = reinterpret_cast< wxRect * >(argp1);
7074 ecode2 = SWIG_AsVal_int(obj1, &val2);
7075 if (!SWIG_IsOK(ecode2)) {
7076 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Deflate" "', expected argument " "2"" of type '" "int""'");
7077 }
7078 arg2 = static_cast< int >(val2);
7079 ecode3 = SWIG_AsVal_int(obj2, &val3);
7080 if (!SWIG_IsOK(ecode3)) {
7081 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Deflate" "', expected argument " "3"" of type '" "int""'");
7082 }
7083 arg3 = static_cast< int >(val3);
7084 {
7085 PyThreadState* __tstate = wxPyBeginAllowThreads();
7086 {
7087 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
7088 result = (wxRect *) &_result_ref;
7089 }
7090 wxPyEndAllowThreads(__tstate);
7091 if (PyErr_Occurred()) SWIG_fail;
7092 }
7093 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7094 return resultobj;
7095 fail:
7096 return NULL;
7097 }
7098
7099
7100 SWIGINTERN PyObject *_wrap_Rect_OffsetXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7101 PyObject *resultobj = 0;
7102 wxRect *arg1 = (wxRect *) 0 ;
7103 int arg2 ;
7104 int arg3 ;
7105 void *argp1 = 0 ;
7106 int res1 = 0 ;
7107 int val2 ;
7108 int ecode2 = 0 ;
7109 int val3 ;
7110 int ecode3 = 0 ;
7111 PyObject * obj0 = 0 ;
7112 PyObject * obj1 = 0 ;
7113 PyObject * obj2 = 0 ;
7114 char * kwnames[] = {
7115 (char *) "self",(char *) "dx",(char *) "dy", NULL
7116 };
7117
7118 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7119 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7120 if (!SWIG_IsOK(res1)) {
7121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_OffsetXY" "', expected argument " "1"" of type '" "wxRect *""'");
7122 }
7123 arg1 = reinterpret_cast< wxRect * >(argp1);
7124 ecode2 = SWIG_AsVal_int(obj1, &val2);
7125 if (!SWIG_IsOK(ecode2)) {
7126 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_OffsetXY" "', expected argument " "2"" of type '" "int""'");
7127 }
7128 arg2 = static_cast< int >(val2);
7129 ecode3 = SWIG_AsVal_int(obj2, &val3);
7130 if (!SWIG_IsOK(ecode3)) {
7131 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_OffsetXY" "', expected argument " "3"" of type '" "int""'");
7132 }
7133 arg3 = static_cast< int >(val3);
7134 {
7135 PyThreadState* __tstate = wxPyBeginAllowThreads();
7136 (arg1)->Offset(arg2,arg3);
7137 wxPyEndAllowThreads(__tstate);
7138 if (PyErr_Occurred()) SWIG_fail;
7139 }
7140 resultobj = SWIG_Py_Void();
7141 return resultobj;
7142 fail:
7143 return NULL;
7144 }
7145
7146
7147 SWIGINTERN PyObject *_wrap_Rect_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7148 PyObject *resultobj = 0;
7149 wxRect *arg1 = (wxRect *) 0 ;
7150 wxPoint *arg2 = 0 ;
7151 void *argp1 = 0 ;
7152 int res1 = 0 ;
7153 wxPoint temp2 ;
7154 PyObject * obj0 = 0 ;
7155 PyObject * obj1 = 0 ;
7156 char * kwnames[] = {
7157 (char *) "self",(char *) "pt", NULL
7158 };
7159
7160 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
7161 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7162 if (!SWIG_IsOK(res1)) {
7163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Offset" "', expected argument " "1"" of type '" "wxRect *""'");
7164 }
7165 arg1 = reinterpret_cast< wxRect * >(argp1);
7166 {
7167 arg2 = &temp2;
7168 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7169 }
7170 {
7171 PyThreadState* __tstate = wxPyBeginAllowThreads();
7172 (arg1)->Offset((wxPoint const &)*arg2);
7173 wxPyEndAllowThreads(__tstate);
7174 if (PyErr_Occurred()) SWIG_fail;
7175 }
7176 resultobj = SWIG_Py_Void();
7177 return resultobj;
7178 fail:
7179 return NULL;
7180 }
7181
7182
7183 SWIGINTERN PyObject *_wrap_Rect_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7184 PyObject *resultobj = 0;
7185 wxRect *arg1 = (wxRect *) 0 ;
7186 wxRect *arg2 = 0 ;
7187 wxRect result;
7188 void *argp1 = 0 ;
7189 int res1 = 0 ;
7190 wxRect temp2 ;
7191 PyObject * obj0 = 0 ;
7192 PyObject * obj1 = 0 ;
7193 char * kwnames[] = {
7194 (char *) "self",(char *) "rect", NULL
7195 };
7196
7197 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
7198 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7199 if (!SWIG_IsOK(res1)) {
7200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersect" "', expected argument " "1"" of type '" "wxRect *""'");
7201 }
7202 arg1 = reinterpret_cast< wxRect * >(argp1);
7203 {
7204 arg2 = &temp2;
7205 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7206 }
7207 {
7208 PyThreadState* __tstate = wxPyBeginAllowThreads();
7209 result = (arg1)->Intersect((wxRect const &)*arg2);
7210 wxPyEndAllowThreads(__tstate);
7211 if (PyErr_Occurred()) SWIG_fail;
7212 }
7213 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7214 return resultobj;
7215 fail:
7216 return NULL;
7217 }
7218
7219
7220 SWIGINTERN PyObject *_wrap_Rect_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7221 PyObject *resultobj = 0;
7222 wxRect *arg1 = (wxRect *) 0 ;
7223 wxRect *arg2 = 0 ;
7224 wxRect result;
7225 void *argp1 = 0 ;
7226 int res1 = 0 ;
7227 wxRect temp2 ;
7228 PyObject * obj0 = 0 ;
7229 PyObject * obj1 = 0 ;
7230 char * kwnames[] = {
7231 (char *) "self",(char *) "rect", NULL
7232 };
7233
7234 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) SWIG_fail;
7235 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7236 if (!SWIG_IsOK(res1)) {
7237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Union" "', expected argument " "1"" of type '" "wxRect *""'");
7238 }
7239 arg1 = reinterpret_cast< wxRect * >(argp1);
7240 {
7241 arg2 = &temp2;
7242 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7243 }
7244 {
7245 PyThreadState* __tstate = wxPyBeginAllowThreads();
7246 result = (arg1)->Union((wxRect const &)*arg2);
7247 wxPyEndAllowThreads(__tstate);
7248 if (PyErr_Occurred()) SWIG_fail;
7249 }
7250 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7251 return resultobj;
7252 fail:
7253 return NULL;
7254 }
7255
7256
7257 SWIGINTERN PyObject *_wrap_Rect___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7258 PyObject *resultobj = 0;
7259 wxRect *arg1 = (wxRect *) 0 ;
7260 wxRect *arg2 = 0 ;
7261 wxRect result;
7262 void *argp1 = 0 ;
7263 int res1 = 0 ;
7264 wxRect temp2 ;
7265 PyObject * obj0 = 0 ;
7266 PyObject * obj1 = 0 ;
7267 char * kwnames[] = {
7268 (char *) "self",(char *) "rect", NULL
7269 };
7270
7271 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) SWIG_fail;
7272 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7273 if (!SWIG_IsOK(res1)) {
7274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___add__" "', expected argument " "1"" of type '" "wxRect const *""'");
7275 }
7276 arg1 = reinterpret_cast< wxRect * >(argp1);
7277 {
7278 arg2 = &temp2;
7279 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7280 }
7281 {
7282 PyThreadState* __tstate = wxPyBeginAllowThreads();
7283 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
7284 wxPyEndAllowThreads(__tstate);
7285 if (PyErr_Occurred()) SWIG_fail;
7286 }
7287 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7288 return resultobj;
7289 fail:
7290 return NULL;
7291 }
7292
7293
7294 SWIGINTERN PyObject *_wrap_Rect___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7295 PyObject *resultobj = 0;
7296 wxRect *arg1 = (wxRect *) 0 ;
7297 wxRect *arg2 = 0 ;
7298 wxRect *result = 0 ;
7299 void *argp1 = 0 ;
7300 int res1 = 0 ;
7301 wxRect temp2 ;
7302 PyObject * obj0 = 0 ;
7303 PyObject * obj1 = 0 ;
7304 char * kwnames[] = {
7305 (char *) "self",(char *) "rect", NULL
7306 };
7307
7308 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
7309 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
7310 if (!SWIG_IsOK(res1)) {
7311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___iadd__" "', expected argument " "1"" of type '" "wxRect *""'");
7312 }
7313 arg1 = reinterpret_cast< wxRect * >(argp1);
7314 {
7315 arg2 = &temp2;
7316 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7317 }
7318 {
7319 PyThreadState* __tstate = wxPyBeginAllowThreads();
7320 {
7321 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
7322 result = (wxRect *) &_result_ref;
7323 }
7324 wxPyEndAllowThreads(__tstate);
7325 if (PyErr_Occurred()) SWIG_fail;
7326 }
7327 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7328 return resultobj;
7329 fail:
7330 return NULL;
7331 }
7332
7333
7334 SWIGINTERN PyObject *_wrap_Rect___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7335 PyObject *resultobj = 0;
7336 wxRect *arg1 = (wxRect *) 0 ;
7337 PyObject *arg2 = (PyObject *) 0 ;
7338 bool result;
7339 void *argp1 = 0 ;
7340 int res1 = 0 ;
7341 PyObject * obj0 = 0 ;
7342 PyObject * obj1 = 0 ;
7343 char * kwnames[] = {
7344 (char *) "self",(char *) "other", NULL
7345 };
7346
7347 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
7348 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7349 if (!SWIG_IsOK(res1)) {
7350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___eq__" "', expected argument " "1"" of type '" "wxRect *""'");
7351 }
7352 arg1 = reinterpret_cast< wxRect * >(argp1);
7353 arg2 = obj1;
7354 {
7355 result = (bool)wxRect___eq__(arg1,arg2);
7356 if (PyErr_Occurred()) SWIG_fail;
7357 }
7358 {
7359 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7360 }
7361 return resultobj;
7362 fail:
7363 return NULL;
7364 }
7365
7366
7367 SWIGINTERN PyObject *_wrap_Rect___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7368 PyObject *resultobj = 0;
7369 wxRect *arg1 = (wxRect *) 0 ;
7370 PyObject *arg2 = (PyObject *) 0 ;
7371 bool result;
7372 void *argp1 = 0 ;
7373 int res1 = 0 ;
7374 PyObject * obj0 = 0 ;
7375 PyObject * obj1 = 0 ;
7376 char * kwnames[] = {
7377 (char *) "self",(char *) "other", NULL
7378 };
7379
7380 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
7381 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7382 if (!SWIG_IsOK(res1)) {
7383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___ne__" "', expected argument " "1"" of type '" "wxRect *""'");
7384 }
7385 arg1 = reinterpret_cast< wxRect * >(argp1);
7386 arg2 = obj1;
7387 {
7388 result = (bool)wxRect___ne__(arg1,arg2);
7389 if (PyErr_Occurred()) SWIG_fail;
7390 }
7391 {
7392 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7393 }
7394 return resultobj;
7395 fail:
7396 return NULL;
7397 }
7398
7399
7400 SWIGINTERN PyObject *_wrap_Rect_InsideXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7401 PyObject *resultobj = 0;
7402 wxRect *arg1 = (wxRect *) 0 ;
7403 int arg2 ;
7404 int arg3 ;
7405 bool result;
7406 void *argp1 = 0 ;
7407 int res1 = 0 ;
7408 int val2 ;
7409 int ecode2 = 0 ;
7410 int val3 ;
7411 int ecode3 = 0 ;
7412 PyObject * obj0 = 0 ;
7413 PyObject * obj1 = 0 ;
7414 PyObject * obj2 = 0 ;
7415 char * kwnames[] = {
7416 (char *) "self",(char *) "x",(char *) "y", NULL
7417 };
7418
7419 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_InsideXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7420 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7421 if (!SWIG_IsOK(res1)) {
7422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_InsideXY" "', expected argument " "1"" of type '" "wxRect const *""'");
7423 }
7424 arg1 = reinterpret_cast< wxRect * >(argp1);
7425 ecode2 = SWIG_AsVal_int(obj1, &val2);
7426 if (!SWIG_IsOK(ecode2)) {
7427 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_InsideXY" "', expected argument " "2"" of type '" "int""'");
7428 }
7429 arg2 = static_cast< int >(val2);
7430 ecode3 = SWIG_AsVal_int(obj2, &val3);
7431 if (!SWIG_IsOK(ecode3)) {
7432 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_InsideXY" "', expected argument " "3"" of type '" "int""'");
7433 }
7434 arg3 = static_cast< int >(val3);
7435 {
7436 PyThreadState* __tstate = wxPyBeginAllowThreads();
7437 result = (bool)((wxRect const *)arg1)->Inside(arg2,arg3);
7438 wxPyEndAllowThreads(__tstate);
7439 if (PyErr_Occurred()) SWIG_fail;
7440 }
7441 {
7442 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7443 }
7444 return resultobj;
7445 fail:
7446 return NULL;
7447 }
7448
7449
7450 SWIGINTERN PyObject *_wrap_Rect_Inside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7451 PyObject *resultobj = 0;
7452 wxRect *arg1 = (wxRect *) 0 ;
7453 wxPoint *arg2 = 0 ;
7454 bool result;
7455 void *argp1 = 0 ;
7456 int res1 = 0 ;
7457 wxPoint temp2 ;
7458 PyObject * obj0 = 0 ;
7459 PyObject * obj1 = 0 ;
7460 char * kwnames[] = {
7461 (char *) "self",(char *) "pt", NULL
7462 };
7463
7464 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Inside",kwnames,&obj0,&obj1)) SWIG_fail;
7465 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7466 if (!SWIG_IsOK(res1)) {
7467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inside" "', expected argument " "1"" of type '" "wxRect const *""'");
7468 }
7469 arg1 = reinterpret_cast< wxRect * >(argp1);
7470 {
7471 arg2 = &temp2;
7472 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7473 }
7474 {
7475 PyThreadState* __tstate = wxPyBeginAllowThreads();
7476 result = (bool)((wxRect const *)arg1)->Inside((wxPoint const &)*arg2);
7477 wxPyEndAllowThreads(__tstate);
7478 if (PyErr_Occurred()) SWIG_fail;
7479 }
7480 {
7481 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7482 }
7483 return resultobj;
7484 fail:
7485 return NULL;
7486 }
7487
7488
7489 SWIGINTERN PyObject *_wrap_Rect_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7490 PyObject *resultobj = 0;
7491 wxRect *arg1 = (wxRect *) 0 ;
7492 wxRect *arg2 = 0 ;
7493 bool result;
7494 void *argp1 = 0 ;
7495 int res1 = 0 ;
7496 wxRect temp2 ;
7497 PyObject * obj0 = 0 ;
7498 PyObject * obj1 = 0 ;
7499 char * kwnames[] = {
7500 (char *) "self",(char *) "rect", NULL
7501 };
7502
7503 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
7504 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7505 if (!SWIG_IsOK(res1)) {
7506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersects" "', expected argument " "1"" of type '" "wxRect const *""'");
7507 }
7508 arg1 = reinterpret_cast< wxRect * >(argp1);
7509 {
7510 arg2 = &temp2;
7511 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7512 }
7513 {
7514 PyThreadState* __tstate = wxPyBeginAllowThreads();
7515 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
7516 wxPyEndAllowThreads(__tstate);
7517 if (PyErr_Occurred()) SWIG_fail;
7518 }
7519 {
7520 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7521 }
7522 return resultobj;
7523 fail:
7524 return NULL;
7525 }
7526
7527
7528 SWIGINTERN PyObject *_wrap_Rect_CenterIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7529 PyObject *resultobj = 0;
7530 wxRect *arg1 = (wxRect *) 0 ;
7531 wxRect *arg2 = 0 ;
7532 int arg3 = (int) wxBOTH ;
7533 wxRect result;
7534 void *argp1 = 0 ;
7535 int res1 = 0 ;
7536 wxRect temp2 ;
7537 int val3 ;
7538 int ecode3 = 0 ;
7539 PyObject * obj0 = 0 ;
7540 PyObject * obj1 = 0 ;
7541 PyObject * obj2 = 0 ;
7542 char * kwnames[] = {
7543 (char *) "self",(char *) "r",(char *) "dir", NULL
7544 };
7545
7546 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Rect_CenterIn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7547 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7548 if (!SWIG_IsOK(res1)) {
7549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_CenterIn" "', expected argument " "1"" of type '" "wxRect *""'");
7550 }
7551 arg1 = reinterpret_cast< wxRect * >(argp1);
7552 {
7553 arg2 = &temp2;
7554 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7555 }
7556 if (obj2) {
7557 ecode3 = SWIG_AsVal_int(obj2, &val3);
7558 if (!SWIG_IsOK(ecode3)) {
7559 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_CenterIn" "', expected argument " "3"" of type '" "int""'");
7560 }
7561 arg3 = static_cast< int >(val3);
7562 }
7563 {
7564 PyThreadState* __tstate = wxPyBeginAllowThreads();
7565 result = (arg1)->CenterIn((wxRect const &)*arg2,arg3);
7566 wxPyEndAllowThreads(__tstate);
7567 if (PyErr_Occurred()) SWIG_fail;
7568 }
7569 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7570 return resultobj;
7571 fail:
7572 return NULL;
7573 }
7574
7575
7576 SWIGINTERN PyObject *_wrap_Rect_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7577 PyObject *resultobj = 0;
7578 wxRect *arg1 = (wxRect *) 0 ;
7579 int arg2 ;
7580 void *argp1 = 0 ;
7581 int res1 = 0 ;
7582 int val2 ;
7583 int ecode2 = 0 ;
7584 PyObject *swig_obj[2] ;
7585
7586 if (!SWIG_Python_UnpackTuple(args,"Rect_x_set",2,2,swig_obj)) SWIG_fail;
7587 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7588 if (!SWIG_IsOK(res1)) {
7589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_set" "', expected argument " "1"" of type '" "wxRect *""'");
7590 }
7591 arg1 = reinterpret_cast< wxRect * >(argp1);
7592 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7593 if (!SWIG_IsOK(ecode2)) {
7594 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_x_set" "', expected argument " "2"" of type '" "int""'");
7595 }
7596 arg2 = static_cast< int >(val2);
7597 if (arg1) (arg1)->x = arg2;
7598
7599 resultobj = SWIG_Py_Void();
7600 return resultobj;
7601 fail:
7602 return NULL;
7603 }
7604
7605
7606 SWIGINTERN PyObject *_wrap_Rect_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7607 PyObject *resultobj = 0;
7608 wxRect *arg1 = (wxRect *) 0 ;
7609 int result;
7610 void *argp1 = 0 ;
7611 int res1 = 0 ;
7612 PyObject *swig_obj[1] ;
7613
7614 if (!args) SWIG_fail;
7615 swig_obj[0] = args;
7616 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7617 if (!SWIG_IsOK(res1)) {
7618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_get" "', expected argument " "1"" of type '" "wxRect *""'");
7619 }
7620 arg1 = reinterpret_cast< wxRect * >(argp1);
7621 result = (int) ((arg1)->x);
7622 resultobj = SWIG_From_int(static_cast< int >(result));
7623 return resultobj;
7624 fail:
7625 return NULL;
7626 }
7627
7628
7629 SWIGINTERN PyObject *_wrap_Rect_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7630 PyObject *resultobj = 0;
7631 wxRect *arg1 = (wxRect *) 0 ;
7632 int arg2 ;
7633 void *argp1 = 0 ;
7634 int res1 = 0 ;
7635 int val2 ;
7636 int ecode2 = 0 ;
7637 PyObject *swig_obj[2] ;
7638
7639 if (!SWIG_Python_UnpackTuple(args,"Rect_y_set",2,2,swig_obj)) SWIG_fail;
7640 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7641 if (!SWIG_IsOK(res1)) {
7642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_set" "', expected argument " "1"" of type '" "wxRect *""'");
7643 }
7644 arg1 = reinterpret_cast< wxRect * >(argp1);
7645 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7646 if (!SWIG_IsOK(ecode2)) {
7647 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_y_set" "', expected argument " "2"" of type '" "int""'");
7648 }
7649 arg2 = static_cast< int >(val2);
7650 if (arg1) (arg1)->y = arg2;
7651
7652 resultobj = SWIG_Py_Void();
7653 return resultobj;
7654 fail:
7655 return NULL;
7656 }
7657
7658
7659 SWIGINTERN PyObject *_wrap_Rect_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7660 PyObject *resultobj = 0;
7661 wxRect *arg1 = (wxRect *) 0 ;
7662 int result;
7663 void *argp1 = 0 ;
7664 int res1 = 0 ;
7665 PyObject *swig_obj[1] ;
7666
7667 if (!args) SWIG_fail;
7668 swig_obj[0] = args;
7669 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7670 if (!SWIG_IsOK(res1)) {
7671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_get" "', expected argument " "1"" of type '" "wxRect *""'");
7672 }
7673 arg1 = reinterpret_cast< wxRect * >(argp1);
7674 result = (int) ((arg1)->y);
7675 resultobj = SWIG_From_int(static_cast< int >(result));
7676 return resultobj;
7677 fail:
7678 return NULL;
7679 }
7680
7681
7682 SWIGINTERN PyObject *_wrap_Rect_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7683 PyObject *resultobj = 0;
7684 wxRect *arg1 = (wxRect *) 0 ;
7685 int arg2 ;
7686 void *argp1 = 0 ;
7687 int res1 = 0 ;
7688 int val2 ;
7689 int ecode2 = 0 ;
7690 PyObject *swig_obj[2] ;
7691
7692 if (!SWIG_Python_UnpackTuple(args,"Rect_width_set",2,2,swig_obj)) SWIG_fail;
7693 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7694 if (!SWIG_IsOK(res1)) {
7695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_set" "', expected argument " "1"" of type '" "wxRect *""'");
7696 }
7697 arg1 = reinterpret_cast< wxRect * >(argp1);
7698 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7699 if (!SWIG_IsOK(ecode2)) {
7700 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_width_set" "', expected argument " "2"" of type '" "int""'");
7701 }
7702 arg2 = static_cast< int >(val2);
7703 if (arg1) (arg1)->width = arg2;
7704
7705 resultobj = SWIG_Py_Void();
7706 return resultobj;
7707 fail:
7708 return NULL;
7709 }
7710
7711
7712 SWIGINTERN PyObject *_wrap_Rect_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7713 PyObject *resultobj = 0;
7714 wxRect *arg1 = (wxRect *) 0 ;
7715 int result;
7716 void *argp1 = 0 ;
7717 int res1 = 0 ;
7718 PyObject *swig_obj[1] ;
7719
7720 if (!args) SWIG_fail;
7721 swig_obj[0] = args;
7722 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7723 if (!SWIG_IsOK(res1)) {
7724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_get" "', expected argument " "1"" of type '" "wxRect *""'");
7725 }
7726 arg1 = reinterpret_cast< wxRect * >(argp1);
7727 result = (int) ((arg1)->width);
7728 resultobj = SWIG_From_int(static_cast< int >(result));
7729 return resultobj;
7730 fail:
7731 return NULL;
7732 }
7733
7734
7735 SWIGINTERN PyObject *_wrap_Rect_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7736 PyObject *resultobj = 0;
7737 wxRect *arg1 = (wxRect *) 0 ;
7738 int arg2 ;
7739 void *argp1 = 0 ;
7740 int res1 = 0 ;
7741 int val2 ;
7742 int ecode2 = 0 ;
7743 PyObject *swig_obj[2] ;
7744
7745 if (!SWIG_Python_UnpackTuple(args,"Rect_height_set",2,2,swig_obj)) SWIG_fail;
7746 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7747 if (!SWIG_IsOK(res1)) {
7748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_set" "', expected argument " "1"" of type '" "wxRect *""'");
7749 }
7750 arg1 = reinterpret_cast< wxRect * >(argp1);
7751 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7752 if (!SWIG_IsOK(ecode2)) {
7753 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_height_set" "', expected argument " "2"" of type '" "int""'");
7754 }
7755 arg2 = static_cast< int >(val2);
7756 if (arg1) (arg1)->height = arg2;
7757
7758 resultobj = SWIG_Py_Void();
7759 return resultobj;
7760 fail:
7761 return NULL;
7762 }
7763
7764
7765 SWIGINTERN PyObject *_wrap_Rect_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7766 PyObject *resultobj = 0;
7767 wxRect *arg1 = (wxRect *) 0 ;
7768 int result;
7769 void *argp1 = 0 ;
7770 int res1 = 0 ;
7771 PyObject *swig_obj[1] ;
7772
7773 if (!args) SWIG_fail;
7774 swig_obj[0] = args;
7775 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7776 if (!SWIG_IsOK(res1)) {
7777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_get" "', expected argument " "1"" of type '" "wxRect *""'");
7778 }
7779 arg1 = reinterpret_cast< wxRect * >(argp1);
7780 result = (int) ((arg1)->height);
7781 resultobj = SWIG_From_int(static_cast< int >(result));
7782 return resultobj;
7783 fail:
7784 return NULL;
7785 }
7786
7787
7788 SWIGINTERN PyObject *_wrap_Rect_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7789 PyObject *resultobj = 0;
7790 wxRect *arg1 = (wxRect *) 0 ;
7791 int arg2 = (int) 0 ;
7792 int arg3 = (int) 0 ;
7793 int arg4 = (int) 0 ;
7794 int arg5 = (int) 0 ;
7795 void *argp1 = 0 ;
7796 int res1 = 0 ;
7797 int val2 ;
7798 int ecode2 = 0 ;
7799 int val3 ;
7800 int ecode3 = 0 ;
7801 int val4 ;
7802 int ecode4 = 0 ;
7803 int val5 ;
7804 int ecode5 = 0 ;
7805 PyObject * obj0 = 0 ;
7806 PyObject * obj1 = 0 ;
7807 PyObject * obj2 = 0 ;
7808 PyObject * obj3 = 0 ;
7809 PyObject * obj4 = 0 ;
7810 char * kwnames[] = {
7811 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
7812 };
7813
7814 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
7815 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7816 if (!SWIG_IsOK(res1)) {
7817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Set" "', expected argument " "1"" of type '" "wxRect *""'");
7818 }
7819 arg1 = reinterpret_cast< wxRect * >(argp1);
7820 if (obj1) {
7821 ecode2 = SWIG_AsVal_int(obj1, &val2);
7822 if (!SWIG_IsOK(ecode2)) {
7823 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Set" "', expected argument " "2"" of type '" "int""'");
7824 }
7825 arg2 = static_cast< int >(val2);
7826 }
7827 if (obj2) {
7828 ecode3 = SWIG_AsVal_int(obj2, &val3);
7829 if (!SWIG_IsOK(ecode3)) {
7830 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Set" "', expected argument " "3"" of type '" "int""'");
7831 }
7832 arg3 = static_cast< int >(val3);
7833 }
7834 if (obj3) {
7835 ecode4 = SWIG_AsVal_int(obj3, &val4);
7836 if (!SWIG_IsOK(ecode4)) {
7837 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Rect_Set" "', expected argument " "4"" of type '" "int""'");
7838 }
7839 arg4 = static_cast< int >(val4);
7840 }
7841 if (obj4) {
7842 ecode5 = SWIG_AsVal_int(obj4, &val5);
7843 if (!SWIG_IsOK(ecode5)) {
7844 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Rect_Set" "', expected argument " "5"" of type '" "int""'");
7845 }
7846 arg5 = static_cast< int >(val5);
7847 }
7848 {
7849 PyThreadState* __tstate = wxPyBeginAllowThreads();
7850 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
7851 wxPyEndAllowThreads(__tstate);
7852 if (PyErr_Occurred()) SWIG_fail;
7853 }
7854 resultobj = SWIG_Py_Void();
7855 return resultobj;
7856 fail:
7857 return NULL;
7858 }
7859
7860
7861 SWIGINTERN PyObject *_wrap_Rect_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7862 PyObject *resultobj = 0;
7863 wxRect *arg1 = (wxRect *) 0 ;
7864 PyObject *result = 0 ;
7865 void *argp1 = 0 ;
7866 int res1 = 0 ;
7867 PyObject *swig_obj[1] ;
7868
7869 if (!args) SWIG_fail;
7870 swig_obj[0] = args;
7871 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7872 if (!SWIG_IsOK(res1)) {
7873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Get" "', expected argument " "1"" of type '" "wxRect *""'");
7874 }
7875 arg1 = reinterpret_cast< wxRect * >(argp1);
7876 {
7877 PyThreadState* __tstate = wxPyBeginAllowThreads();
7878 result = (PyObject *)wxRect_Get(arg1);
7879 wxPyEndAllowThreads(__tstate);
7880 if (PyErr_Occurred()) SWIG_fail;
7881 }
7882 resultobj = result;
7883 return resultobj;
7884 fail:
7885 return NULL;
7886 }
7887
7888
7889 SWIGINTERN PyObject *Rect_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7890 PyObject *obj;
7891 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7892 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect, SWIG_NewClientData(obj));
7893 return SWIG_Py_Void();
7894 }
7895
7896 SWIGINTERN PyObject *Rect_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7897 return SWIG_Python_InitShadowInstance(args);
7898 }
7899
7900 SWIGINTERN PyObject *_wrap_IntersectRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7901 PyObject *resultobj = 0;
7902 wxRect *arg1 = (wxRect *) 0 ;
7903 wxRect *arg2 = (wxRect *) 0 ;
7904 PyObject *result = 0 ;
7905 void *argp1 = 0 ;
7906 int res1 = 0 ;
7907 void *argp2 = 0 ;
7908 int res2 = 0 ;
7909 PyObject * obj0 = 0 ;
7910 PyObject * obj1 = 0 ;
7911 char * kwnames[] = {
7912 (char *) "r1",(char *) "r2", NULL
7913 };
7914
7915 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) SWIG_fail;
7916 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7917 if (!SWIG_IsOK(res1)) {
7918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntersectRect" "', expected argument " "1"" of type '" "wxRect *""'");
7919 }
7920 arg1 = reinterpret_cast< wxRect * >(argp1);
7921 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
7922 if (!SWIG_IsOK(res2)) {
7923 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntersectRect" "', expected argument " "2"" of type '" "wxRect *""'");
7924 }
7925 arg2 = reinterpret_cast< wxRect * >(argp2);
7926 {
7927 if (!wxPyCheckForApp()) SWIG_fail;
7928 PyThreadState* __tstate = wxPyBeginAllowThreads();
7929 result = (PyObject *)wxIntersectRect(arg1,arg2);
7930 wxPyEndAllowThreads(__tstate);
7931 if (PyErr_Occurred()) SWIG_fail;
7932 }
7933 resultobj = result;
7934 return resultobj;
7935 fail:
7936 return NULL;
7937 }
7938
7939
7940 SWIGINTERN PyObject *_wrap_new_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7941 PyObject *resultobj = 0;
7942 double arg1 = (double) 0.0 ;
7943 double arg2 = (double) 0.0 ;
7944 wxPoint2D *result = 0 ;
7945 double val1 ;
7946 int ecode1 = 0 ;
7947 double val2 ;
7948 int ecode2 = 0 ;
7949 PyObject * obj0 = 0 ;
7950 PyObject * obj1 = 0 ;
7951 char * kwnames[] = {
7952 (char *) "x",(char *) "y", NULL
7953 };
7954
7955 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) SWIG_fail;
7956 if (obj0) {
7957 ecode1 = SWIG_AsVal_double(obj0, &val1);
7958 if (!SWIG_IsOK(ecode1)) {
7959 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point2D" "', expected argument " "1"" of type '" "double""'");
7960 }
7961 arg1 = static_cast< double >(val1);
7962 }
7963 if (obj1) {
7964 ecode2 = SWIG_AsVal_double(obj1, &val2);
7965 if (!SWIG_IsOK(ecode2)) {
7966 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point2D" "', expected argument " "2"" of type '" "double""'");
7967 }
7968 arg2 = static_cast< double >(val2);
7969 }
7970 {
7971 PyThreadState* __tstate = wxPyBeginAllowThreads();
7972 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
7973 wxPyEndAllowThreads(__tstate);
7974 if (PyErr_Occurred()) SWIG_fail;
7975 }
7976 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_NEW | 0 );
7977 return resultobj;
7978 fail:
7979 return NULL;
7980 }
7981
7982
7983 SWIGINTERN PyObject *_wrap_new_Point2DCopy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7984 PyObject *resultobj = 0;
7985 wxPoint2D *arg1 = 0 ;
7986 wxPoint2D *result = 0 ;
7987 wxPoint2D temp1 ;
7988 PyObject * obj0 = 0 ;
7989 char * kwnames[] = {
7990 (char *) "pt", NULL
7991 };
7992
7993 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) SWIG_fail;
7994 {
7995 arg1 = &temp1;
7996 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
7997 }
7998 {
7999 PyThreadState* __tstate = wxPyBeginAllowThreads();
8000 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
8001 wxPyEndAllowThreads(__tstate);
8002 if (PyErr_Occurred()) SWIG_fail;
8003 }
8004 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8005 return resultobj;
8006 fail:
8007 return NULL;
8008 }
8009
8010
8011 SWIGINTERN PyObject *_wrap_new_Point2DFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8012 PyObject *resultobj = 0;
8013 wxPoint *arg1 = 0 ;
8014 wxPoint2D *result = 0 ;
8015 wxPoint temp1 ;
8016 PyObject * obj0 = 0 ;
8017 char * kwnames[] = {
8018 (char *) "pt", NULL
8019 };
8020
8021 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) SWIG_fail;
8022 {
8023 arg1 = &temp1;
8024 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
8025 }
8026 {
8027 PyThreadState* __tstate = wxPyBeginAllowThreads();
8028 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
8029 wxPyEndAllowThreads(__tstate);
8030 if (PyErr_Occurred()) SWIG_fail;
8031 }
8032 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8033 return resultobj;
8034 fail:
8035 return NULL;
8036 }
8037
8038
8039 SWIGINTERN PyObject *_wrap_Point2D_GetFloor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8040 PyObject *resultobj = 0;
8041 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8042 int *arg2 = (int *) 0 ;
8043 int *arg3 = (int *) 0 ;
8044 void *argp1 = 0 ;
8045 int res1 = 0 ;
8046 int temp2 ;
8047 int res2 = SWIG_TMPOBJ ;
8048 int temp3 ;
8049 int res3 = SWIG_TMPOBJ ;
8050 PyObject *swig_obj[1] ;
8051
8052 arg2 = &temp2;
8053 arg3 = &temp3;
8054 if (!args) SWIG_fail;
8055 swig_obj[0] = args;
8056 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8057 if (!SWIG_IsOK(res1)) {
8058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetFloor" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8059 }
8060 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8061 {
8062 PyThreadState* __tstate = wxPyBeginAllowThreads();
8063 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
8064 wxPyEndAllowThreads(__tstate);
8065 if (PyErr_Occurred()) SWIG_fail;
8066 }
8067 resultobj = SWIG_Py_Void();
8068 if (SWIG_IsTmpObj(res2)) {
8069 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8070 } else {
8071 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8072 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8073 }
8074 if (SWIG_IsTmpObj(res3)) {
8075 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8076 } else {
8077 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8078 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8079 }
8080 return resultobj;
8081 fail:
8082 return NULL;
8083 }
8084
8085
8086 SWIGINTERN PyObject *_wrap_Point2D_GetRounded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8087 PyObject *resultobj = 0;
8088 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8089 int *arg2 = (int *) 0 ;
8090 int *arg3 = (int *) 0 ;
8091 void *argp1 = 0 ;
8092 int res1 = 0 ;
8093 int temp2 ;
8094 int res2 = SWIG_TMPOBJ ;
8095 int temp3 ;
8096 int res3 = SWIG_TMPOBJ ;
8097 PyObject *swig_obj[1] ;
8098
8099 arg2 = &temp2;
8100 arg3 = &temp3;
8101 if (!args) SWIG_fail;
8102 swig_obj[0] = args;
8103 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8104 if (!SWIG_IsOK(res1)) {
8105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetRounded" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8106 }
8107 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8108 {
8109 PyThreadState* __tstate = wxPyBeginAllowThreads();
8110 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
8111 wxPyEndAllowThreads(__tstate);
8112 if (PyErr_Occurred()) SWIG_fail;
8113 }
8114 resultobj = SWIG_Py_Void();
8115 if (SWIG_IsTmpObj(res2)) {
8116 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8117 } else {
8118 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8119 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8120 }
8121 if (SWIG_IsTmpObj(res3)) {
8122 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8123 } else {
8124 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8125 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8126 }
8127 return resultobj;
8128 fail:
8129 return NULL;
8130 }
8131
8132
8133 SWIGINTERN PyObject *_wrap_Point2D_GetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8134 PyObject *resultobj = 0;
8135 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8136 double result;
8137 void *argp1 = 0 ;
8138 int res1 = 0 ;
8139 PyObject *swig_obj[1] ;
8140
8141 if (!args) SWIG_fail;
8142 swig_obj[0] = args;
8143 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8144 if (!SWIG_IsOK(res1)) {
8145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8146 }
8147 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8148 {
8149 PyThreadState* __tstate = wxPyBeginAllowThreads();
8150 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
8151 wxPyEndAllowThreads(__tstate);
8152 if (PyErr_Occurred()) SWIG_fail;
8153 }
8154 resultobj = SWIG_From_double(static_cast< double >(result));
8155 return resultobj;
8156 fail:
8157 return NULL;
8158 }
8159
8160
8161 SWIGINTERN PyObject *_wrap_Point2D_GetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8162 PyObject *resultobj = 0;
8163 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8164 double result;
8165 void *argp1 = 0 ;
8166 int res1 = 0 ;
8167 PyObject *swig_obj[1] ;
8168
8169 if (!args) SWIG_fail;
8170 swig_obj[0] = args;
8171 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8172 if (!SWIG_IsOK(res1)) {
8173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8174 }
8175 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8176 {
8177 PyThreadState* __tstate = wxPyBeginAllowThreads();
8178 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
8179 wxPyEndAllowThreads(__tstate);
8180 if (PyErr_Occurred()) SWIG_fail;
8181 }
8182 resultobj = SWIG_From_double(static_cast< double >(result));
8183 return resultobj;
8184 fail:
8185 return NULL;
8186 }
8187
8188
8189 SWIGINTERN PyObject *_wrap_Point2D_SetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8190 PyObject *resultobj = 0;
8191 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8192 double arg2 ;
8193 void *argp1 = 0 ;
8194 int res1 = 0 ;
8195 double val2 ;
8196 int ecode2 = 0 ;
8197 PyObject * obj0 = 0 ;
8198 PyObject * obj1 = 0 ;
8199 char * kwnames[] = {
8200 (char *) "self",(char *) "length", NULL
8201 };
8202
8203 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) SWIG_fail;
8204 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8205 if (!SWIG_IsOK(res1)) {
8206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8207 }
8208 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8209 ecode2 = SWIG_AsVal_double(obj1, &val2);
8210 if (!SWIG_IsOK(ecode2)) {
8211 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorLength" "', expected argument " "2"" of type '" "double""'");
8212 }
8213 arg2 = static_cast< double >(val2);
8214 {
8215 PyThreadState* __tstate = wxPyBeginAllowThreads();
8216 (arg1)->SetVectorLength(arg2);
8217 wxPyEndAllowThreads(__tstate);
8218 if (PyErr_Occurred()) SWIG_fail;
8219 }
8220 resultobj = SWIG_Py_Void();
8221 return resultobj;
8222 fail:
8223 return NULL;
8224 }
8225
8226
8227 SWIGINTERN PyObject *_wrap_Point2D_SetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8228 PyObject *resultobj = 0;
8229 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8230 double arg2 ;
8231 void *argp1 = 0 ;
8232 int res1 = 0 ;
8233 double val2 ;
8234 int ecode2 = 0 ;
8235 PyObject * obj0 = 0 ;
8236 PyObject * obj1 = 0 ;
8237 char * kwnames[] = {
8238 (char *) "self",(char *) "degrees", NULL
8239 };
8240
8241 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) SWIG_fail;
8242 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8243 if (!SWIG_IsOK(res1)) {
8244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8245 }
8246 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8247 ecode2 = SWIG_AsVal_double(obj1, &val2);
8248 if (!SWIG_IsOK(ecode2)) {
8249 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorAngle" "', expected argument " "2"" of type '" "double""'");
8250 }
8251 arg2 = static_cast< double >(val2);
8252 {
8253 PyThreadState* __tstate = wxPyBeginAllowThreads();
8254 (arg1)->SetVectorAngle(arg2);
8255 wxPyEndAllowThreads(__tstate);
8256 if (PyErr_Occurred()) SWIG_fail;
8257 }
8258 resultobj = SWIG_Py_Void();
8259 return resultobj;
8260 fail:
8261 return NULL;
8262 }
8263
8264
8265 SWIGINTERN PyObject *_wrap_Point2D_GetDistance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8266 PyObject *resultobj = 0;
8267 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8268 wxPoint2D *arg2 = 0 ;
8269 double result;
8270 void *argp1 = 0 ;
8271 int res1 = 0 ;
8272 wxPoint2D temp2 ;
8273 PyObject * obj0 = 0 ;
8274 PyObject * obj1 = 0 ;
8275 char * kwnames[] = {
8276 (char *) "self",(char *) "pt", NULL
8277 };
8278
8279 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) SWIG_fail;
8280 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8281 if (!SWIG_IsOK(res1)) {
8282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistance" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8283 }
8284 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8285 {
8286 arg2 = &temp2;
8287 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8288 }
8289 {
8290 PyThreadState* __tstate = wxPyBeginAllowThreads();
8291 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
8292 wxPyEndAllowThreads(__tstate);
8293 if (PyErr_Occurred()) SWIG_fail;
8294 }
8295 resultobj = SWIG_From_double(static_cast< double >(result));
8296 return resultobj;
8297 fail:
8298 return NULL;
8299 }
8300
8301
8302 SWIGINTERN PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8303 PyObject *resultobj = 0;
8304 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8305 wxPoint2D *arg2 = 0 ;
8306 double result;
8307 void *argp1 = 0 ;
8308 int res1 = 0 ;
8309 wxPoint2D temp2 ;
8310 PyObject * obj0 = 0 ;
8311 PyObject * obj1 = 0 ;
8312 char * kwnames[] = {
8313 (char *) "self",(char *) "pt", NULL
8314 };
8315
8316 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) SWIG_fail;
8317 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8318 if (!SWIG_IsOK(res1)) {
8319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistanceSquare" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8320 }
8321 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8322 {
8323 arg2 = &temp2;
8324 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8325 }
8326 {
8327 PyThreadState* __tstate = wxPyBeginAllowThreads();
8328 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
8329 wxPyEndAllowThreads(__tstate);
8330 if (PyErr_Occurred()) SWIG_fail;
8331 }
8332 resultobj = SWIG_From_double(static_cast< double >(result));
8333 return resultobj;
8334 fail:
8335 return NULL;
8336 }
8337
8338
8339 SWIGINTERN PyObject *_wrap_Point2D_GetDotProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8340 PyObject *resultobj = 0;
8341 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8342 wxPoint2D *arg2 = 0 ;
8343 double result;
8344 void *argp1 = 0 ;
8345 int res1 = 0 ;
8346 wxPoint2D temp2 ;
8347 PyObject * obj0 = 0 ;
8348 PyObject * obj1 = 0 ;
8349 char * kwnames[] = {
8350 (char *) "self",(char *) "vec", NULL
8351 };
8352
8353 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8354 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8355 if (!SWIG_IsOK(res1)) {
8356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDotProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8357 }
8358 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8359 {
8360 arg2 = &temp2;
8361 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8362 }
8363 {
8364 PyThreadState* __tstate = wxPyBeginAllowThreads();
8365 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
8366 wxPyEndAllowThreads(__tstate);
8367 if (PyErr_Occurred()) SWIG_fail;
8368 }
8369 resultobj = SWIG_From_double(static_cast< double >(result));
8370 return resultobj;
8371 fail:
8372 return NULL;
8373 }
8374
8375
8376 SWIGINTERN PyObject *_wrap_Point2D_GetCrossProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8377 PyObject *resultobj = 0;
8378 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8379 wxPoint2D *arg2 = 0 ;
8380 double result;
8381 void *argp1 = 0 ;
8382 int res1 = 0 ;
8383 wxPoint2D temp2 ;
8384 PyObject * obj0 = 0 ;
8385 PyObject * obj1 = 0 ;
8386 char * kwnames[] = {
8387 (char *) "self",(char *) "vec", NULL
8388 };
8389
8390 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8391 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8392 if (!SWIG_IsOK(res1)) {
8393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetCrossProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8394 }
8395 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8396 {
8397 arg2 = &temp2;
8398 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8399 }
8400 {
8401 PyThreadState* __tstate = wxPyBeginAllowThreads();
8402 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
8403 wxPyEndAllowThreads(__tstate);
8404 if (PyErr_Occurred()) SWIG_fail;
8405 }
8406 resultobj = SWIG_From_double(static_cast< double >(result));
8407 return resultobj;
8408 fail:
8409 return NULL;
8410 }
8411
8412
8413 SWIGINTERN PyObject *_wrap_Point2D___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8414 PyObject *resultobj = 0;
8415 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8416 wxPoint2D result;
8417 void *argp1 = 0 ;
8418 int res1 = 0 ;
8419 PyObject *swig_obj[1] ;
8420
8421 if (!args) SWIG_fail;
8422 swig_obj[0] = args;
8423 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8424 if (!SWIG_IsOK(res1)) {
8425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___neg__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8426 }
8427 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8428 {
8429 PyThreadState* __tstate = wxPyBeginAllowThreads();
8430 result = (arg1)->operator -();
8431 wxPyEndAllowThreads(__tstate);
8432 if (PyErr_Occurred()) SWIG_fail;
8433 }
8434 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8435 return resultobj;
8436 fail:
8437 return NULL;
8438 }
8439
8440
8441 SWIGINTERN PyObject *_wrap_Point2D___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8442 PyObject *resultobj = 0;
8443 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8444 wxPoint2D *arg2 = 0 ;
8445 wxPoint2D *result = 0 ;
8446 void *argp1 = 0 ;
8447 int res1 = 0 ;
8448 wxPoint2D temp2 ;
8449 PyObject * obj0 = 0 ;
8450 PyObject * obj1 = 0 ;
8451 char * kwnames[] = {
8452 (char *) "self",(char *) "pt", NULL
8453 };
8454
8455 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
8456 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8457 if (!SWIG_IsOK(res1)) {
8458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___iadd__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8459 }
8460 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8461 {
8462 arg2 = &temp2;
8463 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8464 }
8465 {
8466 PyThreadState* __tstate = wxPyBeginAllowThreads();
8467 {
8468 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
8469 result = (wxPoint2D *) &_result_ref;
8470 }
8471 wxPyEndAllowThreads(__tstate);
8472 if (PyErr_Occurred()) SWIG_fail;
8473 }
8474 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8475 return resultobj;
8476 fail:
8477 return NULL;
8478 }
8479
8480
8481 SWIGINTERN PyObject *_wrap_Point2D___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8482 PyObject *resultobj = 0;
8483 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8484 wxPoint2D *arg2 = 0 ;
8485 wxPoint2D *result = 0 ;
8486 void *argp1 = 0 ;
8487 int res1 = 0 ;
8488 wxPoint2D temp2 ;
8489 PyObject * obj0 = 0 ;
8490 PyObject * obj1 = 0 ;
8491 char * kwnames[] = {
8492 (char *) "self",(char *) "pt", NULL
8493 };
8494
8495 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
8496 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8497 if (!SWIG_IsOK(res1)) {
8498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___isub__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8499 }
8500 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8501 {
8502 arg2 = &temp2;
8503 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8504 }
8505 {
8506 PyThreadState* __tstate = wxPyBeginAllowThreads();
8507 {
8508 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
8509 result = (wxPoint2D *) &_result_ref;
8510 }
8511 wxPyEndAllowThreads(__tstate);
8512 if (PyErr_Occurred()) SWIG_fail;
8513 }
8514 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8515 return resultobj;
8516 fail:
8517 return NULL;
8518 }
8519
8520
8521 SWIGINTERN PyObject *_wrap_Point2D___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8522 PyObject *resultobj = 0;
8523 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8524 wxPoint2D *arg2 = 0 ;
8525 wxPoint2D *result = 0 ;
8526 void *argp1 = 0 ;
8527 int res1 = 0 ;
8528 wxPoint2D temp2 ;
8529 PyObject * obj0 = 0 ;
8530 PyObject * obj1 = 0 ;
8531 char * kwnames[] = {
8532 (char *) "self",(char *) "pt", NULL
8533 };
8534
8535 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
8536 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8537 if (!SWIG_IsOK(res1)) {
8538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___imul__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8539 }
8540 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8541 {
8542 arg2 = &temp2;
8543 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8544 }
8545 {
8546 PyThreadState* __tstate = wxPyBeginAllowThreads();
8547 {
8548 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
8549 result = (wxPoint2D *) &_result_ref;
8550 }
8551 wxPyEndAllowThreads(__tstate);
8552 if (PyErr_Occurred()) SWIG_fail;
8553 }
8554 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8555 return resultobj;
8556 fail:
8557 return NULL;
8558 }
8559
8560
8561 SWIGINTERN PyObject *_wrap_Point2D___idiv__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8562 PyObject *resultobj = 0;
8563 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8564 wxPoint2D *arg2 = 0 ;
8565 wxPoint2D *result = 0 ;
8566 void *argp1 = 0 ;
8567 int res1 = 0 ;
8568 wxPoint2D temp2 ;
8569 PyObject * obj0 = 0 ;
8570 PyObject * obj1 = 0 ;
8571 char * kwnames[] = {
8572 (char *) "self",(char *) "pt", NULL
8573 };
8574
8575 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) SWIG_fail;
8576 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8577 if (!SWIG_IsOK(res1)) {
8578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___idiv__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8579 }
8580 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8581 {
8582 arg2 = &temp2;
8583 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8584 }
8585 {
8586 PyThreadState* __tstate = wxPyBeginAllowThreads();
8587 {
8588 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
8589 result = (wxPoint2D *) &_result_ref;
8590 }
8591 wxPyEndAllowThreads(__tstate);
8592 if (PyErr_Occurred()) SWIG_fail;
8593 }
8594 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8595 return resultobj;
8596 fail:
8597 return NULL;
8598 }
8599
8600
8601 SWIGINTERN PyObject *_wrap_Point2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8602 PyObject *resultobj = 0;
8603 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8604 PyObject *arg2 = (PyObject *) 0 ;
8605 bool result;
8606 void *argp1 = 0 ;
8607 int res1 = 0 ;
8608 PyObject * obj0 = 0 ;
8609 PyObject * obj1 = 0 ;
8610 char * kwnames[] = {
8611 (char *) "self",(char *) "other", NULL
8612 };
8613
8614 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
8615 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8616 if (!SWIG_IsOK(res1)) {
8617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___eq__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8618 }
8619 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8620 arg2 = obj1;
8621 {
8622 result = (bool)wxPoint2D___eq__(arg1,arg2);
8623 if (PyErr_Occurred()) SWIG_fail;
8624 }
8625 {
8626 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8627 }
8628 return resultobj;
8629 fail:
8630 return NULL;
8631 }
8632
8633
8634 SWIGINTERN PyObject *_wrap_Point2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8635 PyObject *resultobj = 0;
8636 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8637 PyObject *arg2 = (PyObject *) 0 ;
8638 bool result;
8639 void *argp1 = 0 ;
8640 int res1 = 0 ;
8641 PyObject * obj0 = 0 ;
8642 PyObject * obj1 = 0 ;
8643 char * kwnames[] = {
8644 (char *) "self",(char *) "other", NULL
8645 };
8646
8647 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
8648 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8649 if (!SWIG_IsOK(res1)) {
8650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___ne__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8651 }
8652 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8653 arg2 = obj1;
8654 {
8655 result = (bool)wxPoint2D___ne__(arg1,arg2);
8656 if (PyErr_Occurred()) SWIG_fail;
8657 }
8658 {
8659 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8660 }
8661 return resultobj;
8662 fail:
8663 return NULL;
8664 }
8665
8666
8667 SWIGINTERN PyObject *_wrap_Point2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8668 PyObject *resultobj = 0;
8669 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8670 double arg2 ;
8671 void *argp1 = 0 ;
8672 int res1 = 0 ;
8673 double val2 ;
8674 int ecode2 = 0 ;
8675 PyObject *swig_obj[2] ;
8676
8677 if (!SWIG_Python_UnpackTuple(args,"Point2D_x_set",2,2,swig_obj)) SWIG_fail;
8678 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8679 if (!SWIG_IsOK(res1)) {
8680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8681 }
8682 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8683 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8684 if (!SWIG_IsOK(ecode2)) {
8685 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_x_set" "', expected argument " "2"" of type '" "double""'");
8686 }
8687 arg2 = static_cast< double >(val2);
8688 if (arg1) (arg1)->m_x = arg2;
8689
8690 resultobj = SWIG_Py_Void();
8691 return resultobj;
8692 fail:
8693 return NULL;
8694 }
8695
8696
8697 SWIGINTERN PyObject *_wrap_Point2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8698 PyObject *resultobj = 0;
8699 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8700 double result;
8701 void *argp1 = 0 ;
8702 int res1 = 0 ;
8703 PyObject *swig_obj[1] ;
8704
8705 if (!args) SWIG_fail;
8706 swig_obj[0] = args;
8707 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8708 if (!SWIG_IsOK(res1)) {
8709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8710 }
8711 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8712 result = (double) ((arg1)->m_x);
8713 resultobj = SWIG_From_double(static_cast< double >(result));
8714 return resultobj;
8715 fail:
8716 return NULL;
8717 }
8718
8719
8720 SWIGINTERN PyObject *_wrap_Point2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8721 PyObject *resultobj = 0;
8722 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8723 double arg2 ;
8724 void *argp1 = 0 ;
8725 int res1 = 0 ;
8726 double val2 ;
8727 int ecode2 = 0 ;
8728 PyObject *swig_obj[2] ;
8729
8730 if (!SWIG_Python_UnpackTuple(args,"Point2D_y_set",2,2,swig_obj)) SWIG_fail;
8731 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8732 if (!SWIG_IsOK(res1)) {
8733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8734 }
8735 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8736 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8737 if (!SWIG_IsOK(ecode2)) {
8738 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_y_set" "', expected argument " "2"" of type '" "double""'");
8739 }
8740 arg2 = static_cast< double >(val2);
8741 if (arg1) (arg1)->m_y = arg2;
8742
8743 resultobj = SWIG_Py_Void();
8744 return resultobj;
8745 fail:
8746 return NULL;
8747 }
8748
8749
8750 SWIGINTERN PyObject *_wrap_Point2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8751 PyObject *resultobj = 0;
8752 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8753 double result;
8754 void *argp1 = 0 ;
8755 int res1 = 0 ;
8756 PyObject *swig_obj[1] ;
8757
8758 if (!args) SWIG_fail;
8759 swig_obj[0] = args;
8760 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8761 if (!SWIG_IsOK(res1)) {
8762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8763 }
8764 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8765 result = (double) ((arg1)->m_y);
8766 resultobj = SWIG_From_double(static_cast< double >(result));
8767 return resultobj;
8768 fail:
8769 return NULL;
8770 }
8771
8772
8773 SWIGINTERN PyObject *_wrap_Point2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8774 PyObject *resultobj = 0;
8775 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8776 double arg2 = (double) 0 ;
8777 double arg3 = (double) 0 ;
8778 void *argp1 = 0 ;
8779 int res1 = 0 ;
8780 double val2 ;
8781 int ecode2 = 0 ;
8782 double val3 ;
8783 int ecode3 = 0 ;
8784 PyObject * obj0 = 0 ;
8785 PyObject * obj1 = 0 ;
8786 PyObject * obj2 = 0 ;
8787 char * kwnames[] = {
8788 (char *) "self",(char *) "x",(char *) "y", NULL
8789 };
8790
8791 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8792 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8793 if (!SWIG_IsOK(res1)) {
8794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8795 }
8796 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8797 if (obj1) {
8798 ecode2 = SWIG_AsVal_double(obj1, &val2);
8799 if (!SWIG_IsOK(ecode2)) {
8800 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_Set" "', expected argument " "2"" of type '" "double""'");
8801 }
8802 arg2 = static_cast< double >(val2);
8803 }
8804 if (obj2) {
8805 ecode3 = SWIG_AsVal_double(obj2, &val3);
8806 if (!SWIG_IsOK(ecode3)) {
8807 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point2D_Set" "', expected argument " "3"" of type '" "double""'");
8808 }
8809 arg3 = static_cast< double >(val3);
8810 }
8811 {
8812 PyThreadState* __tstate = wxPyBeginAllowThreads();
8813 wxPoint2D_Set(arg1,arg2,arg3);
8814 wxPyEndAllowThreads(__tstate);
8815 if (PyErr_Occurred()) SWIG_fail;
8816 }
8817 resultobj = SWIG_Py_Void();
8818 return resultobj;
8819 fail:
8820 return NULL;
8821 }
8822
8823
8824 SWIGINTERN PyObject *_wrap_Point2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8825 PyObject *resultobj = 0;
8826 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8827 PyObject *result = 0 ;
8828 void *argp1 = 0 ;
8829 int res1 = 0 ;
8830 PyObject *swig_obj[1] ;
8831
8832 if (!args) SWIG_fail;
8833 swig_obj[0] = args;
8834 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8835 if (!SWIG_IsOK(res1)) {
8836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8837 }
8838 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8839 {
8840 PyThreadState* __tstate = wxPyBeginAllowThreads();
8841 result = (PyObject *)wxPoint2D_Get(arg1);
8842 wxPyEndAllowThreads(__tstate);
8843 if (PyErr_Occurred()) SWIG_fail;
8844 }
8845 resultobj = result;
8846 return resultobj;
8847 fail:
8848 return NULL;
8849 }
8850
8851
8852 SWIGINTERN PyObject *Point2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8853 PyObject *obj;
8854 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8855 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint2D, SWIG_NewClientData(obj));
8856 return SWIG_Py_Void();
8857 }
8858
8859 SWIGINTERN PyObject *Point2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8860 return SWIG_Python_InitShadowInstance(args);
8861 }
8862
8863 SWIGINTERN int DefaultPosition_set(PyObject *) {
8864 SWIG_Error(SWIG_AttributeError,"Variable DefaultPosition is read-only.");
8865 return 1;
8866 }
8867
8868
8869 SWIGINTERN PyObject *DefaultPosition_get(void) {
8870 PyObject *pyobj = 0;
8871
8872 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0 );
8873 return pyobj;
8874 }
8875
8876
8877 SWIGINTERN int DefaultSize_set(PyObject *) {
8878 SWIG_Error(SWIG_AttributeError,"Variable DefaultSize is read-only.");
8879 return 1;
8880 }
8881
8882
8883 SWIGINTERN PyObject *DefaultSize_get(void) {
8884 PyObject *pyobj = 0;
8885
8886 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSize), SWIGTYPE_p_wxSize, 0 );
8887 return pyobj;
8888 }
8889
8890
8891 SWIGINTERN PyObject *_wrap_new_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8892 PyObject *resultobj = 0;
8893 PyObject *arg1 = (PyObject *) 0 ;
8894 wxPyInputStream *result = 0 ;
8895 PyObject * obj0 = 0 ;
8896 char * kwnames[] = {
8897 (char *) "p", NULL
8898 };
8899
8900 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) SWIG_fail;
8901 arg1 = obj0;
8902 {
8903 PyThreadState* __tstate = wxPyBeginAllowThreads();
8904 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
8905 wxPyEndAllowThreads(__tstate);
8906 if (PyErr_Occurred()) SWIG_fail;
8907 }
8908 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_NEW | 0 );
8909 return resultobj;
8910 fail:
8911 return NULL;
8912 }
8913
8914
8915 SWIGINTERN PyObject *_wrap_delete_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8916 PyObject *resultobj = 0;
8917 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8918 void *argp1 = 0 ;
8919 int res1 = 0 ;
8920 PyObject *swig_obj[1] ;
8921
8922 if (!args) SWIG_fail;
8923 swig_obj[0] = args;
8924 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_DISOWN | 0 );
8925 if (!SWIG_IsOK(res1)) {
8926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InputStream" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
8927 }
8928 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
8929 {
8930 PyThreadState* __tstate = wxPyBeginAllowThreads();
8931 delete arg1;
8932
8933 wxPyEndAllowThreads(__tstate);
8934 if (PyErr_Occurred()) SWIG_fail;
8935 }
8936 resultobj = SWIG_Py_Void();
8937 return resultobj;
8938 fail:
8939 return NULL;
8940 }
8941
8942
8943 SWIGINTERN PyObject *_wrap_InputStream_close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8944 PyObject *resultobj = 0;
8945 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8946 void *argp1 = 0 ;
8947 int res1 = 0 ;
8948 PyObject *swig_obj[1] ;
8949
8950 if (!args) SWIG_fail;
8951 swig_obj[0] = args;
8952 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
8953 if (!SWIG_IsOK(res1)) {
8954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_close" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
8955 }
8956 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
8957 {
8958 PyThreadState* __tstate = wxPyBeginAllowThreads();
8959 (arg1)->close();
8960 wxPyEndAllowThreads(__tstate);
8961 if (PyErr_Occurred()) SWIG_fail;
8962 }
8963 resultobj = SWIG_Py_Void();
8964 return resultobj;
8965 fail:
8966 return NULL;
8967 }
8968
8969
8970 SWIGINTERN PyObject *_wrap_InputStream_flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8971 PyObject *resultobj = 0;
8972 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8973 void *argp1 = 0 ;
8974 int res1 = 0 ;
8975 PyObject *swig_obj[1] ;
8976
8977 if (!args) SWIG_fail;
8978 swig_obj[0] = args;
8979 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
8980 if (!SWIG_IsOK(res1)) {
8981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_flush" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
8982 }
8983 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
8984 {
8985 PyThreadState* __tstate = wxPyBeginAllowThreads();
8986 (arg1)->flush();
8987 wxPyEndAllowThreads(__tstate);
8988 if (PyErr_Occurred()) SWIG_fail;
8989 }
8990 resultobj = SWIG_Py_Void();
8991 return resultobj;
8992 fail:
8993 return NULL;
8994 }
8995
8996
8997 SWIGINTERN PyObject *_wrap_InputStream_eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8998 PyObject *resultobj = 0;
8999 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9000 bool result;
9001 void *argp1 = 0 ;
9002 int res1 = 0 ;
9003 PyObject *swig_obj[1] ;
9004
9005 if (!args) SWIG_fail;
9006 swig_obj[0] = args;
9007 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9008 if (!SWIG_IsOK(res1)) {
9009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9010 }
9011 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9012 {
9013 PyThreadState* __tstate = wxPyBeginAllowThreads();
9014 result = (bool)(arg1)->eof();
9015 wxPyEndAllowThreads(__tstate);
9016 if (PyErr_Occurred()) SWIG_fail;
9017 }
9018 {
9019 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9020 }
9021 return resultobj;
9022 fail:
9023 return NULL;
9024 }
9025
9026
9027 SWIGINTERN PyObject *_wrap_InputStream_read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9028 PyObject *resultobj = 0;
9029 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9030 int arg2 = (int) -1 ;
9031 PyObject *result = 0 ;
9032 void *argp1 = 0 ;
9033 int res1 = 0 ;
9034 int val2 ;
9035 int ecode2 = 0 ;
9036 PyObject * obj0 = 0 ;
9037 PyObject * obj1 = 0 ;
9038 char * kwnames[] = {
9039 (char *) "self",(char *) "size", NULL
9040 };
9041
9042 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) SWIG_fail;
9043 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9044 if (!SWIG_IsOK(res1)) {
9045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_read" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9046 }
9047 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9048 if (obj1) {
9049 ecode2 = SWIG_AsVal_int(obj1, &val2);
9050 if (!SWIG_IsOK(ecode2)) {
9051 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_read" "', expected argument " "2"" of type '" "int""'");
9052 }
9053 arg2 = static_cast< int >(val2);
9054 }
9055 {
9056 PyThreadState* __tstate = wxPyBeginAllowThreads();
9057 result = (PyObject *)(arg1)->read(arg2);
9058 wxPyEndAllowThreads(__tstate);
9059 if (PyErr_Occurred()) SWIG_fail;
9060 }
9061 resultobj = result;
9062 return resultobj;
9063 fail:
9064 return NULL;
9065 }
9066
9067
9068 SWIGINTERN PyObject *_wrap_InputStream_readline(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9069 PyObject *resultobj = 0;
9070 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9071 int arg2 = (int) -1 ;
9072 PyObject *result = 0 ;
9073 void *argp1 = 0 ;
9074 int res1 = 0 ;
9075 int val2 ;
9076 int ecode2 = 0 ;
9077 PyObject * obj0 = 0 ;
9078 PyObject * obj1 = 0 ;
9079 char * kwnames[] = {
9080 (char *) "self",(char *) "size", NULL
9081 };
9082
9083 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) SWIG_fail;
9084 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9085 if (!SWIG_IsOK(res1)) {
9086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readline" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9087 }
9088 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9089 if (obj1) {
9090 ecode2 = SWIG_AsVal_int(obj1, &val2);
9091 if (!SWIG_IsOK(ecode2)) {
9092 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readline" "', expected argument " "2"" of type '" "int""'");
9093 }
9094 arg2 = static_cast< int >(val2);
9095 }
9096 {
9097 PyThreadState* __tstate = wxPyBeginAllowThreads();
9098 result = (PyObject *)(arg1)->readline(arg2);
9099 wxPyEndAllowThreads(__tstate);
9100 if (PyErr_Occurred()) SWIG_fail;
9101 }
9102 resultobj = result;
9103 return resultobj;
9104 fail:
9105 return NULL;
9106 }
9107
9108
9109 SWIGINTERN PyObject *_wrap_InputStream_readlines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9110 PyObject *resultobj = 0;
9111 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9112 int arg2 = (int) -1 ;
9113 PyObject *result = 0 ;
9114 void *argp1 = 0 ;
9115 int res1 = 0 ;
9116 int val2 ;
9117 int ecode2 = 0 ;
9118 PyObject * obj0 = 0 ;
9119 PyObject * obj1 = 0 ;
9120 char * kwnames[] = {
9121 (char *) "self",(char *) "sizehint", NULL
9122 };
9123
9124 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) SWIG_fail;
9125 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9126 if (!SWIG_IsOK(res1)) {
9127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readlines" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9128 }
9129 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9130 if (obj1) {
9131 ecode2 = SWIG_AsVal_int(obj1, &val2);
9132 if (!SWIG_IsOK(ecode2)) {
9133 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readlines" "', expected argument " "2"" of type '" "int""'");
9134 }
9135 arg2 = static_cast< int >(val2);
9136 }
9137 {
9138 PyThreadState* __tstate = wxPyBeginAllowThreads();
9139 result = (PyObject *)(arg1)->readlines(arg2);
9140 wxPyEndAllowThreads(__tstate);
9141 if (PyErr_Occurred()) SWIG_fail;
9142 }
9143 resultobj = result;
9144 return resultobj;
9145 fail:
9146 return NULL;
9147 }
9148
9149
9150 SWIGINTERN PyObject *_wrap_InputStream_seek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9151 PyObject *resultobj = 0;
9152 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9153 int arg2 ;
9154 int arg3 = (int) 0 ;
9155 void *argp1 = 0 ;
9156 int res1 = 0 ;
9157 int val2 ;
9158 int ecode2 = 0 ;
9159 int val3 ;
9160 int ecode3 = 0 ;
9161 PyObject * obj0 = 0 ;
9162 PyObject * obj1 = 0 ;
9163 PyObject * obj2 = 0 ;
9164 char * kwnames[] = {
9165 (char *) "self",(char *) "offset",(char *) "whence", NULL
9166 };
9167
9168 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9169 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9170 if (!SWIG_IsOK(res1)) {
9171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_seek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9172 }
9173 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9174 ecode2 = SWIG_AsVal_int(obj1, &val2);
9175 if (!SWIG_IsOK(ecode2)) {
9176 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_seek" "', expected argument " "2"" of type '" "int""'");
9177 }
9178 arg2 = static_cast< int >(val2);
9179 if (obj2) {
9180 ecode3 = SWIG_AsVal_int(obj2, &val3);
9181 if (!SWIG_IsOK(ecode3)) {
9182 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_seek" "', expected argument " "3"" of type '" "int""'");
9183 }
9184 arg3 = static_cast< int >(val3);
9185 }
9186 {
9187 PyThreadState* __tstate = wxPyBeginAllowThreads();
9188 (arg1)->seek(arg2,arg3);
9189 wxPyEndAllowThreads(__tstate);
9190 if (PyErr_Occurred()) SWIG_fail;
9191 }
9192 resultobj = SWIG_Py_Void();
9193 return resultobj;
9194 fail:
9195 return NULL;
9196 }
9197
9198
9199 SWIGINTERN PyObject *_wrap_InputStream_tell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9200 PyObject *resultobj = 0;
9201 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9202 int result;
9203 void *argp1 = 0 ;
9204 int res1 = 0 ;
9205 PyObject *swig_obj[1] ;
9206
9207 if (!args) SWIG_fail;
9208 swig_obj[0] = args;
9209 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9210 if (!SWIG_IsOK(res1)) {
9211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_tell" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9212 }
9213 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9214 {
9215 PyThreadState* __tstate = wxPyBeginAllowThreads();
9216 result = (int)(arg1)->tell();
9217 wxPyEndAllowThreads(__tstate);
9218 if (PyErr_Occurred()) SWIG_fail;
9219 }
9220 resultobj = SWIG_From_int(static_cast< int >(result));
9221 return resultobj;
9222 fail:
9223 return NULL;
9224 }
9225
9226
9227 SWIGINTERN PyObject *_wrap_InputStream_Peek(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9228 PyObject *resultobj = 0;
9229 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9230 char result;
9231 void *argp1 = 0 ;
9232 int res1 = 0 ;
9233 PyObject *swig_obj[1] ;
9234
9235 if (!args) SWIG_fail;
9236 swig_obj[0] = args;
9237 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9238 if (!SWIG_IsOK(res1)) {
9239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Peek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9240 }
9241 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9242 {
9243 PyThreadState* __tstate = wxPyBeginAllowThreads();
9244 result = (char)(arg1)->Peek();
9245 wxPyEndAllowThreads(__tstate);
9246 if (PyErr_Occurred()) SWIG_fail;
9247 }
9248 resultobj = SWIG_From_char(static_cast< char >(result));
9249 return resultobj;
9250 fail:
9251 return NULL;
9252 }
9253
9254
9255 SWIGINTERN PyObject *_wrap_InputStream_GetC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9256 PyObject *resultobj = 0;
9257 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9258 char result;
9259 void *argp1 = 0 ;
9260 int res1 = 0 ;
9261 PyObject *swig_obj[1] ;
9262
9263 if (!args) SWIG_fail;
9264 swig_obj[0] = args;
9265 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9266 if (!SWIG_IsOK(res1)) {
9267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_GetC" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9268 }
9269 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9270 {
9271 PyThreadState* __tstate = wxPyBeginAllowThreads();
9272 result = (char)(arg1)->GetC();
9273 wxPyEndAllowThreads(__tstate);
9274 if (PyErr_Occurred()) SWIG_fail;
9275 }
9276 resultobj = SWIG_From_char(static_cast< char >(result));
9277 return resultobj;
9278 fail:
9279 return NULL;
9280 }
9281
9282
9283 SWIGINTERN PyObject *_wrap_InputStream_LastRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9284 PyObject *resultobj = 0;
9285 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9286 size_t result;
9287 void *argp1 = 0 ;
9288 int res1 = 0 ;
9289 PyObject *swig_obj[1] ;
9290
9291 if (!args) SWIG_fail;
9292 swig_obj[0] = args;
9293 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9294 if (!SWIG_IsOK(res1)) {
9295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_LastRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9296 }
9297 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9298 {
9299 PyThreadState* __tstate = wxPyBeginAllowThreads();
9300 result = (size_t)(arg1)->LastRead();
9301 wxPyEndAllowThreads(__tstate);
9302 if (PyErr_Occurred()) SWIG_fail;
9303 }
9304 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9305 return resultobj;
9306 fail:
9307 return NULL;
9308 }
9309
9310
9311 SWIGINTERN PyObject *_wrap_InputStream_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9312 PyObject *resultobj = 0;
9313 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9314 bool result;
9315 void *argp1 = 0 ;
9316 int res1 = 0 ;
9317 PyObject *swig_obj[1] ;
9318
9319 if (!args) SWIG_fail;
9320 swig_obj[0] = args;
9321 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9322 if (!SWIG_IsOK(res1)) {
9323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_CanRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9324 }
9325 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9326 {
9327 PyThreadState* __tstate = wxPyBeginAllowThreads();
9328 result = (bool)(arg1)->CanRead();
9329 wxPyEndAllowThreads(__tstate);
9330 if (PyErr_Occurred()) SWIG_fail;
9331 }
9332 {
9333 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9334 }
9335 return resultobj;
9336 fail:
9337 return NULL;
9338 }
9339
9340
9341 SWIGINTERN PyObject *_wrap_InputStream_Eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9342 PyObject *resultobj = 0;
9343 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9344 bool 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_Eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9354 }
9355 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9356 {
9357 PyThreadState* __tstate = wxPyBeginAllowThreads();
9358 result = (bool)(arg1)->Eof();
9359 wxPyEndAllowThreads(__tstate);
9360 if (PyErr_Occurred()) SWIG_fail;
9361 }
9362 {
9363 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9364 }
9365 return resultobj;
9366 fail:
9367 return NULL;
9368 }
9369
9370
9371 SWIGINTERN PyObject *_wrap_InputStream_Ungetch(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9372 PyObject *resultobj = 0;
9373 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9374 char arg2 ;
9375 bool result;
9376 void *argp1 = 0 ;
9377 int res1 = 0 ;
9378 char val2 ;
9379 int ecode2 = 0 ;
9380 PyObject * obj0 = 0 ;
9381 PyObject * obj1 = 0 ;
9382 char * kwnames[] = {
9383 (char *) "self",(char *) "c", NULL
9384 };
9385
9386 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) SWIG_fail;
9387 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9388 if (!SWIG_IsOK(res1)) {
9389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Ungetch" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9390 }
9391 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9392 ecode2 = SWIG_AsVal_char(obj1, &val2);
9393 if (!SWIG_IsOK(ecode2)) {
9394 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_Ungetch" "', expected argument " "2"" of type '" "char""'");
9395 }
9396 arg2 = static_cast< char >(val2);
9397 {
9398 PyThreadState* __tstate = wxPyBeginAllowThreads();
9399 result = (bool)(arg1)->Ungetch(arg2);
9400 wxPyEndAllowThreads(__tstate);
9401 if (PyErr_Occurred()) SWIG_fail;
9402 }
9403 {
9404 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9405 }
9406 return resultobj;
9407 fail:
9408 return NULL;
9409 }
9410
9411
9412 SWIGINTERN PyObject *_wrap_InputStream_SeekI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9413 PyObject *resultobj = 0;
9414 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9415 long arg2 ;
9416 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
9417 long result;
9418 void *argp1 = 0 ;
9419 int res1 = 0 ;
9420 long val2 ;
9421 int ecode2 = 0 ;
9422 int val3 ;
9423 int ecode3 = 0 ;
9424 PyObject * obj0 = 0 ;
9425 PyObject * obj1 = 0 ;
9426 PyObject * obj2 = 0 ;
9427 char * kwnames[] = {
9428 (char *) "self",(char *) "pos",(char *) "mode", NULL
9429 };
9430
9431 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9432 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9433 if (!SWIG_IsOK(res1)) {
9434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_SeekI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9435 }
9436 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9437 ecode2 = SWIG_AsVal_long(obj1, &val2);
9438 if (!SWIG_IsOK(ecode2)) {
9439 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_SeekI" "', expected argument " "2"" of type '" "long""'");
9440 }
9441 arg2 = static_cast< long >(val2);
9442 if (obj2) {
9443 ecode3 = SWIG_AsVal_int(obj2, &val3);
9444 if (!SWIG_IsOK(ecode3)) {
9445 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_SeekI" "', expected argument " "3"" of type '" "wxSeekMode""'");
9446 }
9447 arg3 = static_cast< wxSeekMode >(val3);
9448 }
9449 {
9450 PyThreadState* __tstate = wxPyBeginAllowThreads();
9451 result = (long)(arg1)->SeekI(arg2,arg3);
9452 wxPyEndAllowThreads(__tstate);
9453 if (PyErr_Occurred()) SWIG_fail;
9454 }
9455 resultobj = SWIG_From_long(static_cast< long >(result));
9456 return resultobj;
9457 fail:
9458 return NULL;
9459 }
9460
9461
9462 SWIGINTERN PyObject *_wrap_InputStream_TellI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9463 PyObject *resultobj = 0;
9464 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9465 long result;
9466 void *argp1 = 0 ;
9467 int res1 = 0 ;
9468 PyObject *swig_obj[1] ;
9469
9470 if (!args) SWIG_fail;
9471 swig_obj[0] = args;
9472 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9473 if (!SWIG_IsOK(res1)) {
9474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_TellI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9475 }
9476 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9477 {
9478 PyThreadState* __tstate = wxPyBeginAllowThreads();
9479 result = (long)(arg1)->TellI();
9480 wxPyEndAllowThreads(__tstate);
9481 if (PyErr_Occurred()) SWIG_fail;
9482 }
9483 resultobj = SWIG_From_long(static_cast< long >(result));
9484 return resultobj;
9485 fail:
9486 return NULL;
9487 }
9488
9489
9490 SWIGINTERN PyObject *InputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9491 PyObject *obj;
9492 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9493 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyInputStream, SWIG_NewClientData(obj));
9494 return SWIG_Py_Void();
9495 }
9496
9497 SWIGINTERN PyObject *InputStream_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9498 return SWIG_Python_InitShadowInstance(args);
9499 }
9500
9501 SWIGINTERN PyObject *_wrap_OutputStream_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9502 PyObject *resultobj = 0;
9503 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9504 PyObject *arg2 = (PyObject *) 0 ;
9505 void *argp1 = 0 ;
9506 int res1 = 0 ;
9507 PyObject * obj0 = 0 ;
9508 PyObject * obj1 = 0 ;
9509 char * kwnames[] = {
9510 (char *) "self",(char *) "obj", NULL
9511 };
9512
9513 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) SWIG_fail;
9514 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9515 if (!SWIG_IsOK(res1)) {
9516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_write" "', expected argument " "1"" of type '" "wxOutputStream *""'");
9517 }
9518 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9519 arg2 = obj1;
9520 {
9521 PyThreadState* __tstate = wxPyBeginAllowThreads();
9522 wxOutputStream_write(arg1,arg2);
9523 wxPyEndAllowThreads(__tstate);
9524 if (PyErr_Occurred()) SWIG_fail;
9525 }
9526 resultobj = SWIG_Py_Void();
9527 return resultobj;
9528 fail:
9529 return NULL;
9530 }
9531
9532
9533 SWIGINTERN PyObject *_wrap_OutputStream_LastWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9534 PyObject *resultobj = 0;
9535 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9536 size_t result;
9537 void *argp1 = 0 ;
9538 int res1 = 0 ;
9539 PyObject *swig_obj[1] ;
9540
9541 if (!args) SWIG_fail;
9542 swig_obj[0] = args;
9543 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9544 if (!SWIG_IsOK(res1)) {
9545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_LastWrite" "', expected argument " "1"" of type '" "wxOutputStream const *""'");
9546 }
9547 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9548 {
9549 PyThreadState* __tstate = wxPyBeginAllowThreads();
9550 result = (size_t)((wxOutputStream const *)arg1)->LastWrite();
9551 wxPyEndAllowThreads(__tstate);
9552 if (PyErr_Occurred()) SWIG_fail;
9553 }
9554 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9555 return resultobj;
9556 fail:
9557 return NULL;
9558 }
9559
9560
9561 SWIGINTERN PyObject *OutputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9562 PyObject *obj;
9563 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9564 SWIG_TypeNewClientData(SWIGTYPE_p_wxOutputStream, SWIG_NewClientData(obj));
9565 return SWIG_Py_Void();
9566 }
9567
9568 SWIGINTERN PyObject *_wrap_new_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9569 PyObject *resultobj = 0;
9570 wxInputStream *arg1 = (wxInputStream *) 0 ;
9571 wxString *arg2 = 0 ;
9572 wxString *arg3 = 0 ;
9573 wxString *arg4 = 0 ;
9574 wxDateTime arg5 ;
9575 wxFSFile *result = 0 ;
9576 wxPyInputStream *temp1 ;
9577 bool temp2 = false ;
9578 bool temp3 = false ;
9579 bool temp4 = false ;
9580 void *argp5 ;
9581 int res5 = 0 ;
9582 PyObject * obj0 = 0 ;
9583 PyObject * obj1 = 0 ;
9584 PyObject * obj2 = 0 ;
9585 PyObject * obj3 = 0 ;
9586 PyObject * obj4 = 0 ;
9587 char * kwnames[] = {
9588 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
9589 };
9590
9591 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9592 {
9593 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
9594 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
9595 } else {
9596 PyErr_Clear(); // clear the failure of the wxPyConvert above
9597 arg1 = wxPyCBInputStream_create(obj0, true);
9598 if (arg1 == NULL) {
9599 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
9600 SWIG_fail;
9601 }
9602 }
9603 }
9604 {
9605 arg2 = wxString_in_helper(obj1);
9606 if (arg2 == NULL) SWIG_fail;
9607 temp2 = true;
9608 }
9609 {
9610 arg3 = wxString_in_helper(obj2);
9611 if (arg3 == NULL) SWIG_fail;
9612 temp3 = true;
9613 }
9614 {
9615 arg4 = wxString_in_helper(obj3);
9616 if (arg4 == NULL) SWIG_fail;
9617 temp4 = true;
9618 }
9619 {
9620 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDateTime, 0 | 0);
9621 if (!SWIG_IsOK(res5)) {
9622 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9623 }
9624 if (!argp5) {
9625 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9626 } else {
9627 wxDateTime * temp = reinterpret_cast< wxDateTime * >(argp5);
9628 arg5 = *temp;
9629 if (SWIG_IsNewObj(res5)) delete temp;
9630 }
9631 }
9632 {
9633 PyThreadState* __tstate = wxPyBeginAllowThreads();
9634 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
9635 wxPyEndAllowThreads(__tstate);
9636 if (PyErr_Occurred()) SWIG_fail;
9637 }
9638 {
9639 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
9640 }
9641 {
9642 if (temp2)
9643 delete arg2;
9644 }
9645 {
9646 if (temp3)
9647 delete arg3;
9648 }
9649 {
9650 if (temp4)
9651 delete arg4;
9652 }
9653 return resultobj;
9654 fail:
9655 {
9656 if (temp2)
9657 delete arg2;
9658 }
9659 {
9660 if (temp3)
9661 delete arg3;
9662 }
9663 {
9664 if (temp4)
9665 delete arg4;
9666 }
9667 return NULL;
9668 }
9669
9670
9671 SWIGINTERN PyObject *_wrap_delete_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9672 PyObject *resultobj = 0;
9673 wxFSFile *arg1 = (wxFSFile *) 0 ;
9674 void *argp1 = 0 ;
9675 int res1 = 0 ;
9676 PyObject *swig_obj[1] ;
9677
9678 if (!args) SWIG_fail;
9679 swig_obj[0] = args;
9680 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, SWIG_POINTER_DISOWN | 0 );
9681 if (!SWIG_IsOK(res1)) {
9682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FSFile" "', expected argument " "1"" of type '" "wxFSFile *""'");
9683 }
9684 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9685 {
9686 PyThreadState* __tstate = wxPyBeginAllowThreads();
9687 delete arg1;
9688
9689 wxPyEndAllowThreads(__tstate);
9690 if (PyErr_Occurred()) SWIG_fail;
9691 }
9692 resultobj = SWIG_Py_Void();
9693 return resultobj;
9694 fail:
9695 return NULL;
9696 }
9697
9698
9699 SWIGINTERN PyObject *_wrap_FSFile_GetStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9700 PyObject *resultobj = 0;
9701 wxFSFile *arg1 = (wxFSFile *) 0 ;
9702 wxInputStream *result = 0 ;
9703 void *argp1 = 0 ;
9704 int res1 = 0 ;
9705 PyObject *swig_obj[1] ;
9706
9707 if (!args) SWIG_fail;
9708 swig_obj[0] = args;
9709 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9710 if (!SWIG_IsOK(res1)) {
9711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
9712 }
9713 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9714 {
9715 PyThreadState* __tstate = wxPyBeginAllowThreads();
9716 result = (wxInputStream *)(arg1)->GetStream();
9717 wxPyEndAllowThreads(__tstate);
9718 if (PyErr_Occurred()) SWIG_fail;
9719 }
9720 {
9721 wxPyInputStream * _ptr = NULL;
9722
9723 if (result) {
9724 _ptr = new wxPyInputStream(result);
9725 }
9726 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
9727 }
9728 return resultobj;
9729 fail:
9730 return NULL;
9731 }
9732
9733
9734 SWIGINTERN PyObject *_wrap_FSFile_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9735 PyObject *resultobj = 0;
9736 wxFSFile *arg1 = (wxFSFile *) 0 ;
9737 wxString *result = 0 ;
9738 void *argp1 = 0 ;
9739 int res1 = 0 ;
9740 PyObject *swig_obj[1] ;
9741
9742 if (!args) SWIG_fail;
9743 swig_obj[0] = args;
9744 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9745 if (!SWIG_IsOK(res1)) {
9746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetMimeType" "', expected argument " "1"" of type '" "wxFSFile *""'");
9747 }
9748 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9749 {
9750 PyThreadState* __tstate = wxPyBeginAllowThreads();
9751 {
9752 wxString const &_result_ref = (arg1)->GetMimeType();
9753 result = (wxString *) &_result_ref;
9754 }
9755 wxPyEndAllowThreads(__tstate);
9756 if (PyErr_Occurred()) SWIG_fail;
9757 }
9758 {
9759 #if wxUSE_UNICODE
9760 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9761 #else
9762 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9763 #endif
9764 }
9765 return resultobj;
9766 fail:
9767 return NULL;
9768 }
9769
9770
9771 SWIGINTERN PyObject *_wrap_FSFile_GetLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9772 PyObject *resultobj = 0;
9773 wxFSFile *arg1 = (wxFSFile *) 0 ;
9774 wxString *result = 0 ;
9775 void *argp1 = 0 ;
9776 int res1 = 0 ;
9777 PyObject *swig_obj[1] ;
9778
9779 if (!args) SWIG_fail;
9780 swig_obj[0] = args;
9781 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9782 if (!SWIG_IsOK(res1)) {
9783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetLocation" "', expected argument " "1"" of type '" "wxFSFile *""'");
9784 }
9785 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9786 {
9787 PyThreadState* __tstate = wxPyBeginAllowThreads();
9788 {
9789 wxString const &_result_ref = (arg1)->GetLocation();
9790 result = (wxString *) &_result_ref;
9791 }
9792 wxPyEndAllowThreads(__tstate);
9793 if (PyErr_Occurred()) SWIG_fail;
9794 }
9795 {
9796 #if wxUSE_UNICODE
9797 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9798 #else
9799 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9800 #endif
9801 }
9802 return resultobj;
9803 fail:
9804 return NULL;
9805 }
9806
9807
9808 SWIGINTERN PyObject *_wrap_FSFile_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9809 PyObject *resultobj = 0;
9810 wxFSFile *arg1 = (wxFSFile *) 0 ;
9811 wxString *result = 0 ;
9812 void *argp1 = 0 ;
9813 int res1 = 0 ;
9814 PyObject *swig_obj[1] ;
9815
9816 if (!args) SWIG_fail;
9817 swig_obj[0] = args;
9818 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9819 if (!SWIG_IsOK(res1)) {
9820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetAnchor" "', expected argument " "1"" of type '" "wxFSFile *""'");
9821 }
9822 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9823 {
9824 PyThreadState* __tstate = wxPyBeginAllowThreads();
9825 {
9826 wxString const &_result_ref = (arg1)->GetAnchor();
9827 result = (wxString *) &_result_ref;
9828 }
9829 wxPyEndAllowThreads(__tstate);
9830 if (PyErr_Occurred()) SWIG_fail;
9831 }
9832 {
9833 #if wxUSE_UNICODE
9834 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9835 #else
9836 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9837 #endif
9838 }
9839 return resultobj;
9840 fail:
9841 return NULL;
9842 }
9843
9844
9845 SWIGINTERN PyObject *_wrap_FSFile_GetModificationTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9846 PyObject *resultobj = 0;
9847 wxFSFile *arg1 = (wxFSFile *) 0 ;
9848 wxDateTime result;
9849 void *argp1 = 0 ;
9850 int res1 = 0 ;
9851 PyObject *swig_obj[1] ;
9852
9853 if (!args) SWIG_fail;
9854 swig_obj[0] = args;
9855 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9856 if (!SWIG_IsOK(res1)) {
9857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetModificationTime" "', expected argument " "1"" of type '" "wxFSFile *""'");
9858 }
9859 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9860 {
9861 PyThreadState* __tstate = wxPyBeginAllowThreads();
9862 result = (arg1)->GetModificationTime();
9863 wxPyEndAllowThreads(__tstate);
9864 if (PyErr_Occurred()) SWIG_fail;
9865 }
9866 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
9867 return resultobj;
9868 fail:
9869 return NULL;
9870 }
9871
9872
9873 SWIGINTERN PyObject *FSFile_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9874 PyObject *obj;
9875 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9876 SWIG_TypeNewClientData(SWIGTYPE_p_wxFSFile, SWIG_NewClientData(obj));
9877 return SWIG_Py_Void();
9878 }
9879
9880 SWIGINTERN PyObject *FSFile_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9881 return SWIG_Python_InitShadowInstance(args);
9882 }
9883
9884 SWIGINTERN PyObject *_wrap_delete_CPPFileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9885 PyObject *resultobj = 0;
9886 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
9887 void *argp1 = 0 ;
9888 int res1 = 0 ;
9889 PyObject *swig_obj[1] ;
9890
9891 if (!args) SWIG_fail;
9892 swig_obj[0] = args;
9893 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
9894 if (!SWIG_IsOK(res1)) {
9895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CPPFileSystemHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
9896 }
9897 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
9898 {
9899 PyThreadState* __tstate = wxPyBeginAllowThreads();
9900 delete arg1;
9901
9902 wxPyEndAllowThreads(__tstate);
9903 if (PyErr_Occurred()) SWIG_fail;
9904 }
9905 resultobj = SWIG_Py_Void();
9906 return resultobj;
9907 fail:
9908 return NULL;
9909 }
9910
9911
9912 SWIGINTERN PyObject *CPPFileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9913 PyObject *obj;
9914 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9915 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystemHandler, SWIG_NewClientData(obj));
9916 return SWIG_Py_Void();
9917 }
9918
9919 SWIGINTERN PyObject *_wrap_new_FileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9920 PyObject *resultobj = 0;
9921 wxPyFileSystemHandler *result = 0 ;
9922
9923 if (!SWIG_Python_UnpackTuple(args,"new_FileSystemHandler",0,0,0)) SWIG_fail;
9924 {
9925 PyThreadState* __tstate = wxPyBeginAllowThreads();
9926 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
9927 wxPyEndAllowThreads(__tstate);
9928 if (PyErr_Occurred()) SWIG_fail;
9929 }
9930 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_NEW | 0 );
9931 return resultobj;
9932 fail:
9933 return NULL;
9934 }
9935
9936
9937 SWIGINTERN PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9938 PyObject *resultobj = 0;
9939 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
9940 PyObject *arg2 = (PyObject *) 0 ;
9941 PyObject *arg3 = (PyObject *) 0 ;
9942 void *argp1 = 0 ;
9943 int res1 = 0 ;
9944 PyObject * obj0 = 0 ;
9945 PyObject * obj1 = 0 ;
9946 PyObject * obj2 = 0 ;
9947 char * kwnames[] = {
9948 (char *) "self",(char *) "self",(char *) "_class", NULL
9949 };
9950
9951 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9952 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
9953 if (!SWIG_IsOK(res1)) {
9954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
9955 }
9956 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
9957 arg2 = obj1;
9958 arg3 = obj2;
9959 {
9960 PyThreadState* __tstate = wxPyBeginAllowThreads();
9961 (arg1)->_setCallbackInfo(arg2,arg3);
9962 wxPyEndAllowThreads(__tstate);
9963 if (PyErr_Occurred()) SWIG_fail;
9964 }
9965 resultobj = SWIG_Py_Void();
9966 return resultobj;
9967 fail:
9968 return NULL;
9969 }
9970
9971
9972 SWIGINTERN PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9973 PyObject *resultobj = 0;
9974 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
9975 wxString *arg2 = 0 ;
9976 bool result;
9977 void *argp1 = 0 ;
9978 int res1 = 0 ;
9979 bool temp2 = false ;
9980 PyObject * obj0 = 0 ;
9981 PyObject * obj1 = 0 ;
9982 char * kwnames[] = {
9983 (char *) "self",(char *) "location", NULL
9984 };
9985
9986 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
9987 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
9988 if (!SWIG_IsOK(res1)) {
9989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_CanOpen" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
9990 }
9991 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
9992 {
9993 arg2 = wxString_in_helper(obj1);
9994 if (arg2 == NULL) SWIG_fail;
9995 temp2 = true;
9996 }
9997 {
9998 PyThreadState* __tstate = wxPyBeginAllowThreads();
9999 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
10000 wxPyEndAllowThreads(__tstate);
10001 if (PyErr_Occurred()) SWIG_fail;
10002 }
10003 {
10004 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10005 }
10006 {
10007 if (temp2)
10008 delete arg2;
10009 }
10010 return resultobj;
10011 fail:
10012 {
10013 if (temp2)
10014 delete arg2;
10015 }
10016 return NULL;
10017 }
10018
10019
10020 SWIGINTERN PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10021 PyObject *resultobj = 0;
10022 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10023 wxFileSystem *arg2 = 0 ;
10024 wxString *arg3 = 0 ;
10025 wxFSFile *result = 0 ;
10026 void *argp1 = 0 ;
10027 int res1 = 0 ;
10028 void *argp2 = 0 ;
10029 int res2 = 0 ;
10030 bool temp3 = false ;
10031 PyObject * obj0 = 0 ;
10032 PyObject * obj1 = 0 ;
10033 PyObject * obj2 = 0 ;
10034 char * kwnames[] = {
10035 (char *) "self",(char *) "fs",(char *) "location", NULL
10036 };
10037
10038 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10039 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10040 if (!SWIG_IsOK(res1)) {
10041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10042 }
10043 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10044 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
10045 if (!SWIG_IsOK(res2)) {
10046 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10047 }
10048 if (!argp2) {
10049 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10050 }
10051 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
10052 {
10053 arg3 = wxString_in_helper(obj2);
10054 if (arg3 == NULL) SWIG_fail;
10055 temp3 = true;
10056 }
10057 {
10058 PyThreadState* __tstate = wxPyBeginAllowThreads();
10059 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
10060 wxPyEndAllowThreads(__tstate);
10061 if (PyErr_Occurred()) SWIG_fail;
10062 }
10063 {
10064 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
10065 }
10066 {
10067 if (temp3)
10068 delete arg3;
10069 }
10070 return resultobj;
10071 fail:
10072 {
10073 if (temp3)
10074 delete arg3;
10075 }
10076 return NULL;
10077 }
10078
10079
10080 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10081 PyObject *resultobj = 0;
10082 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10083 wxString *arg2 = 0 ;
10084 int arg3 = (int) 0 ;
10085 wxString result;
10086 void *argp1 = 0 ;
10087 int res1 = 0 ;
10088 bool temp2 = false ;
10089 int val3 ;
10090 int ecode3 = 0 ;
10091 PyObject * obj0 = 0 ;
10092 PyObject * obj1 = 0 ;
10093 PyObject * obj2 = 0 ;
10094 char * kwnames[] = {
10095 (char *) "self",(char *) "spec",(char *) "flags", NULL
10096 };
10097
10098 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10099 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10100 if (!SWIG_IsOK(res1)) {
10101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10102 }
10103 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10104 {
10105 arg2 = wxString_in_helper(obj1);
10106 if (arg2 == NULL) SWIG_fail;
10107 temp2 = true;
10108 }
10109 if (obj2) {
10110 ecode3 = SWIG_AsVal_int(obj2, &val3);
10111 if (!SWIG_IsOK(ecode3)) {
10112 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
10113 }
10114 arg3 = static_cast< int >(val3);
10115 }
10116 {
10117 PyThreadState* __tstate = wxPyBeginAllowThreads();
10118 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10119 wxPyEndAllowThreads(__tstate);
10120 if (PyErr_Occurred()) SWIG_fail;
10121 }
10122 {
10123 #if wxUSE_UNICODE
10124 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10125 #else
10126 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10127 #endif
10128 }
10129 {
10130 if (temp2)
10131 delete arg2;
10132 }
10133 return resultobj;
10134 fail:
10135 {
10136 if (temp2)
10137 delete arg2;
10138 }
10139 return NULL;
10140 }
10141
10142
10143 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10144 PyObject *resultobj = 0;
10145 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10146 wxString result;
10147 void *argp1 = 0 ;
10148 int res1 = 0 ;
10149 PyObject *swig_obj[1] ;
10150
10151 if (!args) SWIG_fail;
10152 swig_obj[0] = args;
10153 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10154 if (!SWIG_IsOK(res1)) {
10155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindNext" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10156 }
10157 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10158 {
10159 PyThreadState* __tstate = wxPyBeginAllowThreads();
10160 result = (arg1)->FindNext();
10161 wxPyEndAllowThreads(__tstate);
10162 if (PyErr_Occurred()) SWIG_fail;
10163 }
10164 {
10165 #if wxUSE_UNICODE
10166 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10167 #else
10168 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10169 #endif
10170 }
10171 return resultobj;
10172 fail:
10173 return NULL;
10174 }
10175
10176
10177 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10178 PyObject *resultobj = 0;
10179 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10180 wxString *arg2 = 0 ;
10181 wxString result;
10182 void *argp1 = 0 ;
10183 int res1 = 0 ;
10184 bool temp2 = false ;
10185 PyObject * obj0 = 0 ;
10186 PyObject * obj1 = 0 ;
10187 char * kwnames[] = {
10188 (char *) "self",(char *) "location", NULL
10189 };
10190
10191 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) SWIG_fail;
10192 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10193 if (!SWIG_IsOK(res1)) {
10194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetProtocol" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10195 }
10196 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10197 {
10198 arg2 = wxString_in_helper(obj1);
10199 if (arg2 == NULL) SWIG_fail;
10200 temp2 = true;
10201 }
10202 {
10203 PyThreadState* __tstate = wxPyBeginAllowThreads();
10204 result = (arg1)->GetProtocol((wxString const &)*arg2);
10205 wxPyEndAllowThreads(__tstate);
10206 if (PyErr_Occurred()) SWIG_fail;
10207 }
10208 {
10209 #if wxUSE_UNICODE
10210 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10211 #else
10212 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10213 #endif
10214 }
10215 {
10216 if (temp2)
10217 delete arg2;
10218 }
10219 return resultobj;
10220 fail:
10221 {
10222 if (temp2)
10223 delete arg2;
10224 }
10225 return NULL;
10226 }
10227
10228
10229 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10230 PyObject *resultobj = 0;
10231 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10232 wxString *arg2 = 0 ;
10233 wxString result;
10234 void *argp1 = 0 ;
10235 int res1 = 0 ;
10236 bool temp2 = false ;
10237 PyObject * obj0 = 0 ;
10238 PyObject * obj1 = 0 ;
10239 char * kwnames[] = {
10240 (char *) "self",(char *) "location", NULL
10241 };
10242
10243 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10244 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10245 if (!SWIG_IsOK(res1)) {
10246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetLeftLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10247 }
10248 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10249 {
10250 arg2 = wxString_in_helper(obj1);
10251 if (arg2 == NULL) SWIG_fail;
10252 temp2 = true;
10253 }
10254 {
10255 PyThreadState* __tstate = wxPyBeginAllowThreads();
10256 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
10257 wxPyEndAllowThreads(__tstate);
10258 if (PyErr_Occurred()) SWIG_fail;
10259 }
10260 {
10261 #if wxUSE_UNICODE
10262 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10263 #else
10264 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10265 #endif
10266 }
10267 {
10268 if (temp2)
10269 delete arg2;
10270 }
10271 return resultobj;
10272 fail:
10273 {
10274 if (temp2)
10275 delete arg2;
10276 }
10277 return NULL;
10278 }
10279
10280
10281 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10282 PyObject *resultobj = 0;
10283 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10284 wxString *arg2 = 0 ;
10285 wxString result;
10286 void *argp1 = 0 ;
10287 int res1 = 0 ;
10288 bool temp2 = false ;
10289 PyObject * obj0 = 0 ;
10290 PyObject * obj1 = 0 ;
10291 char * kwnames[] = {
10292 (char *) "self",(char *) "location", NULL
10293 };
10294
10295 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) SWIG_fail;
10296 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10297 if (!SWIG_IsOK(res1)) {
10298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetAnchor" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10299 }
10300 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10301 {
10302 arg2 = wxString_in_helper(obj1);
10303 if (arg2 == NULL) SWIG_fail;
10304 temp2 = true;
10305 }
10306 {
10307 PyThreadState* __tstate = wxPyBeginAllowThreads();
10308 result = (arg1)->GetAnchor((wxString const &)*arg2);
10309 wxPyEndAllowThreads(__tstate);
10310 if (PyErr_Occurred()) SWIG_fail;
10311 }
10312 {
10313 #if wxUSE_UNICODE
10314 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10315 #else
10316 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10317 #endif
10318 }
10319 {
10320 if (temp2)
10321 delete arg2;
10322 }
10323 return resultobj;
10324 fail:
10325 {
10326 if (temp2)
10327 delete arg2;
10328 }
10329 return NULL;
10330 }
10331
10332
10333 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10334 PyObject *resultobj = 0;
10335 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10336 wxString *arg2 = 0 ;
10337 wxString result;
10338 void *argp1 = 0 ;
10339 int res1 = 0 ;
10340 bool temp2 = false ;
10341 PyObject * obj0 = 0 ;
10342 PyObject * obj1 = 0 ;
10343 char * kwnames[] = {
10344 (char *) "self",(char *) "location", NULL
10345 };
10346
10347 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10348 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10349 if (!SWIG_IsOK(res1)) {
10350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetRightLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10351 }
10352 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10353 {
10354 arg2 = wxString_in_helper(obj1);
10355 if (arg2 == NULL) SWIG_fail;
10356 temp2 = true;
10357 }
10358 {
10359 PyThreadState* __tstate = wxPyBeginAllowThreads();
10360 result = (arg1)->GetRightLocation((wxString const &)*arg2);
10361 wxPyEndAllowThreads(__tstate);
10362 if (PyErr_Occurred()) SWIG_fail;
10363 }
10364 {
10365 #if wxUSE_UNICODE
10366 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10367 #else
10368 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10369 #endif
10370 }
10371 {
10372 if (temp2)
10373 delete arg2;
10374 }
10375 return resultobj;
10376 fail:
10377 {
10378 if (temp2)
10379 delete arg2;
10380 }
10381 return NULL;
10382 }
10383
10384
10385 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10386 PyObject *resultobj = 0;
10387 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10388 wxString *arg2 = 0 ;
10389 wxString result;
10390 void *argp1 = 0 ;
10391 int res1 = 0 ;
10392 bool temp2 = false ;
10393 PyObject * obj0 = 0 ;
10394 PyObject * obj1 = 0 ;
10395 char * kwnames[] = {
10396 (char *) "self",(char *) "location", NULL
10397 };
10398
10399 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) SWIG_fail;
10400 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10401 if (!SWIG_IsOK(res1)) {
10402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetMimeTypeFromExt" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10403 }
10404 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10405 {
10406 arg2 = wxString_in_helper(obj1);
10407 if (arg2 == NULL) SWIG_fail;
10408 temp2 = true;
10409 }
10410 {
10411 PyThreadState* __tstate = wxPyBeginAllowThreads();
10412 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
10413 wxPyEndAllowThreads(__tstate);
10414 if (PyErr_Occurred()) SWIG_fail;
10415 }
10416 {
10417 #if wxUSE_UNICODE
10418 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10419 #else
10420 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10421 #endif
10422 }
10423 {
10424 if (temp2)
10425 delete arg2;
10426 }
10427 return resultobj;
10428 fail:
10429 {
10430 if (temp2)
10431 delete arg2;
10432 }
10433 return NULL;
10434 }
10435
10436
10437 SWIGINTERN PyObject *FileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10438 PyObject *obj;
10439 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10440 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileSystemHandler, SWIG_NewClientData(obj));
10441 return SWIG_Py_Void();
10442 }
10443
10444 SWIGINTERN PyObject *FileSystemHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10445 return SWIG_Python_InitShadowInstance(args);
10446 }
10447
10448 SWIGINTERN PyObject *_wrap_new_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10449 PyObject *resultobj = 0;
10450 wxFileSystem *result = 0 ;
10451
10452 if (!SWIG_Python_UnpackTuple(args,"new_FileSystem",0,0,0)) SWIG_fail;
10453 {
10454 PyThreadState* __tstate = wxPyBeginAllowThreads();
10455 result = (wxFileSystem *)new wxFileSystem();
10456 wxPyEndAllowThreads(__tstate);
10457 if (PyErr_Occurred()) SWIG_fail;
10458 }
10459 {
10460 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
10461 }
10462 return resultobj;
10463 fail:
10464 return NULL;
10465 }
10466
10467
10468 SWIGINTERN PyObject *_wrap_delete_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10469 PyObject *resultobj = 0;
10470 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10471 void *argp1 = 0 ;
10472 int res1 = 0 ;
10473 PyObject *swig_obj[1] ;
10474
10475 if (!args) SWIG_fail;
10476 swig_obj[0] = args;
10477 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, SWIG_POINTER_DISOWN | 0 );
10478 if (!SWIG_IsOK(res1)) {
10479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileSystem" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10480 }
10481 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10482 {
10483 PyThreadState* __tstate = wxPyBeginAllowThreads();
10484 delete arg1;
10485
10486 wxPyEndAllowThreads(__tstate);
10487 if (PyErr_Occurred()) SWIG_fail;
10488 }
10489 resultobj = SWIG_Py_Void();
10490 return resultobj;
10491 fail:
10492 return NULL;
10493 }
10494
10495
10496 SWIGINTERN PyObject *_wrap_FileSystem_ChangePathTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10497 PyObject *resultobj = 0;
10498 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10499 wxString *arg2 = 0 ;
10500 bool arg3 = (bool) false ;
10501 void *argp1 = 0 ;
10502 int res1 = 0 ;
10503 bool temp2 = false ;
10504 bool val3 ;
10505 int ecode3 = 0 ;
10506 PyObject * obj0 = 0 ;
10507 PyObject * obj1 = 0 ;
10508 PyObject * obj2 = 0 ;
10509 char * kwnames[] = {
10510 (char *) "self",(char *) "location",(char *) "is_dir", NULL
10511 };
10512
10513 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10514 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10515 if (!SWIG_IsOK(res1)) {
10516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_ChangePathTo" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10517 }
10518 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10519 {
10520 arg2 = wxString_in_helper(obj1);
10521 if (arg2 == NULL) SWIG_fail;
10522 temp2 = true;
10523 }
10524 if (obj2) {
10525 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10526 if (!SWIG_IsOK(ecode3)) {
10527 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_ChangePathTo" "', expected argument " "3"" of type '" "bool""'");
10528 }
10529 arg3 = static_cast< bool >(val3);
10530 }
10531 {
10532 PyThreadState* __tstate = wxPyBeginAllowThreads();
10533 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
10534 wxPyEndAllowThreads(__tstate);
10535 if (PyErr_Occurred()) SWIG_fail;
10536 }
10537 resultobj = SWIG_Py_Void();
10538 {
10539 if (temp2)
10540 delete arg2;
10541 }
10542 return resultobj;
10543 fail:
10544 {
10545 if (temp2)
10546 delete arg2;
10547 }
10548 return NULL;
10549 }
10550
10551
10552 SWIGINTERN PyObject *_wrap_FileSystem_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10553 PyObject *resultobj = 0;
10554 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10555 wxString result;
10556 void *argp1 = 0 ;
10557 int res1 = 0 ;
10558 PyObject *swig_obj[1] ;
10559
10560 if (!args) SWIG_fail;
10561 swig_obj[0] = args;
10562 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10563 if (!SWIG_IsOK(res1)) {
10564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_GetPath" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10565 }
10566 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10567 {
10568 PyThreadState* __tstate = wxPyBeginAllowThreads();
10569 result = (arg1)->GetPath();
10570 wxPyEndAllowThreads(__tstate);
10571 if (PyErr_Occurred()) SWIG_fail;
10572 }
10573 {
10574 #if wxUSE_UNICODE
10575 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10576 #else
10577 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10578 #endif
10579 }
10580 return resultobj;
10581 fail:
10582 return NULL;
10583 }
10584
10585
10586 SWIGINTERN PyObject *_wrap_FileSystem_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10587 PyObject *resultobj = 0;
10588 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10589 wxString *arg2 = 0 ;
10590 wxFSFile *result = 0 ;
10591 void *argp1 = 0 ;
10592 int res1 = 0 ;
10593 bool temp2 = false ;
10594 PyObject * obj0 = 0 ;
10595 PyObject * obj1 = 0 ;
10596 char * kwnames[] = {
10597 (char *) "self",(char *) "location", NULL
10598 };
10599
10600 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) SWIG_fail;
10601 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10602 if (!SWIG_IsOK(res1)) {
10603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_OpenFile" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10604 }
10605 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10606 {
10607 arg2 = wxString_in_helper(obj1);
10608 if (arg2 == NULL) SWIG_fail;
10609 temp2 = true;
10610 }
10611 {
10612 PyThreadState* __tstate = wxPyBeginAllowThreads();
10613 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
10614 wxPyEndAllowThreads(__tstate);
10615 if (PyErr_Occurred()) SWIG_fail;
10616 }
10617 {
10618 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
10619 }
10620 {
10621 if (temp2)
10622 delete arg2;
10623 }
10624 return resultobj;
10625 fail:
10626 {
10627 if (temp2)
10628 delete arg2;
10629 }
10630 return NULL;
10631 }
10632
10633
10634 SWIGINTERN PyObject *_wrap_FileSystem_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10635 PyObject *resultobj = 0;
10636 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10637 wxString *arg2 = 0 ;
10638 int arg3 = (int) 0 ;
10639 wxString result;
10640 void *argp1 = 0 ;
10641 int res1 = 0 ;
10642 bool temp2 = false ;
10643 int val3 ;
10644 int ecode3 = 0 ;
10645 PyObject * obj0 = 0 ;
10646 PyObject * obj1 = 0 ;
10647 PyObject * obj2 = 0 ;
10648 char * kwnames[] = {
10649 (char *) "self",(char *) "spec",(char *) "flags", NULL
10650 };
10651
10652 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10653 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10654 if (!SWIG_IsOK(res1)) {
10655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindFirst" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10656 }
10657 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10658 {
10659 arg2 = wxString_in_helper(obj1);
10660 if (arg2 == NULL) SWIG_fail;
10661 temp2 = true;
10662 }
10663 if (obj2) {
10664 ecode3 = SWIG_AsVal_int(obj2, &val3);
10665 if (!SWIG_IsOK(ecode3)) {
10666 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_FindFirst" "', expected argument " "3"" of type '" "int""'");
10667 }
10668 arg3 = static_cast< int >(val3);
10669 }
10670 {
10671 PyThreadState* __tstate = wxPyBeginAllowThreads();
10672 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10673 wxPyEndAllowThreads(__tstate);
10674 if (PyErr_Occurred()) SWIG_fail;
10675 }
10676 {
10677 #if wxUSE_UNICODE
10678 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10679 #else
10680 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10681 #endif
10682 }
10683 {
10684 if (temp2)
10685 delete arg2;
10686 }
10687 return resultobj;
10688 fail:
10689 {
10690 if (temp2)
10691 delete arg2;
10692 }
10693 return NULL;
10694 }
10695
10696
10697 SWIGINTERN PyObject *_wrap_FileSystem_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10698 PyObject *resultobj = 0;
10699 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10700 wxString result;
10701 void *argp1 = 0 ;
10702 int res1 = 0 ;
10703 PyObject *swig_obj[1] ;
10704
10705 if (!args) SWIG_fail;
10706 swig_obj[0] = args;
10707 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10708 if (!SWIG_IsOK(res1)) {
10709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindNext" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10710 }
10711 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10712 {
10713 PyThreadState* __tstate = wxPyBeginAllowThreads();
10714 result = (arg1)->FindNext();
10715 wxPyEndAllowThreads(__tstate);
10716 if (PyErr_Occurred()) SWIG_fail;
10717 }
10718 {
10719 #if wxUSE_UNICODE
10720 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10721 #else
10722 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10723 #endif
10724 }
10725 return resultobj;
10726 fail:
10727 return NULL;
10728 }
10729
10730
10731 SWIGINTERN PyObject *_wrap_FileSystem_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10732 PyObject *resultobj = 0;
10733 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
10734 int res1 = 0 ;
10735 PyObject * obj0 = 0 ;
10736 char * kwnames[] = {
10737 (char *) "handler", NULL
10738 };
10739
10740 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) SWIG_fail;
10741 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
10742 if (!SWIG_IsOK(res1)) {
10743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_AddHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
10744 }
10745 {
10746 PyThreadState* __tstate = wxPyBeginAllowThreads();
10747 wxFileSystem::AddHandler(arg1);
10748 wxPyEndAllowThreads(__tstate);
10749 if (PyErr_Occurred()) SWIG_fail;
10750 }
10751 resultobj = SWIG_Py_Void();
10752 return resultobj;
10753 fail:
10754 return NULL;
10755 }
10756
10757
10758 SWIGINTERN PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10759 PyObject *resultobj = 0;
10760
10761 if (!SWIG_Python_UnpackTuple(args,"FileSystem_CleanUpHandlers",0,0,0)) SWIG_fail;
10762 {
10763 PyThreadState* __tstate = wxPyBeginAllowThreads();
10764 wxFileSystem::CleanUpHandlers();
10765 wxPyEndAllowThreads(__tstate);
10766 if (PyErr_Occurred()) SWIG_fail;
10767 }
10768 resultobj = SWIG_Py_Void();
10769 return resultobj;
10770 fail:
10771 return NULL;
10772 }
10773
10774
10775 SWIGINTERN PyObject *_wrap_FileSystem_FileNameToURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10776 PyObject *resultobj = 0;
10777 wxString *arg1 = 0 ;
10778 wxString result;
10779 bool temp1 = false ;
10780 PyObject * obj0 = 0 ;
10781 char * kwnames[] = {
10782 (char *) "filename", NULL
10783 };
10784
10785 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) SWIG_fail;
10786 {
10787 arg1 = wxString_in_helper(obj0);
10788 if (arg1 == NULL) SWIG_fail;
10789 temp1 = true;
10790 }
10791 {
10792 PyThreadState* __tstate = wxPyBeginAllowThreads();
10793 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
10794 wxPyEndAllowThreads(__tstate);
10795 if (PyErr_Occurred()) SWIG_fail;
10796 }
10797 {
10798 #if wxUSE_UNICODE
10799 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10800 #else
10801 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10802 #endif
10803 }
10804 {
10805 if (temp1)
10806 delete arg1;
10807 }
10808 return resultobj;
10809 fail:
10810 {
10811 if (temp1)
10812 delete arg1;
10813 }
10814 return NULL;
10815 }
10816
10817
10818 SWIGINTERN PyObject *_wrap_FileSystem_URLToFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10819 PyObject *resultobj = 0;
10820 wxString *arg1 = 0 ;
10821 wxString result;
10822 bool temp1 = false ;
10823 PyObject * obj0 = 0 ;
10824 char * kwnames[] = {
10825 (char *) "url", NULL
10826 };
10827
10828 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) SWIG_fail;
10829 {
10830 arg1 = wxString_in_helper(obj0);
10831 if (arg1 == NULL) SWIG_fail;
10832 temp1 = true;
10833 }
10834 {
10835 PyThreadState* __tstate = wxPyBeginAllowThreads();
10836 result = wxFileSystem_URLToFileName((wxString const &)*arg1);
10837 wxPyEndAllowThreads(__tstate);
10838 if (PyErr_Occurred()) SWIG_fail;
10839 }
10840 {
10841 #if wxUSE_UNICODE
10842 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10843 #else
10844 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10845 #endif
10846 }
10847 {
10848 if (temp1)
10849 delete arg1;
10850 }
10851 return resultobj;
10852 fail:
10853 {
10854 if (temp1)
10855 delete arg1;
10856 }
10857 return NULL;
10858 }
10859
10860
10861 SWIGINTERN PyObject *FileSystem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10862 PyObject *obj;
10863 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10864 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystem, SWIG_NewClientData(obj));
10865 return SWIG_Py_Void();
10866 }
10867
10868 SWIGINTERN PyObject *FileSystem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10869 return SWIG_Python_InitShadowInstance(args);
10870 }
10871
10872 SWIGINTERN PyObject *_wrap_new_InternetFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10873 PyObject *resultobj = 0;
10874 wxInternetFSHandler *result = 0 ;
10875
10876 if (!SWIG_Python_UnpackTuple(args,"new_InternetFSHandler",0,0,0)) SWIG_fail;
10877 {
10878 PyThreadState* __tstate = wxPyBeginAllowThreads();
10879 result = (wxInternetFSHandler *)new wxInternetFSHandler();
10880 wxPyEndAllowThreads(__tstate);
10881 if (PyErr_Occurred()) SWIG_fail;
10882 }
10883 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_NEW | 0 );
10884 return resultobj;
10885 fail:
10886 return NULL;
10887 }
10888
10889
10890 SWIGINTERN PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10891 PyObject *resultobj = 0;
10892 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
10893 wxString *arg2 = 0 ;
10894 bool result;
10895 void *argp1 = 0 ;
10896 int res1 = 0 ;
10897 bool temp2 = false ;
10898 PyObject * obj0 = 0 ;
10899 PyObject * obj1 = 0 ;
10900 char * kwnames[] = {
10901 (char *) "self",(char *) "location", NULL
10902 };
10903
10904 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
10905 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
10906 if (!SWIG_IsOK(res1)) {
10907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
10908 }
10909 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
10910 {
10911 arg2 = wxString_in_helper(obj1);
10912 if (arg2 == NULL) SWIG_fail;
10913 temp2 = true;
10914 }
10915 {
10916 PyThreadState* __tstate = wxPyBeginAllowThreads();
10917 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
10918 wxPyEndAllowThreads(__tstate);
10919 if (PyErr_Occurred()) SWIG_fail;
10920 }
10921 {
10922 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10923 }
10924 {
10925 if (temp2)
10926 delete arg2;
10927 }
10928 return resultobj;
10929 fail:
10930 {
10931 if (temp2)
10932 delete arg2;
10933 }
10934 return NULL;
10935 }
10936
10937
10938 SWIGINTERN PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10939 PyObject *resultobj = 0;
10940 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
10941 wxFileSystem *arg2 = 0 ;
10942 wxString *arg3 = 0 ;
10943 wxFSFile *result = 0 ;
10944 void *argp1 = 0 ;
10945 int res1 = 0 ;
10946 void *argp2 = 0 ;
10947 int res2 = 0 ;
10948 bool temp3 = false ;
10949 PyObject * obj0 = 0 ;
10950 PyObject * obj1 = 0 ;
10951 PyObject * obj2 = 0 ;
10952 char * kwnames[] = {
10953 (char *) "self",(char *) "fs",(char *) "location", NULL
10954 };
10955
10956 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10957 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
10958 if (!SWIG_IsOK(res1)) {
10959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
10960 }
10961 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
10962 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
10963 if (!SWIG_IsOK(res2)) {
10964 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10965 }
10966 if (!argp2) {
10967 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10968 }
10969 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
10970 {
10971 arg3 = wxString_in_helper(obj2);
10972 if (arg3 == NULL) SWIG_fail;
10973 temp3 = true;
10974 }
10975 {
10976 PyThreadState* __tstate = wxPyBeginAllowThreads();
10977 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
10978 wxPyEndAllowThreads(__tstate);
10979 if (PyErr_Occurred()) SWIG_fail;
10980 }
10981 {
10982 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
10983 }
10984 {
10985 if (temp3)
10986 delete arg3;
10987 }
10988 return resultobj;
10989 fail:
10990 {
10991 if (temp3)
10992 delete arg3;
10993 }
10994 return NULL;
10995 }
10996
10997
10998 SWIGINTERN PyObject *InternetFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10999 PyObject *obj;
11000 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11001 SWIG_TypeNewClientData(SWIGTYPE_p_wxInternetFSHandler, SWIG_NewClientData(obj));
11002 return SWIG_Py_Void();
11003 }
11004
11005 SWIGINTERN PyObject *InternetFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11006 return SWIG_Python_InitShadowInstance(args);
11007 }
11008
11009 SWIGINTERN PyObject *_wrap_new_ZipFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11010 PyObject *resultobj = 0;
11011 wxZipFSHandler *result = 0 ;
11012
11013 if (!SWIG_Python_UnpackTuple(args,"new_ZipFSHandler",0,0,0)) SWIG_fail;
11014 {
11015 PyThreadState* __tstate = wxPyBeginAllowThreads();
11016 result = (wxZipFSHandler *)new wxZipFSHandler();
11017 wxPyEndAllowThreads(__tstate);
11018 if (PyErr_Occurred()) SWIG_fail;
11019 }
11020 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_NEW | 0 );
11021 return resultobj;
11022 fail:
11023 return NULL;
11024 }
11025
11026
11027 SWIGINTERN PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11028 PyObject *resultobj = 0;
11029 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11030 wxString *arg2 = 0 ;
11031 bool result;
11032 void *argp1 = 0 ;
11033 int res1 = 0 ;
11034 bool temp2 = false ;
11035 PyObject * obj0 = 0 ;
11036 PyObject * obj1 = 0 ;
11037 char * kwnames[] = {
11038 (char *) "self",(char *) "location", NULL
11039 };
11040
11041 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11042 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11043 if (!SWIG_IsOK(res1)) {
11044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11045 }
11046 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11047 {
11048 arg2 = wxString_in_helper(obj1);
11049 if (arg2 == NULL) SWIG_fail;
11050 temp2 = true;
11051 }
11052 {
11053 PyThreadState* __tstate = wxPyBeginAllowThreads();
11054 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11055 wxPyEndAllowThreads(__tstate);
11056 if (PyErr_Occurred()) SWIG_fail;
11057 }
11058 {
11059 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11060 }
11061 {
11062 if (temp2)
11063 delete arg2;
11064 }
11065 return resultobj;
11066 fail:
11067 {
11068 if (temp2)
11069 delete arg2;
11070 }
11071 return NULL;
11072 }
11073
11074
11075 SWIGINTERN PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11076 PyObject *resultobj = 0;
11077 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11078 wxFileSystem *arg2 = 0 ;
11079 wxString *arg3 = 0 ;
11080 wxFSFile *result = 0 ;
11081 void *argp1 = 0 ;
11082 int res1 = 0 ;
11083 void *argp2 = 0 ;
11084 int res2 = 0 ;
11085 bool temp3 = false ;
11086 PyObject * obj0 = 0 ;
11087 PyObject * obj1 = 0 ;
11088 PyObject * obj2 = 0 ;
11089 char * kwnames[] = {
11090 (char *) "self",(char *) "fs",(char *) "location", NULL
11091 };
11092
11093 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11094 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11095 if (!SWIG_IsOK(res1)) {
11096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11097 }
11098 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11099 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11100 if (!SWIG_IsOK(res2)) {
11101 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11102 }
11103 if (!argp2) {
11104 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11105 }
11106 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11107 {
11108 arg3 = wxString_in_helper(obj2);
11109 if (arg3 == NULL) SWIG_fail;
11110 temp3 = true;
11111 }
11112 {
11113 PyThreadState* __tstate = wxPyBeginAllowThreads();
11114 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11115 wxPyEndAllowThreads(__tstate);
11116 if (PyErr_Occurred()) SWIG_fail;
11117 }
11118 {
11119 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
11120 }
11121 {
11122 if (temp3)
11123 delete arg3;
11124 }
11125 return resultobj;
11126 fail:
11127 {
11128 if (temp3)
11129 delete arg3;
11130 }
11131 return NULL;
11132 }
11133
11134
11135 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11136 PyObject *resultobj = 0;
11137 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11138 wxString *arg2 = 0 ;
11139 int arg3 = (int) 0 ;
11140 wxString result;
11141 void *argp1 = 0 ;
11142 int res1 = 0 ;
11143 bool temp2 = false ;
11144 int val3 ;
11145 int ecode3 = 0 ;
11146 PyObject * obj0 = 0 ;
11147 PyObject * obj1 = 0 ;
11148 PyObject * obj2 = 0 ;
11149 char * kwnames[] = {
11150 (char *) "self",(char *) "spec",(char *) "flags", NULL
11151 };
11152
11153 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11154 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11155 if (!SWIG_IsOK(res1)) {
11156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11157 }
11158 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11159 {
11160 arg2 = wxString_in_helper(obj1);
11161 if (arg2 == NULL) SWIG_fail;
11162 temp2 = true;
11163 }
11164 if (obj2) {
11165 ecode3 = SWIG_AsVal_int(obj2, &val3);
11166 if (!SWIG_IsOK(ecode3)) {
11167 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11168 }
11169 arg3 = static_cast< int >(val3);
11170 }
11171 {
11172 PyThreadState* __tstate = wxPyBeginAllowThreads();
11173 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11174 wxPyEndAllowThreads(__tstate);
11175 if (PyErr_Occurred()) SWIG_fail;
11176 }
11177 {
11178 #if wxUSE_UNICODE
11179 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11180 #else
11181 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11182 #endif
11183 }
11184 {
11185 if (temp2)
11186 delete arg2;
11187 }
11188 return resultobj;
11189 fail:
11190 {
11191 if (temp2)
11192 delete arg2;
11193 }
11194 return NULL;
11195 }
11196
11197
11198 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11199 PyObject *resultobj = 0;
11200 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11201 wxString result;
11202 void *argp1 = 0 ;
11203 int res1 = 0 ;
11204 PyObject *swig_obj[1] ;
11205
11206 if (!args) SWIG_fail;
11207 swig_obj[0] = args;
11208 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11209 if (!SWIG_IsOK(res1)) {
11210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindNext" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11211 }
11212 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11213 {
11214 PyThreadState* __tstate = wxPyBeginAllowThreads();
11215 result = (arg1)->FindNext();
11216 wxPyEndAllowThreads(__tstate);
11217 if (PyErr_Occurred()) SWIG_fail;
11218 }
11219 {
11220 #if wxUSE_UNICODE
11221 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11222 #else
11223 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11224 #endif
11225 }
11226 return resultobj;
11227 fail:
11228 return NULL;
11229 }
11230
11231
11232 SWIGINTERN PyObject *ZipFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11233 PyObject *obj;
11234 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11235 SWIG_TypeNewClientData(SWIGTYPE_p_wxZipFSHandler, SWIG_NewClientData(obj));
11236 return SWIG_Py_Void();
11237 }
11238
11239 SWIGINTERN PyObject *ZipFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11240 return SWIG_Python_InitShadowInstance(args);
11241 }
11242
11243 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11244 PyObject *resultobj = 0;
11245 wxString *arg1 = 0 ;
11246 wxImage *arg2 = 0 ;
11247 long arg3 ;
11248 bool temp1 = false ;
11249 void *argp2 = 0 ;
11250 int res2 = 0 ;
11251 long val3 ;
11252 int ecode3 = 0 ;
11253 PyObject * obj0 = 0 ;
11254 PyObject * obj1 = 0 ;
11255 PyObject * obj2 = 0 ;
11256 char * kwnames[] = {
11257 (char *) "filename",(char *) "image",(char *) "type", NULL
11258 };
11259
11260 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11261 {
11262 arg1 = wxString_in_helper(obj0);
11263 if (arg1 == NULL) SWIG_fail;
11264 temp1 = true;
11265 }
11266 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
11267 if (!SWIG_IsOK(res2)) {
11268 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11269 }
11270 if (!argp2) {
11271 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11272 }
11273 arg2 = reinterpret_cast< wxImage * >(argp2);
11274 ecode3 = SWIG_AsVal_long(obj2, &val3);
11275 if (!SWIG_IsOK(ecode3)) {
11276 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "3"" of type '" "long""'");
11277 }
11278 arg3 = static_cast< long >(val3);
11279 {
11280 PyThreadState* __tstate = wxPyBeginAllowThreads();
11281 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
11282 wxPyEndAllowThreads(__tstate);
11283 if (PyErr_Occurred()) SWIG_fail;
11284 }
11285 resultobj = SWIG_Py_Void();
11286 {
11287 if (temp1)
11288 delete arg1;
11289 }
11290 return resultobj;
11291 fail:
11292 {
11293 if (temp1)
11294 delete arg1;
11295 }
11296 return NULL;
11297 }
11298
11299
11300 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11301 PyObject *resultobj = 0;
11302 wxString *arg1 = 0 ;
11303 wxBitmap *arg2 = 0 ;
11304 long arg3 ;
11305 bool temp1 = false ;
11306 void *argp2 = 0 ;
11307 int res2 = 0 ;
11308 long val3 ;
11309 int ecode3 = 0 ;
11310 PyObject * obj0 = 0 ;
11311 PyObject * obj1 = 0 ;
11312 PyObject * obj2 = 0 ;
11313 char * kwnames[] = {
11314 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
11315 };
11316
11317 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11318 {
11319 arg1 = wxString_in_helper(obj0);
11320 if (arg1 == NULL) SWIG_fail;
11321 temp1 = true;
11322 }
11323 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
11324 if (!SWIG_IsOK(res2)) {
11325 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11326 }
11327 if (!argp2) {
11328 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11329 }
11330 arg2 = reinterpret_cast< wxBitmap * >(argp2);
11331 ecode3 = SWIG_AsVal_long(obj2, &val3);
11332 if (!SWIG_IsOK(ecode3)) {
11333 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "3"" of type '" "long""'");
11334 }
11335 arg3 = static_cast< long >(val3);
11336 {
11337 PyThreadState* __tstate = wxPyBeginAllowThreads();
11338 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
11339 wxPyEndAllowThreads(__tstate);
11340 if (PyErr_Occurred()) SWIG_fail;
11341 }
11342 resultobj = SWIG_Py_Void();
11343 {
11344 if (temp1)
11345 delete arg1;
11346 }
11347 return resultobj;
11348 fail:
11349 {
11350 if (temp1)
11351 delete arg1;
11352 }
11353 return NULL;
11354 }
11355
11356
11357 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11358 PyObject *resultobj = 0;
11359 wxString *arg1 = 0 ;
11360 PyObject *arg2 = (PyObject *) 0 ;
11361 bool temp1 = false ;
11362 PyObject * obj0 = 0 ;
11363 PyObject * obj1 = 0 ;
11364 char * kwnames[] = {
11365 (char *) "filename",(char *) "data", NULL
11366 };
11367
11368 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) SWIG_fail;
11369 {
11370 arg1 = wxString_in_helper(obj0);
11371 if (arg1 == NULL) SWIG_fail;
11372 temp1 = true;
11373 }
11374 arg2 = obj1;
11375 {
11376 PyThreadState* __tstate = wxPyBeginAllowThreads();
11377 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
11378 wxPyEndAllowThreads(__tstate);
11379 if (PyErr_Occurred()) SWIG_fail;
11380 }
11381 resultobj = SWIG_Py_Void();
11382 {
11383 if (temp1)
11384 delete arg1;
11385 }
11386 return resultobj;
11387 fail:
11388 {
11389 if (temp1)
11390 delete arg1;
11391 }
11392 return NULL;
11393 }
11394
11395
11396 SWIGINTERN PyObject *_wrap_new_MemoryFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11397 PyObject *resultobj = 0;
11398 wxMemoryFSHandler *result = 0 ;
11399
11400 if (!SWIG_Python_UnpackTuple(args,"new_MemoryFSHandler",0,0,0)) SWIG_fail;
11401 {
11402 PyThreadState* __tstate = wxPyBeginAllowThreads();
11403 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
11404 wxPyEndAllowThreads(__tstate);
11405 if (PyErr_Occurred()) SWIG_fail;
11406 }
11407 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_NEW | 0 );
11408 return resultobj;
11409 fail:
11410 return NULL;
11411 }
11412
11413
11414 SWIGINTERN PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11415 PyObject *resultobj = 0;
11416 wxString *arg1 = 0 ;
11417 bool temp1 = false ;
11418 PyObject * obj0 = 0 ;
11419 char * kwnames[] = {
11420 (char *) "filename", NULL
11421 };
11422
11423 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) SWIG_fail;
11424 {
11425 arg1 = wxString_in_helper(obj0);
11426 if (arg1 == NULL) SWIG_fail;
11427 temp1 = true;
11428 }
11429 {
11430 PyThreadState* __tstate = wxPyBeginAllowThreads();
11431 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
11432 wxPyEndAllowThreads(__tstate);
11433 if (PyErr_Occurred()) SWIG_fail;
11434 }
11435 resultobj = SWIG_Py_Void();
11436 {
11437 if (temp1)
11438 delete arg1;
11439 }
11440 return resultobj;
11441 fail:
11442 {
11443 if (temp1)
11444 delete arg1;
11445 }
11446 return NULL;
11447 }
11448
11449
11450 SWIGINTERN PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11451 PyObject *resultobj = 0;
11452 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11453 wxString *arg2 = 0 ;
11454 bool result;
11455 void *argp1 = 0 ;
11456 int res1 = 0 ;
11457 bool temp2 = false ;
11458 PyObject * obj0 = 0 ;
11459 PyObject * obj1 = 0 ;
11460 char * kwnames[] = {
11461 (char *) "self",(char *) "location", NULL
11462 };
11463
11464 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11465 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11466 if (!SWIG_IsOK(res1)) {
11467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11468 }
11469 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11470 {
11471 arg2 = wxString_in_helper(obj1);
11472 if (arg2 == NULL) SWIG_fail;
11473 temp2 = true;
11474 }
11475 {
11476 PyThreadState* __tstate = wxPyBeginAllowThreads();
11477 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11478 wxPyEndAllowThreads(__tstate);
11479 if (PyErr_Occurred()) SWIG_fail;
11480 }
11481 {
11482 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11483 }
11484 {
11485 if (temp2)
11486 delete arg2;
11487 }
11488 return resultobj;
11489 fail:
11490 {
11491 if (temp2)
11492 delete arg2;
11493 }
11494 return NULL;
11495 }
11496
11497
11498 SWIGINTERN PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11499 PyObject *resultobj = 0;
11500 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11501 wxFileSystem *arg2 = 0 ;
11502 wxString *arg3 = 0 ;
11503 wxFSFile *result = 0 ;
11504 void *argp1 = 0 ;
11505 int res1 = 0 ;
11506 void *argp2 = 0 ;
11507 int res2 = 0 ;
11508 bool temp3 = false ;
11509 PyObject * obj0 = 0 ;
11510 PyObject * obj1 = 0 ;
11511 PyObject * obj2 = 0 ;
11512 char * kwnames[] = {
11513 (char *) "self",(char *) "fs",(char *) "location", NULL
11514 };
11515
11516 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11517 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11518 if (!SWIG_IsOK(res1)) {
11519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11520 }
11521 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11522 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11523 if (!SWIG_IsOK(res2)) {
11524 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11525 }
11526 if (!argp2) {
11527 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11528 }
11529 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11530 {
11531 arg3 = wxString_in_helper(obj2);
11532 if (arg3 == NULL) SWIG_fail;
11533 temp3 = true;
11534 }
11535 {
11536 PyThreadState* __tstate = wxPyBeginAllowThreads();
11537 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11538 wxPyEndAllowThreads(__tstate);
11539 if (PyErr_Occurred()) SWIG_fail;
11540 }
11541 {
11542 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
11543 }
11544 {
11545 if (temp3)
11546 delete arg3;
11547 }
11548 return resultobj;
11549 fail:
11550 {
11551 if (temp3)
11552 delete arg3;
11553 }
11554 return NULL;
11555 }
11556
11557
11558 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11559 PyObject *resultobj = 0;
11560 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11561 wxString *arg2 = 0 ;
11562 int arg3 = (int) 0 ;
11563 wxString result;
11564 void *argp1 = 0 ;
11565 int res1 = 0 ;
11566 bool temp2 = false ;
11567 int val3 ;
11568 int ecode3 = 0 ;
11569 PyObject * obj0 = 0 ;
11570 PyObject * obj1 = 0 ;
11571 PyObject * obj2 = 0 ;
11572 char * kwnames[] = {
11573 (char *) "self",(char *) "spec",(char *) "flags", NULL
11574 };
11575
11576 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11577 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11578 if (!SWIG_IsOK(res1)) {
11579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11580 }
11581 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11582 {
11583 arg2 = wxString_in_helper(obj1);
11584 if (arg2 == NULL) SWIG_fail;
11585 temp2 = true;
11586 }
11587 if (obj2) {
11588 ecode3 = SWIG_AsVal_int(obj2, &val3);
11589 if (!SWIG_IsOK(ecode3)) {
11590 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11591 }
11592 arg3 = static_cast< int >(val3);
11593 }
11594 {
11595 PyThreadState* __tstate = wxPyBeginAllowThreads();
11596 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11597 wxPyEndAllowThreads(__tstate);
11598 if (PyErr_Occurred()) SWIG_fail;
11599 }
11600 {
11601 #if wxUSE_UNICODE
11602 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11603 #else
11604 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11605 #endif
11606 }
11607 {
11608 if (temp2)
11609 delete arg2;
11610 }
11611 return resultobj;
11612 fail:
11613 {
11614 if (temp2)
11615 delete arg2;
11616 }
11617 return NULL;
11618 }
11619
11620
11621 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11622 PyObject *resultobj = 0;
11623 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11624 wxString result;
11625 void *argp1 = 0 ;
11626 int res1 = 0 ;
11627 PyObject *swig_obj[1] ;
11628
11629 if (!args) SWIG_fail;
11630 swig_obj[0] = args;
11631 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11632 if (!SWIG_IsOK(res1)) {
11633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindNext" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11634 }
11635 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11636 {
11637 PyThreadState* __tstate = wxPyBeginAllowThreads();
11638 result = (arg1)->FindNext();
11639 wxPyEndAllowThreads(__tstate);
11640 if (PyErr_Occurred()) SWIG_fail;
11641 }
11642 {
11643 #if wxUSE_UNICODE
11644 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11645 #else
11646 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11647 #endif
11648 }
11649 return resultobj;
11650 fail:
11651 return NULL;
11652 }
11653
11654
11655 SWIGINTERN PyObject *MemoryFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11656 PyObject *obj;
11657 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11658 SWIG_TypeNewClientData(SWIGTYPE_p_wxMemoryFSHandler, SWIG_NewClientData(obj));
11659 return SWIG_Py_Void();
11660 }
11661
11662 SWIGINTERN PyObject *MemoryFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11663 return SWIG_Python_InitShadowInstance(args);
11664 }
11665
11666 SWIGINTERN PyObject *_wrap_ImageHandler_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11667 PyObject *resultobj = 0;
11668 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11669 wxString result;
11670 void *argp1 = 0 ;
11671 int res1 = 0 ;
11672 PyObject *swig_obj[1] ;
11673
11674 if (!args) SWIG_fail;
11675 swig_obj[0] = args;
11676 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11677 if (!SWIG_IsOK(res1)) {
11678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11679 }
11680 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11681 {
11682 PyThreadState* __tstate = wxPyBeginAllowThreads();
11683 result = (arg1)->GetName();
11684 wxPyEndAllowThreads(__tstate);
11685 if (PyErr_Occurred()) SWIG_fail;
11686 }
11687 {
11688 #if wxUSE_UNICODE
11689 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11690 #else
11691 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11692 #endif
11693 }
11694 return resultobj;
11695 fail:
11696 return NULL;
11697 }
11698
11699
11700 SWIGINTERN PyObject *_wrap_ImageHandler_GetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11701 PyObject *resultobj = 0;
11702 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11703 wxString result;
11704 void *argp1 = 0 ;
11705 int res1 = 0 ;
11706 PyObject *swig_obj[1] ;
11707
11708 if (!args) SWIG_fail;
11709 swig_obj[0] = args;
11710 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11711 if (!SWIG_IsOK(res1)) {
11712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11713 }
11714 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11715 {
11716 PyThreadState* __tstate = wxPyBeginAllowThreads();
11717 result = (arg1)->GetExtension();
11718 wxPyEndAllowThreads(__tstate);
11719 if (PyErr_Occurred()) SWIG_fail;
11720 }
11721 {
11722 #if wxUSE_UNICODE
11723 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11724 #else
11725 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11726 #endif
11727 }
11728 return resultobj;
11729 fail:
11730 return NULL;
11731 }
11732
11733
11734 SWIGINTERN PyObject *_wrap_ImageHandler_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11735 PyObject *resultobj = 0;
11736 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11737 long result;
11738 void *argp1 = 0 ;
11739 int res1 = 0 ;
11740 PyObject *swig_obj[1] ;
11741
11742 if (!args) SWIG_fail;
11743 swig_obj[0] = args;
11744 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11745 if (!SWIG_IsOK(res1)) {
11746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11747 }
11748 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11749 {
11750 PyThreadState* __tstate = wxPyBeginAllowThreads();
11751 result = (long)(arg1)->GetType();
11752 wxPyEndAllowThreads(__tstate);
11753 if (PyErr_Occurred()) SWIG_fail;
11754 }
11755 resultobj = SWIG_From_long(static_cast< long >(result));
11756 return resultobj;
11757 fail:
11758 return NULL;
11759 }
11760
11761
11762 SWIGINTERN PyObject *_wrap_ImageHandler_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11763 PyObject *resultobj = 0;
11764 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11765 wxString result;
11766 void *argp1 = 0 ;
11767 int res1 = 0 ;
11768 PyObject *swig_obj[1] ;
11769
11770 if (!args) SWIG_fail;
11771 swig_obj[0] = args;
11772 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11773 if (!SWIG_IsOK(res1)) {
11774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11775 }
11776 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11777 {
11778 PyThreadState* __tstate = wxPyBeginAllowThreads();
11779 result = (arg1)->GetMimeType();
11780 wxPyEndAllowThreads(__tstate);
11781 if (PyErr_Occurred()) SWIG_fail;
11782 }
11783 {
11784 #if wxUSE_UNICODE
11785 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11786 #else
11787 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11788 #endif
11789 }
11790 return resultobj;
11791 fail:
11792 return NULL;
11793 }
11794
11795
11796 SWIGINTERN PyObject *_wrap_ImageHandler_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11797 PyObject *resultobj = 0;
11798 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11799 wxString *arg2 = 0 ;
11800 bool result;
11801 void *argp1 = 0 ;
11802 int res1 = 0 ;
11803 bool temp2 = false ;
11804 PyObject * obj0 = 0 ;
11805 PyObject * obj1 = 0 ;
11806 char * kwnames[] = {
11807 (char *) "self",(char *) "name", NULL
11808 };
11809
11810 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) SWIG_fail;
11811 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11812 if (!SWIG_IsOK(res1)) {
11813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanRead" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11814 }
11815 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11816 {
11817 arg2 = wxString_in_helper(obj1);
11818 if (arg2 == NULL) SWIG_fail;
11819 temp2 = true;
11820 }
11821 {
11822 PyThreadState* __tstate = wxPyBeginAllowThreads();
11823 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
11824 wxPyEndAllowThreads(__tstate);
11825 if (PyErr_Occurred()) SWIG_fail;
11826 }
11827 {
11828 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11829 }
11830 {
11831 if (temp2)
11832 delete arg2;
11833 }
11834 return resultobj;
11835 fail:
11836 {
11837 if (temp2)
11838 delete arg2;
11839 }
11840 return NULL;
11841 }
11842
11843
11844 SWIGINTERN PyObject *_wrap_ImageHandler_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11845 PyObject *resultobj = 0;
11846 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11847 wxString *arg2 = 0 ;
11848 void *argp1 = 0 ;
11849 int res1 = 0 ;
11850 bool temp2 = false ;
11851 PyObject * obj0 = 0 ;
11852 PyObject * obj1 = 0 ;
11853 char * kwnames[] = {
11854 (char *) "self",(char *) "name", NULL
11855 };
11856
11857 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
11858 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11859 if (!SWIG_IsOK(res1)) {
11860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11861 }
11862 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11863 {
11864 arg2 = wxString_in_helper(obj1);
11865 if (arg2 == NULL) SWIG_fail;
11866 temp2 = true;
11867 }
11868 {
11869 PyThreadState* __tstate = wxPyBeginAllowThreads();
11870 (arg1)->SetName((wxString const &)*arg2);
11871 wxPyEndAllowThreads(__tstate);
11872 if (PyErr_Occurred()) SWIG_fail;
11873 }
11874 resultobj = SWIG_Py_Void();
11875 {
11876 if (temp2)
11877 delete arg2;
11878 }
11879 return resultobj;
11880 fail:
11881 {
11882 if (temp2)
11883 delete arg2;
11884 }
11885 return NULL;
11886 }
11887
11888
11889 SWIGINTERN PyObject *_wrap_ImageHandler_SetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11890 PyObject *resultobj = 0;
11891 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11892 wxString *arg2 = 0 ;
11893 void *argp1 = 0 ;
11894 int res1 = 0 ;
11895 bool temp2 = false ;
11896 PyObject * obj0 = 0 ;
11897 PyObject * obj1 = 0 ;
11898 char * kwnames[] = {
11899 (char *) "self",(char *) "extension", NULL
11900 };
11901
11902 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) SWIG_fail;
11903 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11904 if (!SWIG_IsOK(res1)) {
11905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11906 }
11907 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11908 {
11909 arg2 = wxString_in_helper(obj1);
11910 if (arg2 == NULL) SWIG_fail;
11911 temp2 = true;
11912 }
11913 {
11914 PyThreadState* __tstate = wxPyBeginAllowThreads();
11915 (arg1)->SetExtension((wxString const &)*arg2);
11916 wxPyEndAllowThreads(__tstate);
11917 if (PyErr_Occurred()) SWIG_fail;
11918 }
11919 resultobj = SWIG_Py_Void();
11920 {
11921 if (temp2)
11922 delete arg2;
11923 }
11924 return resultobj;
11925 fail:
11926 {
11927 if (temp2)
11928 delete arg2;
11929 }
11930 return NULL;
11931 }
11932
11933
11934 SWIGINTERN PyObject *_wrap_ImageHandler_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11935 PyObject *resultobj = 0;
11936 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11937 long arg2 ;
11938 void *argp1 = 0 ;
11939 int res1 = 0 ;
11940 long val2 ;
11941 int ecode2 = 0 ;
11942 PyObject * obj0 = 0 ;
11943 PyObject * obj1 = 0 ;
11944 char * kwnames[] = {
11945 (char *) "self",(char *) "type", NULL
11946 };
11947
11948 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
11949 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11950 if (!SWIG_IsOK(res1)) {
11951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11952 }
11953 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11954 ecode2 = SWIG_AsVal_long(obj1, &val2);
11955 if (!SWIG_IsOK(ecode2)) {
11956 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHandler_SetType" "', expected argument " "2"" of type '" "long""'");
11957 }
11958 arg2 = static_cast< long >(val2);
11959 {
11960 PyThreadState* __tstate = wxPyBeginAllowThreads();
11961 (arg1)->SetType(arg2);
11962 wxPyEndAllowThreads(__tstate);
11963 if (PyErr_Occurred()) SWIG_fail;
11964 }
11965 resultobj = SWIG_Py_Void();
11966 return resultobj;
11967 fail:
11968 return NULL;
11969 }
11970
11971
11972 SWIGINTERN PyObject *_wrap_ImageHandler_SetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11973 PyObject *resultobj = 0;
11974 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11975 wxString *arg2 = 0 ;
11976 void *argp1 = 0 ;
11977 int res1 = 0 ;
11978 bool temp2 = false ;
11979 PyObject * obj0 = 0 ;
11980 PyObject * obj1 = 0 ;
11981 char * kwnames[] = {
11982 (char *) "self",(char *) "mimetype", NULL
11983 };
11984
11985 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
11986 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11987 if (!SWIG_IsOK(res1)) {
11988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11989 }
11990 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11991 {
11992 arg2 = wxString_in_helper(obj1);
11993 if (arg2 == NULL) SWIG_fail;
11994 temp2 = true;
11995 }
11996 {
11997 PyThreadState* __tstate = wxPyBeginAllowThreads();
11998 (arg1)->SetMimeType((wxString const &)*arg2);
11999 wxPyEndAllowThreads(__tstate);
12000 if (PyErr_Occurred()) SWIG_fail;
12001 }
12002 resultobj = SWIG_Py_Void();
12003 {
12004 if (temp2)
12005 delete arg2;
12006 }
12007 return resultobj;
12008 fail:
12009 {
12010 if (temp2)
12011 delete arg2;
12012 }
12013 return NULL;
12014 }
12015
12016
12017 SWIGINTERN PyObject *ImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12018 PyObject *obj;
12019 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12020 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHandler, SWIG_NewClientData(obj));
12021 return SWIG_Py_Void();
12022 }
12023
12024 SWIGINTERN PyObject *_wrap_new_PyImageHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12025 PyObject *resultobj = 0;
12026 wxPyImageHandler *result = 0 ;
12027
12028 if (!SWIG_Python_UnpackTuple(args,"new_PyImageHandler",0,0,0)) SWIG_fail;
12029 {
12030 PyThreadState* __tstate = wxPyBeginAllowThreads();
12031 result = (wxPyImageHandler *)new wxPyImageHandler();
12032 wxPyEndAllowThreads(__tstate);
12033 if (PyErr_Occurred()) SWIG_fail;
12034 }
12035 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyImageHandler, SWIG_POINTER_NEW | 0 );
12036 return resultobj;
12037 fail:
12038 return NULL;
12039 }
12040
12041
12042 SWIGINTERN PyObject *_wrap_PyImageHandler__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12043 PyObject *resultobj = 0;
12044 wxPyImageHandler *arg1 = (wxPyImageHandler *) 0 ;
12045 PyObject *arg2 = (PyObject *) 0 ;
12046 void *argp1 = 0 ;
12047 int res1 = 0 ;
12048 PyObject * obj0 = 0 ;
12049 PyObject * obj1 = 0 ;
12050 char * kwnames[] = {
12051 (char *) "self",(char *) "self", NULL
12052 };
12053
12054 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyImageHandler__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
12055 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyImageHandler, 0 | 0 );
12056 if (!SWIG_IsOK(res1)) {
12057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyImageHandler__SetSelf" "', expected argument " "1"" of type '" "wxPyImageHandler *""'");
12058 }
12059 arg1 = reinterpret_cast< wxPyImageHandler * >(argp1);
12060 arg2 = obj1;
12061 {
12062 PyThreadState* __tstate = wxPyBeginAllowThreads();
12063 (arg1)->_SetSelf(arg2);
12064 wxPyEndAllowThreads(__tstate);
12065 if (PyErr_Occurred()) SWIG_fail;
12066 }
12067 resultobj = SWIG_Py_Void();
12068 return resultobj;
12069 fail:
12070 return NULL;
12071 }
12072
12073
12074 SWIGINTERN PyObject *PyImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12075 PyObject *obj;
12076 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12077 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyImageHandler, SWIG_NewClientData(obj));
12078 return SWIG_Py_Void();
12079 }
12080
12081 SWIGINTERN PyObject *PyImageHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12082 return SWIG_Python_InitShadowInstance(args);
12083 }
12084
12085 SWIGINTERN PyObject *_wrap_new_ImageHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12086 PyObject *resultobj = 0;
12087 wxImageHistogram *result = 0 ;
12088
12089 if (!SWIG_Python_UnpackTuple(args,"new_ImageHistogram",0,0,0)) SWIG_fail;
12090 {
12091 PyThreadState* __tstate = wxPyBeginAllowThreads();
12092 result = (wxImageHistogram *)new wxImageHistogram();
12093 wxPyEndAllowThreads(__tstate);
12094 if (PyErr_Occurred()) SWIG_fail;
12095 }
12096 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_NEW | 0 );
12097 return resultobj;
12098 fail:
12099 return NULL;
12100 }
12101
12102
12103 SWIGINTERN PyObject *_wrap_ImageHistogram_MakeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12104 PyObject *resultobj = 0;
12105 byte arg1 ;
12106 byte arg2 ;
12107 byte arg3 ;
12108 unsigned long result;
12109 unsigned char val1 ;
12110 int ecode1 = 0 ;
12111 unsigned char val2 ;
12112 int ecode2 = 0 ;
12113 unsigned char val3 ;
12114 int ecode3 = 0 ;
12115 PyObject * obj0 = 0 ;
12116 PyObject * obj1 = 0 ;
12117 PyObject * obj2 = 0 ;
12118 char * kwnames[] = {
12119 (char *) "r",(char *) "g",(char *) "b", NULL
12120 };
12121
12122 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12123 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12124 if (!SWIG_IsOK(ecode1)) {
12125 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ImageHistogram_MakeKey" "', expected argument " "1"" of type '" "byte""'");
12126 }
12127 arg1 = static_cast< byte >(val1);
12128 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12129 if (!SWIG_IsOK(ecode2)) {
12130 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_MakeKey" "', expected argument " "2"" of type '" "byte""'");
12131 }
12132 arg2 = static_cast< byte >(val2);
12133 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12134 if (!SWIG_IsOK(ecode3)) {
12135 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_MakeKey" "', expected argument " "3"" of type '" "byte""'");
12136 }
12137 arg3 = static_cast< byte >(val3);
12138 {
12139 PyThreadState* __tstate = wxPyBeginAllowThreads();
12140 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
12141 wxPyEndAllowThreads(__tstate);
12142 if (PyErr_Occurred()) SWIG_fail;
12143 }
12144 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12145 return resultobj;
12146 fail:
12147 return NULL;
12148 }
12149
12150
12151 SWIGINTERN PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12152 PyObject *resultobj = 0;
12153 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12154 byte *arg2 = (byte *) 0 ;
12155 byte *arg3 = (byte *) 0 ;
12156 byte *arg4 = (byte *) 0 ;
12157 byte arg5 = (byte) 1 ;
12158 byte arg6 = (byte) 0 ;
12159 byte arg7 = (byte) 0 ;
12160 bool result;
12161 void *argp1 = 0 ;
12162 int res1 = 0 ;
12163 byte temp2 ;
12164 int res2 = SWIG_TMPOBJ ;
12165 byte temp3 ;
12166 int res3 = SWIG_TMPOBJ ;
12167 byte temp4 ;
12168 int res4 = SWIG_TMPOBJ ;
12169 unsigned char val5 ;
12170 int ecode5 = 0 ;
12171 unsigned char val6 ;
12172 int ecode6 = 0 ;
12173 unsigned char val7 ;
12174 int ecode7 = 0 ;
12175 PyObject * obj0 = 0 ;
12176 PyObject * obj1 = 0 ;
12177 PyObject * obj2 = 0 ;
12178 PyObject * obj3 = 0 ;
12179 char * kwnames[] = {
12180 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
12181 };
12182
12183 arg2 = &temp2;
12184 arg3 = &temp3;
12185 arg4 = &temp4;
12186 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12187 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12188 if (!SWIG_IsOK(res1)) {
12189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImageHistogram const *""'");
12190 }
12191 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12192 if (obj1) {
12193 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
12194 if (!SWIG_IsOK(ecode5)) {
12195 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
12196 }
12197 arg5 = static_cast< byte >(val5);
12198 }
12199 if (obj2) {
12200 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
12201 if (!SWIG_IsOK(ecode6)) {
12202 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
12203 }
12204 arg6 = static_cast< byte >(val6);
12205 }
12206 if (obj3) {
12207 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
12208 if (!SWIG_IsOK(ecode7)) {
12209 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
12210 }
12211 arg7 = static_cast< byte >(val7);
12212 }
12213 {
12214 PyThreadState* __tstate = wxPyBeginAllowThreads();
12215 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
12216 wxPyEndAllowThreads(__tstate);
12217 if (PyErr_Occurred()) SWIG_fail;
12218 }
12219 {
12220 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12221 }
12222 if (SWIG_IsTmpObj(res2)) {
12223 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
12224 } else {
12225 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12226 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
12227 }
12228 if (SWIG_IsTmpObj(res3)) {
12229 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
12230 } else {
12231 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12232 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
12233 }
12234 if (SWIG_IsTmpObj(res4)) {
12235 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
12236 } else {
12237 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12238 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
12239 }
12240 return resultobj;
12241 fail:
12242 return NULL;
12243 }
12244
12245
12246 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12247 PyObject *resultobj = 0;
12248 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12249 unsigned long arg2 ;
12250 unsigned long result;
12251 void *argp1 = 0 ;
12252 int res1 = 0 ;
12253 unsigned long val2 ;
12254 int ecode2 = 0 ;
12255 PyObject * obj0 = 0 ;
12256 PyObject * obj1 = 0 ;
12257 char * kwnames[] = {
12258 (char *) "self",(char *) "key", NULL
12259 };
12260
12261 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) SWIG_fail;
12262 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12263 if (!SWIG_IsOK(res1)) {
12264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCount" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12265 }
12266 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12267 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
12268 if (!SWIG_IsOK(ecode2)) {
12269 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCount" "', expected argument " "2"" of type '" "unsigned long""'");
12270 }
12271 arg2 = static_cast< unsigned long >(val2);
12272 {
12273 PyThreadState* __tstate = wxPyBeginAllowThreads();
12274 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
12275 wxPyEndAllowThreads(__tstate);
12276 if (PyErr_Occurred()) SWIG_fail;
12277 }
12278 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12279 return resultobj;
12280 fail:
12281 return NULL;
12282 }
12283
12284
12285 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12286 PyObject *resultobj = 0;
12287 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12288 byte arg2 ;
12289 byte arg3 ;
12290 byte arg4 ;
12291 unsigned long result;
12292 void *argp1 = 0 ;
12293 int res1 = 0 ;
12294 unsigned char val2 ;
12295 int ecode2 = 0 ;
12296 unsigned char val3 ;
12297 int ecode3 = 0 ;
12298 unsigned char val4 ;
12299 int ecode4 = 0 ;
12300 PyObject * obj0 = 0 ;
12301 PyObject * obj1 = 0 ;
12302 PyObject * obj2 = 0 ;
12303 PyObject * obj3 = 0 ;
12304 char * kwnames[] = {
12305 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12306 };
12307
12308 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12309 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12310 if (!SWIG_IsOK(res1)) {
12311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12312 }
12313 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12314 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12315 if (!SWIG_IsOK(ecode2)) {
12316 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "2"" of type '" "byte""'");
12317 }
12318 arg2 = static_cast< byte >(val2);
12319 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12320 if (!SWIG_IsOK(ecode3)) {
12321 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "3"" of type '" "byte""'");
12322 }
12323 arg3 = static_cast< byte >(val3);
12324 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
12325 if (!SWIG_IsOK(ecode4)) {
12326 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "4"" of type '" "byte""'");
12327 }
12328 arg4 = static_cast< byte >(val4);
12329 {
12330 PyThreadState* __tstate = wxPyBeginAllowThreads();
12331 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
12332 wxPyEndAllowThreads(__tstate);
12333 if (PyErr_Occurred()) SWIG_fail;
12334 }
12335 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12336 return resultobj;
12337 fail:
12338 return NULL;
12339 }
12340
12341
12342 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12343 PyObject *resultobj = 0;
12344 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12345 wxColour *arg2 = 0 ;
12346 unsigned long result;
12347 void *argp1 = 0 ;
12348 int res1 = 0 ;
12349 wxColour temp2 ;
12350 PyObject * obj0 = 0 ;
12351 PyObject * obj1 = 0 ;
12352 char * kwnames[] = {
12353 (char *) "self",(char *) "colour", NULL
12354 };
12355
12356 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) SWIG_fail;
12357 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12358 if (!SWIG_IsOK(res1)) {
12359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountColour" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12360 }
12361 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12362 {
12363 arg2 = &temp2;
12364 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
12365 }
12366 {
12367 PyThreadState* __tstate = wxPyBeginAllowThreads();
12368 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
12369 wxPyEndAllowThreads(__tstate);
12370 if (PyErr_Occurred()) SWIG_fail;
12371 }
12372 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12373 return resultobj;
12374 fail:
12375 return NULL;
12376 }
12377
12378
12379 SWIGINTERN PyObject *ImageHistogram_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12380 PyObject *obj;
12381 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12382 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHistogram, SWIG_NewClientData(obj));
12383 return SWIG_Py_Void();
12384 }
12385
12386 SWIGINTERN PyObject *ImageHistogram_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12387 return SWIG_Python_InitShadowInstance(args);
12388 }
12389
12390 SWIGINTERN PyObject *_wrap_new_Image_RGBValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12391 PyObject *resultobj = 0;
12392 byte arg1 = (byte) 0 ;
12393 byte arg2 = (byte) 0 ;
12394 byte arg3 = (byte) 0 ;
12395 wxImage_RGBValue *result = 0 ;
12396 unsigned char val1 ;
12397 int ecode1 = 0 ;
12398 unsigned char val2 ;
12399 int ecode2 = 0 ;
12400 unsigned char val3 ;
12401 int ecode3 = 0 ;
12402 PyObject * obj0 = 0 ;
12403 PyObject * obj1 = 0 ;
12404 PyObject * obj2 = 0 ;
12405 char * kwnames[] = {
12406 (char *) "r",(char *) "g",(char *) "b", NULL
12407 };
12408
12409 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_RGBValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12410 if (obj0) {
12411 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12412 if (!SWIG_IsOK(ecode1)) {
12413 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_RGBValue" "', expected argument " "1"" of type '" "byte""'");
12414 }
12415 arg1 = static_cast< byte >(val1);
12416 }
12417 if (obj1) {
12418 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12419 if (!SWIG_IsOK(ecode2)) {
12420 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_RGBValue" "', expected argument " "2"" of type '" "byte""'");
12421 }
12422 arg2 = static_cast< byte >(val2);
12423 }
12424 if (obj2) {
12425 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12426 if (!SWIG_IsOK(ecode3)) {
12427 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_RGBValue" "', expected argument " "3"" of type '" "byte""'");
12428 }
12429 arg3 = static_cast< byte >(val3);
12430 }
12431 {
12432 PyThreadState* __tstate = wxPyBeginAllowThreads();
12433 result = (wxImage_RGBValue *)new wxImage_RGBValue(arg1,arg2,arg3);
12434 wxPyEndAllowThreads(__tstate);
12435 if (PyErr_Occurred()) SWIG_fail;
12436 }
12437 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_NEW | 0 );
12438 return resultobj;
12439 fail:
12440 return NULL;
12441 }
12442
12443
12444 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12445 PyObject *resultobj = 0;
12446 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12447 byte arg2 ;
12448 void *argp1 = 0 ;
12449 int res1 = 0 ;
12450 unsigned char val2 ;
12451 int ecode2 = 0 ;
12452 PyObject *swig_obj[2] ;
12453
12454 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_red_set",2,2,swig_obj)) SWIG_fail;
12455 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12456 if (!SWIG_IsOK(res1)) {
12457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12458 }
12459 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12460 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12461 if (!SWIG_IsOK(ecode2)) {
12462 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_red_set" "', expected argument " "2"" of type '" "byte""'");
12463 }
12464 arg2 = static_cast< byte >(val2);
12465 if (arg1) (arg1)->red = arg2;
12466
12467 resultobj = SWIG_Py_Void();
12468 return resultobj;
12469 fail:
12470 return NULL;
12471 }
12472
12473
12474 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12475 PyObject *resultobj = 0;
12476 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12477 byte result;
12478 void *argp1 = 0 ;
12479 int res1 = 0 ;
12480 PyObject *swig_obj[1] ;
12481
12482 if (!args) SWIG_fail;
12483 swig_obj[0] = args;
12484 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12485 if (!SWIG_IsOK(res1)) {
12486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12487 }
12488 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12489 result = (byte) ((arg1)->red);
12490 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12491 return resultobj;
12492 fail:
12493 return NULL;
12494 }
12495
12496
12497 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12498 PyObject *resultobj = 0;
12499 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12500 byte arg2 ;
12501 void *argp1 = 0 ;
12502 int res1 = 0 ;
12503 unsigned char val2 ;
12504 int ecode2 = 0 ;
12505 PyObject *swig_obj[2] ;
12506
12507 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_green_set",2,2,swig_obj)) SWIG_fail;
12508 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12509 if (!SWIG_IsOK(res1)) {
12510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12511 }
12512 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12513 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12514 if (!SWIG_IsOK(ecode2)) {
12515 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_green_set" "', expected argument " "2"" of type '" "byte""'");
12516 }
12517 arg2 = static_cast< byte >(val2);
12518 if (arg1) (arg1)->green = arg2;
12519
12520 resultobj = SWIG_Py_Void();
12521 return resultobj;
12522 fail:
12523 return NULL;
12524 }
12525
12526
12527 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12528 PyObject *resultobj = 0;
12529 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12530 byte result;
12531 void *argp1 = 0 ;
12532 int res1 = 0 ;
12533 PyObject *swig_obj[1] ;
12534
12535 if (!args) SWIG_fail;
12536 swig_obj[0] = args;
12537 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12538 if (!SWIG_IsOK(res1)) {
12539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12540 }
12541 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12542 result = (byte) ((arg1)->green);
12543 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12544 return resultobj;
12545 fail:
12546 return NULL;
12547 }
12548
12549
12550 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12551 PyObject *resultobj = 0;
12552 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12553 byte arg2 ;
12554 void *argp1 = 0 ;
12555 int res1 = 0 ;
12556 unsigned char val2 ;
12557 int ecode2 = 0 ;
12558 PyObject *swig_obj[2] ;
12559
12560 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_blue_set",2,2,swig_obj)) SWIG_fail;
12561 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12562 if (!SWIG_IsOK(res1)) {
12563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12564 }
12565 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12566 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12567 if (!SWIG_IsOK(ecode2)) {
12568 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_blue_set" "', expected argument " "2"" of type '" "byte""'");
12569 }
12570 arg2 = static_cast< byte >(val2);
12571 if (arg1) (arg1)->blue = arg2;
12572
12573 resultobj = SWIG_Py_Void();
12574 return resultobj;
12575 fail:
12576 return NULL;
12577 }
12578
12579
12580 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12581 PyObject *resultobj = 0;
12582 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12583 byte result;
12584 void *argp1 = 0 ;
12585 int res1 = 0 ;
12586 PyObject *swig_obj[1] ;
12587
12588 if (!args) SWIG_fail;
12589 swig_obj[0] = args;
12590 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12591 if (!SWIG_IsOK(res1)) {
12592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12593 }
12594 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12595 result = (byte) ((arg1)->blue);
12596 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12597 return resultobj;
12598 fail:
12599 return NULL;
12600 }
12601
12602
12603 SWIGINTERN PyObject *Image_RGBValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12604 PyObject *obj;
12605 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12606 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_RGBValue, SWIG_NewClientData(obj));
12607 return SWIG_Py_Void();
12608 }
12609
12610 SWIGINTERN PyObject *Image_RGBValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12611 return SWIG_Python_InitShadowInstance(args);
12612 }
12613
12614 SWIGINTERN PyObject *_wrap_new_Image_HSVValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12615 PyObject *resultobj = 0;
12616 double arg1 = (double) 0.0 ;
12617 double arg2 = (double) 0.0 ;
12618 double arg3 = (double) 0.0 ;
12619 wxImage_HSVValue *result = 0 ;
12620 double val1 ;
12621 int ecode1 = 0 ;
12622 double val2 ;
12623 int ecode2 = 0 ;
12624 double val3 ;
12625 int ecode3 = 0 ;
12626 PyObject * obj0 = 0 ;
12627 PyObject * obj1 = 0 ;
12628 PyObject * obj2 = 0 ;
12629 char * kwnames[] = {
12630 (char *) "h",(char *) "s",(char *) "v", NULL
12631 };
12632
12633 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_HSVValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12634 if (obj0) {
12635 ecode1 = SWIG_AsVal_double(obj0, &val1);
12636 if (!SWIG_IsOK(ecode1)) {
12637 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_HSVValue" "', expected argument " "1"" of type '" "double""'");
12638 }
12639 arg1 = static_cast< double >(val1);
12640 }
12641 if (obj1) {
12642 ecode2 = SWIG_AsVal_double(obj1, &val2);
12643 if (!SWIG_IsOK(ecode2)) {
12644 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_HSVValue" "', expected argument " "2"" of type '" "double""'");
12645 }
12646 arg2 = static_cast< double >(val2);
12647 }
12648 if (obj2) {
12649 ecode3 = SWIG_AsVal_double(obj2, &val3);
12650 if (!SWIG_IsOK(ecode3)) {
12651 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_HSVValue" "', expected argument " "3"" of type '" "double""'");
12652 }
12653 arg3 = static_cast< double >(val3);
12654 }
12655 {
12656 PyThreadState* __tstate = wxPyBeginAllowThreads();
12657 result = (wxImage_HSVValue *)new wxImage_HSVValue(arg1,arg2,arg3);
12658 wxPyEndAllowThreads(__tstate);
12659 if (PyErr_Occurred()) SWIG_fail;
12660 }
12661 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_NEW | 0 );
12662 return resultobj;
12663 fail:
12664 return NULL;
12665 }
12666
12667
12668 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12669 PyObject *resultobj = 0;
12670 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12671 double arg2 ;
12672 void *argp1 = 0 ;
12673 int res1 = 0 ;
12674 double val2 ;
12675 int ecode2 = 0 ;
12676 PyObject *swig_obj[2] ;
12677
12678 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_hue_set",2,2,swig_obj)) SWIG_fail;
12679 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12680 if (!SWIG_IsOK(res1)) {
12681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12682 }
12683 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12684 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12685 if (!SWIG_IsOK(ecode2)) {
12686 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_hue_set" "', expected argument " "2"" of type '" "double""'");
12687 }
12688 arg2 = static_cast< double >(val2);
12689 if (arg1) (arg1)->hue = arg2;
12690
12691 resultobj = SWIG_Py_Void();
12692 return resultobj;
12693 fail:
12694 return NULL;
12695 }
12696
12697
12698 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12699 PyObject *resultobj = 0;
12700 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12701 double result;
12702 void *argp1 = 0 ;
12703 int res1 = 0 ;
12704 PyObject *swig_obj[1] ;
12705
12706 if (!args) SWIG_fail;
12707 swig_obj[0] = args;
12708 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12709 if (!SWIG_IsOK(res1)) {
12710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12711 }
12712 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12713 result = (double) ((arg1)->hue);
12714 resultobj = SWIG_From_double(static_cast< double >(result));
12715 return resultobj;
12716 fail:
12717 return NULL;
12718 }
12719
12720
12721 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12722 PyObject *resultobj = 0;
12723 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12724 double arg2 ;
12725 void *argp1 = 0 ;
12726 int res1 = 0 ;
12727 double val2 ;
12728 int ecode2 = 0 ;
12729 PyObject *swig_obj[2] ;
12730
12731 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_saturation_set",2,2,swig_obj)) SWIG_fail;
12732 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12733 if (!SWIG_IsOK(res1)) {
12734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12735 }
12736 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12737 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12738 if (!SWIG_IsOK(ecode2)) {
12739 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "2"" of type '" "double""'");
12740 }
12741 arg2 = static_cast< double >(val2);
12742 if (arg1) (arg1)->saturation = arg2;
12743
12744 resultobj = SWIG_Py_Void();
12745 return resultobj;
12746 fail:
12747 return NULL;
12748 }
12749
12750
12751 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12752 PyObject *resultobj = 0;
12753 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12754 double result;
12755 void *argp1 = 0 ;
12756 int res1 = 0 ;
12757 PyObject *swig_obj[1] ;
12758
12759 if (!args) SWIG_fail;
12760 swig_obj[0] = args;
12761 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12762 if (!SWIG_IsOK(res1)) {
12763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12764 }
12765 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12766 result = (double) ((arg1)->saturation);
12767 resultobj = SWIG_From_double(static_cast< double >(result));
12768 return resultobj;
12769 fail:
12770 return NULL;
12771 }
12772
12773
12774 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12775 PyObject *resultobj = 0;
12776 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12777 double arg2 ;
12778 void *argp1 = 0 ;
12779 int res1 = 0 ;
12780 double val2 ;
12781 int ecode2 = 0 ;
12782 PyObject *swig_obj[2] ;
12783
12784 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_value_set",2,2,swig_obj)) SWIG_fail;
12785 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12786 if (!SWIG_IsOK(res1)) {
12787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12788 }
12789 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12790 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12791 if (!SWIG_IsOK(ecode2)) {
12792 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_value_set" "', expected argument " "2"" of type '" "double""'");
12793 }
12794 arg2 = static_cast< double >(val2);
12795 if (arg1) (arg1)->value = arg2;
12796
12797 resultobj = SWIG_Py_Void();
12798 return resultobj;
12799 fail:
12800 return NULL;
12801 }
12802
12803
12804 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12805 PyObject *resultobj = 0;
12806 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12807 double result;
12808 void *argp1 = 0 ;
12809 int res1 = 0 ;
12810 PyObject *swig_obj[1] ;
12811
12812 if (!args) SWIG_fail;
12813 swig_obj[0] = args;
12814 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12815 if (!SWIG_IsOK(res1)) {
12816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12817 }
12818 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12819 result = (double) ((arg1)->value);
12820 resultobj = SWIG_From_double(static_cast< double >(result));
12821 return resultobj;
12822 fail:
12823 return NULL;
12824 }
12825
12826
12827 SWIGINTERN PyObject *Image_HSVValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12828 PyObject *obj;
12829 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12830 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_HSVValue, SWIG_NewClientData(obj));
12831 return SWIG_Py_Void();
12832 }
12833
12834 SWIGINTERN PyObject *Image_HSVValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12835 return SWIG_Python_InitShadowInstance(args);
12836 }
12837
12838 SWIGINTERN PyObject *_wrap_new_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12839 PyObject *resultobj = 0;
12840 wxString *arg1 = 0 ;
12841 long arg2 = (long) wxBITMAP_TYPE_ANY ;
12842 int arg3 = (int) -1 ;
12843 wxImage *result = 0 ;
12844 bool temp1 = false ;
12845 long val2 ;
12846 int ecode2 = 0 ;
12847 int val3 ;
12848 int ecode3 = 0 ;
12849 PyObject * obj0 = 0 ;
12850 PyObject * obj1 = 0 ;
12851 PyObject * obj2 = 0 ;
12852 char * kwnames[] = {
12853 (char *) "name",(char *) "type",(char *) "index", NULL
12854 };
12855
12856 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12857 {
12858 arg1 = wxString_in_helper(obj0);
12859 if (arg1 == NULL) SWIG_fail;
12860 temp1 = true;
12861 }
12862 if (obj1) {
12863 ecode2 = SWIG_AsVal_long(obj1, &val2);
12864 if (!SWIG_IsOK(ecode2)) {
12865 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image" "', expected argument " "2"" of type '" "long""'");
12866 }
12867 arg2 = static_cast< long >(val2);
12868 }
12869 if (obj2) {
12870 ecode3 = SWIG_AsVal_int(obj2, &val3);
12871 if (!SWIG_IsOK(ecode3)) {
12872 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image" "', expected argument " "3"" of type '" "int""'");
12873 }
12874 arg3 = static_cast< int >(val3);
12875 }
12876 {
12877 PyThreadState* __tstate = wxPyBeginAllowThreads();
12878 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
12879 wxPyEndAllowThreads(__tstate);
12880 if (PyErr_Occurred()) SWIG_fail;
12881 }
12882 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_NEW | 0 );
12883 {
12884 if (temp1)
12885 delete arg1;
12886 }
12887 return resultobj;
12888 fail:
12889 {
12890 if (temp1)
12891 delete arg1;
12892 }
12893 return NULL;
12894 }
12895
12896
12897 SWIGINTERN PyObject *_wrap_delete_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12898 PyObject *resultobj = 0;
12899 wxImage *arg1 = (wxImage *) 0 ;
12900 void *argp1 = 0 ;
12901 int res1 = 0 ;
12902 PyObject *swig_obj[1] ;
12903
12904 if (!args) SWIG_fail;
12905 swig_obj[0] = args;
12906 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, SWIG_POINTER_DISOWN | 0 );
12907 if (!SWIG_IsOK(res1)) {
12908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Image" "', expected argument " "1"" of type '" "wxImage *""'");
12909 }
12910 arg1 = reinterpret_cast< wxImage * >(argp1);
12911 {
12912 PyThreadState* __tstate = wxPyBeginAllowThreads();
12913 delete arg1;
12914
12915 wxPyEndAllowThreads(__tstate);
12916 if (PyErr_Occurred()) SWIG_fail;
12917 }
12918 resultobj = SWIG_Py_Void();
12919 return resultobj;
12920 fail:
12921 return NULL;
12922 }
12923
12924
12925 SWIGINTERN PyObject *_wrap_new_ImageFromMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12926 PyObject *resultobj = 0;
12927 wxString *arg1 = 0 ;
12928 wxString *arg2 = 0 ;
12929 int arg3 = (int) -1 ;
12930 wxImage *result = 0 ;
12931 bool temp1 = false ;
12932 bool temp2 = false ;
12933 int val3 ;
12934 int ecode3 = 0 ;
12935 PyObject * obj0 = 0 ;
12936 PyObject * obj1 = 0 ;
12937 PyObject * obj2 = 0 ;
12938 char * kwnames[] = {
12939 (char *) "name",(char *) "mimetype",(char *) "index", NULL
12940 };
12941
12942 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12943 {
12944 arg1 = wxString_in_helper(obj0);
12945 if (arg1 == NULL) SWIG_fail;
12946 temp1 = true;
12947 }
12948 {
12949 arg2 = wxString_in_helper(obj1);
12950 if (arg2 == NULL) SWIG_fail;
12951 temp2 = true;
12952 }
12953 if (obj2) {
12954 ecode3 = SWIG_AsVal_int(obj2, &val3);
12955 if (!SWIG_IsOK(ecode3)) {
12956 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromMime" "', expected argument " "3"" of type '" "int""'");
12957 }
12958 arg3 = static_cast< int >(val3);
12959 }
12960 {
12961 PyThreadState* __tstate = wxPyBeginAllowThreads();
12962 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
12963 wxPyEndAllowThreads(__tstate);
12964 if (PyErr_Occurred()) SWIG_fail;
12965 }
12966 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
12967 {
12968 if (temp1)
12969 delete arg1;
12970 }
12971 {
12972 if (temp2)
12973 delete arg2;
12974 }
12975 return resultobj;
12976 fail:
12977 {
12978 if (temp1)
12979 delete arg1;
12980 }
12981 {
12982 if (temp2)
12983 delete arg2;
12984 }
12985 return NULL;
12986 }
12987
12988
12989 SWIGINTERN PyObject *_wrap_new_ImageFromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12990 PyObject *resultobj = 0;
12991 wxInputStream *arg1 = 0 ;
12992 long arg2 = (long) wxBITMAP_TYPE_ANY ;
12993 int arg3 = (int) -1 ;
12994 wxImage *result = 0 ;
12995 wxPyInputStream *temp1 ;
12996 bool created1 ;
12997 long val2 ;
12998 int ecode2 = 0 ;
12999 int val3 ;
13000 int ecode3 = 0 ;
13001 PyObject * obj0 = 0 ;
13002 PyObject * obj1 = 0 ;
13003 PyObject * obj2 = 0 ;
13004 char * kwnames[] = {
13005 (char *) "stream",(char *) "type",(char *) "index", NULL
13006 };
13007
13008 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13009 {
13010 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13011 arg1 = temp1->m_wxis;
13012 created1 = false;
13013 } else {
13014 PyErr_Clear(); // clear the failure of the wxPyConvert above
13015 arg1 = wxPyCBInputStream_create(obj0, false);
13016 if (arg1 == NULL) {
13017 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13018 SWIG_fail;
13019 }
13020 created1 = true;
13021 }
13022 }
13023 if (obj1) {
13024 ecode2 = SWIG_AsVal_long(obj1, &val2);
13025 if (!SWIG_IsOK(ecode2)) {
13026 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromStream" "', expected argument " "2"" of type '" "long""'");
13027 }
13028 arg2 = static_cast< long >(val2);
13029 }
13030 if (obj2) {
13031 ecode3 = SWIG_AsVal_int(obj2, &val3);
13032 if (!SWIG_IsOK(ecode3)) {
13033 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStream" "', expected argument " "3"" of type '" "int""'");
13034 }
13035 arg3 = static_cast< int >(val3);
13036 }
13037 {
13038 PyThreadState* __tstate = wxPyBeginAllowThreads();
13039 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
13040 wxPyEndAllowThreads(__tstate);
13041 if (PyErr_Occurred()) SWIG_fail;
13042 }
13043 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13044 {
13045 if (created1) delete arg1;
13046 }
13047 return resultobj;
13048 fail:
13049 {
13050 if (created1) delete arg1;
13051 }
13052 return NULL;
13053 }
13054
13055
13056 SWIGINTERN PyObject *_wrap_new_ImageFromStreamMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13057 PyObject *resultobj = 0;
13058 wxInputStream *arg1 = 0 ;
13059 wxString *arg2 = 0 ;
13060 int arg3 = (int) -1 ;
13061 wxImage *result = 0 ;
13062 wxPyInputStream *temp1 ;
13063 bool created1 ;
13064 bool temp2 = false ;
13065 int val3 ;
13066 int ecode3 = 0 ;
13067 PyObject * obj0 = 0 ;
13068 PyObject * obj1 = 0 ;
13069 PyObject * obj2 = 0 ;
13070 char * kwnames[] = {
13071 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
13072 };
13073
13074 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13075 {
13076 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13077 arg1 = temp1->m_wxis;
13078 created1 = false;
13079 } else {
13080 PyErr_Clear(); // clear the failure of the wxPyConvert above
13081 arg1 = wxPyCBInputStream_create(obj0, false);
13082 if (arg1 == NULL) {
13083 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13084 SWIG_fail;
13085 }
13086 created1 = true;
13087 }
13088 }
13089 {
13090 arg2 = wxString_in_helper(obj1);
13091 if (arg2 == NULL) SWIG_fail;
13092 temp2 = true;
13093 }
13094 if (obj2) {
13095 ecode3 = SWIG_AsVal_int(obj2, &val3);
13096 if (!SWIG_IsOK(ecode3)) {
13097 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStreamMime" "', expected argument " "3"" of type '" "int""'");
13098 }
13099 arg3 = static_cast< int >(val3);
13100 }
13101 {
13102 PyThreadState* __tstate = wxPyBeginAllowThreads();
13103 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
13104 wxPyEndAllowThreads(__tstate);
13105 if (PyErr_Occurred()) SWIG_fail;
13106 }
13107 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13108 {
13109 if (created1) delete arg1;
13110 }
13111 {
13112 if (temp2)
13113 delete arg2;
13114 }
13115 return resultobj;
13116 fail:
13117 {
13118 if (created1) delete arg1;
13119 }
13120 {
13121 if (temp2)
13122 delete arg2;
13123 }
13124 return NULL;
13125 }
13126
13127
13128 SWIGINTERN PyObject *_wrap_new_EmptyImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13129 PyObject *resultobj = 0;
13130 int arg1 = (int) 0 ;
13131 int arg2 = (int) 0 ;
13132 bool arg3 = (bool) true ;
13133 wxImage *result = 0 ;
13134 int val1 ;
13135 int ecode1 = 0 ;
13136 int val2 ;
13137 int ecode2 = 0 ;
13138 bool val3 ;
13139 int ecode3 = 0 ;
13140 PyObject * obj0 = 0 ;
13141 PyObject * obj1 = 0 ;
13142 PyObject * obj2 = 0 ;
13143 char * kwnames[] = {
13144 (char *) "width",(char *) "height",(char *) "clear", NULL
13145 };
13146
13147 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13148 if (obj0) {
13149 ecode1 = SWIG_AsVal_int(obj0, &val1);
13150 if (!SWIG_IsOK(ecode1)) {
13151 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EmptyImage" "', expected argument " "1"" of type '" "int""'");
13152 }
13153 arg1 = static_cast< int >(val1);
13154 }
13155 if (obj1) {
13156 ecode2 = SWIG_AsVal_int(obj1, &val2);
13157 if (!SWIG_IsOK(ecode2)) {
13158 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EmptyImage" "', expected argument " "2"" of type '" "int""'");
13159 }
13160 arg2 = static_cast< int >(val2);
13161 }
13162 if (obj2) {
13163 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13164 if (!SWIG_IsOK(ecode3)) {
13165 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EmptyImage" "', expected argument " "3"" of type '" "bool""'");
13166 }
13167 arg3 = static_cast< bool >(val3);
13168 }
13169 {
13170 PyThreadState* __tstate = wxPyBeginAllowThreads();
13171 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
13172 wxPyEndAllowThreads(__tstate);
13173 if (PyErr_Occurred()) SWIG_fail;
13174 }
13175 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13176 return resultobj;
13177 fail:
13178 return NULL;
13179 }
13180
13181
13182 SWIGINTERN PyObject *_wrap_new_ImageFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13183 PyObject *resultobj = 0;
13184 wxBitmap *arg1 = 0 ;
13185 wxImage *result = 0 ;
13186 void *argp1 = 0 ;
13187 int res1 = 0 ;
13188 PyObject * obj0 = 0 ;
13189 char * kwnames[] = {
13190 (char *) "bitmap", NULL
13191 };
13192
13193 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) SWIG_fail;
13194 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
13195 if (!SWIG_IsOK(res1)) {
13196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13197 }
13198 if (!argp1) {
13199 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13200 }
13201 arg1 = reinterpret_cast< wxBitmap * >(argp1);
13202 {
13203 if (!wxPyCheckForApp()) SWIG_fail;
13204 PyThreadState* __tstate = wxPyBeginAllowThreads();
13205 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
13206 wxPyEndAllowThreads(__tstate);
13207 if (PyErr_Occurred()) SWIG_fail;
13208 }
13209 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13210 return resultobj;
13211 fail:
13212 return NULL;
13213 }
13214
13215
13216 SWIGINTERN PyObject *_wrap_new_ImageFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13217 PyObject *resultobj = 0;
13218 int arg1 ;
13219 int arg2 ;
13220 buffer arg3 ;
13221 int arg4 ;
13222 wxImage *result = 0 ;
13223 int val1 ;
13224 int ecode1 = 0 ;
13225 int val2 ;
13226 int ecode2 = 0 ;
13227 PyObject * obj0 = 0 ;
13228 PyObject * obj1 = 0 ;
13229 PyObject * obj2 = 0 ;
13230 char * kwnames[] = {
13231 (char *) "width",(char *) "height",(char *) "data", NULL
13232 };
13233
13234 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13235 ecode1 = SWIG_AsVal_int(obj0, &val1);
13236 if (!SWIG_IsOK(ecode1)) {
13237 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromData" "', expected argument " "1"" of type '" "int""'");
13238 }
13239 arg1 = static_cast< int >(val1);
13240 ecode2 = SWIG_AsVal_int(obj1, &val2);
13241 if (!SWIG_IsOK(ecode2)) {
13242 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromData" "', expected argument " "2"" of type '" "int""'");
13243 }
13244 arg2 = static_cast< int >(val2);
13245 {
13246 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
13247 }
13248 {
13249 PyThreadState* __tstate = wxPyBeginAllowThreads();
13250 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
13251 wxPyEndAllowThreads(__tstate);
13252 if (PyErr_Occurred()) SWIG_fail;
13253 }
13254 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13255 return resultobj;
13256 fail:
13257 return NULL;
13258 }
13259
13260
13261 SWIGINTERN PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13262 PyObject *resultobj = 0;
13263 int arg1 ;
13264 int arg2 ;
13265 buffer arg3 ;
13266 int arg4 ;
13267 buffer arg5 ;
13268 int arg6 ;
13269 wxImage *result = 0 ;
13270 int val1 ;
13271 int ecode1 = 0 ;
13272 int val2 ;
13273 int ecode2 = 0 ;
13274 PyObject * obj0 = 0 ;
13275 PyObject * obj1 = 0 ;
13276 PyObject * obj2 = 0 ;
13277 PyObject * obj3 = 0 ;
13278 char * kwnames[] = {
13279 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
13280 };
13281
13282 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13283 ecode1 = SWIG_AsVal_int(obj0, &val1);
13284 if (!SWIG_IsOK(ecode1)) {
13285 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "1"" of type '" "int""'");
13286 }
13287 arg1 = static_cast< int >(val1);
13288 ecode2 = SWIG_AsVal_int(obj1, &val2);
13289 if (!SWIG_IsOK(ecode2)) {
13290 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "2"" of type '" "int""'");
13291 }
13292 arg2 = static_cast< int >(val2);
13293 {
13294 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
13295 }
13296 {
13297 if (!PyArg_Parse(obj3, "t#", &arg5, &arg6)) SWIG_fail;
13298 }
13299 {
13300 PyThreadState* __tstate = wxPyBeginAllowThreads();
13301 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
13302 wxPyEndAllowThreads(__tstate);
13303 if (PyErr_Occurred()) SWIG_fail;
13304 }
13305 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13306 return resultobj;
13307 fail:
13308 return NULL;
13309 }
13310
13311
13312 SWIGINTERN PyObject *_wrap_Image_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13313 PyObject *resultobj = 0;
13314 wxImage *arg1 = (wxImage *) 0 ;
13315 int arg2 ;
13316 int arg3 ;
13317 bool arg4 = (bool) true ;
13318 void *argp1 = 0 ;
13319 int res1 = 0 ;
13320 int val2 ;
13321 int ecode2 = 0 ;
13322 int val3 ;
13323 int ecode3 = 0 ;
13324 bool val4 ;
13325 int ecode4 = 0 ;
13326 PyObject * obj0 = 0 ;
13327 PyObject * obj1 = 0 ;
13328 PyObject * obj2 = 0 ;
13329 PyObject * obj3 = 0 ;
13330 char * kwnames[] = {
13331 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
13332 };
13333
13334 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13335 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13336 if (!SWIG_IsOK(res1)) {
13337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Create" "', expected argument " "1"" of type '" "wxImage *""'");
13338 }
13339 arg1 = reinterpret_cast< wxImage * >(argp1);
13340 ecode2 = SWIG_AsVal_int(obj1, &val2);
13341 if (!SWIG_IsOK(ecode2)) {
13342 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Create" "', expected argument " "2"" of type '" "int""'");
13343 }
13344 arg2 = static_cast< int >(val2);
13345 ecode3 = SWIG_AsVal_int(obj2, &val3);
13346 if (!SWIG_IsOK(ecode3)) {
13347 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Create" "', expected argument " "3"" of type '" "int""'");
13348 }
13349 arg3 = static_cast< int >(val3);
13350 if (obj3) {
13351 ecode4 = SWIG_AsVal_bool(obj3, &val4);
13352 if (!SWIG_IsOK(ecode4)) {
13353 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Create" "', expected argument " "4"" of type '" "bool""'");
13354 }
13355 arg4 = static_cast< bool >(val4);
13356 }
13357 {
13358 PyThreadState* __tstate = wxPyBeginAllowThreads();
13359 (arg1)->Create(arg2,arg3,arg4);
13360 wxPyEndAllowThreads(__tstate);
13361 if (PyErr_Occurred()) SWIG_fail;
13362 }
13363 resultobj = SWIG_Py_Void();
13364 return resultobj;
13365 fail:
13366 return NULL;
13367 }
13368
13369
13370 SWIGINTERN PyObject *_wrap_Image_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13371 PyObject *resultobj = 0;
13372 wxImage *arg1 = (wxImage *) 0 ;
13373 void *argp1 = 0 ;
13374 int res1 = 0 ;
13375 PyObject *swig_obj[1] ;
13376
13377 if (!args) SWIG_fail;
13378 swig_obj[0] = args;
13379 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13380 if (!SWIG_IsOK(res1)) {
13381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Destroy" "', expected argument " "1"" of type '" "wxImage *""'");
13382 }
13383 arg1 = reinterpret_cast< wxImage * >(argp1);
13384 {
13385 PyThreadState* __tstate = wxPyBeginAllowThreads();
13386 (arg1)->Destroy();
13387 wxPyEndAllowThreads(__tstate);
13388 if (PyErr_Occurred()) SWIG_fail;
13389 }
13390 resultobj = SWIG_Py_Void();
13391 return resultobj;
13392 fail:
13393 return NULL;
13394 }
13395
13396
13397 SWIGINTERN PyObject *_wrap_Image_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13398 PyObject *resultobj = 0;
13399 wxImage *arg1 = (wxImage *) 0 ;
13400 int arg2 ;
13401 int arg3 ;
13402 SwigValueWrapper<wxImage > result;
13403 void *argp1 = 0 ;
13404 int res1 = 0 ;
13405 int val2 ;
13406 int ecode2 = 0 ;
13407 int val3 ;
13408 int ecode3 = 0 ;
13409 PyObject * obj0 = 0 ;
13410 PyObject * obj1 = 0 ;
13411 PyObject * obj2 = 0 ;
13412 char * kwnames[] = {
13413 (char *) "self",(char *) "width",(char *) "height", NULL
13414 };
13415
13416 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13417 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13418 if (!SWIG_IsOK(res1)) {
13419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Scale" "', expected argument " "1"" of type '" "wxImage *""'");
13420 }
13421 arg1 = reinterpret_cast< wxImage * >(argp1);
13422 ecode2 = SWIG_AsVal_int(obj1, &val2);
13423 if (!SWIG_IsOK(ecode2)) {
13424 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Scale" "', expected argument " "2"" of type '" "int""'");
13425 }
13426 arg2 = static_cast< int >(val2);
13427 ecode3 = SWIG_AsVal_int(obj2, &val3);
13428 if (!SWIG_IsOK(ecode3)) {
13429 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Scale" "', expected argument " "3"" of type '" "int""'");
13430 }
13431 arg3 = static_cast< int >(val3);
13432 {
13433 PyThreadState* __tstate = wxPyBeginAllowThreads();
13434 result = (arg1)->Scale(arg2,arg3);
13435 wxPyEndAllowThreads(__tstate);
13436 if (PyErr_Occurred()) SWIG_fail;
13437 }
13438 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13439 return resultobj;
13440 fail:
13441 return NULL;
13442 }
13443
13444
13445 SWIGINTERN PyObject *_wrap_Image_ShrinkBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13446 PyObject *resultobj = 0;
13447 wxImage *arg1 = (wxImage *) 0 ;
13448 int arg2 ;
13449 int arg3 ;
13450 SwigValueWrapper<wxImage > result;
13451 void *argp1 = 0 ;
13452 int res1 = 0 ;
13453 int val2 ;
13454 int ecode2 = 0 ;
13455 int val3 ;
13456 int ecode3 = 0 ;
13457 PyObject * obj0 = 0 ;
13458 PyObject * obj1 = 0 ;
13459 PyObject * obj2 = 0 ;
13460 char * kwnames[] = {
13461 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
13462 };
13463
13464 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13465 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13466 if (!SWIG_IsOK(res1)) {
13467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ShrinkBy" "', expected argument " "1"" of type '" "wxImage const *""'");
13468 }
13469 arg1 = reinterpret_cast< wxImage * >(argp1);
13470 ecode2 = SWIG_AsVal_int(obj1, &val2);
13471 if (!SWIG_IsOK(ecode2)) {
13472 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ShrinkBy" "', expected argument " "2"" of type '" "int""'");
13473 }
13474 arg2 = static_cast< int >(val2);
13475 ecode3 = SWIG_AsVal_int(obj2, &val3);
13476 if (!SWIG_IsOK(ecode3)) {
13477 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ShrinkBy" "', expected argument " "3"" of type '" "int""'");
13478 }
13479 arg3 = static_cast< int >(val3);
13480 {
13481 PyThreadState* __tstate = wxPyBeginAllowThreads();
13482 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
13483 wxPyEndAllowThreads(__tstate);
13484 if (PyErr_Occurred()) SWIG_fail;
13485 }
13486 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13487 return resultobj;
13488 fail:
13489 return NULL;
13490 }
13491
13492
13493 SWIGINTERN PyObject *_wrap_Image_Rescale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13494 PyObject *resultobj = 0;
13495 wxImage *arg1 = (wxImage *) 0 ;
13496 int arg2 ;
13497 int arg3 ;
13498 wxImage *result = 0 ;
13499 void *argp1 = 0 ;
13500 int res1 = 0 ;
13501 int val2 ;
13502 int ecode2 = 0 ;
13503 int val3 ;
13504 int ecode3 = 0 ;
13505 PyObject * obj0 = 0 ;
13506 PyObject * obj1 = 0 ;
13507 PyObject * obj2 = 0 ;
13508 char * kwnames[] = {
13509 (char *) "self",(char *) "width",(char *) "height", NULL
13510 };
13511
13512 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Rescale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13513 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13514 if (!SWIG_IsOK(res1)) {
13515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rescale" "', expected argument " "1"" of type '" "wxImage *""'");
13516 }
13517 arg1 = reinterpret_cast< wxImage * >(argp1);
13518 ecode2 = SWIG_AsVal_int(obj1, &val2);
13519 if (!SWIG_IsOK(ecode2)) {
13520 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rescale" "', expected argument " "2"" of type '" "int""'");
13521 }
13522 arg2 = static_cast< int >(val2);
13523 ecode3 = SWIG_AsVal_int(obj2, &val3);
13524 if (!SWIG_IsOK(ecode3)) {
13525 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Rescale" "', expected argument " "3"" of type '" "int""'");
13526 }
13527 arg3 = static_cast< int >(val3);
13528 {
13529 PyThreadState* __tstate = wxPyBeginAllowThreads();
13530 {
13531 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3);
13532 result = (wxImage *) &_result_ref;
13533 }
13534 wxPyEndAllowThreads(__tstate);
13535 if (PyErr_Occurred()) SWIG_fail;
13536 }
13537 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13538 return resultobj;
13539 fail:
13540 return NULL;
13541 }
13542
13543
13544 SWIGINTERN PyObject *_wrap_Image_Resize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13545 PyObject *resultobj = 0;
13546 wxImage *arg1 = (wxImage *) 0 ;
13547 wxSize *arg2 = 0 ;
13548 wxPoint *arg3 = 0 ;
13549 int arg4 = (int) -1 ;
13550 int arg5 = (int) -1 ;
13551 int arg6 = (int) -1 ;
13552 wxImage *result = 0 ;
13553 void *argp1 = 0 ;
13554 int res1 = 0 ;
13555 wxSize temp2 ;
13556 wxPoint temp3 ;
13557 int val4 ;
13558 int ecode4 = 0 ;
13559 int val5 ;
13560 int ecode5 = 0 ;
13561 int val6 ;
13562 int ecode6 = 0 ;
13563 PyObject * obj0 = 0 ;
13564 PyObject * obj1 = 0 ;
13565 PyObject * obj2 = 0 ;
13566 PyObject * obj3 = 0 ;
13567 PyObject * obj4 = 0 ;
13568 PyObject * obj5 = 0 ;
13569 char * kwnames[] = {
13570 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
13571 };
13572
13573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13574 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13575 if (!SWIG_IsOK(res1)) {
13576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Resize" "', expected argument " "1"" of type '" "wxImage *""'");
13577 }
13578 arg1 = reinterpret_cast< wxImage * >(argp1);
13579 {
13580 arg2 = &temp2;
13581 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
13582 }
13583 {
13584 arg3 = &temp3;
13585 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13586 }
13587 if (obj3) {
13588 ecode4 = SWIG_AsVal_int(obj3, &val4);
13589 if (!SWIG_IsOK(ecode4)) {
13590 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Resize" "', expected argument " "4"" of type '" "int""'");
13591 }
13592 arg4 = static_cast< int >(val4);
13593 }
13594 if (obj4) {
13595 ecode5 = SWIG_AsVal_int(obj4, &val5);
13596 if (!SWIG_IsOK(ecode5)) {
13597 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Resize" "', expected argument " "5"" of type '" "int""'");
13598 }
13599 arg5 = static_cast< int >(val5);
13600 }
13601 if (obj5) {
13602 ecode6 = SWIG_AsVal_int(obj5, &val6);
13603 if (!SWIG_IsOK(ecode6)) {
13604 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Resize" "', expected argument " "6"" of type '" "int""'");
13605 }
13606 arg6 = static_cast< int >(val6);
13607 }
13608 {
13609 PyThreadState* __tstate = wxPyBeginAllowThreads();
13610 {
13611 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
13612 result = (wxImage *) &_result_ref;
13613 }
13614 wxPyEndAllowThreads(__tstate);
13615 if (PyErr_Occurred()) SWIG_fail;
13616 }
13617 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13618 return resultobj;
13619 fail:
13620 return NULL;
13621 }
13622
13623
13624 SWIGINTERN PyObject *_wrap_Image_SetRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13625 PyObject *resultobj = 0;
13626 wxImage *arg1 = (wxImage *) 0 ;
13627 int arg2 ;
13628 int arg3 ;
13629 byte arg4 ;
13630 byte arg5 ;
13631 byte arg6 ;
13632 void *argp1 = 0 ;
13633 int res1 = 0 ;
13634 int val2 ;
13635 int ecode2 = 0 ;
13636 int val3 ;
13637 int ecode3 = 0 ;
13638 unsigned char val4 ;
13639 int ecode4 = 0 ;
13640 unsigned char val5 ;
13641 int ecode5 = 0 ;
13642 unsigned char val6 ;
13643 int ecode6 = 0 ;
13644 PyObject * obj0 = 0 ;
13645 PyObject * obj1 = 0 ;
13646 PyObject * obj2 = 0 ;
13647 PyObject * obj3 = 0 ;
13648 PyObject * obj4 = 0 ;
13649 PyObject * obj5 = 0 ;
13650 char * kwnames[] = {
13651 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
13652 };
13653
13654 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13655 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13656 if (!SWIG_IsOK(res1)) {
13657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGB" "', expected argument " "1"" of type '" "wxImage *""'");
13658 }
13659 arg1 = reinterpret_cast< wxImage * >(argp1);
13660 ecode2 = SWIG_AsVal_int(obj1, &val2);
13661 if (!SWIG_IsOK(ecode2)) {
13662 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetRGB" "', expected argument " "2"" of type '" "int""'");
13663 }
13664 arg2 = static_cast< int >(val2);
13665 ecode3 = SWIG_AsVal_int(obj2, &val3);
13666 if (!SWIG_IsOK(ecode3)) {
13667 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGB" "', expected argument " "3"" of type '" "int""'");
13668 }
13669 arg3 = static_cast< int >(val3);
13670 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13671 if (!SWIG_IsOK(ecode4)) {
13672 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGB" "', expected argument " "4"" of type '" "byte""'");
13673 }
13674 arg4 = static_cast< byte >(val4);
13675 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
13676 if (!SWIG_IsOK(ecode5)) {
13677 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGB" "', expected argument " "5"" of type '" "byte""'");
13678 }
13679 arg5 = static_cast< byte >(val5);
13680 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
13681 if (!SWIG_IsOK(ecode6)) {
13682 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_SetRGB" "', expected argument " "6"" of type '" "byte""'");
13683 }
13684 arg6 = static_cast< byte >(val6);
13685 {
13686 PyThreadState* __tstate = wxPyBeginAllowThreads();
13687 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
13688 wxPyEndAllowThreads(__tstate);
13689 if (PyErr_Occurred()) SWIG_fail;
13690 }
13691 resultobj = SWIG_Py_Void();
13692 return resultobj;
13693 fail:
13694 return NULL;
13695 }
13696
13697
13698 SWIGINTERN PyObject *_wrap_Image_SetRGBRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13699 PyObject *resultobj = 0;
13700 wxImage *arg1 = (wxImage *) 0 ;
13701 wxRect *arg2 = 0 ;
13702 byte arg3 ;
13703 byte arg4 ;
13704 byte arg5 ;
13705 void *argp1 = 0 ;
13706 int res1 = 0 ;
13707 wxRect temp2 ;
13708 unsigned char val3 ;
13709 int ecode3 = 0 ;
13710 unsigned char val4 ;
13711 int ecode4 = 0 ;
13712 unsigned char val5 ;
13713 int ecode5 = 0 ;
13714 PyObject * obj0 = 0 ;
13715 PyObject * obj1 = 0 ;
13716 PyObject * obj2 = 0 ;
13717 PyObject * obj3 = 0 ;
13718 PyObject * obj4 = 0 ;
13719 char * kwnames[] = {
13720 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
13721 };
13722
13723 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
13724 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13725 if (!SWIG_IsOK(res1)) {
13726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGBRect" "', expected argument " "1"" of type '" "wxImage *""'");
13727 }
13728 arg1 = reinterpret_cast< wxImage * >(argp1);
13729 {
13730 arg2 = &temp2;
13731 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13732 }
13733 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
13734 if (!SWIG_IsOK(ecode3)) {
13735 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGBRect" "', expected argument " "3"" of type '" "byte""'");
13736 }
13737 arg3 = static_cast< byte >(val3);
13738 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13739 if (!SWIG_IsOK(ecode4)) {
13740 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGBRect" "', expected argument " "4"" of type '" "byte""'");
13741 }
13742 arg4 = static_cast< byte >(val4);
13743 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
13744 if (!SWIG_IsOK(ecode5)) {
13745 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGBRect" "', expected argument " "5"" of type '" "byte""'");
13746 }
13747 arg5 = static_cast< byte >(val5);
13748 {
13749 PyThreadState* __tstate = wxPyBeginAllowThreads();
13750 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
13751 wxPyEndAllowThreads(__tstate);
13752 if (PyErr_Occurred()) SWIG_fail;
13753 }
13754 resultobj = SWIG_Py_Void();
13755 return resultobj;
13756 fail:
13757 return NULL;
13758 }
13759
13760
13761 SWIGINTERN PyObject *_wrap_Image_GetRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13762 PyObject *resultobj = 0;
13763 wxImage *arg1 = (wxImage *) 0 ;
13764 int arg2 ;
13765 int arg3 ;
13766 byte result;
13767 void *argp1 = 0 ;
13768 int res1 = 0 ;
13769 int val2 ;
13770 int ecode2 = 0 ;
13771 int val3 ;
13772 int ecode3 = 0 ;
13773 PyObject * obj0 = 0 ;
13774 PyObject * obj1 = 0 ;
13775 PyObject * obj2 = 0 ;
13776 char * kwnames[] = {
13777 (char *) "self",(char *) "x",(char *) "y", NULL
13778 };
13779
13780 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13781 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13782 if (!SWIG_IsOK(res1)) {
13783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetRed" "', expected argument " "1"" of type '" "wxImage *""'");
13784 }
13785 arg1 = reinterpret_cast< wxImage * >(argp1);
13786 ecode2 = SWIG_AsVal_int(obj1, &val2);
13787 if (!SWIG_IsOK(ecode2)) {
13788 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetRed" "', expected argument " "2"" of type '" "int""'");
13789 }
13790 arg2 = static_cast< int >(val2);
13791 ecode3 = SWIG_AsVal_int(obj2, &val3);
13792 if (!SWIG_IsOK(ecode3)) {
13793 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetRed" "', expected argument " "3"" of type '" "int""'");
13794 }
13795 arg3 = static_cast< int >(val3);
13796 {
13797 PyThreadState* __tstate = wxPyBeginAllowThreads();
13798 result = (byte)(arg1)->GetRed(arg2,arg3);
13799 wxPyEndAllowThreads(__tstate);
13800 if (PyErr_Occurred()) SWIG_fail;
13801 }
13802 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13803 return resultobj;
13804 fail:
13805 return NULL;
13806 }
13807
13808
13809 SWIGINTERN PyObject *_wrap_Image_GetGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13810 PyObject *resultobj = 0;
13811 wxImage *arg1 = (wxImage *) 0 ;
13812 int arg2 ;
13813 int arg3 ;
13814 byte result;
13815 void *argp1 = 0 ;
13816 int res1 = 0 ;
13817 int val2 ;
13818 int ecode2 = 0 ;
13819 int val3 ;
13820 int ecode3 = 0 ;
13821 PyObject * obj0 = 0 ;
13822 PyObject * obj1 = 0 ;
13823 PyObject * obj2 = 0 ;
13824 char * kwnames[] = {
13825 (char *) "self",(char *) "x",(char *) "y", NULL
13826 };
13827
13828 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13829 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13830 if (!SWIG_IsOK(res1)) {
13831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetGreen" "', expected argument " "1"" of type '" "wxImage *""'");
13832 }
13833 arg1 = reinterpret_cast< wxImage * >(argp1);
13834 ecode2 = SWIG_AsVal_int(obj1, &val2);
13835 if (!SWIG_IsOK(ecode2)) {
13836 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetGreen" "', expected argument " "2"" of type '" "int""'");
13837 }
13838 arg2 = static_cast< int >(val2);
13839 ecode3 = SWIG_AsVal_int(obj2, &val3);
13840 if (!SWIG_IsOK(ecode3)) {
13841 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetGreen" "', expected argument " "3"" of type '" "int""'");
13842 }
13843 arg3 = static_cast< int >(val3);
13844 {
13845 PyThreadState* __tstate = wxPyBeginAllowThreads();
13846 result = (byte)(arg1)->GetGreen(arg2,arg3);
13847 wxPyEndAllowThreads(__tstate);
13848 if (PyErr_Occurred()) SWIG_fail;
13849 }
13850 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13851 return resultobj;
13852 fail:
13853 return NULL;
13854 }
13855
13856
13857 SWIGINTERN PyObject *_wrap_Image_GetBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13858 PyObject *resultobj = 0;
13859 wxImage *arg1 = (wxImage *) 0 ;
13860 int arg2 ;
13861 int arg3 ;
13862 byte result;
13863 void *argp1 = 0 ;
13864 int res1 = 0 ;
13865 int val2 ;
13866 int ecode2 = 0 ;
13867 int val3 ;
13868 int ecode3 = 0 ;
13869 PyObject * obj0 = 0 ;
13870 PyObject * obj1 = 0 ;
13871 PyObject * obj2 = 0 ;
13872 char * kwnames[] = {
13873 (char *) "self",(char *) "x",(char *) "y", NULL
13874 };
13875
13876 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13877 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13878 if (!SWIG_IsOK(res1)) {
13879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetBlue" "', expected argument " "1"" of type '" "wxImage *""'");
13880 }
13881 arg1 = reinterpret_cast< wxImage * >(argp1);
13882 ecode2 = SWIG_AsVal_int(obj1, &val2);
13883 if (!SWIG_IsOK(ecode2)) {
13884 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetBlue" "', expected argument " "2"" of type '" "int""'");
13885 }
13886 arg2 = static_cast< int >(val2);
13887 ecode3 = SWIG_AsVal_int(obj2, &val3);
13888 if (!SWIG_IsOK(ecode3)) {
13889 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetBlue" "', expected argument " "3"" of type '" "int""'");
13890 }
13891 arg3 = static_cast< int >(val3);
13892 {
13893 PyThreadState* __tstate = wxPyBeginAllowThreads();
13894 result = (byte)(arg1)->GetBlue(arg2,arg3);
13895 wxPyEndAllowThreads(__tstate);
13896 if (PyErr_Occurred()) SWIG_fail;
13897 }
13898 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13899 return resultobj;
13900 fail:
13901 return NULL;
13902 }
13903
13904
13905 SWIGINTERN PyObject *_wrap_Image_SetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13906 PyObject *resultobj = 0;
13907 wxImage *arg1 = (wxImage *) 0 ;
13908 int arg2 ;
13909 int arg3 ;
13910 byte arg4 ;
13911 void *argp1 = 0 ;
13912 int res1 = 0 ;
13913 int val2 ;
13914 int ecode2 = 0 ;
13915 int val3 ;
13916 int ecode3 = 0 ;
13917 unsigned char val4 ;
13918 int ecode4 = 0 ;
13919 PyObject * obj0 = 0 ;
13920 PyObject * obj1 = 0 ;
13921 PyObject * obj2 = 0 ;
13922 PyObject * obj3 = 0 ;
13923 char * kwnames[] = {
13924 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
13925 };
13926
13927 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13928 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13929 if (!SWIG_IsOK(res1)) {
13930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
13931 }
13932 arg1 = reinterpret_cast< wxImage * >(argp1);
13933 ecode2 = SWIG_AsVal_int(obj1, &val2);
13934 if (!SWIG_IsOK(ecode2)) {
13935 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetAlpha" "', expected argument " "2"" of type '" "int""'");
13936 }
13937 arg2 = static_cast< int >(val2);
13938 ecode3 = SWIG_AsVal_int(obj2, &val3);
13939 if (!SWIG_IsOK(ecode3)) {
13940 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetAlpha" "', expected argument " "3"" of type '" "int""'");
13941 }
13942 arg3 = static_cast< int >(val3);
13943 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13944 if (!SWIG_IsOK(ecode4)) {
13945 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetAlpha" "', expected argument " "4"" of type '" "byte""'");
13946 }
13947 arg4 = static_cast< byte >(val4);
13948 {
13949 PyThreadState* __tstate = wxPyBeginAllowThreads();
13950 (arg1)->SetAlpha(arg2,arg3,arg4);
13951 wxPyEndAllowThreads(__tstate);
13952 if (PyErr_Occurred()) SWIG_fail;
13953 }
13954 resultobj = SWIG_Py_Void();
13955 return resultobj;
13956 fail:
13957 return NULL;
13958 }
13959
13960
13961 SWIGINTERN PyObject *_wrap_Image_GetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13962 PyObject *resultobj = 0;
13963 wxImage *arg1 = (wxImage *) 0 ;
13964 int arg2 ;
13965 int arg3 ;
13966 byte result;
13967 void *argp1 = 0 ;
13968 int res1 = 0 ;
13969 int val2 ;
13970 int ecode2 = 0 ;
13971 int val3 ;
13972 int ecode3 = 0 ;
13973 PyObject * obj0 = 0 ;
13974 PyObject * obj1 = 0 ;
13975 PyObject * obj2 = 0 ;
13976 char * kwnames[] = {
13977 (char *) "self",(char *) "x",(char *) "y", NULL
13978 };
13979
13980 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13981 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13982 if (!SWIG_IsOK(res1)) {
13983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
13984 }
13985 arg1 = reinterpret_cast< wxImage * >(argp1);
13986 ecode2 = SWIG_AsVal_int(obj1, &val2);
13987 if (!SWIG_IsOK(ecode2)) {
13988 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetAlpha" "', expected argument " "2"" of type '" "int""'");
13989 }
13990 arg2 = static_cast< int >(val2);
13991 ecode3 = SWIG_AsVal_int(obj2, &val3);
13992 if (!SWIG_IsOK(ecode3)) {
13993 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetAlpha" "', expected argument " "3"" of type '" "int""'");
13994 }
13995 arg3 = static_cast< int >(val3);
13996 {
13997 PyThreadState* __tstate = wxPyBeginAllowThreads();
13998 result = (byte)(arg1)->GetAlpha(arg2,arg3);
13999 wxPyEndAllowThreads(__tstate);
14000 if (PyErr_Occurred()) SWIG_fail;
14001 }
14002 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14003 return resultobj;
14004 fail:
14005 return NULL;
14006 }
14007
14008
14009 SWIGINTERN PyObject *_wrap_Image_HasAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14010 PyObject *resultobj = 0;
14011 wxImage *arg1 = (wxImage *) 0 ;
14012 bool result;
14013 void *argp1 = 0 ;
14014 int res1 = 0 ;
14015 PyObject *swig_obj[1] ;
14016
14017 if (!args) SWIG_fail;
14018 swig_obj[0] = args;
14019 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14020 if (!SWIG_IsOK(res1)) {
14021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14022 }
14023 arg1 = reinterpret_cast< wxImage * >(argp1);
14024 {
14025 PyThreadState* __tstate = wxPyBeginAllowThreads();
14026 result = (bool)(arg1)->HasAlpha();
14027 wxPyEndAllowThreads(__tstate);
14028 if (PyErr_Occurred()) SWIG_fail;
14029 }
14030 {
14031 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14032 }
14033 return resultobj;
14034 fail:
14035 return NULL;
14036 }
14037
14038
14039 SWIGINTERN PyObject *_wrap_Image_InitAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14040 PyObject *resultobj = 0;
14041 wxImage *arg1 = (wxImage *) 0 ;
14042 void *argp1 = 0 ;
14043 int res1 = 0 ;
14044 PyObject *swig_obj[1] ;
14045
14046 if (!args) SWIG_fail;
14047 swig_obj[0] = args;
14048 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14049 if (!SWIG_IsOK(res1)) {
14050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InitAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14051 }
14052 arg1 = reinterpret_cast< wxImage * >(argp1);
14053 {
14054 PyThreadState* __tstate = wxPyBeginAllowThreads();
14055 (arg1)->InitAlpha();
14056 wxPyEndAllowThreads(__tstate);
14057 if (PyErr_Occurred()) SWIG_fail;
14058 }
14059 resultobj = SWIG_Py_Void();
14060 return resultobj;
14061 fail:
14062 return NULL;
14063 }
14064
14065
14066 SWIGINTERN PyObject *_wrap_Image_IsTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14067 PyObject *resultobj = 0;
14068 wxImage *arg1 = (wxImage *) 0 ;
14069 int arg2 ;
14070 int arg3 ;
14071 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14072 bool result;
14073 void *argp1 = 0 ;
14074 int res1 = 0 ;
14075 int val2 ;
14076 int ecode2 = 0 ;
14077 int val3 ;
14078 int ecode3 = 0 ;
14079 unsigned char val4 ;
14080 int ecode4 = 0 ;
14081 PyObject * obj0 = 0 ;
14082 PyObject * obj1 = 0 ;
14083 PyObject * obj2 = 0 ;
14084 PyObject * obj3 = 0 ;
14085 char * kwnames[] = {
14086 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
14087 };
14088
14089 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14090 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14091 if (!SWIG_IsOK(res1)) {
14092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsTransparent" "', expected argument " "1"" of type '" "wxImage const *""'");
14093 }
14094 arg1 = reinterpret_cast< wxImage * >(argp1);
14095 ecode2 = SWIG_AsVal_int(obj1, &val2);
14096 if (!SWIG_IsOK(ecode2)) {
14097 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_IsTransparent" "', expected argument " "2"" of type '" "int""'");
14098 }
14099 arg2 = static_cast< int >(val2);
14100 ecode3 = SWIG_AsVal_int(obj2, &val3);
14101 if (!SWIG_IsOK(ecode3)) {
14102 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_IsTransparent" "', expected argument " "3"" of type '" "int""'");
14103 }
14104 arg3 = static_cast< int >(val3);
14105 if (obj3) {
14106 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14107 if (!SWIG_IsOK(ecode4)) {
14108 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_IsTransparent" "', expected argument " "4"" of type '" "byte""'");
14109 }
14110 arg4 = static_cast< byte >(val4);
14111 }
14112 {
14113 PyThreadState* __tstate = wxPyBeginAllowThreads();
14114 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
14115 wxPyEndAllowThreads(__tstate);
14116 if (PyErr_Occurred()) SWIG_fail;
14117 }
14118 {
14119 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14120 }
14121 return resultobj;
14122 fail:
14123 return NULL;
14124 }
14125
14126
14127 SWIGINTERN PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14128 PyObject *resultobj = 0;
14129 wxImage *arg1 = (wxImage *) 0 ;
14130 byte *arg2 = (byte *) 0 ;
14131 byte *arg3 = (byte *) 0 ;
14132 byte *arg4 = (byte *) 0 ;
14133 byte arg5 = (byte) 0 ;
14134 byte arg6 = (byte) 0 ;
14135 byte arg7 = (byte) 0 ;
14136 bool result;
14137 void *argp1 = 0 ;
14138 int res1 = 0 ;
14139 byte temp2 ;
14140 int res2 = SWIG_TMPOBJ ;
14141 byte temp3 ;
14142 int res3 = SWIG_TMPOBJ ;
14143 byte temp4 ;
14144 int res4 = SWIG_TMPOBJ ;
14145 unsigned char val5 ;
14146 int ecode5 = 0 ;
14147 unsigned char val6 ;
14148 int ecode6 = 0 ;
14149 unsigned char val7 ;
14150 int ecode7 = 0 ;
14151 PyObject * obj0 = 0 ;
14152 PyObject * obj1 = 0 ;
14153 PyObject * obj2 = 0 ;
14154 PyObject * obj3 = 0 ;
14155 char * kwnames[] = {
14156 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
14157 };
14158
14159 arg2 = &temp2;
14160 arg3 = &temp3;
14161 arg4 = &temp4;
14162 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14163 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14164 if (!SWIG_IsOK(res1)) {
14165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImage const *""'");
14166 }
14167 arg1 = reinterpret_cast< wxImage * >(argp1);
14168 if (obj1) {
14169 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
14170 if (!SWIG_IsOK(ecode5)) {
14171 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
14172 }
14173 arg5 = static_cast< byte >(val5);
14174 }
14175 if (obj2) {
14176 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
14177 if (!SWIG_IsOK(ecode6)) {
14178 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
14179 }
14180 arg6 = static_cast< byte >(val6);
14181 }
14182 if (obj3) {
14183 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
14184 if (!SWIG_IsOK(ecode7)) {
14185 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
14186 }
14187 arg7 = static_cast< byte >(val7);
14188 }
14189 {
14190 PyThreadState* __tstate = wxPyBeginAllowThreads();
14191 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
14192 wxPyEndAllowThreads(__tstate);
14193 if (PyErr_Occurred()) SWIG_fail;
14194 }
14195 {
14196 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14197 }
14198 if (SWIG_IsTmpObj(res2)) {
14199 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
14200 } else {
14201 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14202 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
14203 }
14204 if (SWIG_IsTmpObj(res3)) {
14205 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
14206 } else {
14207 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14208 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
14209 }
14210 if (SWIG_IsTmpObj(res4)) {
14211 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
14212 } else {
14213 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14214 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
14215 }
14216 return resultobj;
14217 fail:
14218 return NULL;
14219 }
14220
14221
14222 SWIGINTERN PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14223 PyObject *resultobj = 0;
14224 wxImage *arg1 = (wxImage *) 0 ;
14225 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14226 bool result;
14227 void *argp1 = 0 ;
14228 int res1 = 0 ;
14229 unsigned char val2 ;
14230 int ecode2 = 0 ;
14231 PyObject * obj0 = 0 ;
14232 PyObject * obj1 = 0 ;
14233 char * kwnames[] = {
14234 (char *) "self",(char *) "threshold", NULL
14235 };
14236
14237 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) SWIG_fail;
14238 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14239 if (!SWIG_IsOK(res1)) {
14240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "1"" of type '" "wxImage *""'");
14241 }
14242 arg1 = reinterpret_cast< wxImage * >(argp1);
14243 if (obj1) {
14244 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14245 if (!SWIG_IsOK(ecode2)) {
14246 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "2"" of type '" "byte""'");
14247 }
14248 arg2 = static_cast< byte >(val2);
14249 }
14250 {
14251 PyThreadState* __tstate = wxPyBeginAllowThreads();
14252 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
14253 wxPyEndAllowThreads(__tstate);
14254 if (PyErr_Occurred()) SWIG_fail;
14255 }
14256 {
14257 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14258 }
14259 return resultobj;
14260 fail:
14261 return NULL;
14262 }
14263
14264
14265 SWIGINTERN PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14266 PyObject *resultobj = 0;
14267 wxImage *arg1 = (wxImage *) 0 ;
14268 byte arg2 ;
14269 byte arg3 ;
14270 byte arg4 ;
14271 bool result;
14272 void *argp1 = 0 ;
14273 int res1 = 0 ;
14274 unsigned char val2 ;
14275 int ecode2 = 0 ;
14276 unsigned char val3 ;
14277 int ecode3 = 0 ;
14278 unsigned char val4 ;
14279 int ecode4 = 0 ;
14280 PyObject * obj0 = 0 ;
14281 PyObject * obj1 = 0 ;
14282 PyObject * obj2 = 0 ;
14283 PyObject * obj3 = 0 ;
14284 char * kwnames[] = {
14285 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
14286 };
14287
14288 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14289 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14290 if (!SWIG_IsOK(res1)) {
14291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14292 }
14293 arg1 = reinterpret_cast< wxImage * >(argp1);
14294 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14295 if (!SWIG_IsOK(ecode2)) {
14296 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "2"" of type '" "byte""'");
14297 }
14298 arg2 = static_cast< byte >(val2);
14299 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14300 if (!SWIG_IsOK(ecode3)) {
14301 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "3"" of type '" "byte""'");
14302 }
14303 arg3 = static_cast< byte >(val3);
14304 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14305 if (!SWIG_IsOK(ecode4)) {
14306 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "4"" of type '" "byte""'");
14307 }
14308 arg4 = static_cast< byte >(val4);
14309 {
14310 PyThreadState* __tstate = wxPyBeginAllowThreads();
14311 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
14312 wxPyEndAllowThreads(__tstate);
14313 if (PyErr_Occurred()) SWIG_fail;
14314 }
14315 {
14316 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14317 }
14318 return resultobj;
14319 fail:
14320 return NULL;
14321 }
14322
14323
14324 SWIGINTERN PyObject *_wrap_Image_SetMaskFromImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14325 PyObject *resultobj = 0;
14326 wxImage *arg1 = (wxImage *) 0 ;
14327 wxImage *arg2 = 0 ;
14328 byte arg3 ;
14329 byte arg4 ;
14330 byte arg5 ;
14331 bool result;
14332 void *argp1 = 0 ;
14333 int res1 = 0 ;
14334 void *argp2 = 0 ;
14335 int res2 = 0 ;
14336 unsigned char val3 ;
14337 int ecode3 = 0 ;
14338 unsigned char val4 ;
14339 int ecode4 = 0 ;
14340 unsigned char val5 ;
14341 int ecode5 = 0 ;
14342 PyObject * obj0 = 0 ;
14343 PyObject * obj1 = 0 ;
14344 PyObject * obj2 = 0 ;
14345 PyObject * obj3 = 0 ;
14346 PyObject * obj4 = 0 ;
14347 char * kwnames[] = {
14348 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
14349 };
14350
14351 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
14352 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14353 if (!SWIG_IsOK(res1)) {
14354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskFromImage" "', expected argument " "1"" of type '" "wxImage *""'");
14355 }
14356 arg1 = reinterpret_cast< wxImage * >(argp1);
14357 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
14358 if (!SWIG_IsOK(res2)) {
14359 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14360 }
14361 if (!argp2) {
14362 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14363 }
14364 arg2 = reinterpret_cast< wxImage * >(argp2);
14365 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14366 if (!SWIG_IsOK(ecode3)) {
14367 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskFromImage" "', expected argument " "3"" of type '" "byte""'");
14368 }
14369 arg3 = static_cast< byte >(val3);
14370 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14371 if (!SWIG_IsOK(ecode4)) {
14372 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskFromImage" "', expected argument " "4"" of type '" "byte""'");
14373 }
14374 arg4 = static_cast< byte >(val4);
14375 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
14376 if (!SWIG_IsOK(ecode5)) {
14377 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetMaskFromImage" "', expected argument " "5"" of type '" "byte""'");
14378 }
14379 arg5 = static_cast< byte >(val5);
14380 {
14381 PyThreadState* __tstate = wxPyBeginAllowThreads();
14382 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
14383 wxPyEndAllowThreads(__tstate);
14384 if (PyErr_Occurred()) SWIG_fail;
14385 }
14386 {
14387 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14388 }
14389 return resultobj;
14390 fail:
14391 return NULL;
14392 }
14393
14394
14395 SWIGINTERN PyObject *_wrap_Image_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14396 PyObject *resultobj = 0;
14397 wxString *arg1 = 0 ;
14398 bool result;
14399 bool temp1 = false ;
14400 PyObject * obj0 = 0 ;
14401 char * kwnames[] = {
14402 (char *) "filename", NULL
14403 };
14404
14405 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) SWIG_fail;
14406 {
14407 arg1 = wxString_in_helper(obj0);
14408 if (arg1 == NULL) SWIG_fail;
14409 temp1 = true;
14410 }
14411 {
14412 PyThreadState* __tstate = wxPyBeginAllowThreads();
14413 result = (bool)wxImage::CanRead((wxString const &)*arg1);
14414 wxPyEndAllowThreads(__tstate);
14415 if (PyErr_Occurred()) SWIG_fail;
14416 }
14417 {
14418 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14419 }
14420 {
14421 if (temp1)
14422 delete arg1;
14423 }
14424 return resultobj;
14425 fail:
14426 {
14427 if (temp1)
14428 delete arg1;
14429 }
14430 return NULL;
14431 }
14432
14433
14434 SWIGINTERN PyObject *_wrap_Image_GetImageCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14435 PyObject *resultobj = 0;
14436 wxString *arg1 = 0 ;
14437 long arg2 = (long) wxBITMAP_TYPE_ANY ;
14438 int result;
14439 bool temp1 = false ;
14440 long val2 ;
14441 int ecode2 = 0 ;
14442 PyObject * obj0 = 0 ;
14443 PyObject * obj1 = 0 ;
14444 char * kwnames[] = {
14445 (char *) "filename",(char *) "type", NULL
14446 };
14447
14448 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) SWIG_fail;
14449 {
14450 arg1 = wxString_in_helper(obj0);
14451 if (arg1 == NULL) SWIG_fail;
14452 temp1 = true;
14453 }
14454 if (obj1) {
14455 ecode2 = SWIG_AsVal_long(obj1, &val2);
14456 if (!SWIG_IsOK(ecode2)) {
14457 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetImageCount" "', expected argument " "2"" of type '" "long""'");
14458 }
14459 arg2 = static_cast< long >(val2);
14460 }
14461 {
14462 PyThreadState* __tstate = wxPyBeginAllowThreads();
14463 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
14464 wxPyEndAllowThreads(__tstate);
14465 if (PyErr_Occurred()) SWIG_fail;
14466 }
14467 resultobj = SWIG_From_int(static_cast< int >(result));
14468 {
14469 if (temp1)
14470 delete arg1;
14471 }
14472 return resultobj;
14473 fail:
14474 {
14475 if (temp1)
14476 delete arg1;
14477 }
14478 return NULL;
14479 }
14480
14481
14482 SWIGINTERN PyObject *_wrap_Image_LoadFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14483 PyObject *resultobj = 0;
14484 wxImage *arg1 = (wxImage *) 0 ;
14485 wxString *arg2 = 0 ;
14486 long arg3 = (long) wxBITMAP_TYPE_ANY ;
14487 int arg4 = (int) -1 ;
14488 bool result;
14489 void *argp1 = 0 ;
14490 int res1 = 0 ;
14491 bool temp2 = false ;
14492 long val3 ;
14493 int ecode3 = 0 ;
14494 int val4 ;
14495 int ecode4 = 0 ;
14496 PyObject * obj0 = 0 ;
14497 PyObject * obj1 = 0 ;
14498 PyObject * obj2 = 0 ;
14499 PyObject * obj3 = 0 ;
14500 char * kwnames[] = {
14501 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
14502 };
14503
14504 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14505 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14506 if (!SWIG_IsOK(res1)) {
14507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadFile" "', expected argument " "1"" of type '" "wxImage *""'");
14508 }
14509 arg1 = reinterpret_cast< wxImage * >(argp1);
14510 {
14511 arg2 = wxString_in_helper(obj1);
14512 if (arg2 == NULL) SWIG_fail;
14513 temp2 = true;
14514 }
14515 if (obj2) {
14516 ecode3 = SWIG_AsVal_long(obj2, &val3);
14517 if (!SWIG_IsOK(ecode3)) {
14518 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadFile" "', expected argument " "3"" of type '" "long""'");
14519 }
14520 arg3 = static_cast< long >(val3);
14521 }
14522 if (obj3) {
14523 ecode4 = SWIG_AsVal_int(obj3, &val4);
14524 if (!SWIG_IsOK(ecode4)) {
14525 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadFile" "', expected argument " "4"" of type '" "int""'");
14526 }
14527 arg4 = static_cast< int >(val4);
14528 }
14529 {
14530 PyThreadState* __tstate = wxPyBeginAllowThreads();
14531 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
14532 wxPyEndAllowThreads(__tstate);
14533 if (PyErr_Occurred()) SWIG_fail;
14534 }
14535 {
14536 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14537 }
14538 {
14539 if (temp2)
14540 delete arg2;
14541 }
14542 return resultobj;
14543 fail:
14544 {
14545 if (temp2)
14546 delete arg2;
14547 }
14548 return NULL;
14549 }
14550
14551
14552 SWIGINTERN PyObject *_wrap_Image_LoadMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14553 PyObject *resultobj = 0;
14554 wxImage *arg1 = (wxImage *) 0 ;
14555 wxString *arg2 = 0 ;
14556 wxString *arg3 = 0 ;
14557 int arg4 = (int) -1 ;
14558 bool result;
14559 void *argp1 = 0 ;
14560 int res1 = 0 ;
14561 bool temp2 = false ;
14562 bool temp3 = false ;
14563 int val4 ;
14564 int ecode4 = 0 ;
14565 PyObject * obj0 = 0 ;
14566 PyObject * obj1 = 0 ;
14567 PyObject * obj2 = 0 ;
14568 PyObject * obj3 = 0 ;
14569 char * kwnames[] = {
14570 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
14571 };
14572
14573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14574 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14575 if (!SWIG_IsOK(res1)) {
14576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14577 }
14578 arg1 = reinterpret_cast< wxImage * >(argp1);
14579 {
14580 arg2 = wxString_in_helper(obj1);
14581 if (arg2 == NULL) SWIG_fail;
14582 temp2 = true;
14583 }
14584 {
14585 arg3 = wxString_in_helper(obj2);
14586 if (arg3 == NULL) SWIG_fail;
14587 temp3 = true;
14588 }
14589 if (obj3) {
14590 ecode4 = SWIG_AsVal_int(obj3, &val4);
14591 if (!SWIG_IsOK(ecode4)) {
14592 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeFile" "', expected argument " "4"" of type '" "int""'");
14593 }
14594 arg4 = static_cast< int >(val4);
14595 }
14596 {
14597 PyThreadState* __tstate = wxPyBeginAllowThreads();
14598 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
14599 wxPyEndAllowThreads(__tstate);
14600 if (PyErr_Occurred()) SWIG_fail;
14601 }
14602 {
14603 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14604 }
14605 {
14606 if (temp2)
14607 delete arg2;
14608 }
14609 {
14610 if (temp3)
14611 delete arg3;
14612 }
14613 return resultobj;
14614 fail:
14615 {
14616 if (temp2)
14617 delete arg2;
14618 }
14619 {
14620 if (temp3)
14621 delete arg3;
14622 }
14623 return NULL;
14624 }
14625
14626
14627 SWIGINTERN PyObject *_wrap_Image_SaveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14628 PyObject *resultobj = 0;
14629 wxImage *arg1 = (wxImage *) 0 ;
14630 wxString *arg2 = 0 ;
14631 int arg3 ;
14632 bool result;
14633 void *argp1 = 0 ;
14634 int res1 = 0 ;
14635 bool temp2 = false ;
14636 int val3 ;
14637 int ecode3 = 0 ;
14638 PyObject * obj0 = 0 ;
14639 PyObject * obj1 = 0 ;
14640 PyObject * obj2 = 0 ;
14641 char * kwnames[] = {
14642 (char *) "self",(char *) "name",(char *) "type", NULL
14643 };
14644
14645 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14646 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14647 if (!SWIG_IsOK(res1)) {
14648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveFile" "', expected argument " "1"" of type '" "wxImage *""'");
14649 }
14650 arg1 = reinterpret_cast< wxImage * >(argp1);
14651 {
14652 arg2 = wxString_in_helper(obj1);
14653 if (arg2 == NULL) SWIG_fail;
14654 temp2 = true;
14655 }
14656 ecode3 = SWIG_AsVal_int(obj2, &val3);
14657 if (!SWIG_IsOK(ecode3)) {
14658 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SaveFile" "', expected argument " "3"" of type '" "int""'");
14659 }
14660 arg3 = static_cast< int >(val3);
14661 {
14662 PyThreadState* __tstate = wxPyBeginAllowThreads();
14663 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
14664 wxPyEndAllowThreads(__tstate);
14665 if (PyErr_Occurred()) SWIG_fail;
14666 }
14667 {
14668 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14669 }
14670 {
14671 if (temp2)
14672 delete arg2;
14673 }
14674 return resultobj;
14675 fail:
14676 {
14677 if (temp2)
14678 delete arg2;
14679 }
14680 return NULL;
14681 }
14682
14683
14684 SWIGINTERN PyObject *_wrap_Image_SaveMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14685 PyObject *resultobj = 0;
14686 wxImage *arg1 = (wxImage *) 0 ;
14687 wxString *arg2 = 0 ;
14688 wxString *arg3 = 0 ;
14689 bool result;
14690 void *argp1 = 0 ;
14691 int res1 = 0 ;
14692 bool temp2 = false ;
14693 bool temp3 = false ;
14694 PyObject * obj0 = 0 ;
14695 PyObject * obj1 = 0 ;
14696 PyObject * obj2 = 0 ;
14697 char * kwnames[] = {
14698 (char *) "self",(char *) "name",(char *) "mimetype", NULL
14699 };
14700
14701 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14702 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14703 if (!SWIG_IsOK(res1)) {
14704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14705 }
14706 arg1 = reinterpret_cast< wxImage * >(argp1);
14707 {
14708 arg2 = wxString_in_helper(obj1);
14709 if (arg2 == NULL) SWIG_fail;
14710 temp2 = true;
14711 }
14712 {
14713 arg3 = wxString_in_helper(obj2);
14714 if (arg3 == NULL) SWIG_fail;
14715 temp3 = true;
14716 }
14717 {
14718 PyThreadState* __tstate = wxPyBeginAllowThreads();
14719 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
14720 wxPyEndAllowThreads(__tstate);
14721 if (PyErr_Occurred()) SWIG_fail;
14722 }
14723 {
14724 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14725 }
14726 {
14727 if (temp2)
14728 delete arg2;
14729 }
14730 {
14731 if (temp3)
14732 delete arg3;
14733 }
14734 return resultobj;
14735 fail:
14736 {
14737 if (temp2)
14738 delete arg2;
14739 }
14740 {
14741 if (temp3)
14742 delete arg3;
14743 }
14744 return NULL;
14745 }
14746
14747
14748 SWIGINTERN PyObject *_wrap_Image_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14749 PyObject *resultobj = 0;
14750 wxInputStream *arg1 = 0 ;
14751 bool result;
14752 wxPyInputStream *temp1 ;
14753 bool created1 ;
14754 PyObject * obj0 = 0 ;
14755 char * kwnames[] = {
14756 (char *) "stream", NULL
14757 };
14758
14759 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) SWIG_fail;
14760 {
14761 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
14762 arg1 = temp1->m_wxis;
14763 created1 = false;
14764 } else {
14765 PyErr_Clear(); // clear the failure of the wxPyConvert above
14766 arg1 = wxPyCBInputStream_create(obj0, false);
14767 if (arg1 == NULL) {
14768 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14769 SWIG_fail;
14770 }
14771 created1 = true;
14772 }
14773 }
14774 {
14775 PyThreadState* __tstate = wxPyBeginAllowThreads();
14776 result = (bool)wxImage::CanRead(*arg1);
14777 wxPyEndAllowThreads(__tstate);
14778 if (PyErr_Occurred()) SWIG_fail;
14779 }
14780 {
14781 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14782 }
14783 {
14784 if (created1) delete arg1;
14785 }
14786 return resultobj;
14787 fail:
14788 {
14789 if (created1) delete arg1;
14790 }
14791 return NULL;
14792 }
14793
14794
14795 SWIGINTERN PyObject *_wrap_Image_LoadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14796 PyObject *resultobj = 0;
14797 wxImage *arg1 = (wxImage *) 0 ;
14798 wxInputStream *arg2 = 0 ;
14799 long arg3 = (long) wxBITMAP_TYPE_ANY ;
14800 int arg4 = (int) -1 ;
14801 bool result;
14802 void *argp1 = 0 ;
14803 int res1 = 0 ;
14804 wxPyInputStream *temp2 ;
14805 bool created2 ;
14806 long val3 ;
14807 int ecode3 = 0 ;
14808 int val4 ;
14809 int ecode4 = 0 ;
14810 PyObject * obj0 = 0 ;
14811 PyObject * obj1 = 0 ;
14812 PyObject * obj2 = 0 ;
14813 PyObject * obj3 = 0 ;
14814 char * kwnames[] = {
14815 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
14816 };
14817
14818 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14819 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14820 if (!SWIG_IsOK(res1)) {
14821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadStream" "', expected argument " "1"" of type '" "wxImage *""'");
14822 }
14823 arg1 = reinterpret_cast< wxImage * >(argp1);
14824 {
14825 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
14826 arg2 = temp2->m_wxis;
14827 created2 = false;
14828 } else {
14829 PyErr_Clear(); // clear the failure of the wxPyConvert above
14830 arg2 = wxPyCBInputStream_create(obj1, false);
14831 if (arg2 == NULL) {
14832 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14833 SWIG_fail;
14834 }
14835 created2 = true;
14836 }
14837 }
14838 if (obj2) {
14839 ecode3 = SWIG_AsVal_long(obj2, &val3);
14840 if (!SWIG_IsOK(ecode3)) {
14841 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadStream" "', expected argument " "3"" of type '" "long""'");
14842 }
14843 arg3 = static_cast< long >(val3);
14844 }
14845 if (obj3) {
14846 ecode4 = SWIG_AsVal_int(obj3, &val4);
14847 if (!SWIG_IsOK(ecode4)) {
14848 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadStream" "', expected argument " "4"" of type '" "int""'");
14849 }
14850 arg4 = static_cast< int >(val4);
14851 }
14852 {
14853 PyThreadState* __tstate = wxPyBeginAllowThreads();
14854 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
14855 wxPyEndAllowThreads(__tstate);
14856 if (PyErr_Occurred()) SWIG_fail;
14857 }
14858 {
14859 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14860 }
14861 {
14862 if (created2) delete arg2;
14863 }
14864 return resultobj;
14865 fail:
14866 {
14867 if (created2) delete arg2;
14868 }
14869 return NULL;
14870 }
14871
14872
14873 SWIGINTERN PyObject *_wrap_Image_LoadMimeStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14874 PyObject *resultobj = 0;
14875 wxImage *arg1 = (wxImage *) 0 ;
14876 wxInputStream *arg2 = 0 ;
14877 wxString *arg3 = 0 ;
14878 int arg4 = (int) -1 ;
14879 bool result;
14880 void *argp1 = 0 ;
14881 int res1 = 0 ;
14882 wxPyInputStream *temp2 ;
14883 bool created2 ;
14884 bool temp3 = false ;
14885 int val4 ;
14886 int ecode4 = 0 ;
14887 PyObject * obj0 = 0 ;
14888 PyObject * obj1 = 0 ;
14889 PyObject * obj2 = 0 ;
14890 PyObject * obj3 = 0 ;
14891 char * kwnames[] = {
14892 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
14893 };
14894
14895 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14896 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14897 if (!SWIG_IsOK(res1)) {
14898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeStream" "', expected argument " "1"" of type '" "wxImage *""'");
14899 }
14900 arg1 = reinterpret_cast< wxImage * >(argp1);
14901 {
14902 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
14903 arg2 = temp2->m_wxis;
14904 created2 = false;
14905 } else {
14906 PyErr_Clear(); // clear the failure of the wxPyConvert above
14907 arg2 = wxPyCBInputStream_create(obj1, false);
14908 if (arg2 == NULL) {
14909 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14910 SWIG_fail;
14911 }
14912 created2 = true;
14913 }
14914 }
14915 {
14916 arg3 = wxString_in_helper(obj2);
14917 if (arg3 == NULL) SWIG_fail;
14918 temp3 = true;
14919 }
14920 if (obj3) {
14921 ecode4 = SWIG_AsVal_int(obj3, &val4);
14922 if (!SWIG_IsOK(ecode4)) {
14923 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeStream" "', expected argument " "4"" of type '" "int""'");
14924 }
14925 arg4 = static_cast< int >(val4);
14926 }
14927 {
14928 PyThreadState* __tstate = wxPyBeginAllowThreads();
14929 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
14930 wxPyEndAllowThreads(__tstate);
14931 if (PyErr_Occurred()) SWIG_fail;
14932 }
14933 {
14934 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14935 }
14936 {
14937 if (created2) delete arg2;
14938 }
14939 {
14940 if (temp3)
14941 delete arg3;
14942 }
14943 return resultobj;
14944 fail:
14945 {
14946 if (created2) delete arg2;
14947 }
14948 {
14949 if (temp3)
14950 delete arg3;
14951 }
14952 return NULL;
14953 }
14954
14955
14956 SWIGINTERN PyObject *_wrap_Image_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14957 PyObject *resultobj = 0;
14958 wxImage *arg1 = (wxImage *) 0 ;
14959 bool result;
14960 void *argp1 = 0 ;
14961 int res1 = 0 ;
14962 PyObject *swig_obj[1] ;
14963
14964 if (!args) SWIG_fail;
14965 swig_obj[0] = args;
14966 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14967 if (!SWIG_IsOK(res1)) {
14968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Ok" "', expected argument " "1"" of type '" "wxImage *""'");
14969 }
14970 arg1 = reinterpret_cast< wxImage * >(argp1);
14971 {
14972 PyThreadState* __tstate = wxPyBeginAllowThreads();
14973 result = (bool)(arg1)->Ok();
14974 wxPyEndAllowThreads(__tstate);
14975 if (PyErr_Occurred()) SWIG_fail;
14976 }
14977 {
14978 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14979 }
14980 return resultobj;
14981 fail:
14982 return NULL;
14983 }
14984
14985
14986 SWIGINTERN PyObject *_wrap_Image_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14987 PyObject *resultobj = 0;
14988 wxImage *arg1 = (wxImage *) 0 ;
14989 int result;
14990 void *argp1 = 0 ;
14991 int res1 = 0 ;
14992 PyObject *swig_obj[1] ;
14993
14994 if (!args) SWIG_fail;
14995 swig_obj[0] = args;
14996 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14997 if (!SWIG_IsOK(res1)) {
14998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetWidth" "', expected argument " "1"" of type '" "wxImage *""'");
14999 }
15000 arg1 = reinterpret_cast< wxImage * >(argp1);
15001 {
15002 PyThreadState* __tstate = wxPyBeginAllowThreads();
15003 result = (int)(arg1)->GetWidth();
15004 wxPyEndAllowThreads(__tstate);
15005 if (PyErr_Occurred()) SWIG_fail;
15006 }
15007 resultobj = SWIG_From_int(static_cast< int >(result));
15008 return resultobj;
15009 fail:
15010 return NULL;
15011 }
15012
15013
15014 SWIGINTERN PyObject *_wrap_Image_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15015 PyObject *resultobj = 0;
15016 wxImage *arg1 = (wxImage *) 0 ;
15017 int result;
15018 void *argp1 = 0 ;
15019 int res1 = 0 ;
15020 PyObject *swig_obj[1] ;
15021
15022 if (!args) SWIG_fail;
15023 swig_obj[0] = args;
15024 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15025 if (!SWIG_IsOK(res1)) {
15026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetHeight" "', expected argument " "1"" of type '" "wxImage *""'");
15027 }
15028 arg1 = reinterpret_cast< wxImage * >(argp1);
15029 {
15030 PyThreadState* __tstate = wxPyBeginAllowThreads();
15031 result = (int)(arg1)->GetHeight();
15032 wxPyEndAllowThreads(__tstate);
15033 if (PyErr_Occurred()) SWIG_fail;
15034 }
15035 resultobj = SWIG_From_int(static_cast< int >(result));
15036 return resultobj;
15037 fail:
15038 return NULL;
15039 }
15040
15041
15042 SWIGINTERN PyObject *_wrap_Image_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15043 PyObject *resultobj = 0;
15044 wxImage *arg1 = (wxImage *) 0 ;
15045 wxSize result;
15046 void *argp1 = 0 ;
15047 int res1 = 0 ;
15048 PyObject *swig_obj[1] ;
15049
15050 if (!args) SWIG_fail;
15051 swig_obj[0] = args;
15052 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15053 if (!SWIG_IsOK(res1)) {
15054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSize" "', expected argument " "1"" of type '" "wxImage *""'");
15055 }
15056 arg1 = reinterpret_cast< wxImage * >(argp1);
15057 {
15058 PyThreadState* __tstate = wxPyBeginAllowThreads();
15059 result = wxImage_GetSize(arg1);
15060 wxPyEndAllowThreads(__tstate);
15061 if (PyErr_Occurred()) SWIG_fail;
15062 }
15063 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
15064 return resultobj;
15065 fail:
15066 return NULL;
15067 }
15068
15069
15070 SWIGINTERN PyObject *_wrap_Image_GetSubImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15071 PyObject *resultobj = 0;
15072 wxImage *arg1 = (wxImage *) 0 ;
15073 wxRect *arg2 = 0 ;
15074 SwigValueWrapper<wxImage > result;
15075 void *argp1 = 0 ;
15076 int res1 = 0 ;
15077 wxRect temp2 ;
15078 PyObject * obj0 = 0 ;
15079 PyObject * obj1 = 0 ;
15080 char * kwnames[] = {
15081 (char *) "self",(char *) "rect", NULL
15082 };
15083
15084 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) SWIG_fail;
15085 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15086 if (!SWIG_IsOK(res1)) {
15087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSubImage" "', expected argument " "1"" of type '" "wxImage *""'");
15088 }
15089 arg1 = reinterpret_cast< wxImage * >(argp1);
15090 {
15091 arg2 = &temp2;
15092 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
15093 }
15094 {
15095 PyThreadState* __tstate = wxPyBeginAllowThreads();
15096 result = (arg1)->GetSubImage((wxRect const &)*arg2);
15097 wxPyEndAllowThreads(__tstate);
15098 if (PyErr_Occurred()) SWIG_fail;
15099 }
15100 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15101 return resultobj;
15102 fail:
15103 return NULL;
15104 }
15105
15106
15107 SWIGINTERN PyObject *_wrap_Image_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15108 PyObject *resultobj = 0;
15109 wxImage *arg1 = (wxImage *) 0 ;
15110 wxSize *arg2 = 0 ;
15111 wxPoint *arg3 = 0 ;
15112 int arg4 = (int) -1 ;
15113 int arg5 = (int) -1 ;
15114 int arg6 = (int) -1 ;
15115 SwigValueWrapper<wxImage > result;
15116 void *argp1 = 0 ;
15117 int res1 = 0 ;
15118 wxSize temp2 ;
15119 wxPoint temp3 ;
15120 int val4 ;
15121 int ecode4 = 0 ;
15122 int val5 ;
15123 int ecode5 = 0 ;
15124 int val6 ;
15125 int ecode6 = 0 ;
15126 PyObject * obj0 = 0 ;
15127 PyObject * obj1 = 0 ;
15128 PyObject * obj2 = 0 ;
15129 PyObject * obj3 = 0 ;
15130 PyObject * obj4 = 0 ;
15131 PyObject * obj5 = 0 ;
15132 char * kwnames[] = {
15133 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
15134 };
15135
15136 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
15137 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15138 if (!SWIG_IsOK(res1)) {
15139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Size" "', expected argument " "1"" of type '" "wxImage const *""'");
15140 }
15141 arg1 = reinterpret_cast< wxImage * >(argp1);
15142 {
15143 arg2 = &temp2;
15144 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
15145 }
15146 {
15147 arg3 = &temp3;
15148 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
15149 }
15150 if (obj3) {
15151 ecode4 = SWIG_AsVal_int(obj3, &val4);
15152 if (!SWIG_IsOK(ecode4)) {
15153 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Size" "', expected argument " "4"" of type '" "int""'");
15154 }
15155 arg4 = static_cast< int >(val4);
15156 }
15157 if (obj4) {
15158 ecode5 = SWIG_AsVal_int(obj4, &val5);
15159 if (!SWIG_IsOK(ecode5)) {
15160 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Size" "', expected argument " "5"" of type '" "int""'");
15161 }
15162 arg5 = static_cast< int >(val5);
15163 }
15164 if (obj5) {
15165 ecode6 = SWIG_AsVal_int(obj5, &val6);
15166 if (!SWIG_IsOK(ecode6)) {
15167 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Size" "', expected argument " "6"" of type '" "int""'");
15168 }
15169 arg6 = static_cast< int >(val6);
15170 }
15171 {
15172 PyThreadState* __tstate = wxPyBeginAllowThreads();
15173 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
15174 wxPyEndAllowThreads(__tstate);
15175 if (PyErr_Occurred()) SWIG_fail;
15176 }
15177 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15178 return resultobj;
15179 fail:
15180 return NULL;
15181 }
15182
15183
15184 SWIGINTERN PyObject *_wrap_Image_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15185 PyObject *resultobj = 0;
15186 wxImage *arg1 = (wxImage *) 0 ;
15187 SwigValueWrapper<wxImage > result;
15188 void *argp1 = 0 ;
15189 int res1 = 0 ;
15190 PyObject *swig_obj[1] ;
15191
15192 if (!args) SWIG_fail;
15193 swig_obj[0] = args;
15194 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15195 if (!SWIG_IsOK(res1)) {
15196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Copy" "', expected argument " "1"" of type '" "wxImage *""'");
15197 }
15198 arg1 = reinterpret_cast< wxImage * >(argp1);
15199 {
15200 PyThreadState* __tstate = wxPyBeginAllowThreads();
15201 result = (arg1)->Copy();
15202 wxPyEndAllowThreads(__tstate);
15203 if (PyErr_Occurred()) SWIG_fail;
15204 }
15205 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15206 return resultobj;
15207 fail:
15208 return NULL;
15209 }
15210
15211
15212 SWIGINTERN PyObject *_wrap_Image_Paste(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15213 PyObject *resultobj = 0;
15214 wxImage *arg1 = (wxImage *) 0 ;
15215 wxImage *arg2 = 0 ;
15216 int arg3 ;
15217 int arg4 ;
15218 void *argp1 = 0 ;
15219 int res1 = 0 ;
15220 void *argp2 = 0 ;
15221 int res2 = 0 ;
15222 int val3 ;
15223 int ecode3 = 0 ;
15224 int val4 ;
15225 int ecode4 = 0 ;
15226 PyObject * obj0 = 0 ;
15227 PyObject * obj1 = 0 ;
15228 PyObject * obj2 = 0 ;
15229 PyObject * obj3 = 0 ;
15230 char * kwnames[] = {
15231 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
15232 };
15233
15234 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15235 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15236 if (!SWIG_IsOK(res1)) {
15237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Paste" "', expected argument " "1"" of type '" "wxImage *""'");
15238 }
15239 arg1 = reinterpret_cast< wxImage * >(argp1);
15240 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
15241 if (!SWIG_IsOK(res2)) {
15242 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15243 }
15244 if (!argp2) {
15245 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15246 }
15247 arg2 = reinterpret_cast< wxImage * >(argp2);
15248 ecode3 = SWIG_AsVal_int(obj2, &val3);
15249 if (!SWIG_IsOK(ecode3)) {
15250 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Paste" "', expected argument " "3"" of type '" "int""'");
15251 }
15252 arg3 = static_cast< int >(val3);
15253 ecode4 = SWIG_AsVal_int(obj3, &val4);
15254 if (!SWIG_IsOK(ecode4)) {
15255 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Paste" "', expected argument " "4"" of type '" "int""'");
15256 }
15257 arg4 = static_cast< int >(val4);
15258 {
15259 PyThreadState* __tstate = wxPyBeginAllowThreads();
15260 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
15261 wxPyEndAllowThreads(__tstate);
15262 if (PyErr_Occurred()) SWIG_fail;
15263 }
15264 resultobj = SWIG_Py_Void();
15265 return resultobj;
15266 fail:
15267 return NULL;
15268 }
15269
15270
15271 SWIGINTERN PyObject *_wrap_Image_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15272 PyObject *resultobj = 0;
15273 wxImage *arg1 = (wxImage *) 0 ;
15274 PyObject *result = 0 ;
15275 void *argp1 = 0 ;
15276 int res1 = 0 ;
15277 PyObject *swig_obj[1] ;
15278
15279 if (!args) SWIG_fail;
15280 swig_obj[0] = args;
15281 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15282 if (!SWIG_IsOK(res1)) {
15283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetData" "', expected argument " "1"" of type '" "wxImage *""'");
15284 }
15285 arg1 = reinterpret_cast< wxImage * >(argp1);
15286 {
15287 PyThreadState* __tstate = wxPyBeginAllowThreads();
15288 result = (PyObject *)wxImage_GetData(arg1);
15289 wxPyEndAllowThreads(__tstate);
15290 if (PyErr_Occurred()) SWIG_fail;
15291 }
15292 resultobj = result;
15293 return resultobj;
15294 fail:
15295 return NULL;
15296 }
15297
15298
15299 SWIGINTERN PyObject *_wrap_Image_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15300 PyObject *resultobj = 0;
15301 wxImage *arg1 = (wxImage *) 0 ;
15302 buffer arg2 ;
15303 int arg3 ;
15304 void *argp1 = 0 ;
15305 int res1 = 0 ;
15306 PyObject * obj0 = 0 ;
15307 PyObject * obj1 = 0 ;
15308 char * kwnames[] = {
15309 (char *) "self",(char *) "data", NULL
15310 };
15311
15312 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
15313 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15314 if (!SWIG_IsOK(res1)) {
15315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetData" "', expected argument " "1"" of type '" "wxImage *""'");
15316 }
15317 arg1 = reinterpret_cast< wxImage * >(argp1);
15318 {
15319 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15320 }
15321 {
15322 PyThreadState* __tstate = wxPyBeginAllowThreads();
15323 wxImage_SetData(arg1,arg2,arg3);
15324 wxPyEndAllowThreads(__tstate);
15325 if (PyErr_Occurred()) SWIG_fail;
15326 }
15327 resultobj = SWIG_Py_Void();
15328 return resultobj;
15329 fail:
15330 return NULL;
15331 }
15332
15333
15334 SWIGINTERN PyObject *_wrap_Image_GetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15335 PyObject *resultobj = 0;
15336 wxImage *arg1 = (wxImage *) 0 ;
15337 PyObject *result = 0 ;
15338 void *argp1 = 0 ;
15339 int res1 = 0 ;
15340 PyObject *swig_obj[1] ;
15341
15342 if (!args) SWIG_fail;
15343 swig_obj[0] = args;
15344 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15345 if (!SWIG_IsOK(res1)) {
15346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15347 }
15348 arg1 = reinterpret_cast< wxImage * >(argp1);
15349 {
15350 PyThreadState* __tstate = wxPyBeginAllowThreads();
15351 result = (PyObject *)wxImage_GetDataBuffer(arg1);
15352 wxPyEndAllowThreads(__tstate);
15353 if (PyErr_Occurred()) SWIG_fail;
15354 }
15355 resultobj = result;
15356 return resultobj;
15357 fail:
15358 return NULL;
15359 }
15360
15361
15362 SWIGINTERN PyObject *_wrap_Image_SetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15363 PyObject *resultobj = 0;
15364 wxImage *arg1 = (wxImage *) 0 ;
15365 buffer arg2 ;
15366 int arg3 ;
15367 void *argp1 = 0 ;
15368 int res1 = 0 ;
15369 PyObject * obj0 = 0 ;
15370 PyObject * obj1 = 0 ;
15371 char * kwnames[] = {
15372 (char *) "self",(char *) "data", NULL
15373 };
15374
15375 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
15376 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15377 if (!SWIG_IsOK(res1)) {
15378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15379 }
15380 arg1 = reinterpret_cast< wxImage * >(argp1);
15381 {
15382 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15383 }
15384 {
15385 PyThreadState* __tstate = wxPyBeginAllowThreads();
15386 wxImage_SetDataBuffer(arg1,arg2,arg3);
15387 wxPyEndAllowThreads(__tstate);
15388 if (PyErr_Occurred()) SWIG_fail;
15389 }
15390 resultobj = SWIG_Py_Void();
15391 return resultobj;
15392 fail:
15393 return NULL;
15394 }
15395
15396
15397 SWIGINTERN PyObject *_wrap_Image_GetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15398 PyObject *resultobj = 0;
15399 wxImage *arg1 = (wxImage *) 0 ;
15400 PyObject *result = 0 ;
15401 void *argp1 = 0 ;
15402 int res1 = 0 ;
15403 PyObject *swig_obj[1] ;
15404
15405 if (!args) SWIG_fail;
15406 swig_obj[0] = args;
15407 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15408 if (!SWIG_IsOK(res1)) {
15409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15410 }
15411 arg1 = reinterpret_cast< wxImage * >(argp1);
15412 {
15413 PyThreadState* __tstate = wxPyBeginAllowThreads();
15414 result = (PyObject *)wxImage_GetAlphaData(arg1);
15415 wxPyEndAllowThreads(__tstate);
15416 if (PyErr_Occurred()) SWIG_fail;
15417 }
15418 resultobj = result;
15419 return resultobj;
15420 fail:
15421 return NULL;
15422 }
15423
15424
15425 SWIGINTERN PyObject *_wrap_Image_SetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15426 PyObject *resultobj = 0;
15427 wxImage *arg1 = (wxImage *) 0 ;
15428 buffer arg2 ;
15429 int arg3 ;
15430 void *argp1 = 0 ;
15431 int res1 = 0 ;
15432 PyObject * obj0 = 0 ;
15433 PyObject * obj1 = 0 ;
15434 char * kwnames[] = {
15435 (char *) "self",(char *) "alpha", NULL
15436 };
15437
15438 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) SWIG_fail;
15439 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15440 if (!SWIG_IsOK(res1)) {
15441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15442 }
15443 arg1 = reinterpret_cast< wxImage * >(argp1);
15444 {
15445 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15446 }
15447 {
15448 PyThreadState* __tstate = wxPyBeginAllowThreads();
15449 wxImage_SetAlphaData(arg1,arg2,arg3);
15450 wxPyEndAllowThreads(__tstate);
15451 if (PyErr_Occurred()) SWIG_fail;
15452 }
15453 resultobj = SWIG_Py_Void();
15454 return resultobj;
15455 fail:
15456 return NULL;
15457 }
15458
15459
15460 SWIGINTERN PyObject *_wrap_Image_GetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15461 PyObject *resultobj = 0;
15462 wxImage *arg1 = (wxImage *) 0 ;
15463 PyObject *result = 0 ;
15464 void *argp1 = 0 ;
15465 int res1 = 0 ;
15466 PyObject *swig_obj[1] ;
15467
15468 if (!args) SWIG_fail;
15469 swig_obj[0] = args;
15470 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15471 if (!SWIG_IsOK(res1)) {
15472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15473 }
15474 arg1 = reinterpret_cast< wxImage * >(argp1);
15475 {
15476 PyThreadState* __tstate = wxPyBeginAllowThreads();
15477 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
15478 wxPyEndAllowThreads(__tstate);
15479 if (PyErr_Occurred()) SWIG_fail;
15480 }
15481 resultobj = result;
15482 return resultobj;
15483 fail:
15484 return NULL;
15485 }
15486
15487
15488 SWIGINTERN PyObject *_wrap_Image_SetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15489 PyObject *resultobj = 0;
15490 wxImage *arg1 = (wxImage *) 0 ;
15491 buffer arg2 ;
15492 int arg3 ;
15493 void *argp1 = 0 ;
15494 int res1 = 0 ;
15495 PyObject * obj0 = 0 ;
15496 PyObject * obj1 = 0 ;
15497 char * kwnames[] = {
15498 (char *) "self",(char *) "alpha", NULL
15499 };
15500
15501 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
15502 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15503 if (!SWIG_IsOK(res1)) {
15504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15505 }
15506 arg1 = reinterpret_cast< wxImage * >(argp1);
15507 {
15508 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15509 }
15510 {
15511 PyThreadState* __tstate = wxPyBeginAllowThreads();
15512 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
15513 wxPyEndAllowThreads(__tstate);
15514 if (PyErr_Occurred()) SWIG_fail;
15515 }
15516 resultobj = SWIG_Py_Void();
15517 return resultobj;
15518 fail:
15519 return NULL;
15520 }
15521
15522
15523 SWIGINTERN PyObject *_wrap_Image_SetMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15524 PyObject *resultobj = 0;
15525 wxImage *arg1 = (wxImage *) 0 ;
15526 byte arg2 ;
15527 byte arg3 ;
15528 byte arg4 ;
15529 void *argp1 = 0 ;
15530 int res1 = 0 ;
15531 unsigned char val2 ;
15532 int ecode2 = 0 ;
15533 unsigned char val3 ;
15534 int ecode3 = 0 ;
15535 unsigned char val4 ;
15536 int ecode4 = 0 ;
15537 PyObject * obj0 = 0 ;
15538 PyObject * obj1 = 0 ;
15539 PyObject * obj2 = 0 ;
15540 PyObject * obj3 = 0 ;
15541 char * kwnames[] = {
15542 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
15543 };
15544
15545 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15546 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15547 if (!SWIG_IsOK(res1)) {
15548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskColour" "', expected argument " "1"" of type '" "wxImage *""'");
15549 }
15550 arg1 = reinterpret_cast< wxImage * >(argp1);
15551 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15552 if (!SWIG_IsOK(ecode2)) {
15553 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMaskColour" "', expected argument " "2"" of type '" "byte""'");
15554 }
15555 arg2 = static_cast< byte >(val2);
15556 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15557 if (!SWIG_IsOK(ecode3)) {
15558 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskColour" "', expected argument " "3"" of type '" "byte""'");
15559 }
15560 arg3 = static_cast< byte >(val3);
15561 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
15562 if (!SWIG_IsOK(ecode4)) {
15563 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskColour" "', expected argument " "4"" of type '" "byte""'");
15564 }
15565 arg4 = static_cast< byte >(val4);
15566 {
15567 PyThreadState* __tstate = wxPyBeginAllowThreads();
15568 (arg1)->SetMaskColour(arg2,arg3,arg4);
15569 wxPyEndAllowThreads(__tstate);
15570 if (PyErr_Occurred()) SWIG_fail;
15571 }
15572 resultobj = SWIG_Py_Void();
15573 return resultobj;
15574 fail:
15575 return NULL;
15576 }
15577
15578
15579 SWIGINTERN PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15580 PyObject *resultobj = 0;
15581 wxImage *arg1 = (wxImage *) 0 ;
15582 byte *arg2 = (byte *) 0 ;
15583 byte *arg3 = (byte *) 0 ;
15584 byte *arg4 = (byte *) 0 ;
15585 void *argp1 = 0 ;
15586 int res1 = 0 ;
15587 byte temp2 ;
15588 int res2 = SWIG_TMPOBJ ;
15589 byte temp3 ;
15590 int res3 = SWIG_TMPOBJ ;
15591 byte temp4 ;
15592 int res4 = SWIG_TMPOBJ ;
15593 PyObject *swig_obj[1] ;
15594
15595 arg2 = &temp2;
15596 arg3 = &temp3;
15597 arg4 = &temp4;
15598 if (!args) SWIG_fail;
15599 swig_obj[0] = args;
15600 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15601 if (!SWIG_IsOK(res1)) {
15602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOrFindMaskColour" "', expected argument " "1"" of type '" "wxImage const *""'");
15603 }
15604 arg1 = reinterpret_cast< wxImage * >(argp1);
15605 {
15606 PyThreadState* __tstate = wxPyBeginAllowThreads();
15607 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
15608 wxPyEndAllowThreads(__tstate);
15609 if (PyErr_Occurred()) SWIG_fail;
15610 }
15611 resultobj = SWIG_Py_Void();
15612 if (SWIG_IsTmpObj(res2)) {
15613 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
15614 } else {
15615 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15616 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
15617 }
15618 if (SWIG_IsTmpObj(res3)) {
15619 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
15620 } else {
15621 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15622 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
15623 }
15624 if (SWIG_IsTmpObj(res4)) {
15625 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
15626 } else {
15627 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15628 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
15629 }
15630 return resultobj;
15631 fail:
15632 return NULL;
15633 }
15634
15635
15636 SWIGINTERN PyObject *_wrap_Image_GetMaskRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15637 PyObject *resultobj = 0;
15638 wxImage *arg1 = (wxImage *) 0 ;
15639 byte result;
15640 void *argp1 = 0 ;
15641 int res1 = 0 ;
15642 PyObject *swig_obj[1] ;
15643
15644 if (!args) SWIG_fail;
15645 swig_obj[0] = args;
15646 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15647 if (!SWIG_IsOK(res1)) {
15648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskRed" "', expected argument " "1"" of type '" "wxImage *""'");
15649 }
15650 arg1 = reinterpret_cast< wxImage * >(argp1);
15651 {
15652 PyThreadState* __tstate = wxPyBeginAllowThreads();
15653 result = (byte)(arg1)->GetMaskRed();
15654 wxPyEndAllowThreads(__tstate);
15655 if (PyErr_Occurred()) SWIG_fail;
15656 }
15657 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15658 return resultobj;
15659 fail:
15660 return NULL;
15661 }
15662
15663
15664 SWIGINTERN PyObject *_wrap_Image_GetMaskGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15665 PyObject *resultobj = 0;
15666 wxImage *arg1 = (wxImage *) 0 ;
15667 byte result;
15668 void *argp1 = 0 ;
15669 int res1 = 0 ;
15670 PyObject *swig_obj[1] ;
15671
15672 if (!args) SWIG_fail;
15673 swig_obj[0] = args;
15674 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15675 if (!SWIG_IsOK(res1)) {
15676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskGreen" "', expected argument " "1"" of type '" "wxImage *""'");
15677 }
15678 arg1 = reinterpret_cast< wxImage * >(argp1);
15679 {
15680 PyThreadState* __tstate = wxPyBeginAllowThreads();
15681 result = (byte)(arg1)->GetMaskGreen();
15682 wxPyEndAllowThreads(__tstate);
15683 if (PyErr_Occurred()) SWIG_fail;
15684 }
15685 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15686 return resultobj;
15687 fail:
15688 return NULL;
15689 }
15690
15691
15692 SWIGINTERN PyObject *_wrap_Image_GetMaskBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15693 PyObject *resultobj = 0;
15694 wxImage *arg1 = (wxImage *) 0 ;
15695 byte result;
15696 void *argp1 = 0 ;
15697 int res1 = 0 ;
15698 PyObject *swig_obj[1] ;
15699
15700 if (!args) SWIG_fail;
15701 swig_obj[0] = args;
15702 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15703 if (!SWIG_IsOK(res1)) {
15704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskBlue" "', expected argument " "1"" of type '" "wxImage *""'");
15705 }
15706 arg1 = reinterpret_cast< wxImage * >(argp1);
15707 {
15708 PyThreadState* __tstate = wxPyBeginAllowThreads();
15709 result = (byte)(arg1)->GetMaskBlue();
15710 wxPyEndAllowThreads(__tstate);
15711 if (PyErr_Occurred()) SWIG_fail;
15712 }
15713 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15714 return resultobj;
15715 fail:
15716 return NULL;
15717 }
15718
15719
15720 SWIGINTERN PyObject *_wrap_Image_SetMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15721 PyObject *resultobj = 0;
15722 wxImage *arg1 = (wxImage *) 0 ;
15723 bool arg2 = (bool) true ;
15724 void *argp1 = 0 ;
15725 int res1 = 0 ;
15726 bool val2 ;
15727 int ecode2 = 0 ;
15728 PyObject * obj0 = 0 ;
15729 PyObject * obj1 = 0 ;
15730 char * kwnames[] = {
15731 (char *) "self",(char *) "mask", NULL
15732 };
15733
15734 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) SWIG_fail;
15735 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15736 if (!SWIG_IsOK(res1)) {
15737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMask" "', expected argument " "1"" of type '" "wxImage *""'");
15738 }
15739 arg1 = reinterpret_cast< wxImage * >(argp1);
15740 if (obj1) {
15741 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15742 if (!SWIG_IsOK(ecode2)) {
15743 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMask" "', expected argument " "2"" of type '" "bool""'");
15744 }
15745 arg2 = static_cast< bool >(val2);
15746 }
15747 {
15748 PyThreadState* __tstate = wxPyBeginAllowThreads();
15749 (arg1)->SetMask(arg2);
15750 wxPyEndAllowThreads(__tstate);
15751 if (PyErr_Occurred()) SWIG_fail;
15752 }
15753 resultobj = SWIG_Py_Void();
15754 return resultobj;
15755 fail:
15756 return NULL;
15757 }
15758
15759
15760 SWIGINTERN PyObject *_wrap_Image_HasMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15761 PyObject *resultobj = 0;
15762 wxImage *arg1 = (wxImage *) 0 ;
15763 bool result;
15764 void *argp1 = 0 ;
15765 int res1 = 0 ;
15766 PyObject *swig_obj[1] ;
15767
15768 if (!args) SWIG_fail;
15769 swig_obj[0] = args;
15770 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15771 if (!SWIG_IsOK(res1)) {
15772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasMask" "', expected argument " "1"" of type '" "wxImage *""'");
15773 }
15774 arg1 = reinterpret_cast< wxImage * >(argp1);
15775 {
15776 PyThreadState* __tstate = wxPyBeginAllowThreads();
15777 result = (bool)(arg1)->HasMask();
15778 wxPyEndAllowThreads(__tstate);
15779 if (PyErr_Occurred()) SWIG_fail;
15780 }
15781 {
15782 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15783 }
15784 return resultobj;
15785 fail:
15786 return NULL;
15787 }
15788
15789
15790 SWIGINTERN PyObject *_wrap_Image_Rotate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15791 PyObject *resultobj = 0;
15792 wxImage *arg1 = (wxImage *) 0 ;
15793 double arg2 ;
15794 wxPoint *arg3 = 0 ;
15795 bool arg4 = (bool) true ;
15796 wxPoint *arg5 = (wxPoint *) NULL ;
15797 SwigValueWrapper<wxImage > result;
15798 void *argp1 = 0 ;
15799 int res1 = 0 ;
15800 double val2 ;
15801 int ecode2 = 0 ;
15802 wxPoint temp3 ;
15803 bool val4 ;
15804 int ecode4 = 0 ;
15805 void *argp5 = 0 ;
15806 int res5 = 0 ;
15807 PyObject * obj0 = 0 ;
15808 PyObject * obj1 = 0 ;
15809 PyObject * obj2 = 0 ;
15810 PyObject * obj3 = 0 ;
15811 PyObject * obj4 = 0 ;
15812 char * kwnames[] = {
15813 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
15814 };
15815
15816 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
15817 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15818 if (!SWIG_IsOK(res1)) {
15819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate" "', expected argument " "1"" of type '" "wxImage const *""'");
15820 }
15821 arg1 = reinterpret_cast< wxImage * >(argp1);
15822 ecode2 = SWIG_AsVal_double(obj1, &val2);
15823 if (!SWIG_IsOK(ecode2)) {
15824 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate" "', expected argument " "2"" of type '" "double""'");
15825 }
15826 arg2 = static_cast< double >(val2);
15827 {
15828 arg3 = &temp3;
15829 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
15830 }
15831 if (obj3) {
15832 ecode4 = SWIG_AsVal_bool(obj3, &val4);
15833 if (!SWIG_IsOK(ecode4)) {
15834 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rotate" "', expected argument " "4"" of type '" "bool""'");
15835 }
15836 arg4 = static_cast< bool >(val4);
15837 }
15838 if (obj4) {
15839 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxPoint, 0 | 0 );
15840 if (!SWIG_IsOK(res5)) {
15841 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Image_Rotate" "', expected argument " "5"" of type '" "wxPoint *""'");
15842 }
15843 arg5 = reinterpret_cast< wxPoint * >(argp5);
15844 }
15845 {
15846 PyThreadState* __tstate = wxPyBeginAllowThreads();
15847 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
15848 wxPyEndAllowThreads(__tstate);
15849 if (PyErr_Occurred()) SWIG_fail;
15850 }
15851 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15852 return resultobj;
15853 fail:
15854 return NULL;
15855 }
15856
15857
15858 SWIGINTERN PyObject *_wrap_Image_Rotate90(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15859 PyObject *resultobj = 0;
15860 wxImage *arg1 = (wxImage *) 0 ;
15861 bool arg2 = (bool) true ;
15862 SwigValueWrapper<wxImage > result;
15863 void *argp1 = 0 ;
15864 int res1 = 0 ;
15865 bool val2 ;
15866 int ecode2 = 0 ;
15867 PyObject * obj0 = 0 ;
15868 PyObject * obj1 = 0 ;
15869 char * kwnames[] = {
15870 (char *) "self",(char *) "clockwise", NULL
15871 };
15872
15873 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) SWIG_fail;
15874 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15875 if (!SWIG_IsOK(res1)) {
15876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate90" "', expected argument " "1"" of type '" "wxImage *""'");
15877 }
15878 arg1 = reinterpret_cast< wxImage * >(argp1);
15879 if (obj1) {
15880 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15881 if (!SWIG_IsOK(ecode2)) {
15882 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate90" "', expected argument " "2"" of type '" "bool""'");
15883 }
15884 arg2 = static_cast< bool >(val2);
15885 }
15886 {
15887 PyThreadState* __tstate = wxPyBeginAllowThreads();
15888 result = (arg1)->Rotate90(arg2);
15889 wxPyEndAllowThreads(__tstate);
15890 if (PyErr_Occurred()) SWIG_fail;
15891 }
15892 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15893 return resultobj;
15894 fail:
15895 return NULL;
15896 }
15897
15898
15899 SWIGINTERN PyObject *_wrap_Image_Mirror(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15900 PyObject *resultobj = 0;
15901 wxImage *arg1 = (wxImage *) 0 ;
15902 bool arg2 = (bool) true ;
15903 SwigValueWrapper<wxImage > result;
15904 void *argp1 = 0 ;
15905 int res1 = 0 ;
15906 bool val2 ;
15907 int ecode2 = 0 ;
15908 PyObject * obj0 = 0 ;
15909 PyObject * obj1 = 0 ;
15910 char * kwnames[] = {
15911 (char *) "self",(char *) "horizontally", NULL
15912 };
15913
15914 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) SWIG_fail;
15915 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15916 if (!SWIG_IsOK(res1)) {
15917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Mirror" "', expected argument " "1"" of type '" "wxImage *""'");
15918 }
15919 arg1 = reinterpret_cast< wxImage * >(argp1);
15920 if (obj1) {
15921 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15922 if (!SWIG_IsOK(ecode2)) {
15923 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Mirror" "', expected argument " "2"" of type '" "bool""'");
15924 }
15925 arg2 = static_cast< bool >(val2);
15926 }
15927 {
15928 PyThreadState* __tstate = wxPyBeginAllowThreads();
15929 result = (arg1)->Mirror(arg2);
15930 wxPyEndAllowThreads(__tstate);
15931 if (PyErr_Occurred()) SWIG_fail;
15932 }
15933 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15934 return resultobj;
15935 fail:
15936 return NULL;
15937 }
15938
15939
15940 SWIGINTERN PyObject *_wrap_Image_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15941 PyObject *resultobj = 0;
15942 wxImage *arg1 = (wxImage *) 0 ;
15943 byte arg2 ;
15944 byte arg3 ;
15945 byte arg4 ;
15946 byte arg5 ;
15947 byte arg6 ;
15948 byte arg7 ;
15949 void *argp1 = 0 ;
15950 int res1 = 0 ;
15951 unsigned char val2 ;
15952 int ecode2 = 0 ;
15953 unsigned char val3 ;
15954 int ecode3 = 0 ;
15955 unsigned char val4 ;
15956 int ecode4 = 0 ;
15957 unsigned char val5 ;
15958 int ecode5 = 0 ;
15959 unsigned char val6 ;
15960 int ecode6 = 0 ;
15961 unsigned char val7 ;
15962 int ecode7 = 0 ;
15963 PyObject * obj0 = 0 ;
15964 PyObject * obj1 = 0 ;
15965 PyObject * obj2 = 0 ;
15966 PyObject * obj3 = 0 ;
15967 PyObject * obj4 = 0 ;
15968 PyObject * obj5 = 0 ;
15969 PyObject * obj6 = 0 ;
15970 char * kwnames[] = {
15971 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
15972 };
15973
15974 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
15975 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15976 if (!SWIG_IsOK(res1)) {
15977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Replace" "', expected argument " "1"" of type '" "wxImage *""'");
15978 }
15979 arg1 = reinterpret_cast< wxImage * >(argp1);
15980 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15981 if (!SWIG_IsOK(ecode2)) {
15982 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Replace" "', expected argument " "2"" of type '" "byte""'");
15983 }
15984 arg2 = static_cast< byte >(val2);
15985 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15986 if (!SWIG_IsOK(ecode3)) {
15987 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Replace" "', expected argument " "3"" of type '" "byte""'");
15988 }
15989 arg3 = static_cast< byte >(val3);
15990 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
15991 if (!SWIG_IsOK(ecode4)) {
15992 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Replace" "', expected argument " "4"" of type '" "byte""'");
15993 }
15994 arg4 = static_cast< byte >(val4);
15995 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
15996 if (!SWIG_IsOK(ecode5)) {
15997 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Replace" "', expected argument " "5"" of type '" "byte""'");
15998 }
15999 arg5 = static_cast< byte >(val5);
16000 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
16001 if (!SWIG_IsOK(ecode6)) {
16002 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Replace" "', expected argument " "6"" of type '" "byte""'");
16003 }
16004 arg6 = static_cast< byte >(val6);
16005 ecode7 = SWIG_AsVal_unsigned_SS_char(obj6, &val7);
16006 if (!SWIG_IsOK(ecode7)) {
16007 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_Replace" "', expected argument " "7"" of type '" "byte""'");
16008 }
16009 arg7 = static_cast< byte >(val7);
16010 {
16011 PyThreadState* __tstate = wxPyBeginAllowThreads();
16012 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
16013 wxPyEndAllowThreads(__tstate);
16014 if (PyErr_Occurred()) SWIG_fail;
16015 }
16016 resultobj = SWIG_Py_Void();
16017 return resultobj;
16018 fail:
16019 return NULL;
16020 }
16021
16022
16023 SWIGINTERN PyObject *_wrap_Image_ConvertToGreyscale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16024 PyObject *resultobj = 0;
16025 wxImage *arg1 = (wxImage *) 0 ;
16026 double arg2 = (double) 0.299 ;
16027 double arg3 = (double) 0.587 ;
16028 double arg4 = (double) 0.114 ;
16029 SwigValueWrapper<wxImage > result;
16030 void *argp1 = 0 ;
16031 int res1 = 0 ;
16032 double val2 ;
16033 int ecode2 = 0 ;
16034 double val3 ;
16035 int ecode3 = 0 ;
16036 double val4 ;
16037 int ecode4 = 0 ;
16038 PyObject * obj0 = 0 ;
16039 PyObject * obj1 = 0 ;
16040 PyObject * obj2 = 0 ;
16041 PyObject * obj3 = 0 ;
16042 char * kwnames[] = {
16043 (char *) "self",(char *) "lr",(char *) "lg",(char *) "lb", NULL
16044 };
16045
16046 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_ConvertToGreyscale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16047 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16048 if (!SWIG_IsOK(res1)) {
16049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToGreyscale" "', expected argument " "1"" of type '" "wxImage const *""'");
16050 }
16051 arg1 = reinterpret_cast< wxImage * >(argp1);
16052 if (obj1) {
16053 ecode2 = SWIG_AsVal_double(obj1, &val2);
16054 if (!SWIG_IsOK(ecode2)) {
16055 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToGreyscale" "', expected argument " "2"" of type '" "double""'");
16056 }
16057 arg2 = static_cast< double >(val2);
16058 }
16059 if (obj2) {
16060 ecode3 = SWIG_AsVal_double(obj2, &val3);
16061 if (!SWIG_IsOK(ecode3)) {
16062 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToGreyscale" "', expected argument " "3"" of type '" "double""'");
16063 }
16064 arg3 = static_cast< double >(val3);
16065 }
16066 if (obj3) {
16067 ecode4 = SWIG_AsVal_double(obj3, &val4);
16068 if (!SWIG_IsOK(ecode4)) {
16069 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToGreyscale" "', expected argument " "4"" of type '" "double""'");
16070 }
16071 arg4 = static_cast< double >(val4);
16072 }
16073 {
16074 PyThreadState* __tstate = wxPyBeginAllowThreads();
16075 result = ((wxImage const *)arg1)->ConvertToGreyscale(arg2,arg3,arg4);
16076 wxPyEndAllowThreads(__tstate);
16077 if (PyErr_Occurred()) SWIG_fail;
16078 }
16079 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16080 return resultobj;
16081 fail:
16082 return NULL;
16083 }
16084
16085
16086 SWIGINTERN PyObject *_wrap_Image_ConvertToMono(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16087 PyObject *resultobj = 0;
16088 wxImage *arg1 = (wxImage *) 0 ;
16089 byte arg2 ;
16090 byte arg3 ;
16091 byte arg4 ;
16092 SwigValueWrapper<wxImage > result;
16093 void *argp1 = 0 ;
16094 int res1 = 0 ;
16095 unsigned char val2 ;
16096 int ecode2 = 0 ;
16097 unsigned char val3 ;
16098 int ecode3 = 0 ;
16099 unsigned char val4 ;
16100 int ecode4 = 0 ;
16101 PyObject * obj0 = 0 ;
16102 PyObject * obj1 = 0 ;
16103 PyObject * obj2 = 0 ;
16104 PyObject * obj3 = 0 ;
16105 char * kwnames[] = {
16106 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
16107 };
16108
16109 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16110 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16111 if (!SWIG_IsOK(res1)) {
16112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMono" "', expected argument " "1"" of type '" "wxImage const *""'");
16113 }
16114 arg1 = reinterpret_cast< wxImage * >(argp1);
16115 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16116 if (!SWIG_IsOK(ecode2)) {
16117 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMono" "', expected argument " "2"" of type '" "byte""'");
16118 }
16119 arg2 = static_cast< byte >(val2);
16120 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16121 if (!SWIG_IsOK(ecode3)) {
16122 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMono" "', expected argument " "3"" of type '" "byte""'");
16123 }
16124 arg3 = static_cast< byte >(val3);
16125 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16126 if (!SWIG_IsOK(ecode4)) {
16127 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMono" "', expected argument " "4"" of type '" "byte""'");
16128 }
16129 arg4 = static_cast< byte >(val4);
16130 {
16131 PyThreadState* __tstate = wxPyBeginAllowThreads();
16132 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
16133 wxPyEndAllowThreads(__tstate);
16134 if (PyErr_Occurred()) SWIG_fail;
16135 }
16136 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16137 return resultobj;
16138 fail:
16139 return NULL;
16140 }
16141
16142
16143 SWIGINTERN PyObject *_wrap_Image_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16144 PyObject *resultobj = 0;
16145 wxImage *arg1 = (wxImage *) 0 ;
16146 wxString *arg2 = 0 ;
16147 wxString *arg3 = 0 ;
16148 void *argp1 = 0 ;
16149 int res1 = 0 ;
16150 bool temp2 = false ;
16151 bool temp3 = false ;
16152 PyObject * obj0 = 0 ;
16153 PyObject * obj1 = 0 ;
16154 PyObject * obj2 = 0 ;
16155 char * kwnames[] = {
16156 (char *) "self",(char *) "name",(char *) "value", NULL
16157 };
16158
16159 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16160 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16161 if (!SWIG_IsOK(res1)) {
16162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOption" "', expected argument " "1"" of type '" "wxImage *""'");
16163 }
16164 arg1 = reinterpret_cast< wxImage * >(argp1);
16165 {
16166 arg2 = wxString_in_helper(obj1);
16167 if (arg2 == NULL) SWIG_fail;
16168 temp2 = true;
16169 }
16170 {
16171 arg3 = wxString_in_helper(obj2);
16172 if (arg3 == NULL) SWIG_fail;
16173 temp3 = true;
16174 }
16175 {
16176 PyThreadState* __tstate = wxPyBeginAllowThreads();
16177 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
16178 wxPyEndAllowThreads(__tstate);
16179 if (PyErr_Occurred()) SWIG_fail;
16180 }
16181 resultobj = SWIG_Py_Void();
16182 {
16183 if (temp2)
16184 delete arg2;
16185 }
16186 {
16187 if (temp3)
16188 delete arg3;
16189 }
16190 return resultobj;
16191 fail:
16192 {
16193 if (temp2)
16194 delete arg2;
16195 }
16196 {
16197 if (temp3)
16198 delete arg3;
16199 }
16200 return NULL;
16201 }
16202
16203
16204 SWIGINTERN PyObject *_wrap_Image_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16205 PyObject *resultobj = 0;
16206 wxImage *arg1 = (wxImage *) 0 ;
16207 wxString *arg2 = 0 ;
16208 int arg3 ;
16209 void *argp1 = 0 ;
16210 int res1 = 0 ;
16211 bool temp2 = false ;
16212 int val3 ;
16213 int ecode3 = 0 ;
16214 PyObject * obj0 = 0 ;
16215 PyObject * obj1 = 0 ;
16216 PyObject * obj2 = 0 ;
16217 char * kwnames[] = {
16218 (char *) "self",(char *) "name",(char *) "value", NULL
16219 };
16220
16221 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) 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_SetOptionInt" "', expected argument " "1"" of type '" "wxImage *""'");
16225 }
16226 arg1 = reinterpret_cast< wxImage * >(argp1);
16227 {
16228 arg2 = wxString_in_helper(obj1);
16229 if (arg2 == NULL) SWIG_fail;
16230 temp2 = true;
16231 }
16232 ecode3 = SWIG_AsVal_int(obj2, &val3);
16233 if (!SWIG_IsOK(ecode3)) {
16234 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetOptionInt" "', expected argument " "3"" of type '" "int""'");
16235 }
16236 arg3 = static_cast< int >(val3);
16237 {
16238 PyThreadState* __tstate = wxPyBeginAllowThreads();
16239 (arg1)->SetOption((wxString const &)*arg2,arg3);
16240 wxPyEndAllowThreads(__tstate);
16241 if (PyErr_Occurred()) SWIG_fail;
16242 }
16243 resultobj = SWIG_Py_Void();
16244 {
16245 if (temp2)
16246 delete arg2;
16247 }
16248 return resultobj;
16249 fail:
16250 {
16251 if (temp2)
16252 delete arg2;
16253 }
16254 return NULL;
16255 }
16256
16257
16258 SWIGINTERN PyObject *_wrap_Image_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16259 PyObject *resultobj = 0;
16260 wxImage *arg1 = (wxImage *) 0 ;
16261 wxString *arg2 = 0 ;
16262 wxString result;
16263 void *argp1 = 0 ;
16264 int res1 = 0 ;
16265 bool temp2 = false ;
16266 PyObject * obj0 = 0 ;
16267 PyObject * obj1 = 0 ;
16268 char * kwnames[] = {
16269 (char *) "self",(char *) "name", NULL
16270 };
16271
16272 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) SWIG_fail;
16273 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16274 if (!SWIG_IsOK(res1)) {
16275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16276 }
16277 arg1 = reinterpret_cast< wxImage * >(argp1);
16278 {
16279 arg2 = wxString_in_helper(obj1);
16280 if (arg2 == NULL) SWIG_fail;
16281 temp2 = true;
16282 }
16283 {
16284 PyThreadState* __tstate = wxPyBeginAllowThreads();
16285 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
16286 wxPyEndAllowThreads(__tstate);
16287 if (PyErr_Occurred()) SWIG_fail;
16288 }
16289 {
16290 #if wxUSE_UNICODE
16291 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16292 #else
16293 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16294 #endif
16295 }
16296 {
16297 if (temp2)
16298 delete arg2;
16299 }
16300 return resultobj;
16301 fail:
16302 {
16303 if (temp2)
16304 delete arg2;
16305 }
16306 return NULL;
16307 }
16308
16309
16310 SWIGINTERN PyObject *_wrap_Image_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16311 PyObject *resultobj = 0;
16312 wxImage *arg1 = (wxImage *) 0 ;
16313 wxString *arg2 = 0 ;
16314 int result;
16315 void *argp1 = 0 ;
16316 int res1 = 0 ;
16317 bool temp2 = false ;
16318 PyObject * obj0 = 0 ;
16319 PyObject * obj1 = 0 ;
16320 char * kwnames[] = {
16321 (char *) "self",(char *) "name", NULL
16322 };
16323
16324 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
16325 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16326 if (!SWIG_IsOK(res1)) {
16327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOptionInt" "', expected argument " "1"" of type '" "wxImage const *""'");
16328 }
16329 arg1 = reinterpret_cast< wxImage * >(argp1);
16330 {
16331 arg2 = wxString_in_helper(obj1);
16332 if (arg2 == NULL) SWIG_fail;
16333 temp2 = true;
16334 }
16335 {
16336 PyThreadState* __tstate = wxPyBeginAllowThreads();
16337 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
16338 wxPyEndAllowThreads(__tstate);
16339 if (PyErr_Occurred()) SWIG_fail;
16340 }
16341 resultobj = SWIG_From_int(static_cast< int >(result));
16342 {
16343 if (temp2)
16344 delete arg2;
16345 }
16346 return resultobj;
16347 fail:
16348 {
16349 if (temp2)
16350 delete arg2;
16351 }
16352 return NULL;
16353 }
16354
16355
16356 SWIGINTERN PyObject *_wrap_Image_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16357 PyObject *resultobj = 0;
16358 wxImage *arg1 = (wxImage *) 0 ;
16359 wxString *arg2 = 0 ;
16360 bool result;
16361 void *argp1 = 0 ;
16362 int res1 = 0 ;
16363 bool temp2 = false ;
16364 PyObject * obj0 = 0 ;
16365 PyObject * obj1 = 0 ;
16366 char * kwnames[] = {
16367 (char *) "self",(char *) "name", NULL
16368 };
16369
16370 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) SWIG_fail;
16371 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16372 if (!SWIG_IsOK(res1)) {
16373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16374 }
16375 arg1 = reinterpret_cast< wxImage * >(argp1);
16376 {
16377 arg2 = wxString_in_helper(obj1);
16378 if (arg2 == NULL) SWIG_fail;
16379 temp2 = true;
16380 }
16381 {
16382 PyThreadState* __tstate = wxPyBeginAllowThreads();
16383 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
16384 wxPyEndAllowThreads(__tstate);
16385 if (PyErr_Occurred()) SWIG_fail;
16386 }
16387 {
16388 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16389 }
16390 {
16391 if (temp2)
16392 delete arg2;
16393 }
16394 return resultobj;
16395 fail:
16396 {
16397 if (temp2)
16398 delete arg2;
16399 }
16400 return NULL;
16401 }
16402
16403
16404 SWIGINTERN PyObject *_wrap_Image_CountColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16405 PyObject *resultobj = 0;
16406 wxImage *arg1 = (wxImage *) 0 ;
16407 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
16408 unsigned long result;
16409 void *argp1 = 0 ;
16410 int res1 = 0 ;
16411 unsigned long val2 ;
16412 int ecode2 = 0 ;
16413 PyObject * obj0 = 0 ;
16414 PyObject * obj1 = 0 ;
16415 char * kwnames[] = {
16416 (char *) "self",(char *) "stopafter", NULL
16417 };
16418
16419 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) SWIG_fail;
16420 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16421 if (!SWIG_IsOK(res1)) {
16422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_CountColours" "', expected argument " "1"" of type '" "wxImage *""'");
16423 }
16424 arg1 = reinterpret_cast< wxImage * >(argp1);
16425 if (obj1) {
16426 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
16427 if (!SWIG_IsOK(ecode2)) {
16428 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_CountColours" "', expected argument " "2"" of type '" "unsigned long""'");
16429 }
16430 arg2 = static_cast< unsigned long >(val2);
16431 }
16432 {
16433 PyThreadState* __tstate = wxPyBeginAllowThreads();
16434 result = (unsigned long)(arg1)->CountColours(arg2);
16435 wxPyEndAllowThreads(__tstate);
16436 if (PyErr_Occurred()) SWIG_fail;
16437 }
16438 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16439 return resultobj;
16440 fail:
16441 return NULL;
16442 }
16443
16444
16445 SWIGINTERN PyObject *_wrap_Image_ComputeHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16446 PyObject *resultobj = 0;
16447 wxImage *arg1 = (wxImage *) 0 ;
16448 wxImageHistogram *arg2 = 0 ;
16449 unsigned long result;
16450 void *argp1 = 0 ;
16451 int res1 = 0 ;
16452 void *argp2 = 0 ;
16453 int res2 = 0 ;
16454 PyObject * obj0 = 0 ;
16455 PyObject * obj1 = 0 ;
16456 char * kwnames[] = {
16457 (char *) "self",(char *) "h", NULL
16458 };
16459
16460 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) SWIG_fail;
16461 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16462 if (!SWIG_IsOK(res1)) {
16463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ComputeHistogram" "', expected argument " "1"" of type '" "wxImage *""'");
16464 }
16465 arg1 = reinterpret_cast< wxImage * >(argp1);
16466 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImageHistogram, 0 );
16467 if (!SWIG_IsOK(res2)) {
16468 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16469 }
16470 if (!argp2) {
16471 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16472 }
16473 arg2 = reinterpret_cast< wxImageHistogram * >(argp2);
16474 {
16475 PyThreadState* __tstate = wxPyBeginAllowThreads();
16476 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
16477 wxPyEndAllowThreads(__tstate);
16478 if (PyErr_Occurred()) SWIG_fail;
16479 }
16480 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16481 return resultobj;
16482 fail:
16483 return NULL;
16484 }
16485
16486
16487 SWIGINTERN PyObject *_wrap_Image_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16488 PyObject *resultobj = 0;
16489 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16490 void *argp1 = 0 ;
16491 int res1 = 0 ;
16492 PyObject * obj0 = 0 ;
16493 char * kwnames[] = {
16494 (char *) "handler", NULL
16495 };
16496
16497 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) SWIG_fail;
16498 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16499 if (!SWIG_IsOK(res1)) {
16500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_AddHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16501 }
16502 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16503 {
16504 PyThreadState* __tstate = wxPyBeginAllowThreads();
16505 wxImage::AddHandler(arg1);
16506 wxPyEndAllowThreads(__tstate);
16507 if (PyErr_Occurred()) SWIG_fail;
16508 }
16509 resultobj = SWIG_Py_Void();
16510 return resultobj;
16511 fail:
16512 return NULL;
16513 }
16514
16515
16516 SWIGINTERN PyObject *_wrap_Image_InsertHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16517 PyObject *resultobj = 0;
16518 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16519 void *argp1 = 0 ;
16520 int res1 = 0 ;
16521 PyObject * obj0 = 0 ;
16522 char * kwnames[] = {
16523 (char *) "handler", NULL
16524 };
16525
16526 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) SWIG_fail;
16527 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16528 if (!SWIG_IsOK(res1)) {
16529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InsertHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16530 }
16531 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16532 {
16533 PyThreadState* __tstate = wxPyBeginAllowThreads();
16534 wxImage::InsertHandler(arg1);
16535 wxPyEndAllowThreads(__tstate);
16536 if (PyErr_Occurred()) SWIG_fail;
16537 }
16538 resultobj = SWIG_Py_Void();
16539 return resultobj;
16540 fail:
16541 return NULL;
16542 }
16543
16544
16545 SWIGINTERN PyObject *_wrap_Image_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16546 PyObject *resultobj = 0;
16547 wxString *arg1 = 0 ;
16548 bool result;
16549 bool temp1 = false ;
16550 PyObject * obj0 = 0 ;
16551 char * kwnames[] = {
16552 (char *) "name", NULL
16553 };
16554
16555 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) SWIG_fail;
16556 {
16557 arg1 = wxString_in_helper(obj0);
16558 if (arg1 == NULL) SWIG_fail;
16559 temp1 = true;
16560 }
16561 {
16562 PyThreadState* __tstate = wxPyBeginAllowThreads();
16563 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
16564 wxPyEndAllowThreads(__tstate);
16565 if (PyErr_Occurred()) SWIG_fail;
16566 }
16567 {
16568 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16569 }
16570 {
16571 if (temp1)
16572 delete arg1;
16573 }
16574 return resultobj;
16575 fail:
16576 {
16577 if (temp1)
16578 delete arg1;
16579 }
16580 return NULL;
16581 }
16582
16583
16584 SWIGINTERN PyObject *_wrap_Image_GetHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16585 PyObject *resultobj = 0;
16586 PyObject *result = 0 ;
16587
16588 if (!SWIG_Python_UnpackTuple(args,"Image_GetHandlers",0,0,0)) SWIG_fail;
16589 {
16590 PyThreadState* __tstate = wxPyBeginAllowThreads();
16591 result = (PyObject *)wxImage_GetHandlers();
16592 wxPyEndAllowThreads(__tstate);
16593 if (PyErr_Occurred()) SWIG_fail;
16594 }
16595 resultobj = result;
16596 return resultobj;
16597 fail:
16598 return NULL;
16599 }
16600
16601
16602 SWIGINTERN PyObject *_wrap_Image_GetImageExtWildcard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16603 PyObject *resultobj = 0;
16604 wxString result;
16605
16606 if (!SWIG_Python_UnpackTuple(args,"Image_GetImageExtWildcard",0,0,0)) SWIG_fail;
16607 {
16608 PyThreadState* __tstate = wxPyBeginAllowThreads();
16609 result = wxImage::GetImageExtWildcard();
16610 wxPyEndAllowThreads(__tstate);
16611 if (PyErr_Occurred()) SWIG_fail;
16612 }
16613 {
16614 #if wxUSE_UNICODE
16615 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16616 #else
16617 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16618 #endif
16619 }
16620 return resultobj;
16621 fail:
16622 return NULL;
16623 }
16624
16625
16626 SWIGINTERN PyObject *_wrap_Image_ConvertToBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16627 PyObject *resultobj = 0;
16628 wxImage *arg1 = (wxImage *) 0 ;
16629 int arg2 = (int) -1 ;
16630 wxBitmap result;
16631 void *argp1 = 0 ;
16632 int res1 = 0 ;
16633 int val2 ;
16634 int ecode2 = 0 ;
16635 PyObject * obj0 = 0 ;
16636 PyObject * obj1 = 0 ;
16637 char * kwnames[] = {
16638 (char *) "self",(char *) "depth", NULL
16639 };
16640
16641 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
16642 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16643 if (!SWIG_IsOK(res1)) {
16644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
16645 }
16646 arg1 = reinterpret_cast< wxImage * >(argp1);
16647 if (obj1) {
16648 ecode2 = SWIG_AsVal_int(obj1, &val2);
16649 if (!SWIG_IsOK(ecode2)) {
16650 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToBitmap" "', expected argument " "2"" of type '" "int""'");
16651 }
16652 arg2 = static_cast< int >(val2);
16653 }
16654 {
16655 if (!wxPyCheckForApp()) SWIG_fail;
16656 PyThreadState* __tstate = wxPyBeginAllowThreads();
16657 result = wxImage_ConvertToBitmap(arg1,arg2);
16658 wxPyEndAllowThreads(__tstate);
16659 if (PyErr_Occurred()) SWIG_fail;
16660 }
16661 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
16662 return resultobj;
16663 fail:
16664 return NULL;
16665 }
16666
16667
16668 SWIGINTERN PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16669 PyObject *resultobj = 0;
16670 wxImage *arg1 = (wxImage *) 0 ;
16671 byte arg2 ;
16672 byte arg3 ;
16673 byte arg4 ;
16674 wxBitmap result;
16675 void *argp1 = 0 ;
16676 int res1 = 0 ;
16677 unsigned char val2 ;
16678 int ecode2 = 0 ;
16679 unsigned char val3 ;
16680 int ecode3 = 0 ;
16681 unsigned char val4 ;
16682 int ecode4 = 0 ;
16683 PyObject * obj0 = 0 ;
16684 PyObject * obj1 = 0 ;
16685 PyObject * obj2 = 0 ;
16686 PyObject * obj3 = 0 ;
16687 char * kwnames[] = {
16688 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
16689 };
16690
16691 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16692 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16693 if (!SWIG_IsOK(res1)) {
16694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
16695 }
16696 arg1 = reinterpret_cast< wxImage * >(argp1);
16697 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16698 if (!SWIG_IsOK(ecode2)) {
16699 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "2"" of type '" "byte""'");
16700 }
16701 arg2 = static_cast< byte >(val2);
16702 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16703 if (!SWIG_IsOK(ecode3)) {
16704 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "3"" of type '" "byte""'");
16705 }
16706 arg3 = static_cast< byte >(val3);
16707 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16708 if (!SWIG_IsOK(ecode4)) {
16709 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "4"" of type '" "byte""'");
16710 }
16711 arg4 = static_cast< byte >(val4);
16712 {
16713 if (!wxPyCheckForApp()) SWIG_fail;
16714 PyThreadState* __tstate = wxPyBeginAllowThreads();
16715 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
16716 wxPyEndAllowThreads(__tstate);
16717 if (PyErr_Occurred()) SWIG_fail;
16718 }
16719 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
16720 return resultobj;
16721 fail:
16722 return NULL;
16723 }
16724
16725
16726 SWIGINTERN PyObject *_wrap_Image_RotateHue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16727 PyObject *resultobj = 0;
16728 wxImage *arg1 = (wxImage *) 0 ;
16729 double arg2 ;
16730 void *argp1 = 0 ;
16731 int res1 = 0 ;
16732 double val2 ;
16733 int ecode2 = 0 ;
16734 PyObject * obj0 = 0 ;
16735 PyObject * obj1 = 0 ;
16736 char * kwnames[] = {
16737 (char *) "self",(char *) "angle", NULL
16738 };
16739
16740 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RotateHue",kwnames,&obj0,&obj1)) SWIG_fail;
16741 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16742 if (!SWIG_IsOK(res1)) {
16743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RotateHue" "', expected argument " "1"" of type '" "wxImage *""'");
16744 }
16745 arg1 = reinterpret_cast< wxImage * >(argp1);
16746 ecode2 = SWIG_AsVal_double(obj1, &val2);
16747 if (!SWIG_IsOK(ecode2)) {
16748 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RotateHue" "', expected argument " "2"" of type '" "double""'");
16749 }
16750 arg2 = static_cast< double >(val2);
16751 {
16752 PyThreadState* __tstate = wxPyBeginAllowThreads();
16753 (arg1)->RotateHue(arg2);
16754 wxPyEndAllowThreads(__tstate);
16755 if (PyErr_Occurred()) SWIG_fail;
16756 }
16757 resultobj = SWIG_Py_Void();
16758 return resultobj;
16759 fail:
16760 return NULL;
16761 }
16762
16763
16764 SWIGINTERN PyObject *_wrap_Image_RGBtoHSV(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16765 PyObject *resultobj = 0;
16766 wxImage_RGBValue arg1 ;
16767 wxImage_HSVValue result;
16768 void *argp1 ;
16769 int res1 = 0 ;
16770 PyObject * obj0 = 0 ;
16771 char * kwnames[] = {
16772 (char *) "rgb", NULL
16773 };
16774
16775 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBtoHSV",kwnames,&obj0)) SWIG_fail;
16776 {
16777 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_RGBValue, 0 | 0);
16778 if (!SWIG_IsOK(res1)) {
16779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
16780 }
16781 if (!argp1) {
16782 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
16783 } else {
16784 wxImage_RGBValue * temp = reinterpret_cast< wxImage_RGBValue * >(argp1);
16785 arg1 = *temp;
16786 if (SWIG_IsNewObj(res1)) delete temp;
16787 }
16788 }
16789 {
16790 PyThreadState* __tstate = wxPyBeginAllowThreads();
16791 result = wxImage::RGBtoHSV(arg1);
16792 wxPyEndAllowThreads(__tstate);
16793 if (PyErr_Occurred()) SWIG_fail;
16794 }
16795 resultobj = SWIG_NewPointerObj((new wxImage_HSVValue(static_cast< const wxImage_HSVValue& >(result))), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_OWN | 0 );
16796 return resultobj;
16797 fail:
16798 return NULL;
16799 }
16800
16801
16802 SWIGINTERN PyObject *_wrap_Image_HSVtoRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16803 PyObject *resultobj = 0;
16804 wxImage_HSVValue arg1 ;
16805 wxImage_RGBValue result;
16806 void *argp1 ;
16807 int res1 = 0 ;
16808 PyObject * obj0 = 0 ;
16809 char * kwnames[] = {
16810 (char *) "hsv", NULL
16811 };
16812
16813 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVtoRGB",kwnames,&obj0)) SWIG_fail;
16814 {
16815 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_HSVValue, 0 | 0);
16816 if (!SWIG_IsOK(res1)) {
16817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
16818 }
16819 if (!argp1) {
16820 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
16821 } else {
16822 wxImage_HSVValue * temp = reinterpret_cast< wxImage_HSVValue * >(argp1);
16823 arg1 = *temp;
16824 if (SWIG_IsNewObj(res1)) delete temp;
16825 }
16826 }
16827 {
16828 PyThreadState* __tstate = wxPyBeginAllowThreads();
16829 result = wxImage::HSVtoRGB(arg1);
16830 wxPyEndAllowThreads(__tstate);
16831 if (PyErr_Occurred()) SWIG_fail;
16832 }
16833 resultobj = SWIG_NewPointerObj((new wxImage_RGBValue(static_cast< const wxImage_RGBValue& >(result))), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_OWN | 0 );
16834 return resultobj;
16835 fail:
16836 return NULL;
16837 }
16838
16839
16840 SWIGINTERN PyObject *Image_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16841 PyObject *obj;
16842 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16843 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage, SWIG_NewClientData(obj));
16844 return SWIG_Py_Void();
16845 }
16846
16847 SWIGINTERN PyObject *Image_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16848 return SWIG_Python_InitShadowInstance(args);
16849 }
16850
16851 SWIGINTERN int NullImage_set(PyObject *) {
16852 SWIG_Error(SWIG_AttributeError,"Variable NullImage is read-only.");
16853 return 1;
16854 }
16855
16856
16857 SWIGINTERN PyObject *NullImage_get(void) {
16858 PyObject *pyobj = 0;
16859
16860 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullImage), SWIGTYPE_p_wxImage, 0 );
16861 return pyobj;
16862 }
16863
16864
16865 SWIGINTERN int IMAGE_OPTION_FILENAME_set(PyObject *) {
16866 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
16867 return 1;
16868 }
16869
16870
16871 SWIGINTERN PyObject *IMAGE_OPTION_FILENAME_get(void) {
16872 PyObject *pyobj = 0;
16873
16874 {
16875 #if wxUSE_UNICODE
16876 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
16877 #else
16878 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
16879 #endif
16880 }
16881 return pyobj;
16882 }
16883
16884
16885 SWIGINTERN int IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
16886 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
16887 return 1;
16888 }
16889
16890
16891 SWIGINTERN PyObject *IMAGE_OPTION_BMP_FORMAT_get(void) {
16892 PyObject *pyobj = 0;
16893
16894 {
16895 #if wxUSE_UNICODE
16896 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
16897 #else
16898 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
16899 #endif
16900 }
16901 return pyobj;
16902 }
16903
16904
16905 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
16906 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
16907 return 1;
16908 }
16909
16910
16911 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
16912 PyObject *pyobj = 0;
16913
16914 {
16915 #if wxUSE_UNICODE
16916 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
16917 #else
16918 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
16919 #endif
16920 }
16921 return pyobj;
16922 }
16923
16924
16925 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
16926 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
16927 return 1;
16928 }
16929
16930
16931 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
16932 PyObject *pyobj = 0;
16933
16934 {
16935 #if wxUSE_UNICODE
16936 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
16937 #else
16938 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
16939 #endif
16940 }
16941 return pyobj;
16942 }
16943
16944
16945 SWIGINTERN int IMAGE_OPTION_RESOLUTION_set(PyObject *) {
16946 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
16947 return 1;
16948 }
16949
16950
16951 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTION_get(void) {
16952 PyObject *pyobj = 0;
16953
16954 {
16955 #if wxUSE_UNICODE
16956 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
16957 #else
16958 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
16959 #endif
16960 }
16961 return pyobj;
16962 }
16963
16964
16965 SWIGINTERN int IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
16966 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
16967 return 1;
16968 }
16969
16970
16971 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONX_get(void) {
16972 PyObject *pyobj = 0;
16973
16974 {
16975 #if wxUSE_UNICODE
16976 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
16977 #else
16978 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
16979 #endif
16980 }
16981 return pyobj;
16982 }
16983
16984
16985 SWIGINTERN int IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
16986 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
16987 return 1;
16988 }
16989
16990
16991 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONY_get(void) {
16992 PyObject *pyobj = 0;
16993
16994 {
16995 #if wxUSE_UNICODE
16996 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
16997 #else
16998 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
16999 #endif
17000 }
17001 return pyobj;
17002 }
17003
17004
17005 SWIGINTERN int IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
17006 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
17007 return 1;
17008 }
17009
17010
17011 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
17012 PyObject *pyobj = 0;
17013
17014 {
17015 #if wxUSE_UNICODE
17016 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17017 #else
17018 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17019 #endif
17020 }
17021 return pyobj;
17022 }
17023
17024
17025 SWIGINTERN int IMAGE_OPTION_QUALITY_set(PyObject *) {
17026 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
17027 return 1;
17028 }
17029
17030
17031 SWIGINTERN PyObject *IMAGE_OPTION_QUALITY_get(void) {
17032 PyObject *pyobj = 0;
17033
17034 {
17035 #if wxUSE_UNICODE
17036 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17037 #else
17038 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17039 #endif
17040 }
17041 return pyobj;
17042 }
17043
17044
17045 SWIGINTERN int IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
17046 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
17047 return 1;
17048 }
17049
17050
17051 SWIGINTERN PyObject *IMAGE_OPTION_BITSPERSAMPLE_get(void) {
17052 PyObject *pyobj = 0;
17053
17054 {
17055 #if wxUSE_UNICODE
17056 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17057 #else
17058 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17059 #endif
17060 }
17061 return pyobj;
17062 }
17063
17064
17065 SWIGINTERN int IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
17066 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
17067 return 1;
17068 }
17069
17070
17071 SWIGINTERN PyObject *IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
17072 PyObject *pyobj = 0;
17073
17074 {
17075 #if wxUSE_UNICODE
17076 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17077 #else
17078 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17079 #endif
17080 }
17081 return pyobj;
17082 }
17083
17084
17085 SWIGINTERN int IMAGE_OPTION_COMPRESSION_set(PyObject *) {
17086 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
17087 return 1;
17088 }
17089
17090
17091 SWIGINTERN PyObject *IMAGE_OPTION_COMPRESSION_get(void) {
17092 PyObject *pyobj = 0;
17093
17094 {
17095 #if wxUSE_UNICODE
17096 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17097 #else
17098 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17099 #endif
17100 }
17101 return pyobj;
17102 }
17103
17104
17105 SWIGINTERN int IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
17106 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
17107 return 1;
17108 }
17109
17110
17111 SWIGINTERN PyObject *IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
17112 PyObject *pyobj = 0;
17113
17114 {
17115 #if wxUSE_UNICODE
17116 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17117 #else
17118 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17119 #endif
17120 }
17121 return pyobj;
17122 }
17123
17124
17125 SWIGINTERN int IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
17126 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
17127 return 1;
17128 }
17129
17130
17131 SWIGINTERN PyObject *IMAGE_OPTION_PNG_FORMAT_get(void) {
17132 PyObject *pyobj = 0;
17133
17134 {
17135 #if wxUSE_UNICODE
17136 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17137 #else
17138 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17139 #endif
17140 }
17141 return pyobj;
17142 }
17143
17144
17145 SWIGINTERN int IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
17146 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
17147 return 1;
17148 }
17149
17150
17151 SWIGINTERN PyObject *IMAGE_OPTION_PNG_BITDEPTH_get(void) {
17152 PyObject *pyobj = 0;
17153
17154 {
17155 #if wxUSE_UNICODE
17156 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17157 #else
17158 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17159 #endif
17160 }
17161 return pyobj;
17162 }
17163
17164
17165 SWIGINTERN PyObject *_wrap_new_BMPHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17166 PyObject *resultobj = 0;
17167 wxBMPHandler *result = 0 ;
17168
17169 if (!SWIG_Python_UnpackTuple(args,"new_BMPHandler",0,0,0)) SWIG_fail;
17170 {
17171 PyThreadState* __tstate = wxPyBeginAllowThreads();
17172 result = (wxBMPHandler *)new wxBMPHandler();
17173 wxPyEndAllowThreads(__tstate);
17174 if (PyErr_Occurred()) SWIG_fail;
17175 }
17176 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBMPHandler, SWIG_POINTER_NEW | 0 );
17177 return resultobj;
17178 fail:
17179 return NULL;
17180 }
17181
17182
17183 SWIGINTERN PyObject *BMPHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17184 PyObject *obj;
17185 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17186 SWIG_TypeNewClientData(SWIGTYPE_p_wxBMPHandler, SWIG_NewClientData(obj));
17187 return SWIG_Py_Void();
17188 }
17189
17190 SWIGINTERN PyObject *BMPHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17191 return SWIG_Python_InitShadowInstance(args);
17192 }
17193
17194 SWIGINTERN PyObject *_wrap_new_ICOHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17195 PyObject *resultobj = 0;
17196 wxICOHandler *result = 0 ;
17197
17198 if (!SWIG_Python_UnpackTuple(args,"new_ICOHandler",0,0,0)) SWIG_fail;
17199 {
17200 PyThreadState* __tstate = wxPyBeginAllowThreads();
17201 result = (wxICOHandler *)new wxICOHandler();
17202 wxPyEndAllowThreads(__tstate);
17203 if (PyErr_Occurred()) SWIG_fail;
17204 }
17205 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxICOHandler, SWIG_POINTER_NEW | 0 );
17206 return resultobj;
17207 fail:
17208 return NULL;
17209 }
17210
17211
17212 SWIGINTERN PyObject *ICOHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17213 PyObject *obj;
17214 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17215 SWIG_TypeNewClientData(SWIGTYPE_p_wxICOHandler, SWIG_NewClientData(obj));
17216 return SWIG_Py_Void();
17217 }
17218
17219 SWIGINTERN PyObject *ICOHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17220 return SWIG_Python_InitShadowInstance(args);
17221 }
17222
17223 SWIGINTERN PyObject *_wrap_new_CURHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17224 PyObject *resultobj = 0;
17225 wxCURHandler *result = 0 ;
17226
17227 if (!SWIG_Python_UnpackTuple(args,"new_CURHandler",0,0,0)) SWIG_fail;
17228 {
17229 PyThreadState* __tstate = wxPyBeginAllowThreads();
17230 result = (wxCURHandler *)new wxCURHandler();
17231 wxPyEndAllowThreads(__tstate);
17232 if (PyErr_Occurred()) SWIG_fail;
17233 }
17234 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCURHandler, SWIG_POINTER_NEW | 0 );
17235 return resultobj;
17236 fail:
17237 return NULL;
17238 }
17239
17240
17241 SWIGINTERN PyObject *CURHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17242 PyObject *obj;
17243 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17244 SWIG_TypeNewClientData(SWIGTYPE_p_wxCURHandler, SWIG_NewClientData(obj));
17245 return SWIG_Py_Void();
17246 }
17247
17248 SWIGINTERN PyObject *CURHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17249 return SWIG_Python_InitShadowInstance(args);
17250 }
17251
17252 SWIGINTERN PyObject *_wrap_new_ANIHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17253 PyObject *resultobj = 0;
17254 wxANIHandler *result = 0 ;
17255
17256 if (!SWIG_Python_UnpackTuple(args,"new_ANIHandler",0,0,0)) SWIG_fail;
17257 {
17258 PyThreadState* __tstate = wxPyBeginAllowThreads();
17259 result = (wxANIHandler *)new wxANIHandler();
17260 wxPyEndAllowThreads(__tstate);
17261 if (PyErr_Occurred()) SWIG_fail;
17262 }
17263 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxANIHandler, SWIG_POINTER_NEW | 0 );
17264 return resultobj;
17265 fail:
17266 return NULL;
17267 }
17268
17269
17270 SWIGINTERN PyObject *ANIHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17271 PyObject *obj;
17272 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17273 SWIG_TypeNewClientData(SWIGTYPE_p_wxANIHandler, SWIG_NewClientData(obj));
17274 return SWIG_Py_Void();
17275 }
17276
17277 SWIGINTERN PyObject *ANIHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17278 return SWIG_Python_InitShadowInstance(args);
17279 }
17280
17281 SWIGINTERN PyObject *_wrap_new_PNGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17282 PyObject *resultobj = 0;
17283 wxPNGHandler *result = 0 ;
17284
17285 if (!SWIG_Python_UnpackTuple(args,"new_PNGHandler",0,0,0)) SWIG_fail;
17286 {
17287 PyThreadState* __tstate = wxPyBeginAllowThreads();
17288 result = (wxPNGHandler *)new wxPNGHandler();
17289 wxPyEndAllowThreads(__tstate);
17290 if (PyErr_Occurred()) SWIG_fail;
17291 }
17292 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNGHandler, SWIG_POINTER_NEW | 0 );
17293 return resultobj;
17294 fail:
17295 return NULL;
17296 }
17297
17298
17299 SWIGINTERN PyObject *PNGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17300 PyObject *obj;
17301 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17302 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNGHandler, SWIG_NewClientData(obj));
17303 return SWIG_Py_Void();
17304 }
17305
17306 SWIGINTERN PyObject *PNGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17307 return SWIG_Python_InitShadowInstance(args);
17308 }
17309
17310 SWIGINTERN PyObject *_wrap_new_GIFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17311 PyObject *resultobj = 0;
17312 wxGIFHandler *result = 0 ;
17313
17314 if (!SWIG_Python_UnpackTuple(args,"new_GIFHandler",0,0,0)) SWIG_fail;
17315 {
17316 PyThreadState* __tstate = wxPyBeginAllowThreads();
17317 result = (wxGIFHandler *)new wxGIFHandler();
17318 wxPyEndAllowThreads(__tstate);
17319 if (PyErr_Occurred()) SWIG_fail;
17320 }
17321 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGIFHandler, SWIG_POINTER_NEW | 0 );
17322 return resultobj;
17323 fail:
17324 return NULL;
17325 }
17326
17327
17328 SWIGINTERN PyObject *GIFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17329 PyObject *obj;
17330 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17331 SWIG_TypeNewClientData(SWIGTYPE_p_wxGIFHandler, SWIG_NewClientData(obj));
17332 return SWIG_Py_Void();
17333 }
17334
17335 SWIGINTERN PyObject *GIFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17336 return SWIG_Python_InitShadowInstance(args);
17337 }
17338
17339 SWIGINTERN PyObject *_wrap_new_PCXHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17340 PyObject *resultobj = 0;
17341 wxPCXHandler *result = 0 ;
17342
17343 if (!SWIG_Python_UnpackTuple(args,"new_PCXHandler",0,0,0)) SWIG_fail;
17344 {
17345 PyThreadState* __tstate = wxPyBeginAllowThreads();
17346 result = (wxPCXHandler *)new wxPCXHandler();
17347 wxPyEndAllowThreads(__tstate);
17348 if (PyErr_Occurred()) SWIG_fail;
17349 }
17350 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPCXHandler, SWIG_POINTER_NEW | 0 );
17351 return resultobj;
17352 fail:
17353 return NULL;
17354 }
17355
17356
17357 SWIGINTERN PyObject *PCXHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17358 PyObject *obj;
17359 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17360 SWIG_TypeNewClientData(SWIGTYPE_p_wxPCXHandler, SWIG_NewClientData(obj));
17361 return SWIG_Py_Void();
17362 }
17363
17364 SWIGINTERN PyObject *PCXHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17365 return SWIG_Python_InitShadowInstance(args);
17366 }
17367
17368 SWIGINTERN PyObject *_wrap_new_JPEGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17369 PyObject *resultobj = 0;
17370 wxJPEGHandler *result = 0 ;
17371
17372 if (!SWIG_Python_UnpackTuple(args,"new_JPEGHandler",0,0,0)) SWIG_fail;
17373 {
17374 PyThreadState* __tstate = wxPyBeginAllowThreads();
17375 result = (wxJPEGHandler *)new wxJPEGHandler();
17376 wxPyEndAllowThreads(__tstate);
17377 if (PyErr_Occurred()) SWIG_fail;
17378 }
17379 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJPEGHandler, SWIG_POINTER_NEW | 0 );
17380 return resultobj;
17381 fail:
17382 return NULL;
17383 }
17384
17385
17386 SWIGINTERN PyObject *JPEGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17387 PyObject *obj;
17388 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17389 SWIG_TypeNewClientData(SWIGTYPE_p_wxJPEGHandler, SWIG_NewClientData(obj));
17390 return SWIG_Py_Void();
17391 }
17392
17393 SWIGINTERN PyObject *JPEGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17394 return SWIG_Python_InitShadowInstance(args);
17395 }
17396
17397 SWIGINTERN PyObject *_wrap_new_PNMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17398 PyObject *resultobj = 0;
17399 wxPNMHandler *result = 0 ;
17400
17401 if (!SWIG_Python_UnpackTuple(args,"new_PNMHandler",0,0,0)) SWIG_fail;
17402 {
17403 PyThreadState* __tstate = wxPyBeginAllowThreads();
17404 result = (wxPNMHandler *)new wxPNMHandler();
17405 wxPyEndAllowThreads(__tstate);
17406 if (PyErr_Occurred()) SWIG_fail;
17407 }
17408 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNMHandler, SWIG_POINTER_NEW | 0 );
17409 return resultobj;
17410 fail:
17411 return NULL;
17412 }
17413
17414
17415 SWIGINTERN PyObject *PNMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17416 PyObject *obj;
17417 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17418 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNMHandler, SWIG_NewClientData(obj));
17419 return SWIG_Py_Void();
17420 }
17421
17422 SWIGINTERN PyObject *PNMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17423 return SWIG_Python_InitShadowInstance(args);
17424 }
17425
17426 SWIGINTERN PyObject *_wrap_new_XPMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17427 PyObject *resultobj = 0;
17428 wxXPMHandler *result = 0 ;
17429
17430 if (!SWIG_Python_UnpackTuple(args,"new_XPMHandler",0,0,0)) SWIG_fail;
17431 {
17432 PyThreadState* __tstate = wxPyBeginAllowThreads();
17433 result = (wxXPMHandler *)new wxXPMHandler();
17434 wxPyEndAllowThreads(__tstate);
17435 if (PyErr_Occurred()) SWIG_fail;
17436 }
17437 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXPMHandler, SWIG_POINTER_NEW | 0 );
17438 return resultobj;
17439 fail:
17440 return NULL;
17441 }
17442
17443
17444 SWIGINTERN PyObject *XPMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17445 PyObject *obj;
17446 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17447 SWIG_TypeNewClientData(SWIGTYPE_p_wxXPMHandler, SWIG_NewClientData(obj));
17448 return SWIG_Py_Void();
17449 }
17450
17451 SWIGINTERN PyObject *XPMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17452 return SWIG_Python_InitShadowInstance(args);
17453 }
17454
17455 SWIGINTERN PyObject *_wrap_new_TIFFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17456 PyObject *resultobj = 0;
17457 wxTIFFHandler *result = 0 ;
17458
17459 if (!SWIG_Python_UnpackTuple(args,"new_TIFFHandler",0,0,0)) SWIG_fail;
17460 {
17461 PyThreadState* __tstate = wxPyBeginAllowThreads();
17462 result = (wxTIFFHandler *)new wxTIFFHandler();
17463 wxPyEndAllowThreads(__tstate);
17464 if (PyErr_Occurred()) SWIG_fail;
17465 }
17466 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTIFFHandler, SWIG_POINTER_NEW | 0 );
17467 return resultobj;
17468 fail:
17469 return NULL;
17470 }
17471
17472
17473 SWIGINTERN PyObject *TIFFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17474 PyObject *obj;
17475 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17476 SWIG_TypeNewClientData(SWIGTYPE_p_wxTIFFHandler, SWIG_NewClientData(obj));
17477 return SWIG_Py_Void();
17478 }
17479
17480 SWIGINTERN PyObject *TIFFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17481 return SWIG_Python_InitShadowInstance(args);
17482 }
17483
17484 SWIGINTERN PyObject *_wrap_Quantize_Quantize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17485 PyObject *resultobj = 0;
17486 wxImage *arg1 = 0 ;
17487 wxImage *arg2 = 0 ;
17488 int arg3 = (int) 236 ;
17489 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
17490 bool result;
17491 void *argp1 = 0 ;
17492 int res1 = 0 ;
17493 void *argp2 = 0 ;
17494 int res2 = 0 ;
17495 int val3 ;
17496 int ecode3 = 0 ;
17497 int val4 ;
17498 int ecode4 = 0 ;
17499 PyObject * obj0 = 0 ;
17500 PyObject * obj1 = 0 ;
17501 PyObject * obj2 = 0 ;
17502 PyObject * obj3 = 0 ;
17503 char * kwnames[] = {
17504 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
17505 };
17506
17507 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17508 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage, 0 | 0);
17509 if (!SWIG_IsOK(res1)) {
17510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17511 }
17512 if (!argp1) {
17513 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17514 }
17515 arg1 = reinterpret_cast< wxImage * >(argp1);
17516 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
17517 if (!SWIG_IsOK(res2)) {
17518 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17519 }
17520 if (!argp2) {
17521 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17522 }
17523 arg2 = reinterpret_cast< wxImage * >(argp2);
17524 if (obj2) {
17525 ecode3 = SWIG_AsVal_int(obj2, &val3);
17526 if (!SWIG_IsOK(ecode3)) {
17527 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Quantize_Quantize" "', expected argument " "3"" of type '" "int""'");
17528 }
17529 arg3 = static_cast< int >(val3);
17530 }
17531 if (obj3) {
17532 ecode4 = SWIG_AsVal_int(obj3, &val4);
17533 if (!SWIG_IsOK(ecode4)) {
17534 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Quantize_Quantize" "', expected argument " "4"" of type '" "int""'");
17535 }
17536 arg4 = static_cast< int >(val4);
17537 }
17538 {
17539 PyThreadState* __tstate = wxPyBeginAllowThreads();
17540 result = (bool)wxQuantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
17541 wxPyEndAllowThreads(__tstate);
17542 if (PyErr_Occurred()) SWIG_fail;
17543 }
17544 {
17545 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17546 }
17547 return resultobj;
17548 fail:
17549 return NULL;
17550 }
17551
17552
17553 SWIGINTERN PyObject *Quantize_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17554 PyObject *obj;
17555 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17556 SWIG_TypeNewClientData(SWIGTYPE_p_wxQuantize, SWIG_NewClientData(obj));
17557 return SWIG_Py_Void();
17558 }
17559
17560 SWIGINTERN PyObject *_wrap_new_EvtHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17561 PyObject *resultobj = 0;
17562 wxEvtHandler *result = 0 ;
17563
17564 if (!SWIG_Python_UnpackTuple(args,"new_EvtHandler",0,0,0)) SWIG_fail;
17565 {
17566 PyThreadState* __tstate = wxPyBeginAllowThreads();
17567 result = (wxEvtHandler *)new wxEvtHandler();
17568 wxPyEndAllowThreads(__tstate);
17569 if (PyErr_Occurred()) SWIG_fail;
17570 }
17571 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_NEW | 0 );
17572 return resultobj;
17573 fail:
17574 return NULL;
17575 }
17576
17577
17578 SWIGINTERN PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17579 PyObject *resultobj = 0;
17580 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17581 wxEvtHandler *result = 0 ;
17582 void *argp1 = 0 ;
17583 int res1 = 0 ;
17584 PyObject *swig_obj[1] ;
17585
17586 if (!args) SWIG_fail;
17587 swig_obj[0] = args;
17588 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17589 if (!SWIG_IsOK(res1)) {
17590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17591 }
17592 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17593 {
17594 PyThreadState* __tstate = wxPyBeginAllowThreads();
17595 result = (wxEvtHandler *)(arg1)->GetNextHandler();
17596 wxPyEndAllowThreads(__tstate);
17597 if (PyErr_Occurred()) SWIG_fail;
17598 }
17599 {
17600 resultobj = wxPyMake_wxObject(result, 0);
17601 }
17602 return resultobj;
17603 fail:
17604 return NULL;
17605 }
17606
17607
17608 SWIGINTERN PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17609 PyObject *resultobj = 0;
17610 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17611 wxEvtHandler *result = 0 ;
17612 void *argp1 = 0 ;
17613 int res1 = 0 ;
17614 PyObject *swig_obj[1] ;
17615
17616 if (!args) SWIG_fail;
17617 swig_obj[0] = args;
17618 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17619 if (!SWIG_IsOK(res1)) {
17620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17621 }
17622 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17623 {
17624 PyThreadState* __tstate = wxPyBeginAllowThreads();
17625 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
17626 wxPyEndAllowThreads(__tstate);
17627 if (PyErr_Occurred()) SWIG_fail;
17628 }
17629 {
17630 resultobj = wxPyMake_wxObject(result, 0);
17631 }
17632 return resultobj;
17633 fail:
17634 return NULL;
17635 }
17636
17637
17638 SWIGINTERN PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17639 PyObject *resultobj = 0;
17640 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17641 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
17642 void *argp1 = 0 ;
17643 int res1 = 0 ;
17644 void *argp2 = 0 ;
17645 int res2 = 0 ;
17646 PyObject * obj0 = 0 ;
17647 PyObject * obj1 = 0 ;
17648 char * kwnames[] = {
17649 (char *) "self",(char *) "handler", NULL
17650 };
17651
17652 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) SWIG_fail;
17653 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17654 if (!SWIG_IsOK(res1)) {
17655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17656 }
17657 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17658 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17659 if (!SWIG_IsOK(res2)) {
17660 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
17661 }
17662 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
17663 {
17664 PyThreadState* __tstate = wxPyBeginAllowThreads();
17665 (arg1)->SetNextHandler(arg2);
17666 wxPyEndAllowThreads(__tstate);
17667 if (PyErr_Occurred()) SWIG_fail;
17668 }
17669 resultobj = SWIG_Py_Void();
17670 return resultobj;
17671 fail:
17672 return NULL;
17673 }
17674
17675
17676 SWIGINTERN PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17677 PyObject *resultobj = 0;
17678 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17679 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
17680 void *argp1 = 0 ;
17681 int res1 = 0 ;
17682 void *argp2 = 0 ;
17683 int res2 = 0 ;
17684 PyObject * obj0 = 0 ;
17685 PyObject * obj1 = 0 ;
17686 char * kwnames[] = {
17687 (char *) "self",(char *) "handler", NULL
17688 };
17689
17690 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) SWIG_fail;
17691 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17692 if (!SWIG_IsOK(res1)) {
17693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17694 }
17695 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17696 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17697 if (!SWIG_IsOK(res2)) {
17698 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
17699 }
17700 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
17701 {
17702 PyThreadState* __tstate = wxPyBeginAllowThreads();
17703 (arg1)->SetPreviousHandler(arg2);
17704 wxPyEndAllowThreads(__tstate);
17705 if (PyErr_Occurred()) SWIG_fail;
17706 }
17707 resultobj = SWIG_Py_Void();
17708 return resultobj;
17709 fail:
17710 return NULL;
17711 }
17712
17713
17714 SWIGINTERN PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17715 PyObject *resultobj = 0;
17716 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17717 bool result;
17718 void *argp1 = 0 ;
17719 int res1 = 0 ;
17720 PyObject *swig_obj[1] ;
17721
17722 if (!args) SWIG_fail;
17723 swig_obj[0] = args;
17724 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17725 if (!SWIG_IsOK(res1)) {
17726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17727 }
17728 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17729 {
17730 PyThreadState* __tstate = wxPyBeginAllowThreads();
17731 result = (bool)(arg1)->GetEvtHandlerEnabled();
17732 wxPyEndAllowThreads(__tstate);
17733 if (PyErr_Occurred()) SWIG_fail;
17734 }
17735 {
17736 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17737 }
17738 return resultobj;
17739 fail:
17740 return NULL;
17741 }
17742
17743
17744 SWIGINTERN PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17745 PyObject *resultobj = 0;
17746 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17747 bool arg2 ;
17748 void *argp1 = 0 ;
17749 int res1 = 0 ;
17750 bool val2 ;
17751 int ecode2 = 0 ;
17752 PyObject * obj0 = 0 ;
17753 PyObject * obj1 = 0 ;
17754 char * kwnames[] = {
17755 (char *) "self",(char *) "enabled", NULL
17756 };
17757
17758 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
17759 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17760 if (!SWIG_IsOK(res1)) {
17761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17762 }
17763 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17764 ecode2 = SWIG_AsVal_bool(obj1, &val2);
17765 if (!SWIG_IsOK(ecode2)) {
17766 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "2"" of type '" "bool""'");
17767 }
17768 arg2 = static_cast< bool >(val2);
17769 {
17770 PyThreadState* __tstate = wxPyBeginAllowThreads();
17771 (arg1)->SetEvtHandlerEnabled(arg2);
17772 wxPyEndAllowThreads(__tstate);
17773 if (PyErr_Occurred()) SWIG_fail;
17774 }
17775 resultobj = SWIG_Py_Void();
17776 return resultobj;
17777 fail:
17778 return NULL;
17779 }
17780
17781
17782 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17783 PyObject *resultobj = 0;
17784 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17785 wxEvent *arg2 = 0 ;
17786 bool result;
17787 void *argp1 = 0 ;
17788 int res1 = 0 ;
17789 void *argp2 = 0 ;
17790 int res2 = 0 ;
17791 PyObject * obj0 = 0 ;
17792 PyObject * obj1 = 0 ;
17793 char * kwnames[] = {
17794 (char *) "self",(char *) "event", NULL
17795 };
17796
17797 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) SWIG_fail;
17798 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17799 if (!SWIG_IsOK(res1)) {
17800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17801 }
17802 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17803 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
17804 if (!SWIG_IsOK(res2)) {
17805 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17806 }
17807 if (!argp2) {
17808 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17809 }
17810 arg2 = reinterpret_cast< wxEvent * >(argp2);
17811 {
17812 PyThreadState* __tstate = wxPyBeginAllowThreads();
17813 result = (bool)(arg1)->ProcessEvent(*arg2);
17814 wxPyEndAllowThreads(__tstate);
17815 if (PyErr_Occurred()) SWIG_fail;
17816 }
17817 {
17818 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17819 }
17820 return resultobj;
17821 fail:
17822 return NULL;
17823 }
17824
17825
17826 SWIGINTERN PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17827 PyObject *resultobj = 0;
17828 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17829 wxEvent *arg2 = 0 ;
17830 void *argp1 = 0 ;
17831 int res1 = 0 ;
17832 void *argp2 = 0 ;
17833 int res2 = 0 ;
17834 PyObject * obj0 = 0 ;
17835 PyObject * obj1 = 0 ;
17836 char * kwnames[] = {
17837 (char *) "self",(char *) "event", NULL
17838 };
17839
17840 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) SWIG_fail;
17841 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17842 if (!SWIG_IsOK(res1)) {
17843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17844 }
17845 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17846 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
17847 if (!SWIG_IsOK(res2)) {
17848 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17849 }
17850 if (!argp2) {
17851 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17852 }
17853 arg2 = reinterpret_cast< wxEvent * >(argp2);
17854 {
17855 PyThreadState* __tstate = wxPyBeginAllowThreads();
17856 (arg1)->AddPendingEvent(*arg2);
17857 wxPyEndAllowThreads(__tstate);
17858 if (PyErr_Occurred()) SWIG_fail;
17859 }
17860 resultobj = SWIG_Py_Void();
17861 return resultobj;
17862 fail:
17863 return NULL;
17864 }
17865
17866
17867 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17868 PyObject *resultobj = 0;
17869 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17870 void *argp1 = 0 ;
17871 int res1 = 0 ;
17872 PyObject *swig_obj[1] ;
17873
17874 if (!args) SWIG_fail;
17875 swig_obj[0] = args;
17876 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17877 if (!SWIG_IsOK(res1)) {
17878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17879 }
17880 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17881 {
17882 PyThreadState* __tstate = wxPyBeginAllowThreads();
17883 (arg1)->ProcessPendingEvents();
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_Connect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17895 PyObject *resultobj = 0;
17896 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17897 int arg2 ;
17898 int arg3 ;
17899 int arg4 ;
17900 PyObject *arg5 = (PyObject *) 0 ;
17901 void *argp1 = 0 ;
17902 int res1 = 0 ;
17903 int val2 ;
17904 int ecode2 = 0 ;
17905 int val3 ;
17906 int ecode3 = 0 ;
17907 int val4 ;
17908 int ecode4 = 0 ;
17909 PyObject * obj0 = 0 ;
17910 PyObject * obj1 = 0 ;
17911 PyObject * obj2 = 0 ;
17912 PyObject * obj3 = 0 ;
17913 PyObject * obj4 = 0 ;
17914 char * kwnames[] = {
17915 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
17916 };
17917
17918 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
17919 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17920 if (!SWIG_IsOK(res1)) {
17921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Connect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17922 }
17923 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17924 ecode2 = SWIG_AsVal_int(obj1, &val2);
17925 if (!SWIG_IsOK(ecode2)) {
17926 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Connect" "', expected argument " "2"" of type '" "int""'");
17927 }
17928 arg2 = static_cast< int >(val2);
17929 ecode3 = SWIG_AsVal_int(obj2, &val3);
17930 if (!SWIG_IsOK(ecode3)) {
17931 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Connect" "', expected argument " "3"" of type '" "int""'");
17932 }
17933 arg3 = static_cast< int >(val3);
17934 ecode4 = SWIG_AsVal_int(obj3, &val4);
17935 if (!SWIG_IsOK(ecode4)) {
17936 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Connect" "', expected argument " "4"" of type '" "int""'");
17937 }
17938 arg4 = static_cast< int >(val4);
17939 arg5 = obj4;
17940 {
17941 PyThreadState* __tstate = wxPyBeginAllowThreads();
17942 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
17943 wxPyEndAllowThreads(__tstate);
17944 if (PyErr_Occurred()) SWIG_fail;
17945 }
17946 resultobj = SWIG_Py_Void();
17947 return resultobj;
17948 fail:
17949 return NULL;
17950 }
17951
17952
17953 SWIGINTERN PyObject *_wrap_EvtHandler_Disconnect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17954 PyObject *resultobj = 0;
17955 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17956 int arg2 ;
17957 int arg3 = (int) -1 ;
17958 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
17959 bool result;
17960 void *argp1 = 0 ;
17961 int res1 = 0 ;
17962 int val2 ;
17963 int ecode2 = 0 ;
17964 int val3 ;
17965 int ecode3 = 0 ;
17966 int val4 ;
17967 int ecode4 = 0 ;
17968 PyObject * obj0 = 0 ;
17969 PyObject * obj1 = 0 ;
17970 PyObject * obj2 = 0 ;
17971 PyObject * obj3 = 0 ;
17972 char * kwnames[] = {
17973 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
17974 };
17975
17976 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17977 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17978 if (!SWIG_IsOK(res1)) {
17979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Disconnect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17980 }
17981 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17982 ecode2 = SWIG_AsVal_int(obj1, &val2);
17983 if (!SWIG_IsOK(ecode2)) {
17984 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Disconnect" "', expected argument " "2"" of type '" "int""'");
17985 }
17986 arg2 = static_cast< int >(val2);
17987 if (obj2) {
17988 ecode3 = SWIG_AsVal_int(obj2, &val3);
17989 if (!SWIG_IsOK(ecode3)) {
17990 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Disconnect" "', expected argument " "3"" of type '" "int""'");
17991 }
17992 arg3 = static_cast< int >(val3);
17993 }
17994 if (obj3) {
17995 ecode4 = SWIG_AsVal_int(obj3, &val4);
17996 if (!SWIG_IsOK(ecode4)) {
17997 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Disconnect" "', expected argument " "4"" of type '" "wxEventType""'");
17998 }
17999 arg4 = static_cast< wxEventType >(val4);
18000 }
18001 {
18002 PyThreadState* __tstate = wxPyBeginAllowThreads();
18003 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
18004 wxPyEndAllowThreads(__tstate);
18005 if (PyErr_Occurred()) SWIG_fail;
18006 }
18007 {
18008 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18009 }
18010 return resultobj;
18011 fail:
18012 return NULL;
18013 }
18014
18015
18016 SWIGINTERN PyObject *_wrap_EvtHandler__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18017 PyObject *resultobj = 0;
18018 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18019 PyObject *arg2 = (PyObject *) 0 ;
18020 bool arg3 = (bool) true ;
18021 void *argp1 = 0 ;
18022 int res1 = 0 ;
18023 bool val3 ;
18024 int ecode3 = 0 ;
18025 PyObject * obj0 = 0 ;
18026 PyObject * obj1 = 0 ;
18027 PyObject * obj2 = 0 ;
18028 char * kwnames[] = {
18029 (char *) "self",(char *) "_self",(char *) "incref", NULL
18030 };
18031
18032 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18033 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18034 if (!SWIG_IsOK(res1)) {
18035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler__setOORInfo" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18036 }
18037 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18038 arg2 = obj1;
18039 if (obj2) {
18040 ecode3 = SWIG_AsVal_bool(obj2, &val3);
18041 if (!SWIG_IsOK(ecode3)) {
18042 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler__setOORInfo" "', expected argument " "3"" of type '" "bool""'");
18043 }
18044 arg3 = static_cast< bool >(val3);
18045 }
18046 {
18047 PyThreadState* __tstate = wxPyBeginAllowThreads();
18048 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
18049 wxPyEndAllowThreads(__tstate);
18050 if (PyErr_Occurred()) SWIG_fail;
18051 }
18052 resultobj = SWIG_Py_Void();
18053 return resultobj;
18054 fail:
18055 return NULL;
18056 }
18057
18058
18059 SWIGINTERN PyObject *EvtHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18060 PyObject *obj;
18061 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18062 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvtHandler, SWIG_NewClientData(obj));
18063 return SWIG_Py_Void();
18064 }
18065
18066 SWIGINTERN PyObject *EvtHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18067 return SWIG_Python_InitShadowInstance(args);
18068 }
18069
18070 SWIGINTERN PyObject *_wrap_NewEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18071 PyObject *resultobj = 0;
18072 wxEventType result;
18073
18074 if (!SWIG_Python_UnpackTuple(args,"NewEventType",0,0,0)) SWIG_fail;
18075 {
18076 PyThreadState* __tstate = wxPyBeginAllowThreads();
18077 result = (wxEventType)wxNewEventType();
18078 wxPyEndAllowThreads(__tstate);
18079 if (PyErr_Occurred()) SWIG_fail;
18080 }
18081 resultobj = SWIG_From_int(static_cast< int >(result));
18082 return resultobj;
18083 fail:
18084 return NULL;
18085 }
18086
18087
18088 SWIGINTERN PyObject *_wrap_delete_Event(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18089 PyObject *resultobj = 0;
18090 wxEvent *arg1 = (wxEvent *) 0 ;
18091 void *argp1 = 0 ;
18092 int res1 = 0 ;
18093 PyObject *swig_obj[1] ;
18094
18095 if (!args) SWIG_fail;
18096 swig_obj[0] = args;
18097 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, SWIG_POINTER_DISOWN | 0 );
18098 if (!SWIG_IsOK(res1)) {
18099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Event" "', expected argument " "1"" of type '" "wxEvent *""'");
18100 }
18101 arg1 = reinterpret_cast< wxEvent * >(argp1);
18102 {
18103 PyThreadState* __tstate = wxPyBeginAllowThreads();
18104 delete arg1;
18105
18106 wxPyEndAllowThreads(__tstate);
18107 if (PyErr_Occurred()) SWIG_fail;
18108 }
18109 resultobj = SWIG_Py_Void();
18110 return resultobj;
18111 fail:
18112 return NULL;
18113 }
18114
18115
18116 SWIGINTERN PyObject *_wrap_Event_SetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18117 PyObject *resultobj = 0;
18118 wxEvent *arg1 = (wxEvent *) 0 ;
18119 wxEventType arg2 ;
18120 void *argp1 = 0 ;
18121 int res1 = 0 ;
18122 int val2 ;
18123 int ecode2 = 0 ;
18124 PyObject * obj0 = 0 ;
18125 PyObject * obj1 = 0 ;
18126 char * kwnames[] = {
18127 (char *) "self",(char *) "typ", NULL
18128 };
18129
18130 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) SWIG_fail;
18131 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18132 if (!SWIG_IsOK(res1)) {
18133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventType" "', expected argument " "1"" of type '" "wxEvent *""'");
18134 }
18135 arg1 = reinterpret_cast< wxEvent * >(argp1);
18136 ecode2 = SWIG_AsVal_int(obj1, &val2);
18137 if (!SWIG_IsOK(ecode2)) {
18138 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetEventType" "', expected argument " "2"" of type '" "wxEventType""'");
18139 }
18140 arg2 = static_cast< wxEventType >(val2);
18141 {
18142 PyThreadState* __tstate = wxPyBeginAllowThreads();
18143 (arg1)->SetEventType(arg2);
18144 wxPyEndAllowThreads(__tstate);
18145 if (PyErr_Occurred()) SWIG_fail;
18146 }
18147 resultobj = SWIG_Py_Void();
18148 return resultobj;
18149 fail:
18150 return NULL;
18151 }
18152
18153
18154 SWIGINTERN PyObject *_wrap_Event_GetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18155 PyObject *resultobj = 0;
18156 wxEvent *arg1 = (wxEvent *) 0 ;
18157 wxEventType result;
18158 void *argp1 = 0 ;
18159 int res1 = 0 ;
18160 PyObject *swig_obj[1] ;
18161
18162 if (!args) SWIG_fail;
18163 swig_obj[0] = args;
18164 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18165 if (!SWIG_IsOK(res1)) {
18166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventType" "', expected argument " "1"" of type '" "wxEvent const *""'");
18167 }
18168 arg1 = reinterpret_cast< wxEvent * >(argp1);
18169 {
18170 PyThreadState* __tstate = wxPyBeginAllowThreads();
18171 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
18172 wxPyEndAllowThreads(__tstate);
18173 if (PyErr_Occurred()) SWIG_fail;
18174 }
18175 resultobj = SWIG_From_int(static_cast< int >(result));
18176 return resultobj;
18177 fail:
18178 return NULL;
18179 }
18180
18181
18182 SWIGINTERN PyObject *_wrap_Event_GetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18183 PyObject *resultobj = 0;
18184 wxEvent *arg1 = (wxEvent *) 0 ;
18185 wxObject *result = 0 ;
18186 void *argp1 = 0 ;
18187 int res1 = 0 ;
18188 PyObject *swig_obj[1] ;
18189
18190 if (!args) SWIG_fail;
18191 swig_obj[0] = args;
18192 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18193 if (!SWIG_IsOK(res1)) {
18194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventObject" "', expected argument " "1"" of type '" "wxEvent const *""'");
18195 }
18196 arg1 = reinterpret_cast< wxEvent * >(argp1);
18197 {
18198 PyThreadState* __tstate = wxPyBeginAllowThreads();
18199 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
18200 wxPyEndAllowThreads(__tstate);
18201 if (PyErr_Occurred()) SWIG_fail;
18202 }
18203 {
18204 resultobj = wxPyMake_wxObject(result, (bool)0);
18205 }
18206 return resultobj;
18207 fail:
18208 return NULL;
18209 }
18210
18211
18212 SWIGINTERN PyObject *_wrap_Event_SetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18213 PyObject *resultobj = 0;
18214 wxEvent *arg1 = (wxEvent *) 0 ;
18215 wxObject *arg2 = (wxObject *) 0 ;
18216 void *argp1 = 0 ;
18217 int res1 = 0 ;
18218 void *argp2 = 0 ;
18219 int res2 = 0 ;
18220 PyObject * obj0 = 0 ;
18221 PyObject * obj1 = 0 ;
18222 char * kwnames[] = {
18223 (char *) "self",(char *) "obj", NULL
18224 };
18225
18226 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) SWIG_fail;
18227 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18228 if (!SWIG_IsOK(res1)) {
18229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventObject" "', expected argument " "1"" of type '" "wxEvent *""'");
18230 }
18231 arg1 = reinterpret_cast< wxEvent * >(argp1);
18232 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxObject, 0 | 0 );
18233 if (!SWIG_IsOK(res2)) {
18234 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_SetEventObject" "', expected argument " "2"" of type '" "wxObject *""'");
18235 }
18236 arg2 = reinterpret_cast< wxObject * >(argp2);
18237 {
18238 PyThreadState* __tstate = wxPyBeginAllowThreads();
18239 (arg1)->SetEventObject(arg2);
18240 wxPyEndAllowThreads(__tstate);
18241 if (PyErr_Occurred()) SWIG_fail;
18242 }
18243 resultobj = SWIG_Py_Void();
18244 return resultobj;
18245 fail:
18246 return NULL;
18247 }
18248
18249
18250 SWIGINTERN PyObject *_wrap_Event_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18251 PyObject *resultobj = 0;
18252 wxEvent *arg1 = (wxEvent *) 0 ;
18253 long result;
18254 void *argp1 = 0 ;
18255 int res1 = 0 ;
18256 PyObject *swig_obj[1] ;
18257
18258 if (!args) SWIG_fail;
18259 swig_obj[0] = args;
18260 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18261 if (!SWIG_IsOK(res1)) {
18262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetTimestamp" "', expected argument " "1"" of type '" "wxEvent const *""'");
18263 }
18264 arg1 = reinterpret_cast< wxEvent * >(argp1);
18265 {
18266 PyThreadState* __tstate = wxPyBeginAllowThreads();
18267 result = (long)((wxEvent const *)arg1)->GetTimestamp();
18268 wxPyEndAllowThreads(__tstate);
18269 if (PyErr_Occurred()) SWIG_fail;
18270 }
18271 resultobj = SWIG_From_long(static_cast< long >(result));
18272 return resultobj;
18273 fail:
18274 return NULL;
18275 }
18276
18277
18278 SWIGINTERN PyObject *_wrap_Event_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18279 PyObject *resultobj = 0;
18280 wxEvent *arg1 = (wxEvent *) 0 ;
18281 long arg2 = (long) 0 ;
18282 void *argp1 = 0 ;
18283 int res1 = 0 ;
18284 long val2 ;
18285 int ecode2 = 0 ;
18286 PyObject * obj0 = 0 ;
18287 PyObject * obj1 = 0 ;
18288 char * kwnames[] = {
18289 (char *) "self",(char *) "ts", NULL
18290 };
18291
18292 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) SWIG_fail;
18293 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18294 if (!SWIG_IsOK(res1)) {
18295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetTimestamp" "', expected argument " "1"" of type '" "wxEvent *""'");
18296 }
18297 arg1 = reinterpret_cast< wxEvent * >(argp1);
18298 if (obj1) {
18299 ecode2 = SWIG_AsVal_long(obj1, &val2);
18300 if (!SWIG_IsOK(ecode2)) {
18301 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetTimestamp" "', expected argument " "2"" of type '" "long""'");
18302 }
18303 arg2 = static_cast< long >(val2);
18304 }
18305 {
18306 PyThreadState* __tstate = wxPyBeginAllowThreads();
18307 (arg1)->SetTimestamp(arg2);
18308 wxPyEndAllowThreads(__tstate);
18309 if (PyErr_Occurred()) SWIG_fail;
18310 }
18311 resultobj = SWIG_Py_Void();
18312 return resultobj;
18313 fail:
18314 return NULL;
18315 }
18316
18317
18318 SWIGINTERN PyObject *_wrap_Event_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18319 PyObject *resultobj = 0;
18320 wxEvent *arg1 = (wxEvent *) 0 ;
18321 int result;
18322 void *argp1 = 0 ;
18323 int res1 = 0 ;
18324 PyObject *swig_obj[1] ;
18325
18326 if (!args) SWIG_fail;
18327 swig_obj[0] = args;
18328 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18329 if (!SWIG_IsOK(res1)) {
18330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetId" "', expected argument " "1"" of type '" "wxEvent const *""'");
18331 }
18332 arg1 = reinterpret_cast< wxEvent * >(argp1);
18333 {
18334 PyThreadState* __tstate = wxPyBeginAllowThreads();
18335 result = (int)((wxEvent const *)arg1)->GetId();
18336 wxPyEndAllowThreads(__tstate);
18337 if (PyErr_Occurred()) SWIG_fail;
18338 }
18339 resultobj = SWIG_From_int(static_cast< int >(result));
18340 return resultobj;
18341 fail:
18342 return NULL;
18343 }
18344
18345
18346 SWIGINTERN PyObject *_wrap_Event_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18347 PyObject *resultobj = 0;
18348 wxEvent *arg1 = (wxEvent *) 0 ;
18349 int arg2 ;
18350 void *argp1 = 0 ;
18351 int res1 = 0 ;
18352 int val2 ;
18353 int ecode2 = 0 ;
18354 PyObject * obj0 = 0 ;
18355 PyObject * obj1 = 0 ;
18356 char * kwnames[] = {
18357 (char *) "self",(char *) "Id", NULL
18358 };
18359
18360 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
18361 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18362 if (!SWIG_IsOK(res1)) {
18363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetId" "', expected argument " "1"" of type '" "wxEvent *""'");
18364 }
18365 arg1 = reinterpret_cast< wxEvent * >(argp1);
18366 ecode2 = SWIG_AsVal_int(obj1, &val2);
18367 if (!SWIG_IsOK(ecode2)) {
18368 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetId" "', expected argument " "2"" of type '" "int""'");
18369 }
18370 arg2 = static_cast< int >(val2);
18371 {
18372 PyThreadState* __tstate = wxPyBeginAllowThreads();
18373 (arg1)->SetId(arg2);
18374 wxPyEndAllowThreads(__tstate);
18375 if (PyErr_Occurred()) SWIG_fail;
18376 }
18377 resultobj = SWIG_Py_Void();
18378 return resultobj;
18379 fail:
18380 return NULL;
18381 }
18382
18383
18384 SWIGINTERN PyObject *_wrap_Event_IsCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18385 PyObject *resultobj = 0;
18386 wxEvent *arg1 = (wxEvent *) 0 ;
18387 bool result;
18388 void *argp1 = 0 ;
18389 int res1 = 0 ;
18390 PyObject *swig_obj[1] ;
18391
18392 if (!args) SWIG_fail;
18393 swig_obj[0] = args;
18394 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18395 if (!SWIG_IsOK(res1)) {
18396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_IsCommandEvent" "', expected argument " "1"" of type '" "wxEvent const *""'");
18397 }
18398 arg1 = reinterpret_cast< wxEvent * >(argp1);
18399 {
18400 PyThreadState* __tstate = wxPyBeginAllowThreads();
18401 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
18402 wxPyEndAllowThreads(__tstate);
18403 if (PyErr_Occurred()) SWIG_fail;
18404 }
18405 {
18406 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18407 }
18408 return resultobj;
18409 fail:
18410 return NULL;
18411 }
18412
18413
18414 SWIGINTERN PyObject *_wrap_Event_Skip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18415 PyObject *resultobj = 0;
18416 wxEvent *arg1 = (wxEvent *) 0 ;
18417 bool arg2 = (bool) true ;
18418 void *argp1 = 0 ;
18419 int res1 = 0 ;
18420 bool val2 ;
18421 int ecode2 = 0 ;
18422 PyObject * obj0 = 0 ;
18423 PyObject * obj1 = 0 ;
18424 char * kwnames[] = {
18425 (char *) "self",(char *) "skip", NULL
18426 };
18427
18428 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) SWIG_fail;
18429 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18430 if (!SWIG_IsOK(res1)) {
18431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Skip" "', expected argument " "1"" of type '" "wxEvent *""'");
18432 }
18433 arg1 = reinterpret_cast< wxEvent * >(argp1);
18434 if (obj1) {
18435 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18436 if (!SWIG_IsOK(ecode2)) {
18437 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_Skip" "', expected argument " "2"" of type '" "bool""'");
18438 }
18439 arg2 = static_cast< bool >(val2);
18440 }
18441 {
18442 PyThreadState* __tstate = wxPyBeginAllowThreads();
18443 (arg1)->Skip(arg2);
18444 wxPyEndAllowThreads(__tstate);
18445 if (PyErr_Occurred()) SWIG_fail;
18446 }
18447 resultobj = SWIG_Py_Void();
18448 return resultobj;
18449 fail:
18450 return NULL;
18451 }
18452
18453
18454 SWIGINTERN PyObject *_wrap_Event_GetSkipped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18455 PyObject *resultobj = 0;
18456 wxEvent *arg1 = (wxEvent *) 0 ;
18457 bool result;
18458 void *argp1 = 0 ;
18459 int res1 = 0 ;
18460 PyObject *swig_obj[1] ;
18461
18462 if (!args) SWIG_fail;
18463 swig_obj[0] = args;
18464 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18465 if (!SWIG_IsOK(res1)) {
18466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetSkipped" "', expected argument " "1"" of type '" "wxEvent const *""'");
18467 }
18468 arg1 = reinterpret_cast< wxEvent * >(argp1);
18469 {
18470 PyThreadState* __tstate = wxPyBeginAllowThreads();
18471 result = (bool)((wxEvent const *)arg1)->GetSkipped();
18472 wxPyEndAllowThreads(__tstate);
18473 if (PyErr_Occurred()) SWIG_fail;
18474 }
18475 {
18476 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18477 }
18478 return resultobj;
18479 fail:
18480 return NULL;
18481 }
18482
18483
18484 SWIGINTERN PyObject *_wrap_Event_ShouldPropagate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18485 PyObject *resultobj = 0;
18486 wxEvent *arg1 = (wxEvent *) 0 ;
18487 bool result;
18488 void *argp1 = 0 ;
18489 int res1 = 0 ;
18490 PyObject *swig_obj[1] ;
18491
18492 if (!args) SWIG_fail;
18493 swig_obj[0] = args;
18494 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18495 if (!SWIG_IsOK(res1)) {
18496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ShouldPropagate" "', expected argument " "1"" of type '" "wxEvent const *""'");
18497 }
18498 arg1 = reinterpret_cast< wxEvent * >(argp1);
18499 {
18500 PyThreadState* __tstate = wxPyBeginAllowThreads();
18501 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
18502 wxPyEndAllowThreads(__tstate);
18503 if (PyErr_Occurred()) SWIG_fail;
18504 }
18505 {
18506 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18507 }
18508 return resultobj;
18509 fail:
18510 return NULL;
18511 }
18512
18513
18514 SWIGINTERN PyObject *_wrap_Event_StopPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18515 PyObject *resultobj = 0;
18516 wxEvent *arg1 = (wxEvent *) 0 ;
18517 int result;
18518 void *argp1 = 0 ;
18519 int res1 = 0 ;
18520 PyObject *swig_obj[1] ;
18521
18522 if (!args) SWIG_fail;
18523 swig_obj[0] = args;
18524 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18525 if (!SWIG_IsOK(res1)) {
18526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_StopPropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18527 }
18528 arg1 = reinterpret_cast< wxEvent * >(argp1);
18529 {
18530 PyThreadState* __tstate = wxPyBeginAllowThreads();
18531 result = (int)(arg1)->StopPropagation();
18532 wxPyEndAllowThreads(__tstate);
18533 if (PyErr_Occurred()) SWIG_fail;
18534 }
18535 resultobj = SWIG_From_int(static_cast< int >(result));
18536 return resultobj;
18537 fail:
18538 return NULL;
18539 }
18540
18541
18542 SWIGINTERN PyObject *_wrap_Event_ResumePropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18543 PyObject *resultobj = 0;
18544 wxEvent *arg1 = (wxEvent *) 0 ;
18545 int arg2 ;
18546 void *argp1 = 0 ;
18547 int res1 = 0 ;
18548 int val2 ;
18549 int ecode2 = 0 ;
18550 PyObject * obj0 = 0 ;
18551 PyObject * obj1 = 0 ;
18552 char * kwnames[] = {
18553 (char *) "self",(char *) "propagationLevel", NULL
18554 };
18555
18556 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) SWIG_fail;
18557 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18558 if (!SWIG_IsOK(res1)) {
18559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ResumePropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18560 }
18561 arg1 = reinterpret_cast< wxEvent * >(argp1);
18562 ecode2 = SWIG_AsVal_int(obj1, &val2);
18563 if (!SWIG_IsOK(ecode2)) {
18564 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_ResumePropagation" "', expected argument " "2"" of type '" "int""'");
18565 }
18566 arg2 = static_cast< int >(val2);
18567 {
18568 PyThreadState* __tstate = wxPyBeginAllowThreads();
18569 (arg1)->ResumePropagation(arg2);
18570 wxPyEndAllowThreads(__tstate);
18571 if (PyErr_Occurred()) SWIG_fail;
18572 }
18573 resultobj = SWIG_Py_Void();
18574 return resultobj;
18575 fail:
18576 return NULL;
18577 }
18578
18579
18580 SWIGINTERN PyObject *_wrap_Event_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18581 PyObject *resultobj = 0;
18582 wxEvent *arg1 = (wxEvent *) 0 ;
18583 wxEvent *result = 0 ;
18584 void *argp1 = 0 ;
18585 int res1 = 0 ;
18586 PyObject *swig_obj[1] ;
18587
18588 if (!args) SWIG_fail;
18589 swig_obj[0] = args;
18590 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18591 if (!SWIG_IsOK(res1)) {
18592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Clone" "', expected argument " "1"" of type '" "wxEvent *""'");
18593 }
18594 arg1 = reinterpret_cast< wxEvent * >(argp1);
18595 {
18596 PyThreadState* __tstate = wxPyBeginAllowThreads();
18597 result = (wxEvent *)(arg1)->Clone();
18598 wxPyEndAllowThreads(__tstate);
18599 if (PyErr_Occurred()) SWIG_fail;
18600 }
18601 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
18602 return resultobj;
18603 fail:
18604 return NULL;
18605 }
18606
18607
18608 SWIGINTERN PyObject *Event_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18609 PyObject *obj;
18610 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18611 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvent, SWIG_NewClientData(obj));
18612 return SWIG_Py_Void();
18613 }
18614
18615 SWIGINTERN PyObject *_wrap_new_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18616 PyObject *resultobj = 0;
18617 wxEvent *arg1 = 0 ;
18618 wxPropagationDisabler *result = 0 ;
18619 void *argp1 = 0 ;
18620 int res1 = 0 ;
18621 PyObject * obj0 = 0 ;
18622 char * kwnames[] = {
18623 (char *) "event", NULL
18624 };
18625
18626 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) SWIG_fail;
18627 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
18628 if (!SWIG_IsOK(res1)) {
18629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
18630 }
18631 if (!argp1) {
18632 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
18633 }
18634 arg1 = reinterpret_cast< wxEvent * >(argp1);
18635 {
18636 PyThreadState* __tstate = wxPyBeginAllowThreads();
18637 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
18638 wxPyEndAllowThreads(__tstate);
18639 if (PyErr_Occurred()) SWIG_fail;
18640 }
18641 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_NEW | 0 );
18642 return resultobj;
18643 fail:
18644 return NULL;
18645 }
18646
18647
18648 SWIGINTERN PyObject *_wrap_delete_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18649 PyObject *resultobj = 0;
18650 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
18651 void *argp1 = 0 ;
18652 int res1 = 0 ;
18653 PyObject *swig_obj[1] ;
18654
18655 if (!args) SWIG_fail;
18656 swig_obj[0] = args;
18657 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_DISOWN | 0 );
18658 if (!SWIG_IsOK(res1)) {
18659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagationDisabler" "', expected argument " "1"" of type '" "wxPropagationDisabler *""'");
18660 }
18661 arg1 = reinterpret_cast< wxPropagationDisabler * >(argp1);
18662 {
18663 PyThreadState* __tstate = wxPyBeginAllowThreads();
18664 delete arg1;
18665
18666 wxPyEndAllowThreads(__tstate);
18667 if (PyErr_Occurred()) SWIG_fail;
18668 }
18669 resultobj = SWIG_Py_Void();
18670 return resultobj;
18671 fail:
18672 return NULL;
18673 }
18674
18675
18676 SWIGINTERN PyObject *PropagationDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18677 PyObject *obj;
18678 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18679 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagationDisabler, SWIG_NewClientData(obj));
18680 return SWIG_Py_Void();
18681 }
18682
18683 SWIGINTERN PyObject *PropagationDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18684 return SWIG_Python_InitShadowInstance(args);
18685 }
18686
18687 SWIGINTERN PyObject *_wrap_new_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18688 PyObject *resultobj = 0;
18689 wxEvent *arg1 = 0 ;
18690 wxPropagateOnce *result = 0 ;
18691 void *argp1 = 0 ;
18692 int res1 = 0 ;
18693 PyObject * obj0 = 0 ;
18694 char * kwnames[] = {
18695 (char *) "event", NULL
18696 };
18697
18698 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) SWIG_fail;
18699 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
18700 if (!SWIG_IsOK(res1)) {
18701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
18702 }
18703 if (!argp1) {
18704 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
18705 }
18706 arg1 = reinterpret_cast< wxEvent * >(argp1);
18707 {
18708 PyThreadState* __tstate = wxPyBeginAllowThreads();
18709 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
18710 wxPyEndAllowThreads(__tstate);
18711 if (PyErr_Occurred()) SWIG_fail;
18712 }
18713 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_NEW | 0 );
18714 return resultobj;
18715 fail:
18716 return NULL;
18717 }
18718
18719
18720 SWIGINTERN PyObject *_wrap_delete_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18721 PyObject *resultobj = 0;
18722 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
18723 void *argp1 = 0 ;
18724 int res1 = 0 ;
18725 PyObject *swig_obj[1] ;
18726
18727 if (!args) SWIG_fail;
18728 swig_obj[0] = args;
18729 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_DISOWN | 0 );
18730 if (!SWIG_IsOK(res1)) {
18731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagateOnce" "', expected argument " "1"" of type '" "wxPropagateOnce *""'");
18732 }
18733 arg1 = reinterpret_cast< wxPropagateOnce * >(argp1);
18734 {
18735 PyThreadState* __tstate = wxPyBeginAllowThreads();
18736 delete arg1;
18737
18738 wxPyEndAllowThreads(__tstate);
18739 if (PyErr_Occurred()) SWIG_fail;
18740 }
18741 resultobj = SWIG_Py_Void();
18742 return resultobj;
18743 fail:
18744 return NULL;
18745 }
18746
18747
18748 SWIGINTERN PyObject *PropagateOnce_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18749 PyObject *obj;
18750 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18751 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagateOnce, SWIG_NewClientData(obj));
18752 return SWIG_Py_Void();
18753 }
18754
18755 SWIGINTERN PyObject *PropagateOnce_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18756 return SWIG_Python_InitShadowInstance(args);
18757 }
18758
18759 SWIGINTERN PyObject *_wrap_new_CommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18760 PyObject *resultobj = 0;
18761 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
18762 int arg2 = (int) 0 ;
18763 wxCommandEvent *result = 0 ;
18764 int val1 ;
18765 int ecode1 = 0 ;
18766 int val2 ;
18767 int ecode2 = 0 ;
18768 PyObject * obj0 = 0 ;
18769 PyObject * obj1 = 0 ;
18770 char * kwnames[] = {
18771 (char *) "commandType",(char *) "winid", NULL
18772 };
18773
18774 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
18775 if (obj0) {
18776 ecode1 = SWIG_AsVal_int(obj0, &val1);
18777 if (!SWIG_IsOK(ecode1)) {
18778 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
18779 }
18780 arg1 = static_cast< wxEventType >(val1);
18781 }
18782 if (obj1) {
18783 ecode2 = SWIG_AsVal_int(obj1, &val2);
18784 if (!SWIG_IsOK(ecode2)) {
18785 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CommandEvent" "', expected argument " "2"" of type '" "int""'");
18786 }
18787 arg2 = static_cast< int >(val2);
18788 }
18789 {
18790 PyThreadState* __tstate = wxPyBeginAllowThreads();
18791 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
18792 wxPyEndAllowThreads(__tstate);
18793 if (PyErr_Occurred()) SWIG_fail;
18794 }
18795 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_NEW | 0 );
18796 return resultobj;
18797 fail:
18798 return NULL;
18799 }
18800
18801
18802 SWIGINTERN PyObject *_wrap_CommandEvent_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18803 PyObject *resultobj = 0;
18804 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18805 int result;
18806 void *argp1 = 0 ;
18807 int res1 = 0 ;
18808 PyObject *swig_obj[1] ;
18809
18810 if (!args) SWIG_fail;
18811 swig_obj[0] = args;
18812 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18813 if (!SWIG_IsOK(res1)) {
18814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18815 }
18816 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18817 {
18818 PyThreadState* __tstate = wxPyBeginAllowThreads();
18819 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
18820 wxPyEndAllowThreads(__tstate);
18821 if (PyErr_Occurred()) SWIG_fail;
18822 }
18823 resultobj = SWIG_From_int(static_cast< int >(result));
18824 return resultobj;
18825 fail:
18826 return NULL;
18827 }
18828
18829
18830 SWIGINTERN PyObject *_wrap_CommandEvent_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18831 PyObject *resultobj = 0;
18832 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18833 wxString *arg2 = 0 ;
18834 void *argp1 = 0 ;
18835 int res1 = 0 ;
18836 bool temp2 = false ;
18837 PyObject * obj0 = 0 ;
18838 PyObject * obj1 = 0 ;
18839 char * kwnames[] = {
18840 (char *) "self",(char *) "s", NULL
18841 };
18842
18843 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) SWIG_fail;
18844 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18845 if (!SWIG_IsOK(res1)) {
18846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetString" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
18847 }
18848 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18849 {
18850 arg2 = wxString_in_helper(obj1);
18851 if (arg2 == NULL) SWIG_fail;
18852 temp2 = true;
18853 }
18854 {
18855 PyThreadState* __tstate = wxPyBeginAllowThreads();
18856 (arg1)->SetString((wxString const &)*arg2);
18857 wxPyEndAllowThreads(__tstate);
18858 if (PyErr_Occurred()) SWIG_fail;
18859 }
18860 resultobj = SWIG_Py_Void();
18861 {
18862 if (temp2)
18863 delete arg2;
18864 }
18865 return resultobj;
18866 fail:
18867 {
18868 if (temp2)
18869 delete arg2;
18870 }
18871 return NULL;
18872 }
18873
18874
18875 SWIGINTERN PyObject *_wrap_CommandEvent_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18876 PyObject *resultobj = 0;
18877 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18878 wxString result;
18879 void *argp1 = 0 ;
18880 int res1 = 0 ;
18881 PyObject *swig_obj[1] ;
18882
18883 if (!args) SWIG_fail;
18884 swig_obj[0] = args;
18885 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18886 if (!SWIG_IsOK(res1)) {
18887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetString" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18888 }
18889 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18890 {
18891 PyThreadState* __tstate = wxPyBeginAllowThreads();
18892 result = ((wxCommandEvent const *)arg1)->GetString();
18893 wxPyEndAllowThreads(__tstate);
18894 if (PyErr_Occurred()) SWIG_fail;
18895 }
18896 {
18897 #if wxUSE_UNICODE
18898 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18899 #else
18900 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18901 #endif
18902 }
18903 return resultobj;
18904 fail:
18905 return NULL;
18906 }
18907
18908
18909 SWIGINTERN PyObject *_wrap_CommandEvent_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18910 PyObject *resultobj = 0;
18911 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18912 bool result;
18913 void *argp1 = 0 ;
18914 int res1 = 0 ;
18915 PyObject *swig_obj[1] ;
18916
18917 if (!args) SWIG_fail;
18918 swig_obj[0] = args;
18919 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18920 if (!SWIG_IsOK(res1)) {
18921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsChecked" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18922 }
18923 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18924 {
18925 PyThreadState* __tstate = wxPyBeginAllowThreads();
18926 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
18927 wxPyEndAllowThreads(__tstate);
18928 if (PyErr_Occurred()) SWIG_fail;
18929 }
18930 {
18931 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18932 }
18933 return resultobj;
18934 fail:
18935 return NULL;
18936 }
18937
18938
18939 SWIGINTERN PyObject *_wrap_CommandEvent_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18940 PyObject *resultobj = 0;
18941 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18942 bool result;
18943 void *argp1 = 0 ;
18944 int res1 = 0 ;
18945 PyObject *swig_obj[1] ;
18946
18947 if (!args) SWIG_fail;
18948 swig_obj[0] = args;
18949 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18950 if (!SWIG_IsOK(res1)) {
18951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18952 }
18953 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18954 {
18955 PyThreadState* __tstate = wxPyBeginAllowThreads();
18956 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
18957 wxPyEndAllowThreads(__tstate);
18958 if (PyErr_Occurred()) SWIG_fail;
18959 }
18960 {
18961 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18962 }
18963 return resultobj;
18964 fail:
18965 return NULL;
18966 }
18967
18968
18969 SWIGINTERN PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18970 PyObject *resultobj = 0;
18971 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18972 long arg2 ;
18973 void *argp1 = 0 ;
18974 int res1 = 0 ;
18975 long val2 ;
18976 int ecode2 = 0 ;
18977 PyObject * obj0 = 0 ;
18978 PyObject * obj1 = 0 ;
18979 char * kwnames[] = {
18980 (char *) "self",(char *) "extraLong", NULL
18981 };
18982
18983 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) SWIG_fail;
18984 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18985 if (!SWIG_IsOK(res1)) {
18986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
18987 }
18988 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18989 ecode2 = SWIG_AsVal_long(obj1, &val2);
18990 if (!SWIG_IsOK(ecode2)) {
18991 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "2"" of type '" "long""'");
18992 }
18993 arg2 = static_cast< long >(val2);
18994 {
18995 PyThreadState* __tstate = wxPyBeginAllowThreads();
18996 (arg1)->SetExtraLong(arg2);
18997 wxPyEndAllowThreads(__tstate);
18998 if (PyErr_Occurred()) SWIG_fail;
18999 }
19000 resultobj = SWIG_Py_Void();
19001 return resultobj;
19002 fail:
19003 return NULL;
19004 }
19005
19006
19007 SWIGINTERN PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19008 PyObject *resultobj = 0;
19009 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19010 long result;
19011 void *argp1 = 0 ;
19012 int res1 = 0 ;
19013 PyObject *swig_obj[1] ;
19014
19015 if (!args) SWIG_fail;
19016 swig_obj[0] = args;
19017 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19018 if (!SWIG_IsOK(res1)) {
19019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19020 }
19021 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19022 {
19023 PyThreadState* __tstate = wxPyBeginAllowThreads();
19024 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
19025 wxPyEndAllowThreads(__tstate);
19026 if (PyErr_Occurred()) SWIG_fail;
19027 }
19028 resultobj = SWIG_From_long(static_cast< long >(result));
19029 return resultobj;
19030 fail:
19031 return NULL;
19032 }
19033
19034
19035 SWIGINTERN PyObject *_wrap_CommandEvent_SetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19036 PyObject *resultobj = 0;
19037 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19038 int arg2 ;
19039 void *argp1 = 0 ;
19040 int res1 = 0 ;
19041 int val2 ;
19042 int ecode2 = 0 ;
19043 PyObject * obj0 = 0 ;
19044 PyObject * obj1 = 0 ;
19045 char * kwnames[] = {
19046 (char *) "self",(char *) "i", NULL
19047 };
19048
19049 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) SWIG_fail;
19050 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19051 if (!SWIG_IsOK(res1)) {
19052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetInt" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19053 }
19054 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19055 ecode2 = SWIG_AsVal_int(obj1, &val2);
19056 if (!SWIG_IsOK(ecode2)) {
19057 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetInt" "', expected argument " "2"" of type '" "int""'");
19058 }
19059 arg2 = static_cast< int >(val2);
19060 {
19061 PyThreadState* __tstate = wxPyBeginAllowThreads();
19062 (arg1)->SetInt(arg2);
19063 wxPyEndAllowThreads(__tstate);
19064 if (PyErr_Occurred()) SWIG_fail;
19065 }
19066 resultobj = SWIG_Py_Void();
19067 return resultobj;
19068 fail:
19069 return NULL;
19070 }
19071
19072
19073 SWIGINTERN PyObject *_wrap_CommandEvent_GetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19074 PyObject *resultobj = 0;
19075 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19076 int result;
19077 void *argp1 = 0 ;
19078 int res1 = 0 ;
19079 PyObject *swig_obj[1] ;
19080
19081 if (!args) SWIG_fail;
19082 swig_obj[0] = args;
19083 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19084 if (!SWIG_IsOK(res1)) {
19085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetInt" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19086 }
19087 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19088 {
19089 PyThreadState* __tstate = wxPyBeginAllowThreads();
19090 result = (int)((wxCommandEvent const *)arg1)->GetInt();
19091 wxPyEndAllowThreads(__tstate);
19092 if (PyErr_Occurred()) SWIG_fail;
19093 }
19094 resultobj = SWIG_From_int(static_cast< int >(result));
19095 return resultobj;
19096 fail:
19097 return NULL;
19098 }
19099
19100
19101 SWIGINTERN PyObject *_wrap_CommandEvent_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19102 PyObject *resultobj = 0;
19103 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19104 PyObject *result = 0 ;
19105 void *argp1 = 0 ;
19106 int res1 = 0 ;
19107 PyObject *swig_obj[1] ;
19108
19109 if (!args) SWIG_fail;
19110 swig_obj[0] = args;
19111 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19112 if (!SWIG_IsOK(res1)) {
19113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19114 }
19115 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19116 {
19117 PyThreadState* __tstate = wxPyBeginAllowThreads();
19118 result = (PyObject *)wxCommandEvent_GetClientData(arg1);
19119 wxPyEndAllowThreads(__tstate);
19120 if (PyErr_Occurred()) SWIG_fail;
19121 }
19122 resultobj = result;
19123 return resultobj;
19124 fail:
19125 return NULL;
19126 }
19127
19128
19129 SWIGINTERN PyObject *_wrap_CommandEvent_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19130 PyObject *resultobj = 0;
19131 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19132 PyObject *arg2 = (PyObject *) 0 ;
19133 void *argp1 = 0 ;
19134 int res1 = 0 ;
19135 PyObject * obj0 = 0 ;
19136 PyObject * obj1 = 0 ;
19137 char * kwnames[] = {
19138 (char *) "self",(char *) "clientData", NULL
19139 };
19140
19141 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
19142 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19143 if (!SWIG_IsOK(res1)) {
19144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19145 }
19146 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19147 arg2 = obj1;
19148 {
19149 PyThreadState* __tstate = wxPyBeginAllowThreads();
19150 wxCommandEvent_SetClientData(arg1,arg2);
19151 wxPyEndAllowThreads(__tstate);
19152 if (PyErr_Occurred()) SWIG_fail;
19153 }
19154 resultobj = SWIG_Py_Void();
19155 return resultobj;
19156 fail:
19157 return NULL;
19158 }
19159
19160
19161 SWIGINTERN PyObject *_wrap_CommandEvent_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19162 PyObject *resultobj = 0;
19163 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19164 wxEvent *result = 0 ;
19165 void *argp1 = 0 ;
19166 int res1 = 0 ;
19167 PyObject *swig_obj[1] ;
19168
19169 if (!args) SWIG_fail;
19170 swig_obj[0] = args;
19171 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19172 if (!SWIG_IsOK(res1)) {
19173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_Clone" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19174 }
19175 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19176 {
19177 PyThreadState* __tstate = wxPyBeginAllowThreads();
19178 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
19179 wxPyEndAllowThreads(__tstate);
19180 if (PyErr_Occurred()) SWIG_fail;
19181 }
19182 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
19183 return resultobj;
19184 fail:
19185 return NULL;
19186 }
19187
19188
19189 SWIGINTERN PyObject *CommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19190 PyObject *obj;
19191 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19192 SWIG_TypeNewClientData(SWIGTYPE_p_wxCommandEvent, SWIG_NewClientData(obj));
19193 return SWIG_Py_Void();
19194 }
19195
19196 SWIGINTERN PyObject *CommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19197 return SWIG_Python_InitShadowInstance(args);
19198 }
19199
19200 SWIGINTERN PyObject *_wrap_new_NotifyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19201 PyObject *resultobj = 0;
19202 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19203 int arg2 = (int) 0 ;
19204 wxNotifyEvent *result = 0 ;
19205 int val1 ;
19206 int ecode1 = 0 ;
19207 int val2 ;
19208 int ecode2 = 0 ;
19209 PyObject * obj0 = 0 ;
19210 PyObject * obj1 = 0 ;
19211 char * kwnames[] = {
19212 (char *) "commandType",(char *) "winid", NULL
19213 };
19214
19215 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
19216 if (obj0) {
19217 ecode1 = SWIG_AsVal_int(obj0, &val1);
19218 if (!SWIG_IsOK(ecode1)) {
19219 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NotifyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19220 }
19221 arg1 = static_cast< wxEventType >(val1);
19222 }
19223 if (obj1) {
19224 ecode2 = SWIG_AsVal_int(obj1, &val2);
19225 if (!SWIG_IsOK(ecode2)) {
19226 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NotifyEvent" "', expected argument " "2"" of type '" "int""'");
19227 }
19228 arg2 = static_cast< int >(val2);
19229 }
19230 {
19231 PyThreadState* __tstate = wxPyBeginAllowThreads();
19232 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
19233 wxPyEndAllowThreads(__tstate);
19234 if (PyErr_Occurred()) SWIG_fail;
19235 }
19236 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_NEW | 0 );
19237 return resultobj;
19238 fail:
19239 return NULL;
19240 }
19241
19242
19243 SWIGINTERN PyObject *_wrap_NotifyEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19244 PyObject *resultobj = 0;
19245 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19246 void *argp1 = 0 ;
19247 int res1 = 0 ;
19248 PyObject *swig_obj[1] ;
19249
19250 if (!args) SWIG_fail;
19251 swig_obj[0] = args;
19252 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19253 if (!SWIG_IsOK(res1)) {
19254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Veto" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19255 }
19256 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19257 {
19258 PyThreadState* __tstate = wxPyBeginAllowThreads();
19259 (arg1)->Veto();
19260 wxPyEndAllowThreads(__tstate);
19261 if (PyErr_Occurred()) SWIG_fail;
19262 }
19263 resultobj = SWIG_Py_Void();
19264 return resultobj;
19265 fail:
19266 return NULL;
19267 }
19268
19269
19270 SWIGINTERN PyObject *_wrap_NotifyEvent_Allow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19271 PyObject *resultobj = 0;
19272 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19273 void *argp1 = 0 ;
19274 int res1 = 0 ;
19275 PyObject *swig_obj[1] ;
19276
19277 if (!args) SWIG_fail;
19278 swig_obj[0] = args;
19279 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19280 if (!SWIG_IsOK(res1)) {
19281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Allow" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19282 }
19283 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19284 {
19285 PyThreadState* __tstate = wxPyBeginAllowThreads();
19286 (arg1)->Allow();
19287 wxPyEndAllowThreads(__tstate);
19288 if (PyErr_Occurred()) SWIG_fail;
19289 }
19290 resultobj = SWIG_Py_Void();
19291 return resultobj;
19292 fail:
19293 return NULL;
19294 }
19295
19296
19297 SWIGINTERN PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19298 PyObject *resultobj = 0;
19299 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19300 bool result;
19301 void *argp1 = 0 ;
19302 int res1 = 0 ;
19303 PyObject *swig_obj[1] ;
19304
19305 if (!args) SWIG_fail;
19306 swig_obj[0] = args;
19307 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19308 if (!SWIG_IsOK(res1)) {
19309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_IsAllowed" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19310 }
19311 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19312 {
19313 PyThreadState* __tstate = wxPyBeginAllowThreads();
19314 result = (bool)(arg1)->IsAllowed();
19315 wxPyEndAllowThreads(__tstate);
19316 if (PyErr_Occurred()) SWIG_fail;
19317 }
19318 {
19319 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19320 }
19321 return resultobj;
19322 fail:
19323 return NULL;
19324 }
19325
19326
19327 SWIGINTERN PyObject *NotifyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19328 PyObject *obj;
19329 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19330 SWIG_TypeNewClientData(SWIGTYPE_p_wxNotifyEvent, SWIG_NewClientData(obj));
19331 return SWIG_Py_Void();
19332 }
19333
19334 SWIGINTERN PyObject *NotifyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19335 return SWIG_Python_InitShadowInstance(args);
19336 }
19337
19338 SWIGINTERN PyObject *_wrap_new_ScrollEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19339 PyObject *resultobj = 0;
19340 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19341 int arg2 = (int) 0 ;
19342 int arg3 = (int) 0 ;
19343 int arg4 = (int) 0 ;
19344 wxScrollEvent *result = 0 ;
19345 int val1 ;
19346 int ecode1 = 0 ;
19347 int val2 ;
19348 int ecode2 = 0 ;
19349 int val3 ;
19350 int ecode3 = 0 ;
19351 int val4 ;
19352 int ecode4 = 0 ;
19353 PyObject * obj0 = 0 ;
19354 PyObject * obj1 = 0 ;
19355 PyObject * obj2 = 0 ;
19356 PyObject * obj3 = 0 ;
19357 char * kwnames[] = {
19358 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
19359 };
19360
19361 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19362 if (obj0) {
19363 ecode1 = SWIG_AsVal_int(obj0, &val1);
19364 if (!SWIG_IsOK(ecode1)) {
19365 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19366 }
19367 arg1 = static_cast< wxEventType >(val1);
19368 }
19369 if (obj1) {
19370 ecode2 = SWIG_AsVal_int(obj1, &val2);
19371 if (!SWIG_IsOK(ecode2)) {
19372 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollEvent" "', expected argument " "2"" of type '" "int""'");
19373 }
19374 arg2 = static_cast< int >(val2);
19375 }
19376 if (obj2) {
19377 ecode3 = SWIG_AsVal_int(obj2, &val3);
19378 if (!SWIG_IsOK(ecode3)) {
19379 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollEvent" "', expected argument " "3"" of type '" "int""'");
19380 }
19381 arg3 = static_cast< int >(val3);
19382 }
19383 if (obj3) {
19384 ecode4 = SWIG_AsVal_int(obj3, &val4);
19385 if (!SWIG_IsOK(ecode4)) {
19386 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ScrollEvent" "', expected argument " "4"" of type '" "int""'");
19387 }
19388 arg4 = static_cast< int >(val4);
19389 }
19390 {
19391 PyThreadState* __tstate = wxPyBeginAllowThreads();
19392 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
19393 wxPyEndAllowThreads(__tstate);
19394 if (PyErr_Occurred()) SWIG_fail;
19395 }
19396 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_NEW | 0 );
19397 return resultobj;
19398 fail:
19399 return NULL;
19400 }
19401
19402
19403 SWIGINTERN PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19404 PyObject *resultobj = 0;
19405 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19406 int result;
19407 void *argp1 = 0 ;
19408 int res1 = 0 ;
19409 PyObject *swig_obj[1] ;
19410
19411 if (!args) SWIG_fail;
19412 swig_obj[0] = args;
19413 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19414 if (!SWIG_IsOK(res1)) {
19415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19416 }
19417 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19418 {
19419 PyThreadState* __tstate = wxPyBeginAllowThreads();
19420 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
19421 wxPyEndAllowThreads(__tstate);
19422 if (PyErr_Occurred()) SWIG_fail;
19423 }
19424 resultobj = SWIG_From_int(static_cast< int >(result));
19425 return resultobj;
19426 fail:
19427 return NULL;
19428 }
19429
19430
19431 SWIGINTERN PyObject *_wrap_ScrollEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19432 PyObject *resultobj = 0;
19433 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19434 int result;
19435 void *argp1 = 0 ;
19436 int res1 = 0 ;
19437 PyObject *swig_obj[1] ;
19438
19439 if (!args) SWIG_fail;
19440 swig_obj[0] = args;
19441 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19442 if (!SWIG_IsOK(res1)) {
19443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19444 }
19445 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19446 {
19447 PyThreadState* __tstate = wxPyBeginAllowThreads();
19448 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
19449 wxPyEndAllowThreads(__tstate);
19450 if (PyErr_Occurred()) SWIG_fail;
19451 }
19452 resultobj = SWIG_From_int(static_cast< int >(result));
19453 return resultobj;
19454 fail:
19455 return NULL;
19456 }
19457
19458
19459 SWIGINTERN PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19460 PyObject *resultobj = 0;
19461 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19462 int arg2 ;
19463 void *argp1 = 0 ;
19464 int res1 = 0 ;
19465 int val2 ;
19466 int ecode2 = 0 ;
19467 PyObject * obj0 = 0 ;
19468 PyObject * obj1 = 0 ;
19469 char * kwnames[] = {
19470 (char *) "self",(char *) "orient", NULL
19471 };
19472
19473 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19474 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19475 if (!SWIG_IsOK(res1)) {
19476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19477 }
19478 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19479 ecode2 = SWIG_AsVal_int(obj1, &val2);
19480 if (!SWIG_IsOK(ecode2)) {
19481 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
19482 }
19483 arg2 = static_cast< int >(val2);
19484 {
19485 PyThreadState* __tstate = wxPyBeginAllowThreads();
19486 (arg1)->SetOrientation(arg2);
19487 wxPyEndAllowThreads(__tstate);
19488 if (PyErr_Occurred()) SWIG_fail;
19489 }
19490 resultobj = SWIG_Py_Void();
19491 return resultobj;
19492 fail:
19493 return NULL;
19494 }
19495
19496
19497 SWIGINTERN PyObject *_wrap_ScrollEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19498 PyObject *resultobj = 0;
19499 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19500 int arg2 ;
19501 void *argp1 = 0 ;
19502 int res1 = 0 ;
19503 int val2 ;
19504 int ecode2 = 0 ;
19505 PyObject * obj0 = 0 ;
19506 PyObject * obj1 = 0 ;
19507 char * kwnames[] = {
19508 (char *) "self",(char *) "pos", NULL
19509 };
19510
19511 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
19512 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19513 if (!SWIG_IsOK(res1)) {
19514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19515 }
19516 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19517 ecode2 = SWIG_AsVal_int(obj1, &val2);
19518 if (!SWIG_IsOK(ecode2)) {
19519 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
19520 }
19521 arg2 = static_cast< int >(val2);
19522 {
19523 PyThreadState* __tstate = wxPyBeginAllowThreads();
19524 (arg1)->SetPosition(arg2);
19525 wxPyEndAllowThreads(__tstate);
19526 if (PyErr_Occurred()) SWIG_fail;
19527 }
19528 resultobj = SWIG_Py_Void();
19529 return resultobj;
19530 fail:
19531 return NULL;
19532 }
19533
19534
19535 SWIGINTERN PyObject *ScrollEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19536 PyObject *obj;
19537 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19538 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollEvent, SWIG_NewClientData(obj));
19539 return SWIG_Py_Void();
19540 }
19541
19542 SWIGINTERN PyObject *ScrollEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19543 return SWIG_Python_InitShadowInstance(args);
19544 }
19545
19546 SWIGINTERN PyObject *_wrap_new_ScrollWinEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19547 PyObject *resultobj = 0;
19548 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19549 int arg2 = (int) 0 ;
19550 int arg3 = (int) 0 ;
19551 wxScrollWinEvent *result = 0 ;
19552 int val1 ;
19553 int ecode1 = 0 ;
19554 int val2 ;
19555 int ecode2 = 0 ;
19556 int val3 ;
19557 int ecode3 = 0 ;
19558 PyObject * obj0 = 0 ;
19559 PyObject * obj1 = 0 ;
19560 PyObject * obj2 = 0 ;
19561 char * kwnames[] = {
19562 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
19563 };
19564
19565 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19566 if (obj0) {
19567 ecode1 = SWIG_AsVal_int(obj0, &val1);
19568 if (!SWIG_IsOK(ecode1)) {
19569 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollWinEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19570 }
19571 arg1 = static_cast< wxEventType >(val1);
19572 }
19573 if (obj1) {
19574 ecode2 = SWIG_AsVal_int(obj1, &val2);
19575 if (!SWIG_IsOK(ecode2)) {
19576 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollWinEvent" "', expected argument " "2"" of type '" "int""'");
19577 }
19578 arg2 = static_cast< int >(val2);
19579 }
19580 if (obj2) {
19581 ecode3 = SWIG_AsVal_int(obj2, &val3);
19582 if (!SWIG_IsOK(ecode3)) {
19583 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollWinEvent" "', expected argument " "3"" of type '" "int""'");
19584 }
19585 arg3 = static_cast< int >(val3);
19586 }
19587 {
19588 PyThreadState* __tstate = wxPyBeginAllowThreads();
19589 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
19590 wxPyEndAllowThreads(__tstate);
19591 if (PyErr_Occurred()) SWIG_fail;
19592 }
19593 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_NEW | 0 );
19594 return resultobj;
19595 fail:
19596 return NULL;
19597 }
19598
19599
19600 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19601 PyObject *resultobj = 0;
19602 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19603 int result;
19604 void *argp1 = 0 ;
19605 int res1 = 0 ;
19606 PyObject *swig_obj[1] ;
19607
19608 if (!args) SWIG_fail;
19609 swig_obj[0] = args;
19610 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19611 if (!SWIG_IsOK(res1)) {
19612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
19613 }
19614 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19615 {
19616 PyThreadState* __tstate = wxPyBeginAllowThreads();
19617 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
19618 wxPyEndAllowThreads(__tstate);
19619 if (PyErr_Occurred()) SWIG_fail;
19620 }
19621 resultobj = SWIG_From_int(static_cast< int >(result));
19622 return resultobj;
19623 fail:
19624 return NULL;
19625 }
19626
19627
19628 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19629 PyObject *resultobj = 0;
19630 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19631 int result;
19632 void *argp1 = 0 ;
19633 int res1 = 0 ;
19634 PyObject *swig_obj[1] ;
19635
19636 if (!args) SWIG_fail;
19637 swig_obj[0] = args;
19638 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19639 if (!SWIG_IsOK(res1)) {
19640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
19641 }
19642 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19643 {
19644 PyThreadState* __tstate = wxPyBeginAllowThreads();
19645 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
19646 wxPyEndAllowThreads(__tstate);
19647 if (PyErr_Occurred()) SWIG_fail;
19648 }
19649 resultobj = SWIG_From_int(static_cast< int >(result));
19650 return resultobj;
19651 fail:
19652 return NULL;
19653 }
19654
19655
19656 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19657 PyObject *resultobj = 0;
19658 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19659 int arg2 ;
19660 void *argp1 = 0 ;
19661 int res1 = 0 ;
19662 int val2 ;
19663 int ecode2 = 0 ;
19664 PyObject * obj0 = 0 ;
19665 PyObject * obj1 = 0 ;
19666 char * kwnames[] = {
19667 (char *) "self",(char *) "orient", NULL
19668 };
19669
19670 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19671 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19672 if (!SWIG_IsOK(res1)) {
19673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
19674 }
19675 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19676 ecode2 = SWIG_AsVal_int(obj1, &val2);
19677 if (!SWIG_IsOK(ecode2)) {
19678 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
19679 }
19680 arg2 = static_cast< int >(val2);
19681 {
19682 PyThreadState* __tstate = wxPyBeginAllowThreads();
19683 (arg1)->SetOrientation(arg2);
19684 wxPyEndAllowThreads(__tstate);
19685 if (PyErr_Occurred()) SWIG_fail;
19686 }
19687 resultobj = SWIG_Py_Void();
19688 return resultobj;
19689 fail:
19690 return NULL;
19691 }
19692
19693
19694 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19695 PyObject *resultobj = 0;
19696 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19697 int arg2 ;
19698 void *argp1 = 0 ;
19699 int res1 = 0 ;
19700 int val2 ;
19701 int ecode2 = 0 ;
19702 PyObject * obj0 = 0 ;
19703 PyObject * obj1 = 0 ;
19704 char * kwnames[] = {
19705 (char *) "self",(char *) "pos", NULL
19706 };
19707
19708 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
19709 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19710 if (!SWIG_IsOK(res1)) {
19711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
19712 }
19713 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19714 ecode2 = SWIG_AsVal_int(obj1, &val2);
19715 if (!SWIG_IsOK(ecode2)) {
19716 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
19717 }
19718 arg2 = static_cast< int >(val2);
19719 {
19720 PyThreadState* __tstate = wxPyBeginAllowThreads();
19721 (arg1)->SetPosition(arg2);
19722 wxPyEndAllowThreads(__tstate);
19723 if (PyErr_Occurred()) SWIG_fail;
19724 }
19725 resultobj = SWIG_Py_Void();
19726 return resultobj;
19727 fail:
19728 return NULL;
19729 }
19730
19731
19732 SWIGINTERN PyObject *ScrollWinEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19733 PyObject *obj;
19734 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19735 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollWinEvent, SWIG_NewClientData(obj));
19736 return SWIG_Py_Void();
19737 }
19738
19739 SWIGINTERN PyObject *ScrollWinEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19740 return SWIG_Python_InitShadowInstance(args);
19741 }
19742
19743 SWIGINTERN PyObject *_wrap_new_MouseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19744 PyObject *resultobj = 0;
19745 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19746 wxMouseEvent *result = 0 ;
19747 int val1 ;
19748 int ecode1 = 0 ;
19749 PyObject * obj0 = 0 ;
19750 char * kwnames[] = {
19751 (char *) "mouseType", NULL
19752 };
19753
19754 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) SWIG_fail;
19755 if (obj0) {
19756 ecode1 = SWIG_AsVal_int(obj0, &val1);
19757 if (!SWIG_IsOK(ecode1)) {
19758 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19759 }
19760 arg1 = static_cast< wxEventType >(val1);
19761 }
19762 {
19763 PyThreadState* __tstate = wxPyBeginAllowThreads();
19764 result = (wxMouseEvent *)new wxMouseEvent(arg1);
19765 wxPyEndAllowThreads(__tstate);
19766 if (PyErr_Occurred()) SWIG_fail;
19767 }
19768 {
19769 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
19770 }
19771 return resultobj;
19772 fail:
19773 return NULL;
19774 }
19775
19776
19777 SWIGINTERN PyObject *_wrap_MouseEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19778 PyObject *resultobj = 0;
19779 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19780 bool result;
19781 void *argp1 = 0 ;
19782 int res1 = 0 ;
19783 PyObject *swig_obj[1] ;
19784
19785 if (!args) SWIG_fail;
19786 swig_obj[0] = args;
19787 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19788 if (!SWIG_IsOK(res1)) {
19789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19790 }
19791 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19792 {
19793 PyThreadState* __tstate = wxPyBeginAllowThreads();
19794 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
19795 wxPyEndAllowThreads(__tstate);
19796 if (PyErr_Occurred()) SWIG_fail;
19797 }
19798 {
19799 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19800 }
19801 return resultobj;
19802 fail:
19803 return NULL;
19804 }
19805
19806
19807 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19808 PyObject *resultobj = 0;
19809 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19810 int arg2 = (int) wxMOUSE_BTN_ANY ;
19811 bool result;
19812 void *argp1 = 0 ;
19813 int res1 = 0 ;
19814 int val2 ;
19815 int ecode2 = 0 ;
19816 PyObject * obj0 = 0 ;
19817 PyObject * obj1 = 0 ;
19818 char * kwnames[] = {
19819 (char *) "self",(char *) "but", NULL
19820 };
19821
19822 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
19823 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19824 if (!SWIG_IsOK(res1)) {
19825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19826 }
19827 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19828 if (obj1) {
19829 ecode2 = SWIG_AsVal_int(obj1, &val2);
19830 if (!SWIG_IsOK(ecode2)) {
19831 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
19832 }
19833 arg2 = static_cast< int >(val2);
19834 }
19835 {
19836 PyThreadState* __tstate = wxPyBeginAllowThreads();
19837 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
19838 wxPyEndAllowThreads(__tstate);
19839 if (PyErr_Occurred()) SWIG_fail;
19840 }
19841 {
19842 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19843 }
19844 return resultobj;
19845 fail:
19846 return NULL;
19847 }
19848
19849
19850 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19851 PyObject *resultobj = 0;
19852 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19853 int arg2 = (int) wxMOUSE_BTN_ANY ;
19854 bool result;
19855 void *argp1 = 0 ;
19856 int res1 = 0 ;
19857 int val2 ;
19858 int ecode2 = 0 ;
19859 PyObject * obj0 = 0 ;
19860 PyObject * obj1 = 0 ;
19861 char * kwnames[] = {
19862 (char *) "self",(char *) "but", NULL
19863 };
19864
19865 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) SWIG_fail;
19866 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19867 if (!SWIG_IsOK(res1)) {
19868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19869 }
19870 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19871 if (obj1) {
19872 ecode2 = SWIG_AsVal_int(obj1, &val2);
19873 if (!SWIG_IsOK(ecode2)) {
19874 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "2"" of type '" "int""'");
19875 }
19876 arg2 = static_cast< int >(val2);
19877 }
19878 {
19879 PyThreadState* __tstate = wxPyBeginAllowThreads();
19880 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
19881 wxPyEndAllowThreads(__tstate);
19882 if (PyErr_Occurred()) SWIG_fail;
19883 }
19884 {
19885 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19886 }
19887 return resultobj;
19888 fail:
19889 return NULL;
19890 }
19891
19892
19893 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19894 PyObject *resultobj = 0;
19895 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19896 int arg2 = (int) wxMOUSE_BTN_ANY ;
19897 bool result;
19898 void *argp1 = 0 ;
19899 int res1 = 0 ;
19900 int val2 ;
19901 int ecode2 = 0 ;
19902 PyObject * obj0 = 0 ;
19903 PyObject * obj1 = 0 ;
19904 char * kwnames[] = {
19905 (char *) "self",(char *) "but", NULL
19906 };
19907
19908 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
19909 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19910 if (!SWIG_IsOK(res1)) {
19911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19912 }
19913 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19914 if (obj1) {
19915 ecode2 = SWIG_AsVal_int(obj1, &val2);
19916 if (!SWIG_IsOK(ecode2)) {
19917 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
19918 }
19919 arg2 = static_cast< int >(val2);
19920 }
19921 {
19922 PyThreadState* __tstate = wxPyBeginAllowThreads();
19923 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
19924 wxPyEndAllowThreads(__tstate);
19925 if (PyErr_Occurred()) SWIG_fail;
19926 }
19927 {
19928 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19929 }
19930 return resultobj;
19931 fail:
19932 return NULL;
19933 }
19934
19935
19936 SWIGINTERN PyObject *_wrap_MouseEvent_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19937 PyObject *resultobj = 0;
19938 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19939 int arg2 ;
19940 bool result;
19941 void *argp1 = 0 ;
19942 int res1 = 0 ;
19943 int val2 ;
19944 int ecode2 = 0 ;
19945 PyObject * obj0 = 0 ;
19946 PyObject * obj1 = 0 ;
19947 char * kwnames[] = {
19948 (char *) "self",(char *) "button", NULL
19949 };
19950
19951 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) SWIG_fail;
19952 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19953 if (!SWIG_IsOK(res1)) {
19954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Button" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19955 }
19956 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19957 ecode2 = SWIG_AsVal_int(obj1, &val2);
19958 if (!SWIG_IsOK(ecode2)) {
19959 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_Button" "', expected argument " "2"" of type '" "int""'");
19960 }
19961 arg2 = static_cast< int >(val2);
19962 {
19963 PyThreadState* __tstate = wxPyBeginAllowThreads();
19964 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
19965 wxPyEndAllowThreads(__tstate);
19966 if (PyErr_Occurred()) SWIG_fail;
19967 }
19968 {
19969 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19970 }
19971 return resultobj;
19972 fail:
19973 return NULL;
19974 }
19975
19976
19977 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19978 PyObject *resultobj = 0;
19979 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19980 int arg2 ;
19981 bool result;
19982 void *argp1 = 0 ;
19983 int res1 = 0 ;
19984 int val2 ;
19985 int ecode2 = 0 ;
19986 PyObject * obj0 = 0 ;
19987 PyObject * obj1 = 0 ;
19988 char * kwnames[] = {
19989 (char *) "self",(char *) "but", NULL
19990 };
19991
19992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
19993 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19994 if (!SWIG_IsOK(res1)) {
19995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19996 }
19997 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19998 ecode2 = SWIG_AsVal_int(obj1, &val2);
19999 if (!SWIG_IsOK(ecode2)) {
20000 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
20001 }
20002 arg2 = static_cast< int >(val2);
20003 {
20004 PyThreadState* __tstate = wxPyBeginAllowThreads();
20005 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
20006 wxPyEndAllowThreads(__tstate);
20007 if (PyErr_Occurred()) SWIG_fail;
20008 }
20009 {
20010 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20011 }
20012 return resultobj;
20013 fail:
20014 return NULL;
20015 }
20016
20017
20018 SWIGINTERN PyObject *_wrap_MouseEvent_GetButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20019 PyObject *resultobj = 0;
20020 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20021 int result;
20022 void *argp1 = 0 ;
20023 int res1 = 0 ;
20024 PyObject *swig_obj[1] ;
20025
20026 if (!args) SWIG_fail;
20027 swig_obj[0] = args;
20028 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20029 if (!SWIG_IsOK(res1)) {
20030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20031 }
20032 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20033 {
20034 PyThreadState* __tstate = wxPyBeginAllowThreads();
20035 result = (int)((wxMouseEvent const *)arg1)->GetButton();
20036 wxPyEndAllowThreads(__tstate);
20037 if (PyErr_Occurred()) SWIG_fail;
20038 }
20039 resultobj = SWIG_From_int(static_cast< int >(result));
20040 return resultobj;
20041 fail:
20042 return NULL;
20043 }
20044
20045
20046 SWIGINTERN PyObject *_wrap_MouseEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20047 PyObject *resultobj = 0;
20048 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20049 bool result;
20050 void *argp1 = 0 ;
20051 int res1 = 0 ;
20052 PyObject *swig_obj[1] ;
20053
20054 if (!args) SWIG_fail;
20055 swig_obj[0] = args;
20056 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20057 if (!SWIG_IsOK(res1)) {
20058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ControlDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20059 }
20060 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20061 {
20062 PyThreadState* __tstate = wxPyBeginAllowThreads();
20063 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
20064 wxPyEndAllowThreads(__tstate);
20065 if (PyErr_Occurred()) SWIG_fail;
20066 }
20067 {
20068 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20069 }
20070 return resultobj;
20071 fail:
20072 return NULL;
20073 }
20074
20075
20076 SWIGINTERN PyObject *_wrap_MouseEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20077 PyObject *resultobj = 0;
20078 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20079 bool result;
20080 void *argp1 = 0 ;
20081 int res1 = 0 ;
20082 PyObject *swig_obj[1] ;
20083
20084 if (!args) SWIG_fail;
20085 swig_obj[0] = args;
20086 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20087 if (!SWIG_IsOK(res1)) {
20088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MetaDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20089 }
20090 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20091 {
20092 PyThreadState* __tstate = wxPyBeginAllowThreads();
20093 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
20094 wxPyEndAllowThreads(__tstate);
20095 if (PyErr_Occurred()) SWIG_fail;
20096 }
20097 {
20098 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20099 }
20100 return resultobj;
20101 fail:
20102 return NULL;
20103 }
20104
20105
20106 SWIGINTERN PyObject *_wrap_MouseEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20107 PyObject *resultobj = 0;
20108 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20109 bool result;
20110 void *argp1 = 0 ;
20111 int res1 = 0 ;
20112 PyObject *swig_obj[1] ;
20113
20114 if (!args) SWIG_fail;
20115 swig_obj[0] = args;
20116 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20117 if (!SWIG_IsOK(res1)) {
20118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_AltDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20119 }
20120 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20121 {
20122 PyThreadState* __tstate = wxPyBeginAllowThreads();
20123 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
20124 wxPyEndAllowThreads(__tstate);
20125 if (PyErr_Occurred()) SWIG_fail;
20126 }
20127 {
20128 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20129 }
20130 return resultobj;
20131 fail:
20132 return NULL;
20133 }
20134
20135
20136 SWIGINTERN PyObject *_wrap_MouseEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20137 PyObject *resultobj = 0;
20138 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20139 bool result;
20140 void *argp1 = 0 ;
20141 int res1 = 0 ;
20142 PyObject *swig_obj[1] ;
20143
20144 if (!args) SWIG_fail;
20145 swig_obj[0] = args;
20146 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20147 if (!SWIG_IsOK(res1)) {
20148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ShiftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20149 }
20150 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20151 {
20152 PyThreadState* __tstate = wxPyBeginAllowThreads();
20153 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
20154 wxPyEndAllowThreads(__tstate);
20155 if (PyErr_Occurred()) SWIG_fail;
20156 }
20157 {
20158 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20159 }
20160 return resultobj;
20161 fail:
20162 return NULL;
20163 }
20164
20165
20166 SWIGINTERN PyObject *_wrap_MouseEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20167 PyObject *resultobj = 0;
20168 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20169 bool result;
20170 void *argp1 = 0 ;
20171 int res1 = 0 ;
20172 PyObject *swig_obj[1] ;
20173
20174 if (!args) SWIG_fail;
20175 swig_obj[0] = args;
20176 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20177 if (!SWIG_IsOK(res1)) {
20178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_CmdDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20179 }
20180 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20181 {
20182 PyThreadState* __tstate = wxPyBeginAllowThreads();
20183 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
20184 wxPyEndAllowThreads(__tstate);
20185 if (PyErr_Occurred()) SWIG_fail;
20186 }
20187 {
20188 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20189 }
20190 return resultobj;
20191 fail:
20192 return NULL;
20193 }
20194
20195
20196 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20197 PyObject *resultobj = 0;
20198 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20199 bool result;
20200 void *argp1 = 0 ;
20201 int res1 = 0 ;
20202 PyObject *swig_obj[1] ;
20203
20204 if (!args) SWIG_fail;
20205 swig_obj[0] = args;
20206 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20207 if (!SWIG_IsOK(res1)) {
20208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20209 }
20210 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20211 {
20212 PyThreadState* __tstate = wxPyBeginAllowThreads();
20213 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
20214 wxPyEndAllowThreads(__tstate);
20215 if (PyErr_Occurred()) SWIG_fail;
20216 }
20217 {
20218 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20219 }
20220 return resultobj;
20221 fail:
20222 return NULL;
20223 }
20224
20225
20226 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20227 PyObject *resultobj = 0;
20228 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20229 bool result;
20230 void *argp1 = 0 ;
20231 int res1 = 0 ;
20232 PyObject *swig_obj[1] ;
20233
20234 if (!args) SWIG_fail;
20235 swig_obj[0] = args;
20236 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20237 if (!SWIG_IsOK(res1)) {
20238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20239 }
20240 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20241 {
20242 PyThreadState* __tstate = wxPyBeginAllowThreads();
20243 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
20244 wxPyEndAllowThreads(__tstate);
20245 if (PyErr_Occurred()) SWIG_fail;
20246 }
20247 {
20248 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20249 }
20250 return resultobj;
20251 fail:
20252 return NULL;
20253 }
20254
20255
20256 SWIGINTERN PyObject *_wrap_MouseEvent_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20257 PyObject *resultobj = 0;
20258 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20259 bool result;
20260 void *argp1 = 0 ;
20261 int res1 = 0 ;
20262 PyObject *swig_obj[1] ;
20263
20264 if (!args) SWIG_fail;
20265 swig_obj[0] = args;
20266 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20267 if (!SWIG_IsOK(res1)) {
20268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20269 }
20270 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20271 {
20272 PyThreadState* __tstate = wxPyBeginAllowThreads();
20273 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
20274 wxPyEndAllowThreads(__tstate);
20275 if (PyErr_Occurred()) SWIG_fail;
20276 }
20277 {
20278 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20279 }
20280 return resultobj;
20281 fail:
20282 return NULL;
20283 }
20284
20285
20286 SWIGINTERN PyObject *_wrap_MouseEvent_LeftUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20287 PyObject *resultobj = 0;
20288 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20289 bool result;
20290 void *argp1 = 0 ;
20291 int res1 = 0 ;
20292 PyObject *swig_obj[1] ;
20293
20294 if (!args) SWIG_fail;
20295 swig_obj[0] = args;
20296 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20297 if (!SWIG_IsOK(res1)) {
20298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20299 }
20300 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20301 {
20302 PyThreadState* __tstate = wxPyBeginAllowThreads();
20303 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
20304 wxPyEndAllowThreads(__tstate);
20305 if (PyErr_Occurred()) SWIG_fail;
20306 }
20307 {
20308 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20309 }
20310 return resultobj;
20311 fail:
20312 return NULL;
20313 }
20314
20315
20316 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20317 PyObject *resultobj = 0;
20318 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20319 bool result;
20320 void *argp1 = 0 ;
20321 int res1 = 0 ;
20322 PyObject *swig_obj[1] ;
20323
20324 if (!args) SWIG_fail;
20325 swig_obj[0] = args;
20326 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20327 if (!SWIG_IsOK(res1)) {
20328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20329 }
20330 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20331 {
20332 PyThreadState* __tstate = wxPyBeginAllowThreads();
20333 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
20334 wxPyEndAllowThreads(__tstate);
20335 if (PyErr_Occurred()) SWIG_fail;
20336 }
20337 {
20338 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20339 }
20340 return resultobj;
20341 fail:
20342 return NULL;
20343 }
20344
20345
20346 SWIGINTERN PyObject *_wrap_MouseEvent_RightUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20347 PyObject *resultobj = 0;
20348 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20349 bool result;
20350 void *argp1 = 0 ;
20351 int res1 = 0 ;
20352 PyObject *swig_obj[1] ;
20353
20354 if (!args) SWIG_fail;
20355 swig_obj[0] = args;
20356 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20357 if (!SWIG_IsOK(res1)) {
20358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20359 }
20360 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20361 {
20362 PyThreadState* __tstate = wxPyBeginAllowThreads();
20363 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
20364 wxPyEndAllowThreads(__tstate);
20365 if (PyErr_Occurred()) SWIG_fail;
20366 }
20367 {
20368 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20369 }
20370 return resultobj;
20371 fail:
20372 return NULL;
20373 }
20374
20375
20376 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20377 PyObject *resultobj = 0;
20378 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20379 bool result;
20380 void *argp1 = 0 ;
20381 int res1 = 0 ;
20382 PyObject *swig_obj[1] ;
20383
20384 if (!args) SWIG_fail;
20385 swig_obj[0] = args;
20386 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20387 if (!SWIG_IsOK(res1)) {
20388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20389 }
20390 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20391 {
20392 PyThreadState* __tstate = wxPyBeginAllowThreads();
20393 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
20394 wxPyEndAllowThreads(__tstate);
20395 if (PyErr_Occurred()) SWIG_fail;
20396 }
20397 {
20398 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20399 }
20400 return resultobj;
20401 fail:
20402 return NULL;
20403 }
20404
20405
20406 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20407 PyObject *resultobj = 0;
20408 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20409 bool result;
20410 void *argp1 = 0 ;
20411 int res1 = 0 ;
20412 PyObject *swig_obj[1] ;
20413
20414 if (!args) SWIG_fail;
20415 swig_obj[0] = args;
20416 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20417 if (!SWIG_IsOK(res1)) {
20418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20419 }
20420 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20421 {
20422 PyThreadState* __tstate = wxPyBeginAllowThreads();
20423 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
20424 wxPyEndAllowThreads(__tstate);
20425 if (PyErr_Occurred()) SWIG_fail;
20426 }
20427 {
20428 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20429 }
20430 return resultobj;
20431 fail:
20432 return NULL;
20433 }
20434
20435
20436 SWIGINTERN PyObject *_wrap_MouseEvent_RightDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20437 PyObject *resultobj = 0;
20438 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20439 bool result;
20440 void *argp1 = 0 ;
20441 int res1 = 0 ;
20442 PyObject *swig_obj[1] ;
20443
20444 if (!args) SWIG_fail;
20445 swig_obj[0] = args;
20446 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20447 if (!SWIG_IsOK(res1)) {
20448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20449 }
20450 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20451 {
20452 PyThreadState* __tstate = wxPyBeginAllowThreads();
20453 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
20454 wxPyEndAllowThreads(__tstate);
20455 if (PyErr_Occurred()) SWIG_fail;
20456 }
20457 {
20458 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20459 }
20460 return resultobj;
20461 fail:
20462 return NULL;
20463 }
20464
20465
20466 SWIGINTERN PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20467 PyObject *resultobj = 0;
20468 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20469 bool result;
20470 void *argp1 = 0 ;
20471 int res1 = 0 ;
20472 PyObject *swig_obj[1] ;
20473
20474 if (!args) SWIG_fail;
20475 swig_obj[0] = args;
20476 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20477 if (!SWIG_IsOK(res1)) {
20478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20479 }
20480 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20481 {
20482 PyThreadState* __tstate = wxPyBeginAllowThreads();
20483 result = (bool)(arg1)->LeftIsDown();
20484 wxPyEndAllowThreads(__tstate);
20485 if (PyErr_Occurred()) SWIG_fail;
20486 }
20487 {
20488 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20489 }
20490 return resultobj;
20491 fail:
20492 return NULL;
20493 }
20494
20495
20496 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20497 PyObject *resultobj = 0;
20498 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20499 bool result;
20500 void *argp1 = 0 ;
20501 int res1 = 0 ;
20502 PyObject *swig_obj[1] ;
20503
20504 if (!args) SWIG_fail;
20505 swig_obj[0] = args;
20506 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20507 if (!SWIG_IsOK(res1)) {
20508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20509 }
20510 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20511 {
20512 PyThreadState* __tstate = wxPyBeginAllowThreads();
20513 result = (bool)(arg1)->MiddleIsDown();
20514 wxPyEndAllowThreads(__tstate);
20515 if (PyErr_Occurred()) SWIG_fail;
20516 }
20517 {
20518 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20519 }
20520 return resultobj;
20521 fail:
20522 return NULL;
20523 }
20524
20525
20526 SWIGINTERN PyObject *_wrap_MouseEvent_RightIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20527 PyObject *resultobj = 0;
20528 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20529 bool result;
20530 void *argp1 = 0 ;
20531 int res1 = 0 ;
20532 PyObject *swig_obj[1] ;
20533
20534 if (!args) SWIG_fail;
20535 swig_obj[0] = args;
20536 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20537 if (!SWIG_IsOK(res1)) {
20538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20539 }
20540 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20541 {
20542 PyThreadState* __tstate = wxPyBeginAllowThreads();
20543 result = (bool)(arg1)->RightIsDown();
20544 wxPyEndAllowThreads(__tstate);
20545 if (PyErr_Occurred()) SWIG_fail;
20546 }
20547 {
20548 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20549 }
20550 return resultobj;
20551 fail:
20552 return NULL;
20553 }
20554
20555
20556 SWIGINTERN PyObject *_wrap_MouseEvent_Dragging(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20557 PyObject *resultobj = 0;
20558 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20559 bool result;
20560 void *argp1 = 0 ;
20561 int res1 = 0 ;
20562 PyObject *swig_obj[1] ;
20563
20564 if (!args) SWIG_fail;
20565 swig_obj[0] = args;
20566 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20567 if (!SWIG_IsOK(res1)) {
20568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Dragging" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20569 }
20570 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20571 {
20572 PyThreadState* __tstate = wxPyBeginAllowThreads();
20573 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
20574 wxPyEndAllowThreads(__tstate);
20575 if (PyErr_Occurred()) SWIG_fail;
20576 }
20577 {
20578 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20579 }
20580 return resultobj;
20581 fail:
20582 return NULL;
20583 }
20584
20585
20586 SWIGINTERN PyObject *_wrap_MouseEvent_Moving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20587 PyObject *resultobj = 0;
20588 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20589 bool result;
20590 void *argp1 = 0 ;
20591 int res1 = 0 ;
20592 PyObject *swig_obj[1] ;
20593
20594 if (!args) SWIG_fail;
20595 swig_obj[0] = args;
20596 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20597 if (!SWIG_IsOK(res1)) {
20598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Moving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20599 }
20600 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20601 {
20602 PyThreadState* __tstate = wxPyBeginAllowThreads();
20603 result = (bool)((wxMouseEvent const *)arg1)->Moving();
20604 wxPyEndAllowThreads(__tstate);
20605 if (PyErr_Occurred()) SWIG_fail;
20606 }
20607 {
20608 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20609 }
20610 return resultobj;
20611 fail:
20612 return NULL;
20613 }
20614
20615
20616 SWIGINTERN PyObject *_wrap_MouseEvent_Entering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20617 PyObject *resultobj = 0;
20618 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20619 bool result;
20620 void *argp1 = 0 ;
20621 int res1 = 0 ;
20622 PyObject *swig_obj[1] ;
20623
20624 if (!args) SWIG_fail;
20625 swig_obj[0] = args;
20626 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20627 if (!SWIG_IsOK(res1)) {
20628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Entering" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20629 }
20630 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20631 {
20632 PyThreadState* __tstate = wxPyBeginAllowThreads();
20633 result = (bool)((wxMouseEvent const *)arg1)->Entering();
20634 wxPyEndAllowThreads(__tstate);
20635 if (PyErr_Occurred()) SWIG_fail;
20636 }
20637 {
20638 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20639 }
20640 return resultobj;
20641 fail:
20642 return NULL;
20643 }
20644
20645
20646 SWIGINTERN PyObject *_wrap_MouseEvent_Leaving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20647 PyObject *resultobj = 0;
20648 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20649 bool result;
20650 void *argp1 = 0 ;
20651 int res1 = 0 ;
20652 PyObject *swig_obj[1] ;
20653
20654 if (!args) SWIG_fail;
20655 swig_obj[0] = args;
20656 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20657 if (!SWIG_IsOK(res1)) {
20658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Leaving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20659 }
20660 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20661 {
20662 PyThreadState* __tstate = wxPyBeginAllowThreads();
20663 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
20664 wxPyEndAllowThreads(__tstate);
20665 if (PyErr_Occurred()) SWIG_fail;
20666 }
20667 {
20668 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20669 }
20670 return resultobj;
20671 fail:
20672 return NULL;
20673 }
20674
20675
20676 SWIGINTERN PyObject *_wrap_MouseEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20677 PyObject *resultobj = 0;
20678 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20679 wxPoint result;
20680 void *argp1 = 0 ;
20681 int res1 = 0 ;
20682 PyObject *swig_obj[1] ;
20683
20684 if (!args) SWIG_fail;
20685 swig_obj[0] = args;
20686 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20687 if (!SWIG_IsOK(res1)) {
20688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPosition" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20689 }
20690 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20691 {
20692 PyThreadState* __tstate = wxPyBeginAllowThreads();
20693 result = (arg1)->GetPosition();
20694 wxPyEndAllowThreads(__tstate);
20695 if (PyErr_Occurred()) SWIG_fail;
20696 }
20697 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
20698 return resultobj;
20699 fail:
20700 return NULL;
20701 }
20702
20703
20704 SWIGINTERN PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20705 PyObject *resultobj = 0;
20706 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20707 long *arg2 = (long *) 0 ;
20708 long *arg3 = (long *) 0 ;
20709 void *argp1 = 0 ;
20710 int res1 = 0 ;
20711 long temp2 ;
20712 int res2 = SWIG_TMPOBJ ;
20713 long temp3 ;
20714 int res3 = SWIG_TMPOBJ ;
20715 PyObject *swig_obj[1] ;
20716
20717 arg2 = &temp2;
20718 arg3 = &temp3;
20719 if (!args) SWIG_fail;
20720 swig_obj[0] = args;
20721 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20722 if (!SWIG_IsOK(res1)) {
20723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20724 }
20725 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20726 {
20727 PyThreadState* __tstate = wxPyBeginAllowThreads();
20728 (arg1)->GetPosition(arg2,arg3);
20729 wxPyEndAllowThreads(__tstate);
20730 if (PyErr_Occurred()) SWIG_fail;
20731 }
20732 resultobj = SWIG_Py_Void();
20733 if (SWIG_IsTmpObj(res2)) {
20734 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
20735 } else {
20736 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20737 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
20738 }
20739 if (SWIG_IsTmpObj(res3)) {
20740 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
20741 } else {
20742 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20743 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
20744 }
20745 return resultobj;
20746 fail:
20747 return NULL;
20748 }
20749
20750
20751 SWIGINTERN PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20752 PyObject *resultobj = 0;
20753 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20754 wxDC *arg2 = 0 ;
20755 wxPoint result;
20756 void *argp1 = 0 ;
20757 int res1 = 0 ;
20758 void *argp2 = 0 ;
20759 int res2 = 0 ;
20760 PyObject * obj0 = 0 ;
20761 PyObject * obj1 = 0 ;
20762 char * kwnames[] = {
20763 (char *) "self",(char *) "dc", NULL
20764 };
20765
20766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) SWIG_fail;
20767 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20768 if (!SWIG_IsOK(res1)) {
20769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20770 }
20771 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20772 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
20773 if (!SWIG_IsOK(res2)) {
20774 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
20775 }
20776 if (!argp2) {
20777 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
20778 }
20779 arg2 = reinterpret_cast< wxDC * >(argp2);
20780 {
20781 PyThreadState* __tstate = wxPyBeginAllowThreads();
20782 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
20783 wxPyEndAllowThreads(__tstate);
20784 if (PyErr_Occurred()) SWIG_fail;
20785 }
20786 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
20787 return resultobj;
20788 fail:
20789 return NULL;
20790 }
20791
20792
20793 SWIGINTERN PyObject *_wrap_MouseEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20794 PyObject *resultobj = 0;
20795 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20796 int result;
20797 void *argp1 = 0 ;
20798 int res1 = 0 ;
20799 PyObject *swig_obj[1] ;
20800
20801 if (!args) SWIG_fail;
20802 swig_obj[0] = args;
20803 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20804 if (!SWIG_IsOK(res1)) {
20805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetX" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20806 }
20807 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20808 {
20809 PyThreadState* __tstate = wxPyBeginAllowThreads();
20810 result = (int)((wxMouseEvent const *)arg1)->GetX();
20811 wxPyEndAllowThreads(__tstate);
20812 if (PyErr_Occurred()) SWIG_fail;
20813 }
20814 resultobj = SWIG_From_int(static_cast< int >(result));
20815 return resultobj;
20816 fail:
20817 return NULL;
20818 }
20819
20820
20821 SWIGINTERN PyObject *_wrap_MouseEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20822 PyObject *resultobj = 0;
20823 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20824 int result;
20825 void *argp1 = 0 ;
20826 int res1 = 0 ;
20827 PyObject *swig_obj[1] ;
20828
20829 if (!args) SWIG_fail;
20830 swig_obj[0] = args;
20831 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20832 if (!SWIG_IsOK(res1)) {
20833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetY" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20834 }
20835 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20836 {
20837 PyThreadState* __tstate = wxPyBeginAllowThreads();
20838 result = (int)((wxMouseEvent const *)arg1)->GetY();
20839 wxPyEndAllowThreads(__tstate);
20840 if (PyErr_Occurred()) SWIG_fail;
20841 }
20842 resultobj = SWIG_From_int(static_cast< int >(result));
20843 return resultobj;
20844 fail:
20845 return NULL;
20846 }
20847
20848
20849 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20850 PyObject *resultobj = 0;
20851 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20852 int result;
20853 void *argp1 = 0 ;
20854 int res1 = 0 ;
20855 PyObject *swig_obj[1] ;
20856
20857 if (!args) SWIG_fail;
20858 swig_obj[0] = args;
20859 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20860 if (!SWIG_IsOK(res1)) {
20861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelRotation" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20862 }
20863 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20864 {
20865 PyThreadState* __tstate = wxPyBeginAllowThreads();
20866 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
20867 wxPyEndAllowThreads(__tstate);
20868 if (PyErr_Occurred()) SWIG_fail;
20869 }
20870 resultobj = SWIG_From_int(static_cast< int >(result));
20871 return resultobj;
20872 fail:
20873 return NULL;
20874 }
20875
20876
20877 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20878 PyObject *resultobj = 0;
20879 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20880 int result;
20881 void *argp1 = 0 ;
20882 int res1 = 0 ;
20883 PyObject *swig_obj[1] ;
20884
20885 if (!args) SWIG_fail;
20886 swig_obj[0] = args;
20887 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20888 if (!SWIG_IsOK(res1)) {
20889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelDelta" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20890 }
20891 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20892 {
20893 PyThreadState* __tstate = wxPyBeginAllowThreads();
20894 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
20895 wxPyEndAllowThreads(__tstate);
20896 if (PyErr_Occurred()) SWIG_fail;
20897 }
20898 resultobj = SWIG_From_int(static_cast< int >(result));
20899 return resultobj;
20900 fail:
20901 return NULL;
20902 }
20903
20904
20905 SWIGINTERN PyObject *_wrap_MouseEvent_GetLinesPerAction(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_GetLinesPerAction" "', 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)->GetLinesPerAction();
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_IsPageScroll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20934 PyObject *resultobj = 0;
20935 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20936 bool 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_IsPageScroll" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20946 }
20947 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20948 {
20949 PyThreadState* __tstate = wxPyBeginAllowThreads();
20950 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
20951 wxPyEndAllowThreads(__tstate);
20952 if (PyErr_Occurred()) SWIG_fail;
20953 }
20954 {
20955 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20956 }
20957 return resultobj;
20958 fail:
20959 return NULL;
20960 }
20961
20962
20963 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20964 PyObject *resultobj = 0;
20965 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20966 int arg2 ;
20967 void *argp1 = 0 ;
20968 int res1 = 0 ;
20969 int val2 ;
20970 int ecode2 = 0 ;
20971 PyObject *swig_obj[2] ;
20972
20973 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
20974 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20975 if (!SWIG_IsOK(res1)) {
20976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20977 }
20978 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20979 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
20980 if (!SWIG_IsOK(ecode2)) {
20981 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
20982 }
20983 arg2 = static_cast< int >(val2);
20984 if (arg1) (arg1)->m_x = arg2;
20985
20986 resultobj = SWIG_Py_Void();
20987 return resultobj;
20988 fail:
20989 return NULL;
20990 }
20991
20992
20993 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20994 PyObject *resultobj = 0;
20995 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20996 int result;
20997 void *argp1 = 0 ;
20998 int res1 = 0 ;
20999 PyObject *swig_obj[1] ;
21000
21001 if (!args) SWIG_fail;
21002 swig_obj[0] = args;
21003 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21004 if (!SWIG_IsOK(res1)) {
21005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21006 }
21007 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21008 result = (int) ((arg1)->m_x);
21009 resultobj = SWIG_From_int(static_cast< int >(result));
21010 return resultobj;
21011 fail:
21012 return NULL;
21013 }
21014
21015
21016 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21017 PyObject *resultobj = 0;
21018 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21019 int arg2 ;
21020 void *argp1 = 0 ;
21021 int res1 = 0 ;
21022 int val2 ;
21023 int ecode2 = 0 ;
21024 PyObject *swig_obj[2] ;
21025
21026 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
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_m_y_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21030 }
21031 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21032 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21033 if (!SWIG_IsOK(ecode2)) {
21034 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
21035 }
21036 arg2 = static_cast< int >(val2);
21037 if (arg1) (arg1)->m_y = arg2;
21038
21039 resultobj = SWIG_Py_Void();
21040 return resultobj;
21041 fail:
21042 return NULL;
21043 }
21044
21045
21046 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21047 PyObject *resultobj = 0;
21048 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21049 int result;
21050 void *argp1 = 0 ;
21051 int res1 = 0 ;
21052 PyObject *swig_obj[1] ;
21053
21054 if (!args) SWIG_fail;
21055 swig_obj[0] = args;
21056 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21057 if (!SWIG_IsOK(res1)) {
21058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21059 }
21060 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21061 result = (int) ((arg1)->m_y);
21062 resultobj = SWIG_From_int(static_cast< int >(result));
21063 return resultobj;
21064 fail:
21065 return NULL;
21066 }
21067
21068
21069 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21070 PyObject *resultobj = 0;
21071 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21072 bool arg2 ;
21073 void *argp1 = 0 ;
21074 int res1 = 0 ;
21075 bool val2 ;
21076 int ecode2 = 0 ;
21077 PyObject *swig_obj[2] ;
21078
21079 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_leftDown_set",2,2,swig_obj)) SWIG_fail;
21080 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21081 if (!SWIG_IsOK(res1)) {
21082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21083 }
21084 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21085 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21086 if (!SWIG_IsOK(ecode2)) {
21087 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "2"" of type '" "bool""'");
21088 }
21089 arg2 = static_cast< bool >(val2);
21090 if (arg1) (arg1)->m_leftDown = arg2;
21091
21092 resultobj = SWIG_Py_Void();
21093 return resultobj;
21094 fail:
21095 return NULL;
21096 }
21097
21098
21099 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21100 PyObject *resultobj = 0;
21101 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21102 bool result;
21103 void *argp1 = 0 ;
21104 int res1 = 0 ;
21105 PyObject *swig_obj[1] ;
21106
21107 if (!args) SWIG_fail;
21108 swig_obj[0] = args;
21109 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21110 if (!SWIG_IsOK(res1)) {
21111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21112 }
21113 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21114 result = (bool) ((arg1)->m_leftDown);
21115 {
21116 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21117 }
21118 return resultobj;
21119 fail:
21120 return NULL;
21121 }
21122
21123
21124 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21125 PyObject *resultobj = 0;
21126 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21127 bool arg2 ;
21128 void *argp1 = 0 ;
21129 int res1 = 0 ;
21130 bool val2 ;
21131 int ecode2 = 0 ;
21132 PyObject *swig_obj[2] ;
21133
21134 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_middleDown_set",2,2,swig_obj)) SWIG_fail;
21135 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21136 if (!SWIG_IsOK(res1)) {
21137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21138 }
21139 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21140 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21141 if (!SWIG_IsOK(ecode2)) {
21142 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "2"" of type '" "bool""'");
21143 }
21144 arg2 = static_cast< bool >(val2);
21145 if (arg1) (arg1)->m_middleDown = arg2;
21146
21147 resultobj = SWIG_Py_Void();
21148 return resultobj;
21149 fail:
21150 return NULL;
21151 }
21152
21153
21154 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21155 PyObject *resultobj = 0;
21156 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21157 bool result;
21158 void *argp1 = 0 ;
21159 int res1 = 0 ;
21160 PyObject *swig_obj[1] ;
21161
21162 if (!args) SWIG_fail;
21163 swig_obj[0] = args;
21164 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21165 if (!SWIG_IsOK(res1)) {
21166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21167 }
21168 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21169 result = (bool) ((arg1)->m_middleDown);
21170 {
21171 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21172 }
21173 return resultobj;
21174 fail:
21175 return NULL;
21176 }
21177
21178
21179 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21180 PyObject *resultobj = 0;
21181 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21182 bool arg2 ;
21183 void *argp1 = 0 ;
21184 int res1 = 0 ;
21185 bool val2 ;
21186 int ecode2 = 0 ;
21187 PyObject *swig_obj[2] ;
21188
21189 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_rightDown_set",2,2,swig_obj)) SWIG_fail;
21190 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21191 if (!SWIG_IsOK(res1)) {
21192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21193 }
21194 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21195 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21196 if (!SWIG_IsOK(ecode2)) {
21197 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "2"" of type '" "bool""'");
21198 }
21199 arg2 = static_cast< bool >(val2);
21200 if (arg1) (arg1)->m_rightDown = arg2;
21201
21202 resultobj = SWIG_Py_Void();
21203 return resultobj;
21204 fail:
21205 return NULL;
21206 }
21207
21208
21209 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21210 PyObject *resultobj = 0;
21211 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21212 bool result;
21213 void *argp1 = 0 ;
21214 int res1 = 0 ;
21215 PyObject *swig_obj[1] ;
21216
21217 if (!args) SWIG_fail;
21218 swig_obj[0] = args;
21219 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21220 if (!SWIG_IsOK(res1)) {
21221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21222 }
21223 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21224 result = (bool) ((arg1)->m_rightDown);
21225 {
21226 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21227 }
21228 return resultobj;
21229 fail:
21230 return NULL;
21231 }
21232
21233
21234 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21235 PyObject *resultobj = 0;
21236 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21237 bool arg2 ;
21238 void *argp1 = 0 ;
21239 int res1 = 0 ;
21240 bool val2 ;
21241 int ecode2 = 0 ;
21242 PyObject *swig_obj[2] ;
21243
21244 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
21245 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21246 if (!SWIG_IsOK(res1)) {
21247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21248 }
21249 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21250 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21251 if (!SWIG_IsOK(ecode2)) {
21252 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
21253 }
21254 arg2 = static_cast< bool >(val2);
21255 if (arg1) (arg1)->m_controlDown = arg2;
21256
21257 resultobj = SWIG_Py_Void();
21258 return resultobj;
21259 fail:
21260 return NULL;
21261 }
21262
21263
21264 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21265 PyObject *resultobj = 0;
21266 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21267 bool result;
21268 void *argp1 = 0 ;
21269 int res1 = 0 ;
21270 PyObject *swig_obj[1] ;
21271
21272 if (!args) SWIG_fail;
21273 swig_obj[0] = args;
21274 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21275 if (!SWIG_IsOK(res1)) {
21276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21277 }
21278 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21279 result = (bool) ((arg1)->m_controlDown);
21280 {
21281 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21282 }
21283 return resultobj;
21284 fail:
21285 return NULL;
21286 }
21287
21288
21289 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21290 PyObject *resultobj = 0;
21291 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21292 bool arg2 ;
21293 void *argp1 = 0 ;
21294 int res1 = 0 ;
21295 bool val2 ;
21296 int ecode2 = 0 ;
21297 PyObject *swig_obj[2] ;
21298
21299 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
21300 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21301 if (!SWIG_IsOK(res1)) {
21302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21303 }
21304 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21305 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21306 if (!SWIG_IsOK(ecode2)) {
21307 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
21308 }
21309 arg2 = static_cast< bool >(val2);
21310 if (arg1) (arg1)->m_shiftDown = arg2;
21311
21312 resultobj = SWIG_Py_Void();
21313 return resultobj;
21314 fail:
21315 return NULL;
21316 }
21317
21318
21319 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21320 PyObject *resultobj = 0;
21321 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21322 bool result;
21323 void *argp1 = 0 ;
21324 int res1 = 0 ;
21325 PyObject *swig_obj[1] ;
21326
21327 if (!args) SWIG_fail;
21328 swig_obj[0] = args;
21329 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21330 if (!SWIG_IsOK(res1)) {
21331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21332 }
21333 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21334 result = (bool) ((arg1)->m_shiftDown);
21335 {
21336 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21337 }
21338 return resultobj;
21339 fail:
21340 return NULL;
21341 }
21342
21343
21344 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21345 PyObject *resultobj = 0;
21346 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21347 bool arg2 ;
21348 void *argp1 = 0 ;
21349 int res1 = 0 ;
21350 bool val2 ;
21351 int ecode2 = 0 ;
21352 PyObject *swig_obj[2] ;
21353
21354 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
21355 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21356 if (!SWIG_IsOK(res1)) {
21357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21358 }
21359 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21360 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21361 if (!SWIG_IsOK(ecode2)) {
21362 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
21363 }
21364 arg2 = static_cast< bool >(val2);
21365 if (arg1) (arg1)->m_altDown = arg2;
21366
21367 resultobj = SWIG_Py_Void();
21368 return resultobj;
21369 fail:
21370 return NULL;
21371 }
21372
21373
21374 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21375 PyObject *resultobj = 0;
21376 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21377 bool result;
21378 void *argp1 = 0 ;
21379 int res1 = 0 ;
21380 PyObject *swig_obj[1] ;
21381
21382 if (!args) SWIG_fail;
21383 swig_obj[0] = args;
21384 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21385 if (!SWIG_IsOK(res1)) {
21386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21387 }
21388 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21389 result = (bool) ((arg1)->m_altDown);
21390 {
21391 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21392 }
21393 return resultobj;
21394 fail:
21395 return NULL;
21396 }
21397
21398
21399 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21400 PyObject *resultobj = 0;
21401 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21402 bool arg2 ;
21403 void *argp1 = 0 ;
21404 int res1 = 0 ;
21405 bool val2 ;
21406 int ecode2 = 0 ;
21407 PyObject *swig_obj[2] ;
21408
21409 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
21410 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21411 if (!SWIG_IsOK(res1)) {
21412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21413 }
21414 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21415 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21416 if (!SWIG_IsOK(ecode2)) {
21417 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
21418 }
21419 arg2 = static_cast< bool >(val2);
21420 if (arg1) (arg1)->m_metaDown = arg2;
21421
21422 resultobj = SWIG_Py_Void();
21423 return resultobj;
21424 fail:
21425 return NULL;
21426 }
21427
21428
21429 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21430 PyObject *resultobj = 0;
21431 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21432 bool result;
21433 void *argp1 = 0 ;
21434 int res1 = 0 ;
21435 PyObject *swig_obj[1] ;
21436
21437 if (!args) SWIG_fail;
21438 swig_obj[0] = args;
21439 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21440 if (!SWIG_IsOK(res1)) {
21441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21442 }
21443 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21444 result = (bool) ((arg1)->m_metaDown);
21445 {
21446 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21447 }
21448 return resultobj;
21449 fail:
21450 return NULL;
21451 }
21452
21453
21454 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21455 PyObject *resultobj = 0;
21456 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21457 int arg2 ;
21458 void *argp1 = 0 ;
21459 int res1 = 0 ;
21460 int val2 ;
21461 int ecode2 = 0 ;
21462 PyObject *swig_obj[2] ;
21463
21464 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelRotation_set",2,2,swig_obj)) SWIG_fail;
21465 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21466 if (!SWIG_IsOK(res1)) {
21467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21468 }
21469 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21470 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21471 if (!SWIG_IsOK(ecode2)) {
21472 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "2"" of type '" "int""'");
21473 }
21474 arg2 = static_cast< int >(val2);
21475 if (arg1) (arg1)->m_wheelRotation = arg2;
21476
21477 resultobj = SWIG_Py_Void();
21478 return resultobj;
21479 fail:
21480 return NULL;
21481 }
21482
21483
21484 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21485 PyObject *resultobj = 0;
21486 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21487 int result;
21488 void *argp1 = 0 ;
21489 int res1 = 0 ;
21490 PyObject *swig_obj[1] ;
21491
21492 if (!args) SWIG_fail;
21493 swig_obj[0] = args;
21494 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21495 if (!SWIG_IsOK(res1)) {
21496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21497 }
21498 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21499 result = (int) ((arg1)->m_wheelRotation);
21500 resultobj = SWIG_From_int(static_cast< int >(result));
21501 return resultobj;
21502 fail:
21503 return NULL;
21504 }
21505
21506
21507 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21508 PyObject *resultobj = 0;
21509 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21510 int arg2 ;
21511 void *argp1 = 0 ;
21512 int res1 = 0 ;
21513 int val2 ;
21514 int ecode2 = 0 ;
21515 PyObject *swig_obj[2] ;
21516
21517 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelDelta_set",2,2,swig_obj)) SWIG_fail;
21518 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21519 if (!SWIG_IsOK(res1)) {
21520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21521 }
21522 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21523 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21524 if (!SWIG_IsOK(ecode2)) {
21525 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "2"" of type '" "int""'");
21526 }
21527 arg2 = static_cast< int >(val2);
21528 if (arg1) (arg1)->m_wheelDelta = arg2;
21529
21530 resultobj = SWIG_Py_Void();
21531 return resultobj;
21532 fail:
21533 return NULL;
21534 }
21535
21536
21537 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21538 PyObject *resultobj = 0;
21539 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21540 int result;
21541 void *argp1 = 0 ;
21542 int res1 = 0 ;
21543 PyObject *swig_obj[1] ;
21544
21545 if (!args) SWIG_fail;
21546 swig_obj[0] = args;
21547 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21548 if (!SWIG_IsOK(res1)) {
21549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21550 }
21551 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21552 result = (int) ((arg1)->m_wheelDelta);
21553 resultobj = SWIG_From_int(static_cast< int >(result));
21554 return resultobj;
21555 fail:
21556 return NULL;
21557 }
21558
21559
21560 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21561 PyObject *resultobj = 0;
21562 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21563 int arg2 ;
21564 void *argp1 = 0 ;
21565 int res1 = 0 ;
21566 int val2 ;
21567 int ecode2 = 0 ;
21568 PyObject *swig_obj[2] ;
21569
21570 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_linesPerAction_set",2,2,swig_obj)) SWIG_fail;
21571 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21572 if (!SWIG_IsOK(res1)) {
21573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21574 }
21575 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21576 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21577 if (!SWIG_IsOK(ecode2)) {
21578 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "2"" of type '" "int""'");
21579 }
21580 arg2 = static_cast< int >(val2);
21581 if (arg1) (arg1)->m_linesPerAction = arg2;
21582
21583 resultobj = SWIG_Py_Void();
21584 return resultobj;
21585 fail:
21586 return NULL;
21587 }
21588
21589
21590 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21591 PyObject *resultobj = 0;
21592 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21593 int result;
21594 void *argp1 = 0 ;
21595 int res1 = 0 ;
21596 PyObject *swig_obj[1] ;
21597
21598 if (!args) SWIG_fail;
21599 swig_obj[0] = args;
21600 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21601 if (!SWIG_IsOK(res1)) {
21602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21603 }
21604 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21605 result = (int) ((arg1)->m_linesPerAction);
21606 resultobj = SWIG_From_int(static_cast< int >(result));
21607 return resultobj;
21608 fail:
21609 return NULL;
21610 }
21611
21612
21613 SWIGINTERN PyObject *MouseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21614 PyObject *obj;
21615 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21616 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseEvent, SWIG_NewClientData(obj));
21617 return SWIG_Py_Void();
21618 }
21619
21620 SWIGINTERN PyObject *MouseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21621 return SWIG_Python_InitShadowInstance(args);
21622 }
21623
21624 SWIGINTERN PyObject *_wrap_new_SetCursorEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21625 PyObject *resultobj = 0;
21626 int arg1 = (int) 0 ;
21627 int arg2 = (int) 0 ;
21628 wxSetCursorEvent *result = 0 ;
21629 int val1 ;
21630 int ecode1 = 0 ;
21631 int val2 ;
21632 int ecode2 = 0 ;
21633 PyObject * obj0 = 0 ;
21634 PyObject * obj1 = 0 ;
21635 char * kwnames[] = {
21636 (char *) "x",(char *) "y", NULL
21637 };
21638
21639 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) SWIG_fail;
21640 if (obj0) {
21641 ecode1 = SWIG_AsVal_int(obj0, &val1);
21642 if (!SWIG_IsOK(ecode1)) {
21643 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SetCursorEvent" "', expected argument " "1"" of type '" "int""'");
21644 }
21645 arg1 = static_cast< int >(val1);
21646 }
21647 if (obj1) {
21648 ecode2 = SWIG_AsVal_int(obj1, &val2);
21649 if (!SWIG_IsOK(ecode2)) {
21650 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SetCursorEvent" "', expected argument " "2"" of type '" "int""'");
21651 }
21652 arg2 = static_cast< int >(val2);
21653 }
21654 {
21655 PyThreadState* __tstate = wxPyBeginAllowThreads();
21656 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
21657 wxPyEndAllowThreads(__tstate);
21658 if (PyErr_Occurred()) SWIG_fail;
21659 }
21660 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_NEW | 0 );
21661 return resultobj;
21662 fail:
21663 return NULL;
21664 }
21665
21666
21667 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21668 PyObject *resultobj = 0;
21669 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21670 int result;
21671 void *argp1 = 0 ;
21672 int res1 = 0 ;
21673 PyObject *swig_obj[1] ;
21674
21675 if (!args) SWIG_fail;
21676 swig_obj[0] = args;
21677 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21678 if (!SWIG_IsOK(res1)) {
21679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetX" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21680 }
21681 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21682 {
21683 PyThreadState* __tstate = wxPyBeginAllowThreads();
21684 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
21685 wxPyEndAllowThreads(__tstate);
21686 if (PyErr_Occurred()) SWIG_fail;
21687 }
21688 resultobj = SWIG_From_int(static_cast< int >(result));
21689 return resultobj;
21690 fail:
21691 return NULL;
21692 }
21693
21694
21695 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21696 PyObject *resultobj = 0;
21697 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21698 int result;
21699 void *argp1 = 0 ;
21700 int res1 = 0 ;
21701 PyObject *swig_obj[1] ;
21702
21703 if (!args) SWIG_fail;
21704 swig_obj[0] = args;
21705 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21706 if (!SWIG_IsOK(res1)) {
21707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetY" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21708 }
21709 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21710 {
21711 PyThreadState* __tstate = wxPyBeginAllowThreads();
21712 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
21713 wxPyEndAllowThreads(__tstate);
21714 if (PyErr_Occurred()) SWIG_fail;
21715 }
21716 resultobj = SWIG_From_int(static_cast< int >(result));
21717 return resultobj;
21718 fail:
21719 return NULL;
21720 }
21721
21722
21723 SWIGINTERN PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21724 PyObject *resultobj = 0;
21725 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21726 wxCursor *arg2 = 0 ;
21727 void *argp1 = 0 ;
21728 int res1 = 0 ;
21729 void *argp2 = 0 ;
21730 int res2 = 0 ;
21731 PyObject * obj0 = 0 ;
21732 PyObject * obj1 = 0 ;
21733 char * kwnames[] = {
21734 (char *) "self",(char *) "cursor", NULL
21735 };
21736
21737 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
21738 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21739 if (!SWIG_IsOK(res1)) {
21740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent *""'");
21741 }
21742 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21743 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
21744 if (!SWIG_IsOK(res2)) {
21745 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
21746 }
21747 if (!argp2) {
21748 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
21749 }
21750 arg2 = reinterpret_cast< wxCursor * >(argp2);
21751 {
21752 PyThreadState* __tstate = wxPyBeginAllowThreads();
21753 (arg1)->SetCursor((wxCursor const &)*arg2);
21754 wxPyEndAllowThreads(__tstate);
21755 if (PyErr_Occurred()) SWIG_fail;
21756 }
21757 resultobj = SWIG_Py_Void();
21758 return resultobj;
21759 fail:
21760 return NULL;
21761 }
21762
21763
21764 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21765 PyObject *resultobj = 0;
21766 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21767 wxCursor *result = 0 ;
21768 void *argp1 = 0 ;
21769 int res1 = 0 ;
21770 PyObject *swig_obj[1] ;
21771
21772 if (!args) SWIG_fail;
21773 swig_obj[0] = args;
21774 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21775 if (!SWIG_IsOK(res1)) {
21776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21777 }
21778 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21779 {
21780 PyThreadState* __tstate = wxPyBeginAllowThreads();
21781 {
21782 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
21783 result = (wxCursor *) &_result_ref;
21784 }
21785 wxPyEndAllowThreads(__tstate);
21786 if (PyErr_Occurred()) SWIG_fail;
21787 }
21788 {
21789 wxCursor* resultptr = new wxCursor(*result);
21790 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
21791 }
21792 return resultobj;
21793 fail:
21794 return NULL;
21795 }
21796
21797
21798 SWIGINTERN PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21799 PyObject *resultobj = 0;
21800 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21801 bool result;
21802 void *argp1 = 0 ;
21803 int res1 = 0 ;
21804 PyObject *swig_obj[1] ;
21805
21806 if (!args) SWIG_fail;
21807 swig_obj[0] = args;
21808 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21809 if (!SWIG_IsOK(res1)) {
21810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_HasCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21811 }
21812 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21813 {
21814 PyThreadState* __tstate = wxPyBeginAllowThreads();
21815 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
21816 wxPyEndAllowThreads(__tstate);
21817 if (PyErr_Occurred()) SWIG_fail;
21818 }
21819 {
21820 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21821 }
21822 return resultobj;
21823 fail:
21824 return NULL;
21825 }
21826
21827
21828 SWIGINTERN PyObject *SetCursorEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21829 PyObject *obj;
21830 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21831 SWIG_TypeNewClientData(SWIGTYPE_p_wxSetCursorEvent, SWIG_NewClientData(obj));
21832 return SWIG_Py_Void();
21833 }
21834
21835 SWIGINTERN PyObject *SetCursorEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21836 return SWIG_Python_InitShadowInstance(args);
21837 }
21838
21839 SWIGINTERN PyObject *_wrap_new_KeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21840 PyObject *resultobj = 0;
21841 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21842 wxKeyEvent *result = 0 ;
21843 int val1 ;
21844 int ecode1 = 0 ;
21845 PyObject * obj0 = 0 ;
21846 char * kwnames[] = {
21847 (char *) "eventType", NULL
21848 };
21849
21850 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) SWIG_fail;
21851 if (obj0) {
21852 ecode1 = SWIG_AsVal_int(obj0, &val1);
21853 if (!SWIG_IsOK(ecode1)) {
21854 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_KeyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
21855 }
21856 arg1 = static_cast< wxEventType >(val1);
21857 }
21858 {
21859 PyThreadState* __tstate = wxPyBeginAllowThreads();
21860 result = (wxKeyEvent *)new wxKeyEvent(arg1);
21861 wxPyEndAllowThreads(__tstate);
21862 if (PyErr_Occurred()) SWIG_fail;
21863 }
21864 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_NEW | 0 );
21865 return resultobj;
21866 fail:
21867 return NULL;
21868 }
21869
21870
21871 SWIGINTERN PyObject *_wrap_KeyEvent_GetModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21872 PyObject *resultobj = 0;
21873 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21874 int result;
21875 void *argp1 = 0 ;
21876 int res1 = 0 ;
21877 PyObject *swig_obj[1] ;
21878
21879 if (!args) SWIG_fail;
21880 swig_obj[0] = args;
21881 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21882 if (!SWIG_IsOK(res1)) {
21883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21884 }
21885 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21886 {
21887 PyThreadState* __tstate = wxPyBeginAllowThreads();
21888 result = (int)((wxKeyEvent const *)arg1)->GetModifiers();
21889 wxPyEndAllowThreads(__tstate);
21890 if (PyErr_Occurred()) SWIG_fail;
21891 }
21892 resultobj = SWIG_From_int(static_cast< int >(result));
21893 return resultobj;
21894 fail:
21895 return NULL;
21896 }
21897
21898
21899 SWIGINTERN PyObject *_wrap_KeyEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21900 PyObject *resultobj = 0;
21901 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21902 bool result;
21903 void *argp1 = 0 ;
21904 int res1 = 0 ;
21905 PyObject *swig_obj[1] ;
21906
21907 if (!args) SWIG_fail;
21908 swig_obj[0] = args;
21909 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21910 if (!SWIG_IsOK(res1)) {
21911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ControlDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21912 }
21913 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21914 {
21915 PyThreadState* __tstate = wxPyBeginAllowThreads();
21916 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
21917 wxPyEndAllowThreads(__tstate);
21918 if (PyErr_Occurred()) SWIG_fail;
21919 }
21920 {
21921 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21922 }
21923 return resultobj;
21924 fail:
21925 return NULL;
21926 }
21927
21928
21929 SWIGINTERN PyObject *_wrap_KeyEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21930 PyObject *resultobj = 0;
21931 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21932 bool result;
21933 void *argp1 = 0 ;
21934 int res1 = 0 ;
21935 PyObject *swig_obj[1] ;
21936
21937 if (!args) SWIG_fail;
21938 swig_obj[0] = args;
21939 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21940 if (!SWIG_IsOK(res1)) {
21941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_MetaDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21942 }
21943 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21944 {
21945 PyThreadState* __tstate = wxPyBeginAllowThreads();
21946 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
21947 wxPyEndAllowThreads(__tstate);
21948 if (PyErr_Occurred()) SWIG_fail;
21949 }
21950 {
21951 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21952 }
21953 return resultobj;
21954 fail:
21955 return NULL;
21956 }
21957
21958
21959 SWIGINTERN PyObject *_wrap_KeyEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21960 PyObject *resultobj = 0;
21961 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21962 bool result;
21963 void *argp1 = 0 ;
21964 int res1 = 0 ;
21965 PyObject *swig_obj[1] ;
21966
21967 if (!args) SWIG_fail;
21968 swig_obj[0] = args;
21969 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21970 if (!SWIG_IsOK(res1)) {
21971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_AltDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21972 }
21973 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21974 {
21975 PyThreadState* __tstate = wxPyBeginAllowThreads();
21976 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
21977 wxPyEndAllowThreads(__tstate);
21978 if (PyErr_Occurred()) SWIG_fail;
21979 }
21980 {
21981 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21982 }
21983 return resultobj;
21984 fail:
21985 return NULL;
21986 }
21987
21988
21989 SWIGINTERN PyObject *_wrap_KeyEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21990 PyObject *resultobj = 0;
21991 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21992 bool result;
21993 void *argp1 = 0 ;
21994 int res1 = 0 ;
21995 PyObject *swig_obj[1] ;
21996
21997 if (!args) SWIG_fail;
21998 swig_obj[0] = args;
21999 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22000 if (!SWIG_IsOK(res1)) {
22001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ShiftDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22002 }
22003 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22004 {
22005 PyThreadState* __tstate = wxPyBeginAllowThreads();
22006 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
22007 wxPyEndAllowThreads(__tstate);
22008 if (PyErr_Occurred()) SWIG_fail;
22009 }
22010 {
22011 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22012 }
22013 return resultobj;
22014 fail:
22015 return NULL;
22016 }
22017
22018
22019 SWIGINTERN PyObject *_wrap_KeyEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22020 PyObject *resultobj = 0;
22021 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22022 bool result;
22023 void *argp1 = 0 ;
22024 int res1 = 0 ;
22025 PyObject *swig_obj[1] ;
22026
22027 if (!args) SWIG_fail;
22028 swig_obj[0] = args;
22029 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22030 if (!SWIG_IsOK(res1)) {
22031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_CmdDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22032 }
22033 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22034 {
22035 PyThreadState* __tstate = wxPyBeginAllowThreads();
22036 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
22037 wxPyEndAllowThreads(__tstate);
22038 if (PyErr_Occurred()) SWIG_fail;
22039 }
22040 {
22041 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22042 }
22043 return resultobj;
22044 fail:
22045 return NULL;
22046 }
22047
22048
22049 SWIGINTERN PyObject *_wrap_KeyEvent_HasModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22050 PyObject *resultobj = 0;
22051 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22052 bool result;
22053 void *argp1 = 0 ;
22054 int res1 = 0 ;
22055 PyObject *swig_obj[1] ;
22056
22057 if (!args) SWIG_fail;
22058 swig_obj[0] = args;
22059 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22060 if (!SWIG_IsOK(res1)) {
22061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_HasModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22062 }
22063 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22064 {
22065 PyThreadState* __tstate = wxPyBeginAllowThreads();
22066 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
22067 wxPyEndAllowThreads(__tstate);
22068 if (PyErr_Occurred()) SWIG_fail;
22069 }
22070 {
22071 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22072 }
22073 return resultobj;
22074 fail:
22075 return NULL;
22076 }
22077
22078
22079 SWIGINTERN PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22080 PyObject *resultobj = 0;
22081 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22082 int result;
22083 void *argp1 = 0 ;
22084 int res1 = 0 ;
22085 PyObject *swig_obj[1] ;
22086
22087 if (!args) SWIG_fail;
22088 swig_obj[0] = args;
22089 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22090 if (!SWIG_IsOK(res1)) {
22091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22092 }
22093 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22094 {
22095 PyThreadState* __tstate = wxPyBeginAllowThreads();
22096 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
22097 wxPyEndAllowThreads(__tstate);
22098 if (PyErr_Occurred()) SWIG_fail;
22099 }
22100 resultobj = SWIG_From_int(static_cast< int >(result));
22101 return resultobj;
22102 fail:
22103 return NULL;
22104 }
22105
22106
22107 SWIGINTERN PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22108 PyObject *resultobj = 0;
22109 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22110 int result;
22111 void *argp1 = 0 ;
22112 int res1 = 0 ;
22113 PyObject *swig_obj[1] ;
22114
22115 if (!args) SWIG_fail;
22116 swig_obj[0] = args;
22117 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22118 if (!SWIG_IsOK(res1)) {
22119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22120 }
22121 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22122 {
22123 PyThreadState* __tstate = wxPyBeginAllowThreads();
22124 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
22125 wxPyEndAllowThreads(__tstate);
22126 if (PyErr_Occurred()) SWIG_fail;
22127 }
22128 resultobj = SWIG_From_int(static_cast< int >(result));
22129 return resultobj;
22130 fail:
22131 return NULL;
22132 }
22133
22134
22135 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22136 PyObject *resultobj = 0;
22137 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22138 unsigned int result;
22139 void *argp1 = 0 ;
22140 int res1 = 0 ;
22141 PyObject *swig_obj[1] ;
22142
22143 if (!args) SWIG_fail;
22144 swig_obj[0] = args;
22145 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22146 if (!SWIG_IsOK(res1)) {
22147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22148 }
22149 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22150 {
22151 PyThreadState* __tstate = wxPyBeginAllowThreads();
22152 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
22153 wxPyEndAllowThreads(__tstate);
22154 if (PyErr_Occurred()) SWIG_fail;
22155 }
22156 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22157 return resultobj;
22158 fail:
22159 return NULL;
22160 }
22161
22162
22163 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22164 PyObject *resultobj = 0;
22165 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22166 unsigned int result;
22167 void *argp1 = 0 ;
22168 int res1 = 0 ;
22169 PyObject *swig_obj[1] ;
22170
22171 if (!args) SWIG_fail;
22172 swig_obj[0] = args;
22173 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22174 if (!SWIG_IsOK(res1)) {
22175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyFlags" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22176 }
22177 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22178 {
22179 PyThreadState* __tstate = wxPyBeginAllowThreads();
22180 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
22181 wxPyEndAllowThreads(__tstate);
22182 if (PyErr_Occurred()) SWIG_fail;
22183 }
22184 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22185 return resultobj;
22186 fail:
22187 return NULL;
22188 }
22189
22190
22191 SWIGINTERN PyObject *_wrap_KeyEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22192 PyObject *resultobj = 0;
22193 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22194 wxPoint 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_GetPosition" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22204 }
22205 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22206 {
22207 PyThreadState* __tstate = wxPyBeginAllowThreads();
22208 result = (arg1)->GetPosition();
22209 wxPyEndAllowThreads(__tstate);
22210 if (PyErr_Occurred()) SWIG_fail;
22211 }
22212 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
22213 return resultobj;
22214 fail:
22215 return NULL;
22216 }
22217
22218
22219 SWIGINTERN PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22220 PyObject *resultobj = 0;
22221 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22222 long *arg2 = (long *) 0 ;
22223 long *arg3 = (long *) 0 ;
22224 void *argp1 = 0 ;
22225 int res1 = 0 ;
22226 long temp2 ;
22227 int res2 = SWIG_TMPOBJ ;
22228 long temp3 ;
22229 int res3 = SWIG_TMPOBJ ;
22230 PyObject *swig_obj[1] ;
22231
22232 arg2 = &temp2;
22233 arg3 = &temp3;
22234 if (!args) SWIG_fail;
22235 swig_obj[0] = args;
22236 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22237 if (!SWIG_IsOK(res1)) {
22238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22239 }
22240 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22241 {
22242 PyThreadState* __tstate = wxPyBeginAllowThreads();
22243 (arg1)->GetPosition(arg2,arg3);
22244 wxPyEndAllowThreads(__tstate);
22245 if (PyErr_Occurred()) SWIG_fail;
22246 }
22247 resultobj = SWIG_Py_Void();
22248 if (SWIG_IsTmpObj(res2)) {
22249 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
22250 } else {
22251 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22252 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
22253 }
22254 if (SWIG_IsTmpObj(res3)) {
22255 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
22256 } else {
22257 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22258 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
22259 }
22260 return resultobj;
22261 fail:
22262 return NULL;
22263 }
22264
22265
22266 SWIGINTERN PyObject *_wrap_KeyEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22267 PyObject *resultobj = 0;
22268 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22269 int result;
22270 void *argp1 = 0 ;
22271 int res1 = 0 ;
22272 PyObject *swig_obj[1] ;
22273
22274 if (!args) SWIG_fail;
22275 swig_obj[0] = args;
22276 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22277 if (!SWIG_IsOK(res1)) {
22278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetX" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22279 }
22280 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22281 {
22282 PyThreadState* __tstate = wxPyBeginAllowThreads();
22283 result = (int)((wxKeyEvent const *)arg1)->GetX();
22284 wxPyEndAllowThreads(__tstate);
22285 if (PyErr_Occurred()) SWIG_fail;
22286 }
22287 resultobj = SWIG_From_int(static_cast< int >(result));
22288 return resultobj;
22289 fail:
22290 return NULL;
22291 }
22292
22293
22294 SWIGINTERN PyObject *_wrap_KeyEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22295 PyObject *resultobj = 0;
22296 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22297 int result;
22298 void *argp1 = 0 ;
22299 int res1 = 0 ;
22300 PyObject *swig_obj[1] ;
22301
22302 if (!args) SWIG_fail;
22303 swig_obj[0] = args;
22304 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22305 if (!SWIG_IsOK(res1)) {
22306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetY" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22307 }
22308 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22309 {
22310 PyThreadState* __tstate = wxPyBeginAllowThreads();
22311 result = (int)((wxKeyEvent const *)arg1)->GetY();
22312 wxPyEndAllowThreads(__tstate);
22313 if (PyErr_Occurred()) SWIG_fail;
22314 }
22315 resultobj = SWIG_From_int(static_cast< int >(result));
22316 return resultobj;
22317 fail:
22318 return NULL;
22319 }
22320
22321
22322 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22323 PyObject *resultobj = 0;
22324 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22325 int arg2 ;
22326 void *argp1 = 0 ;
22327 int res1 = 0 ;
22328 int val2 ;
22329 int ecode2 = 0 ;
22330 PyObject *swig_obj[2] ;
22331
22332 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
22333 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22334 if (!SWIG_IsOK(res1)) {
22335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22336 }
22337 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22338 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22339 if (!SWIG_IsOK(ecode2)) {
22340 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
22341 }
22342 arg2 = static_cast< int >(val2);
22343 if (arg1) (arg1)->m_x = arg2;
22344
22345 resultobj = SWIG_Py_Void();
22346 return resultobj;
22347 fail:
22348 return NULL;
22349 }
22350
22351
22352 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22353 PyObject *resultobj = 0;
22354 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22355 int result;
22356 void *argp1 = 0 ;
22357 int res1 = 0 ;
22358 PyObject *swig_obj[1] ;
22359
22360 if (!args) SWIG_fail;
22361 swig_obj[0] = args;
22362 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22363 if (!SWIG_IsOK(res1)) {
22364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22365 }
22366 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22367 result = (int) ((arg1)->m_x);
22368 resultobj = SWIG_From_int(static_cast< int >(result));
22369 return resultobj;
22370 fail:
22371 return NULL;
22372 }
22373
22374
22375 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22376 PyObject *resultobj = 0;
22377 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22378 int arg2 ;
22379 void *argp1 = 0 ;
22380 int res1 = 0 ;
22381 int val2 ;
22382 int ecode2 = 0 ;
22383 PyObject *swig_obj[2] ;
22384
22385 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
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_m_y_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22389 }
22390 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22391 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22392 if (!SWIG_IsOK(ecode2)) {
22393 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
22394 }
22395 arg2 = static_cast< int >(val2);
22396 if (arg1) (arg1)->m_y = arg2;
22397
22398 resultobj = SWIG_Py_Void();
22399 return resultobj;
22400 fail:
22401 return NULL;
22402 }
22403
22404
22405 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22406 PyObject *resultobj = 0;
22407 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22408 int result;
22409 void *argp1 = 0 ;
22410 int res1 = 0 ;
22411 PyObject *swig_obj[1] ;
22412
22413 if (!args) SWIG_fail;
22414 swig_obj[0] = args;
22415 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22416 if (!SWIG_IsOK(res1)) {
22417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22418 }
22419 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22420 result = (int) ((arg1)->m_y);
22421 resultobj = SWIG_From_int(static_cast< int >(result));
22422 return resultobj;
22423 fail:
22424 return NULL;
22425 }
22426
22427
22428 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22429 PyObject *resultobj = 0;
22430 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22431 long arg2 ;
22432 void *argp1 = 0 ;
22433 int res1 = 0 ;
22434 long val2 ;
22435 int ecode2 = 0 ;
22436 PyObject *swig_obj[2] ;
22437
22438 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_keyCode_set",2,2,swig_obj)) SWIG_fail;
22439 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22440 if (!SWIG_IsOK(res1)) {
22441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22442 }
22443 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22444 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
22445 if (!SWIG_IsOK(ecode2)) {
22446 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "2"" of type '" "long""'");
22447 }
22448 arg2 = static_cast< long >(val2);
22449 if (arg1) (arg1)->m_keyCode = arg2;
22450
22451 resultobj = SWIG_Py_Void();
22452 return resultobj;
22453 fail:
22454 return NULL;
22455 }
22456
22457
22458 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22459 PyObject *resultobj = 0;
22460 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22461 long result;
22462 void *argp1 = 0 ;
22463 int res1 = 0 ;
22464 PyObject *swig_obj[1] ;
22465
22466 if (!args) SWIG_fail;
22467 swig_obj[0] = args;
22468 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22469 if (!SWIG_IsOK(res1)) {
22470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22471 }
22472 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22473 result = (long) ((arg1)->m_keyCode);
22474 resultobj = SWIG_From_long(static_cast< long >(result));
22475 return resultobj;
22476 fail:
22477 return NULL;
22478 }
22479
22480
22481 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22482 PyObject *resultobj = 0;
22483 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22484 bool arg2 ;
22485 void *argp1 = 0 ;
22486 int res1 = 0 ;
22487 bool val2 ;
22488 int ecode2 = 0 ;
22489 PyObject *swig_obj[2] ;
22490
22491 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
22492 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22493 if (!SWIG_IsOK(res1)) {
22494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22495 }
22496 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22497 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22498 if (!SWIG_IsOK(ecode2)) {
22499 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
22500 }
22501 arg2 = static_cast< bool >(val2);
22502 if (arg1) (arg1)->m_controlDown = arg2;
22503
22504 resultobj = SWIG_Py_Void();
22505 return resultobj;
22506 fail:
22507 return NULL;
22508 }
22509
22510
22511 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22512 PyObject *resultobj = 0;
22513 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22514 bool result;
22515 void *argp1 = 0 ;
22516 int res1 = 0 ;
22517 PyObject *swig_obj[1] ;
22518
22519 if (!args) SWIG_fail;
22520 swig_obj[0] = args;
22521 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22522 if (!SWIG_IsOK(res1)) {
22523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22524 }
22525 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22526 result = (bool) ((arg1)->m_controlDown);
22527 {
22528 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22529 }
22530 return resultobj;
22531 fail:
22532 return NULL;
22533 }
22534
22535
22536 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22537 PyObject *resultobj = 0;
22538 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22539 bool arg2 ;
22540 void *argp1 = 0 ;
22541 int res1 = 0 ;
22542 bool val2 ;
22543 int ecode2 = 0 ;
22544 PyObject *swig_obj[2] ;
22545
22546 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
22547 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22548 if (!SWIG_IsOK(res1)) {
22549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22550 }
22551 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22552 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22553 if (!SWIG_IsOK(ecode2)) {
22554 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
22555 }
22556 arg2 = static_cast< bool >(val2);
22557 if (arg1) (arg1)->m_shiftDown = arg2;
22558
22559 resultobj = SWIG_Py_Void();
22560 return resultobj;
22561 fail:
22562 return NULL;
22563 }
22564
22565
22566 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22567 PyObject *resultobj = 0;
22568 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22569 bool result;
22570 void *argp1 = 0 ;
22571 int res1 = 0 ;
22572 PyObject *swig_obj[1] ;
22573
22574 if (!args) SWIG_fail;
22575 swig_obj[0] = args;
22576 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22577 if (!SWIG_IsOK(res1)) {
22578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22579 }
22580 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22581 result = (bool) ((arg1)->m_shiftDown);
22582 {
22583 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22584 }
22585 return resultobj;
22586 fail:
22587 return NULL;
22588 }
22589
22590
22591 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22592 PyObject *resultobj = 0;
22593 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22594 bool arg2 ;
22595 void *argp1 = 0 ;
22596 int res1 = 0 ;
22597 bool val2 ;
22598 int ecode2 = 0 ;
22599 PyObject *swig_obj[2] ;
22600
22601 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
22602 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22603 if (!SWIG_IsOK(res1)) {
22604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22605 }
22606 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22607 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22608 if (!SWIG_IsOK(ecode2)) {
22609 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
22610 }
22611 arg2 = static_cast< bool >(val2);
22612 if (arg1) (arg1)->m_altDown = arg2;
22613
22614 resultobj = SWIG_Py_Void();
22615 return resultobj;
22616 fail:
22617 return NULL;
22618 }
22619
22620
22621 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22622 PyObject *resultobj = 0;
22623 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22624 bool result;
22625 void *argp1 = 0 ;
22626 int res1 = 0 ;
22627 PyObject *swig_obj[1] ;
22628
22629 if (!args) SWIG_fail;
22630 swig_obj[0] = args;
22631 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22632 if (!SWIG_IsOK(res1)) {
22633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22634 }
22635 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22636 result = (bool) ((arg1)->m_altDown);
22637 {
22638 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22639 }
22640 return resultobj;
22641 fail:
22642 return NULL;
22643 }
22644
22645
22646 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22647 PyObject *resultobj = 0;
22648 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22649 bool arg2 ;
22650 void *argp1 = 0 ;
22651 int res1 = 0 ;
22652 bool val2 ;
22653 int ecode2 = 0 ;
22654 PyObject *swig_obj[2] ;
22655
22656 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
22657 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22658 if (!SWIG_IsOK(res1)) {
22659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22660 }
22661 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22662 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22663 if (!SWIG_IsOK(ecode2)) {
22664 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
22665 }
22666 arg2 = static_cast< bool >(val2);
22667 if (arg1) (arg1)->m_metaDown = arg2;
22668
22669 resultobj = SWIG_Py_Void();
22670 return resultobj;
22671 fail:
22672 return NULL;
22673 }
22674
22675
22676 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22677 PyObject *resultobj = 0;
22678 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22679 bool result;
22680 void *argp1 = 0 ;
22681 int res1 = 0 ;
22682 PyObject *swig_obj[1] ;
22683
22684 if (!args) SWIG_fail;
22685 swig_obj[0] = args;
22686 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22687 if (!SWIG_IsOK(res1)) {
22688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22689 }
22690 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22691 result = (bool) ((arg1)->m_metaDown);
22692 {
22693 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22694 }
22695 return resultobj;
22696 fail:
22697 return NULL;
22698 }
22699
22700
22701 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22702 PyObject *resultobj = 0;
22703 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22704 bool arg2 ;
22705 void *argp1 = 0 ;
22706 int res1 = 0 ;
22707 bool val2 ;
22708 int ecode2 = 0 ;
22709 PyObject *swig_obj[2] ;
22710
22711 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_scanCode_set",2,2,swig_obj)) SWIG_fail;
22712 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22713 if (!SWIG_IsOK(res1)) {
22714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22715 }
22716 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22717 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22718 if (!SWIG_IsOK(ecode2)) {
22719 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "2"" of type '" "bool""'");
22720 }
22721 arg2 = static_cast< bool >(val2);
22722 if (arg1) (arg1)->m_scanCode = arg2;
22723
22724 resultobj = SWIG_Py_Void();
22725 return resultobj;
22726 fail:
22727 return NULL;
22728 }
22729
22730
22731 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22732 PyObject *resultobj = 0;
22733 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22734 bool result;
22735 void *argp1 = 0 ;
22736 int res1 = 0 ;
22737 PyObject *swig_obj[1] ;
22738
22739 if (!args) SWIG_fail;
22740 swig_obj[0] = args;
22741 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22742 if (!SWIG_IsOK(res1)) {
22743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22744 }
22745 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22746 result = (bool) ((arg1)->m_scanCode);
22747 {
22748 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22749 }
22750 return resultobj;
22751 fail:
22752 return NULL;
22753 }
22754
22755
22756 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22757 PyObject *resultobj = 0;
22758 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22759 unsigned int arg2 ;
22760 void *argp1 = 0 ;
22761 int res1 = 0 ;
22762 unsigned int val2 ;
22763 int ecode2 = 0 ;
22764 PyObject *swig_obj[2] ;
22765
22766 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawCode_set",2,2,swig_obj)) SWIG_fail;
22767 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22768 if (!SWIG_IsOK(res1)) {
22769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22770 }
22771 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22772 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
22773 if (!SWIG_IsOK(ecode2)) {
22774 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "2"" of type '" "unsigned int""'");
22775 }
22776 arg2 = static_cast< unsigned int >(val2);
22777 if (arg1) (arg1)->m_rawCode = arg2;
22778
22779 resultobj = SWIG_Py_Void();
22780 return resultobj;
22781 fail:
22782 return NULL;
22783 }
22784
22785
22786 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22787 PyObject *resultobj = 0;
22788 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22789 unsigned int result;
22790 void *argp1 = 0 ;
22791 int res1 = 0 ;
22792 PyObject *swig_obj[1] ;
22793
22794 if (!args) SWIG_fail;
22795 swig_obj[0] = args;
22796 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22797 if (!SWIG_IsOK(res1)) {
22798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22799 }
22800 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22801 result = (unsigned int) ((arg1)->m_rawCode);
22802 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22803 return resultobj;
22804 fail:
22805 return NULL;
22806 }
22807
22808
22809 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22810 PyObject *resultobj = 0;
22811 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22812 unsigned int arg2 ;
22813 void *argp1 = 0 ;
22814 int res1 = 0 ;
22815 unsigned int val2 ;
22816 int ecode2 = 0 ;
22817 PyObject *swig_obj[2] ;
22818
22819 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawFlags_set",2,2,swig_obj)) SWIG_fail;
22820 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22821 if (!SWIG_IsOK(res1)) {
22822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22823 }
22824 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22825 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
22826 if (!SWIG_IsOK(ecode2)) {
22827 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "2"" of type '" "unsigned int""'");
22828 }
22829 arg2 = static_cast< unsigned int >(val2);
22830 if (arg1) (arg1)->m_rawFlags = arg2;
22831
22832 resultobj = SWIG_Py_Void();
22833 return resultobj;
22834 fail:
22835 return NULL;
22836 }
22837
22838
22839 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22840 PyObject *resultobj = 0;
22841 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22842 unsigned int result;
22843 void *argp1 = 0 ;
22844 int res1 = 0 ;
22845 PyObject *swig_obj[1] ;
22846
22847 if (!args) SWIG_fail;
22848 swig_obj[0] = args;
22849 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22850 if (!SWIG_IsOK(res1)) {
22851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22852 }
22853 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22854 result = (unsigned int) ((arg1)->m_rawFlags);
22855 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22856 return resultobj;
22857 fail:
22858 return NULL;
22859 }
22860
22861
22862 SWIGINTERN PyObject *KeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22863 PyObject *obj;
22864 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22865 SWIG_TypeNewClientData(SWIGTYPE_p_wxKeyEvent, SWIG_NewClientData(obj));
22866 return SWIG_Py_Void();
22867 }
22868
22869 SWIGINTERN PyObject *KeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22870 return SWIG_Python_InitShadowInstance(args);
22871 }
22872
22873 SWIGINTERN PyObject *_wrap_new_SizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22874 PyObject *resultobj = 0;
22875 wxSize const &arg1_defvalue = wxDefaultSize ;
22876 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
22877 int arg2 = (int) 0 ;
22878 wxSizeEvent *result = 0 ;
22879 wxSize temp1 ;
22880 int val2 ;
22881 int ecode2 = 0 ;
22882 PyObject * obj0 = 0 ;
22883 PyObject * obj1 = 0 ;
22884 char * kwnames[] = {
22885 (char *) "sz",(char *) "winid", NULL
22886 };
22887
22888 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
22889 if (obj0) {
22890 {
22891 arg1 = &temp1;
22892 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
22893 }
22894 }
22895 if (obj1) {
22896 ecode2 = SWIG_AsVal_int(obj1, &val2);
22897 if (!SWIG_IsOK(ecode2)) {
22898 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizeEvent" "', expected argument " "2"" of type '" "int""'");
22899 }
22900 arg2 = static_cast< int >(val2);
22901 }
22902 {
22903 PyThreadState* __tstate = wxPyBeginAllowThreads();
22904 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
22905 wxPyEndAllowThreads(__tstate);
22906 if (PyErr_Occurred()) SWIG_fail;
22907 }
22908 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_NEW | 0 );
22909 return resultobj;
22910 fail:
22911 return NULL;
22912 }
22913
22914
22915 SWIGINTERN PyObject *_wrap_SizeEvent_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22916 PyObject *resultobj = 0;
22917 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
22918 wxSize result;
22919 void *argp1 = 0 ;
22920 int res1 = 0 ;
22921 PyObject *swig_obj[1] ;
22922
22923 if (!args) SWIG_fail;
22924 swig_obj[0] = args;
22925 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
22926 if (!SWIG_IsOK(res1)) {
22927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetSize" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
22928 }
22929 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
22930 {
22931 PyThreadState* __tstate = wxPyBeginAllowThreads();
22932 result = ((wxSizeEvent const *)arg1)->GetSize();
22933 wxPyEndAllowThreads(__tstate);
22934 if (PyErr_Occurred()) SWIG_fail;
22935 }
22936 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
22937 return resultobj;
22938 fail:
22939 return NULL;
22940 }
22941
22942
22943 SWIGINTERN PyObject *_wrap_SizeEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22944 PyObject *resultobj = 0;
22945 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
22946 wxRect result;
22947 void *argp1 = 0 ;
22948 int res1 = 0 ;
22949 PyObject *swig_obj[1] ;
22950
22951 if (!args) SWIG_fail;
22952 swig_obj[0] = args;
22953 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
22954 if (!SWIG_IsOK(res1)) {
22955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetRect" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
22956 }
22957 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
22958 {
22959 PyThreadState* __tstate = wxPyBeginAllowThreads();
22960 result = ((wxSizeEvent const *)arg1)->GetRect();
22961 wxPyEndAllowThreads(__tstate);
22962 if (PyErr_Occurred()) SWIG_fail;
22963 }
22964 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
22965 return resultobj;
22966 fail:
22967 return NULL;
22968 }
22969
22970
22971 SWIGINTERN PyObject *_wrap_SizeEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22972 PyObject *resultobj = 0;
22973 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
22974 wxRect arg2 ;
22975 void *argp1 = 0 ;
22976 int res1 = 0 ;
22977 void *argp2 ;
22978 int res2 = 0 ;
22979 PyObject * obj0 = 0 ;
22980 PyObject * obj1 = 0 ;
22981 char * kwnames[] = {
22982 (char *) "self",(char *) "rect", NULL
22983 };
22984
22985 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
22986 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
22987 if (!SWIG_IsOK(res1)) {
22988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetRect" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
22989 }
22990 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
22991 {
22992 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRect, 0 | 0);
22993 if (!SWIG_IsOK(res2)) {
22994 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
22995 }
22996 if (!argp2) {
22997 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
22998 } else {
22999 wxRect * temp = reinterpret_cast< wxRect * >(argp2);
23000 arg2 = *temp;
23001 if (SWIG_IsNewObj(res2)) delete temp;
23002 }
23003 }
23004 {
23005 PyThreadState* __tstate = wxPyBeginAllowThreads();
23006 (arg1)->SetRect(arg2);
23007 wxPyEndAllowThreads(__tstate);
23008 if (PyErr_Occurred()) SWIG_fail;
23009 }
23010 resultobj = SWIG_Py_Void();
23011 return resultobj;
23012 fail:
23013 return NULL;
23014 }
23015
23016
23017 SWIGINTERN PyObject *_wrap_SizeEvent_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23018 PyObject *resultobj = 0;
23019 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23020 wxSize arg2 ;
23021 void *argp1 = 0 ;
23022 int res1 = 0 ;
23023 void *argp2 ;
23024 int res2 = 0 ;
23025 PyObject * obj0 = 0 ;
23026 PyObject * obj1 = 0 ;
23027 char * kwnames[] = {
23028 (char *) "self",(char *) "size", NULL
23029 };
23030
23031 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
23032 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23033 if (!SWIG_IsOK(res1)) {
23034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetSize" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23035 }
23036 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23037 {
23038 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxSize, 0 | 0);
23039 if (!SWIG_IsOK(res2)) {
23040 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23041 }
23042 if (!argp2) {
23043 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23044 } else {
23045 wxSize * temp = reinterpret_cast< wxSize * >(argp2);
23046 arg2 = *temp;
23047 if (SWIG_IsNewObj(res2)) delete temp;
23048 }
23049 }
23050 {
23051 PyThreadState* __tstate = wxPyBeginAllowThreads();
23052 wxSizeEvent_SetSize(arg1,arg2);
23053 wxPyEndAllowThreads(__tstate);
23054 if (PyErr_Occurred()) SWIG_fail;
23055 }
23056 resultobj = SWIG_Py_Void();
23057 return resultobj;
23058 fail:
23059 return NULL;
23060 }
23061
23062
23063 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23064 PyObject *resultobj = 0;
23065 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23066 wxSize *arg2 = (wxSize *) 0 ;
23067 void *argp1 = 0 ;
23068 int res1 = 0 ;
23069 void *argp2 = 0 ;
23070 int res2 = 0 ;
23071 PyObject *swig_obj[2] ;
23072
23073 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_size_set",2,2,swig_obj)) SWIG_fail;
23074 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23075 if (!SWIG_IsOK(res1)) {
23076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23077 }
23078 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23079 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSize, 0 | 0 );
23080 if (!SWIG_IsOK(res2)) {
23081 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_size_set" "', expected argument " "2"" of type '" "wxSize *""'");
23082 }
23083 arg2 = reinterpret_cast< wxSize * >(argp2);
23084 if (arg1) (arg1)->m_size = *arg2;
23085
23086 resultobj = SWIG_Py_Void();
23087 return resultobj;
23088 fail:
23089 return NULL;
23090 }
23091
23092
23093 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23094 PyObject *resultobj = 0;
23095 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23096 wxSize *result = 0 ;
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_m_size_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23106 }
23107 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23108 result = (wxSize *)& ((arg1)->m_size);
23109 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
23110 return resultobj;
23111 fail:
23112 return NULL;
23113 }
23114
23115
23116 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23117 PyObject *resultobj = 0;
23118 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23119 wxRect *arg2 = (wxRect *) 0 ;
23120 void *argp1 = 0 ;
23121 int res1 = 0 ;
23122 void *argp2 = 0 ;
23123 int res2 = 0 ;
23124 PyObject *swig_obj[2] ;
23125
23126 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_rect_set",2,2,swig_obj)) SWIG_fail;
23127 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23128 if (!SWIG_IsOK(res1)) {
23129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23130 }
23131 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23132 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
23133 if (!SWIG_IsOK(res2)) {
23134 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_rect_set" "', expected argument " "2"" of type '" "wxRect *""'");
23135 }
23136 arg2 = reinterpret_cast< wxRect * >(argp2);
23137 if (arg1) (arg1)->m_rect = *arg2;
23138
23139 resultobj = SWIG_Py_Void();
23140 return resultobj;
23141 fail:
23142 return NULL;
23143 }
23144
23145
23146 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23147 PyObject *resultobj = 0;
23148 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23149 wxRect *result = 0 ;
23150 void *argp1 = 0 ;
23151 int res1 = 0 ;
23152 PyObject *swig_obj[1] ;
23153
23154 if (!args) SWIG_fail;
23155 swig_obj[0] = args;
23156 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23157 if (!SWIG_IsOK(res1)) {
23158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23159 }
23160 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23161 result = (wxRect *)& ((arg1)->m_rect);
23162 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
23163 return resultobj;
23164 fail:
23165 return NULL;
23166 }
23167
23168
23169 SWIGINTERN PyObject *SizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23170 PyObject *obj;
23171 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23172 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizeEvent, SWIG_NewClientData(obj));
23173 return SWIG_Py_Void();
23174 }
23175
23176 SWIGINTERN PyObject *SizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23177 return SWIG_Python_InitShadowInstance(args);
23178 }
23179
23180 SWIGINTERN PyObject *_wrap_new_MoveEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23181 PyObject *resultobj = 0;
23182 wxPoint const &arg1_defvalue = wxDefaultPosition ;
23183 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
23184 int arg2 = (int) 0 ;
23185 wxMoveEvent *result = 0 ;
23186 wxPoint temp1 ;
23187 int val2 ;
23188 int ecode2 = 0 ;
23189 PyObject * obj0 = 0 ;
23190 PyObject * obj1 = 0 ;
23191 char * kwnames[] = {
23192 (char *) "pos",(char *) "winid", NULL
23193 };
23194
23195 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23196 if (obj0) {
23197 {
23198 arg1 = &temp1;
23199 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
23200 }
23201 }
23202 if (obj1) {
23203 ecode2 = SWIG_AsVal_int(obj1, &val2);
23204 if (!SWIG_IsOK(ecode2)) {
23205 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MoveEvent" "', expected argument " "2"" of type '" "int""'");
23206 }
23207 arg2 = static_cast< int >(val2);
23208 }
23209 {
23210 PyThreadState* __tstate = wxPyBeginAllowThreads();
23211 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
23212 wxPyEndAllowThreads(__tstate);
23213 if (PyErr_Occurred()) SWIG_fail;
23214 }
23215 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_NEW | 0 );
23216 return resultobj;
23217 fail:
23218 return NULL;
23219 }
23220
23221
23222 SWIGINTERN PyObject *_wrap_MoveEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23223 PyObject *resultobj = 0;
23224 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23225 wxPoint result;
23226 void *argp1 = 0 ;
23227 int res1 = 0 ;
23228 PyObject *swig_obj[1] ;
23229
23230 if (!args) SWIG_fail;
23231 swig_obj[0] = args;
23232 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23233 if (!SWIG_IsOK(res1)) {
23234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetPosition" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23235 }
23236 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23237 {
23238 PyThreadState* __tstate = wxPyBeginAllowThreads();
23239 result = ((wxMoveEvent const *)arg1)->GetPosition();
23240 wxPyEndAllowThreads(__tstate);
23241 if (PyErr_Occurred()) SWIG_fail;
23242 }
23243 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23244 return resultobj;
23245 fail:
23246 return NULL;
23247 }
23248
23249
23250 SWIGINTERN PyObject *_wrap_MoveEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23251 PyObject *resultobj = 0;
23252 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23253 wxRect result;
23254 void *argp1 = 0 ;
23255 int res1 = 0 ;
23256 PyObject *swig_obj[1] ;
23257
23258 if (!args) SWIG_fail;
23259 swig_obj[0] = args;
23260 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23261 if (!SWIG_IsOK(res1)) {
23262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetRect" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23263 }
23264 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23265 {
23266 PyThreadState* __tstate = wxPyBeginAllowThreads();
23267 result = ((wxMoveEvent const *)arg1)->GetRect();
23268 wxPyEndAllowThreads(__tstate);
23269 if (PyErr_Occurred()) SWIG_fail;
23270 }
23271 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
23272 return resultobj;
23273 fail:
23274 return NULL;
23275 }
23276
23277
23278 SWIGINTERN PyObject *_wrap_MoveEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23279 PyObject *resultobj = 0;
23280 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23281 wxRect *arg2 = 0 ;
23282 void *argp1 = 0 ;
23283 int res1 = 0 ;
23284 wxRect temp2 ;
23285 PyObject * obj0 = 0 ;
23286 PyObject * obj1 = 0 ;
23287 char * kwnames[] = {
23288 (char *) "self",(char *) "rect", NULL
23289 };
23290
23291 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
23292 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23293 if (!SWIG_IsOK(res1)) {
23294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetRect" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23295 }
23296 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23297 {
23298 arg2 = &temp2;
23299 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
23300 }
23301 {
23302 PyThreadState* __tstate = wxPyBeginAllowThreads();
23303 (arg1)->SetRect((wxRect const &)*arg2);
23304 wxPyEndAllowThreads(__tstate);
23305 if (PyErr_Occurred()) SWIG_fail;
23306 }
23307 resultobj = SWIG_Py_Void();
23308 return resultobj;
23309 fail:
23310 return NULL;
23311 }
23312
23313
23314 SWIGINTERN PyObject *_wrap_MoveEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23315 PyObject *resultobj = 0;
23316 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23317 wxPoint *arg2 = 0 ;
23318 void *argp1 = 0 ;
23319 int res1 = 0 ;
23320 wxPoint temp2 ;
23321 PyObject * obj0 = 0 ;
23322 PyObject * obj1 = 0 ;
23323 char * kwnames[] = {
23324 (char *) "self",(char *) "pos", NULL
23325 };
23326
23327 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
23328 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23329 if (!SWIG_IsOK(res1)) {
23330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetPosition" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23331 }
23332 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23333 {
23334 arg2 = &temp2;
23335 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
23336 }
23337 {
23338 PyThreadState* __tstate = wxPyBeginAllowThreads();
23339 (arg1)->SetPosition((wxPoint const &)*arg2);
23340 wxPyEndAllowThreads(__tstate);
23341 if (PyErr_Occurred()) SWIG_fail;
23342 }
23343 resultobj = SWIG_Py_Void();
23344 return resultobj;
23345 fail:
23346 return NULL;
23347 }
23348
23349
23350 SWIGINTERN PyObject *MoveEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23351 PyObject *obj;
23352 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23353 SWIG_TypeNewClientData(SWIGTYPE_p_wxMoveEvent, SWIG_NewClientData(obj));
23354 return SWIG_Py_Void();
23355 }
23356
23357 SWIGINTERN PyObject *MoveEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23358 return SWIG_Python_InitShadowInstance(args);
23359 }
23360
23361 SWIGINTERN PyObject *_wrap_new_PaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23362 PyObject *resultobj = 0;
23363 int arg1 = (int) 0 ;
23364 wxPaintEvent *result = 0 ;
23365 int val1 ;
23366 int ecode1 = 0 ;
23367 PyObject * obj0 = 0 ;
23368 char * kwnames[] = {
23369 (char *) "Id", NULL
23370 };
23371
23372 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) SWIG_fail;
23373 if (obj0) {
23374 ecode1 = SWIG_AsVal_int(obj0, &val1);
23375 if (!SWIG_IsOK(ecode1)) {
23376 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaintEvent" "', expected argument " "1"" of type '" "int""'");
23377 }
23378 arg1 = static_cast< int >(val1);
23379 }
23380 {
23381 PyThreadState* __tstate = wxPyBeginAllowThreads();
23382 result = (wxPaintEvent *)new wxPaintEvent(arg1);
23383 wxPyEndAllowThreads(__tstate);
23384 if (PyErr_Occurred()) SWIG_fail;
23385 }
23386 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_NEW | 0 );
23387 return resultobj;
23388 fail:
23389 return NULL;
23390 }
23391
23392
23393 SWIGINTERN PyObject *PaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23394 PyObject *obj;
23395 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23396 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaintEvent, SWIG_NewClientData(obj));
23397 return SWIG_Py_Void();
23398 }
23399
23400 SWIGINTERN PyObject *PaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23401 return SWIG_Python_InitShadowInstance(args);
23402 }
23403
23404 SWIGINTERN PyObject *_wrap_new_NcPaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23405 PyObject *resultobj = 0;
23406 int arg1 = (int) 0 ;
23407 wxNcPaintEvent *result = 0 ;
23408 int val1 ;
23409 int ecode1 = 0 ;
23410 PyObject * obj0 = 0 ;
23411 char * kwnames[] = {
23412 (char *) "winid", NULL
23413 };
23414
23415 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) SWIG_fail;
23416 if (obj0) {
23417 ecode1 = SWIG_AsVal_int(obj0, &val1);
23418 if (!SWIG_IsOK(ecode1)) {
23419 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NcPaintEvent" "', expected argument " "1"" of type '" "int""'");
23420 }
23421 arg1 = static_cast< int >(val1);
23422 }
23423 {
23424 PyThreadState* __tstate = wxPyBeginAllowThreads();
23425 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
23426 wxPyEndAllowThreads(__tstate);
23427 if (PyErr_Occurred()) SWIG_fail;
23428 }
23429 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNcPaintEvent, SWIG_POINTER_NEW | 0 );
23430 return resultobj;
23431 fail:
23432 return NULL;
23433 }
23434
23435
23436 SWIGINTERN PyObject *NcPaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23437 PyObject *obj;
23438 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23439 SWIG_TypeNewClientData(SWIGTYPE_p_wxNcPaintEvent, SWIG_NewClientData(obj));
23440 return SWIG_Py_Void();
23441 }
23442
23443 SWIGINTERN PyObject *NcPaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23444 return SWIG_Python_InitShadowInstance(args);
23445 }
23446
23447 SWIGINTERN PyObject *_wrap_new_EraseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23448 PyObject *resultobj = 0;
23449 int arg1 = (int) 0 ;
23450 wxDC *arg2 = (wxDC *) NULL ;
23451 wxEraseEvent *result = 0 ;
23452 int val1 ;
23453 int ecode1 = 0 ;
23454 void *argp2 = 0 ;
23455 int res2 = 0 ;
23456 PyObject * obj0 = 0 ;
23457 PyObject * obj1 = 0 ;
23458 char * kwnames[] = {
23459 (char *) "Id",(char *) "dc", NULL
23460 };
23461
23462 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23463 if (obj0) {
23464 ecode1 = SWIG_AsVal_int(obj0, &val1);
23465 if (!SWIG_IsOK(ecode1)) {
23466 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EraseEvent" "', expected argument " "1"" of type '" "int""'");
23467 }
23468 arg1 = static_cast< int >(val1);
23469 }
23470 if (obj1) {
23471 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDC, 0 | 0 );
23472 if (!SWIG_IsOK(res2)) {
23473 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EraseEvent" "', expected argument " "2"" of type '" "wxDC *""'");
23474 }
23475 arg2 = reinterpret_cast< wxDC * >(argp2);
23476 }
23477 {
23478 PyThreadState* __tstate = wxPyBeginAllowThreads();
23479 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
23480 wxPyEndAllowThreads(__tstate);
23481 if (PyErr_Occurred()) SWIG_fail;
23482 }
23483 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_NEW | 0 );
23484 return resultobj;
23485 fail:
23486 return NULL;
23487 }
23488
23489
23490 SWIGINTERN PyObject *_wrap_EraseEvent_GetDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23491 PyObject *resultobj = 0;
23492 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
23493 wxDC *result = 0 ;
23494 void *argp1 = 0 ;
23495 int res1 = 0 ;
23496 PyObject *swig_obj[1] ;
23497
23498 if (!args) SWIG_fail;
23499 swig_obj[0] = args;
23500 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEraseEvent, 0 | 0 );
23501 if (!SWIG_IsOK(res1)) {
23502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EraseEvent_GetDC" "', expected argument " "1"" of type '" "wxEraseEvent const *""'");
23503 }
23504 arg1 = reinterpret_cast< wxEraseEvent * >(argp1);
23505 {
23506 PyThreadState* __tstate = wxPyBeginAllowThreads();
23507 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
23508 wxPyEndAllowThreads(__tstate);
23509 if (PyErr_Occurred()) SWIG_fail;
23510 }
23511 {
23512 resultobj = wxPyMake_wxObject(result, (bool)0);
23513 }
23514 return resultobj;
23515 fail:
23516 return NULL;
23517 }
23518
23519
23520 SWIGINTERN PyObject *EraseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23521 PyObject *obj;
23522 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23523 SWIG_TypeNewClientData(SWIGTYPE_p_wxEraseEvent, SWIG_NewClientData(obj));
23524 return SWIG_Py_Void();
23525 }
23526
23527 SWIGINTERN PyObject *EraseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23528 return SWIG_Python_InitShadowInstance(args);
23529 }
23530
23531 SWIGINTERN PyObject *_wrap_new_FocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23532 PyObject *resultobj = 0;
23533 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23534 int arg2 = (int) 0 ;
23535 wxFocusEvent *result = 0 ;
23536 int val1 ;
23537 int ecode1 = 0 ;
23538 int val2 ;
23539 int ecode2 = 0 ;
23540 PyObject * obj0 = 0 ;
23541 PyObject * obj1 = 0 ;
23542 char * kwnames[] = {
23543 (char *) "type",(char *) "winid", NULL
23544 };
23545
23546 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23547 if (obj0) {
23548 ecode1 = SWIG_AsVal_int(obj0, &val1);
23549 if (!SWIG_IsOK(ecode1)) {
23550 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FocusEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23551 }
23552 arg1 = static_cast< wxEventType >(val1);
23553 }
23554 if (obj1) {
23555 ecode2 = SWIG_AsVal_int(obj1, &val2);
23556 if (!SWIG_IsOK(ecode2)) {
23557 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FocusEvent" "', expected argument " "2"" of type '" "int""'");
23558 }
23559 arg2 = static_cast< int >(val2);
23560 }
23561 {
23562 PyThreadState* __tstate = wxPyBeginAllowThreads();
23563 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
23564 wxPyEndAllowThreads(__tstate);
23565 if (PyErr_Occurred()) SWIG_fail;
23566 }
23567 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_NEW | 0 );
23568 return resultobj;
23569 fail:
23570 return NULL;
23571 }
23572
23573
23574 SWIGINTERN PyObject *_wrap_FocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23575 PyObject *resultobj = 0;
23576 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
23577 wxWindow *result = 0 ;
23578 void *argp1 = 0 ;
23579 int res1 = 0 ;
23580 PyObject *swig_obj[1] ;
23581
23582 if (!args) SWIG_fail;
23583 swig_obj[0] = args;
23584 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
23585 if (!SWIG_IsOK(res1)) {
23586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxFocusEvent const *""'");
23587 }
23588 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
23589 {
23590 PyThreadState* __tstate = wxPyBeginAllowThreads();
23591 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
23592 wxPyEndAllowThreads(__tstate);
23593 if (PyErr_Occurred()) SWIG_fail;
23594 }
23595 {
23596 resultobj = wxPyMake_wxObject(result, (bool)0);
23597 }
23598 return resultobj;
23599 fail:
23600 return NULL;
23601 }
23602
23603
23604 SWIGINTERN PyObject *_wrap_FocusEvent_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23605 PyObject *resultobj = 0;
23606 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
23607 wxWindow *arg2 = (wxWindow *) 0 ;
23608 void *argp1 = 0 ;
23609 int res1 = 0 ;
23610 void *argp2 = 0 ;
23611 int res2 = 0 ;
23612 PyObject * obj0 = 0 ;
23613 PyObject * obj1 = 0 ;
23614 char * kwnames[] = {
23615 (char *) "self",(char *) "win", NULL
23616 };
23617
23618 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
23619 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
23620 if (!SWIG_IsOK(res1)) {
23621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_SetWindow" "', expected argument " "1"" of type '" "wxFocusEvent *""'");
23622 }
23623 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
23624 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
23625 if (!SWIG_IsOK(res2)) {
23626 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FocusEvent_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
23627 }
23628 arg2 = reinterpret_cast< wxWindow * >(argp2);
23629 {
23630 PyThreadState* __tstate = wxPyBeginAllowThreads();
23631 (arg1)->SetWindow(arg2);
23632 wxPyEndAllowThreads(__tstate);
23633 if (PyErr_Occurred()) SWIG_fail;
23634 }
23635 resultobj = SWIG_Py_Void();
23636 return resultobj;
23637 fail:
23638 return NULL;
23639 }
23640
23641
23642 SWIGINTERN PyObject *FocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23643 PyObject *obj;
23644 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23645 SWIG_TypeNewClientData(SWIGTYPE_p_wxFocusEvent, SWIG_NewClientData(obj));
23646 return SWIG_Py_Void();
23647 }
23648
23649 SWIGINTERN PyObject *FocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23650 return SWIG_Python_InitShadowInstance(args);
23651 }
23652
23653 SWIGINTERN PyObject *_wrap_new_ChildFocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23654 PyObject *resultobj = 0;
23655 wxWindow *arg1 = (wxWindow *) NULL ;
23656 wxChildFocusEvent *result = 0 ;
23657 void *argp1 = 0 ;
23658 int res1 = 0 ;
23659 PyObject * obj0 = 0 ;
23660 char * kwnames[] = {
23661 (char *) "win", NULL
23662 };
23663
23664 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) SWIG_fail;
23665 if (obj0) {
23666 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
23667 if (!SWIG_IsOK(res1)) {
23668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ChildFocusEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
23669 }
23670 arg1 = reinterpret_cast< wxWindow * >(argp1);
23671 }
23672 {
23673 PyThreadState* __tstate = wxPyBeginAllowThreads();
23674 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
23675 wxPyEndAllowThreads(__tstate);
23676 if (PyErr_Occurred()) SWIG_fail;
23677 }
23678 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_NEW | 0 );
23679 return resultobj;
23680 fail:
23681 return NULL;
23682 }
23683
23684
23685 SWIGINTERN PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23686 PyObject *resultobj = 0;
23687 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
23688 wxWindow *result = 0 ;
23689 void *argp1 = 0 ;
23690 int res1 = 0 ;
23691 PyObject *swig_obj[1] ;
23692
23693 if (!args) SWIG_fail;
23694 swig_obj[0] = args;
23695 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxChildFocusEvent, 0 | 0 );
23696 if (!SWIG_IsOK(res1)) {
23697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChildFocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxChildFocusEvent const *""'");
23698 }
23699 arg1 = reinterpret_cast< wxChildFocusEvent * >(argp1);
23700 {
23701 PyThreadState* __tstate = wxPyBeginAllowThreads();
23702 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
23703 wxPyEndAllowThreads(__tstate);
23704 if (PyErr_Occurred()) SWIG_fail;
23705 }
23706 {
23707 resultobj = wxPyMake_wxObject(result, (bool)0);
23708 }
23709 return resultobj;
23710 fail:
23711 return NULL;
23712 }
23713
23714
23715 SWIGINTERN PyObject *ChildFocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23716 PyObject *obj;
23717 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23718 SWIG_TypeNewClientData(SWIGTYPE_p_wxChildFocusEvent, SWIG_NewClientData(obj));
23719 return SWIG_Py_Void();
23720 }
23721
23722 SWIGINTERN PyObject *ChildFocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23723 return SWIG_Python_InitShadowInstance(args);
23724 }
23725
23726 SWIGINTERN PyObject *_wrap_new_ActivateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23727 PyObject *resultobj = 0;
23728 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23729 bool arg2 = (bool) true ;
23730 int arg3 = (int) 0 ;
23731 wxActivateEvent *result = 0 ;
23732 int val1 ;
23733 int ecode1 = 0 ;
23734 bool val2 ;
23735 int ecode2 = 0 ;
23736 int val3 ;
23737 int ecode3 = 0 ;
23738 PyObject * obj0 = 0 ;
23739 PyObject * obj1 = 0 ;
23740 PyObject * obj2 = 0 ;
23741 char * kwnames[] = {
23742 (char *) "type",(char *) "active",(char *) "Id", NULL
23743 };
23744
23745 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23746 if (obj0) {
23747 ecode1 = SWIG_AsVal_int(obj0, &val1);
23748 if (!SWIG_IsOK(ecode1)) {
23749 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ActivateEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23750 }
23751 arg1 = static_cast< wxEventType >(val1);
23752 }
23753 if (obj1) {
23754 ecode2 = SWIG_AsVal_bool(obj1, &val2);
23755 if (!SWIG_IsOK(ecode2)) {
23756 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ActivateEvent" "', expected argument " "2"" of type '" "bool""'");
23757 }
23758 arg2 = static_cast< bool >(val2);
23759 }
23760 if (obj2) {
23761 ecode3 = SWIG_AsVal_int(obj2, &val3);
23762 if (!SWIG_IsOK(ecode3)) {
23763 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ActivateEvent" "', expected argument " "3"" of type '" "int""'");
23764 }
23765 arg3 = static_cast< int >(val3);
23766 }
23767 {
23768 PyThreadState* __tstate = wxPyBeginAllowThreads();
23769 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
23770 wxPyEndAllowThreads(__tstate);
23771 if (PyErr_Occurred()) SWIG_fail;
23772 }
23773 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_NEW | 0 );
23774 return resultobj;
23775 fail:
23776 return NULL;
23777 }
23778
23779
23780 SWIGINTERN PyObject *_wrap_ActivateEvent_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23781 PyObject *resultobj = 0;
23782 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
23783 bool result;
23784 void *argp1 = 0 ;
23785 int res1 = 0 ;
23786 PyObject *swig_obj[1] ;
23787
23788 if (!args) SWIG_fail;
23789 swig_obj[0] = args;
23790 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxActivateEvent, 0 | 0 );
23791 if (!SWIG_IsOK(res1)) {
23792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActivateEvent_GetActive" "', expected argument " "1"" of type '" "wxActivateEvent const *""'");
23793 }
23794 arg1 = reinterpret_cast< wxActivateEvent * >(argp1);
23795 {
23796 PyThreadState* __tstate = wxPyBeginAllowThreads();
23797 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
23798 wxPyEndAllowThreads(__tstate);
23799 if (PyErr_Occurred()) SWIG_fail;
23800 }
23801 {
23802 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23803 }
23804 return resultobj;
23805 fail:
23806 return NULL;
23807 }
23808
23809
23810 SWIGINTERN PyObject *ActivateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23811 PyObject *obj;
23812 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23813 SWIG_TypeNewClientData(SWIGTYPE_p_wxActivateEvent, SWIG_NewClientData(obj));
23814 return SWIG_Py_Void();
23815 }
23816
23817 SWIGINTERN PyObject *ActivateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23818 return SWIG_Python_InitShadowInstance(args);
23819 }
23820
23821 SWIGINTERN PyObject *_wrap_new_InitDialogEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23822 PyObject *resultobj = 0;
23823 int arg1 = (int) 0 ;
23824 wxInitDialogEvent *result = 0 ;
23825 int val1 ;
23826 int ecode1 = 0 ;
23827 PyObject * obj0 = 0 ;
23828 char * kwnames[] = {
23829 (char *) "Id", NULL
23830 };
23831
23832 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) SWIG_fail;
23833 if (obj0) {
23834 ecode1 = SWIG_AsVal_int(obj0, &val1);
23835 if (!SWIG_IsOK(ecode1)) {
23836 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InitDialogEvent" "', expected argument " "1"" of type '" "int""'");
23837 }
23838 arg1 = static_cast< int >(val1);
23839 }
23840 {
23841 PyThreadState* __tstate = wxPyBeginAllowThreads();
23842 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
23843 wxPyEndAllowThreads(__tstate);
23844 if (PyErr_Occurred()) SWIG_fail;
23845 }
23846 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInitDialogEvent, SWIG_POINTER_NEW | 0 );
23847 return resultobj;
23848 fail:
23849 return NULL;
23850 }
23851
23852
23853 SWIGINTERN PyObject *InitDialogEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23854 PyObject *obj;
23855 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23856 SWIG_TypeNewClientData(SWIGTYPE_p_wxInitDialogEvent, SWIG_NewClientData(obj));
23857 return SWIG_Py_Void();
23858 }
23859
23860 SWIGINTERN PyObject *InitDialogEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23861 return SWIG_Python_InitShadowInstance(args);
23862 }
23863
23864 SWIGINTERN PyObject *_wrap_new_MenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23865 PyObject *resultobj = 0;
23866 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23867 int arg2 = (int) 0 ;
23868 wxMenu *arg3 = (wxMenu *) NULL ;
23869 wxMenuEvent *result = 0 ;
23870 int val1 ;
23871 int ecode1 = 0 ;
23872 int val2 ;
23873 int ecode2 = 0 ;
23874 void *argp3 = 0 ;
23875 int res3 = 0 ;
23876 PyObject * obj0 = 0 ;
23877 PyObject * obj1 = 0 ;
23878 PyObject * obj2 = 0 ;
23879 char * kwnames[] = {
23880 (char *) "type",(char *) "winid",(char *) "menu", NULL
23881 };
23882
23883 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23884 if (obj0) {
23885 ecode1 = SWIG_AsVal_int(obj0, &val1);
23886 if (!SWIG_IsOK(ecode1)) {
23887 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23888 }
23889 arg1 = static_cast< wxEventType >(val1);
23890 }
23891 if (obj1) {
23892 ecode2 = SWIG_AsVal_int(obj1, &val2);
23893 if (!SWIG_IsOK(ecode2)) {
23894 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuEvent" "', expected argument " "2"" of type '" "int""'");
23895 }
23896 arg2 = static_cast< int >(val2);
23897 }
23898 if (obj2) {
23899 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
23900 if (!SWIG_IsOK(res3)) {
23901 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MenuEvent" "', expected argument " "3"" of type '" "wxMenu *""'");
23902 }
23903 arg3 = reinterpret_cast< wxMenu * >(argp3);
23904 }
23905 {
23906 PyThreadState* __tstate = wxPyBeginAllowThreads();
23907 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
23908 wxPyEndAllowThreads(__tstate);
23909 if (PyErr_Occurred()) SWIG_fail;
23910 }
23911 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_NEW | 0 );
23912 return resultobj;
23913 fail:
23914 return NULL;
23915 }
23916
23917
23918 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenuId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23919 PyObject *resultobj = 0;
23920 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
23921 int result;
23922 void *argp1 = 0 ;
23923 int res1 = 0 ;
23924 PyObject *swig_obj[1] ;
23925
23926 if (!args) SWIG_fail;
23927 swig_obj[0] = args;
23928 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
23929 if (!SWIG_IsOK(res1)) {
23930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenuId" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
23931 }
23932 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
23933 {
23934 PyThreadState* __tstate = wxPyBeginAllowThreads();
23935 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
23936 wxPyEndAllowThreads(__tstate);
23937 if (PyErr_Occurred()) SWIG_fail;
23938 }
23939 resultobj = SWIG_From_int(static_cast< int >(result));
23940 return resultobj;
23941 fail:
23942 return NULL;
23943 }
23944
23945
23946 SWIGINTERN PyObject *_wrap_MenuEvent_IsPopup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23947 PyObject *resultobj = 0;
23948 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
23949 bool result;
23950 void *argp1 = 0 ;
23951 int res1 = 0 ;
23952 PyObject *swig_obj[1] ;
23953
23954 if (!args) SWIG_fail;
23955 swig_obj[0] = args;
23956 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
23957 if (!SWIG_IsOK(res1)) {
23958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_IsPopup" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
23959 }
23960 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
23961 {
23962 PyThreadState* __tstate = wxPyBeginAllowThreads();
23963 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
23964 wxPyEndAllowThreads(__tstate);
23965 if (PyErr_Occurred()) SWIG_fail;
23966 }
23967 {
23968 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23969 }
23970 return resultobj;
23971 fail:
23972 return NULL;
23973 }
23974
23975
23976 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23977 PyObject *resultobj = 0;
23978 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
23979 wxMenu *result = 0 ;
23980 void *argp1 = 0 ;
23981 int res1 = 0 ;
23982 PyObject *swig_obj[1] ;
23983
23984 if (!args) SWIG_fail;
23985 swig_obj[0] = args;
23986 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
23987 if (!SWIG_IsOK(res1)) {
23988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenu" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
23989 }
23990 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
23991 {
23992 PyThreadState* __tstate = wxPyBeginAllowThreads();
23993 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
23994 wxPyEndAllowThreads(__tstate);
23995 if (PyErr_Occurred()) SWIG_fail;
23996 }
23997 {
23998 resultobj = wxPyMake_wxObject(result, (bool)0);
23999 }
24000 return resultobj;
24001 fail:
24002 return NULL;
24003 }
24004
24005
24006 SWIGINTERN PyObject *MenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24007 PyObject *obj;
24008 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24009 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuEvent, SWIG_NewClientData(obj));
24010 return SWIG_Py_Void();
24011 }
24012
24013 SWIGINTERN PyObject *MenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24014 return SWIG_Python_InitShadowInstance(args);
24015 }
24016
24017 SWIGINTERN PyObject *_wrap_new_CloseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24018 PyObject *resultobj = 0;
24019 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24020 int arg2 = (int) 0 ;
24021 wxCloseEvent *result = 0 ;
24022 int val1 ;
24023 int ecode1 = 0 ;
24024 int val2 ;
24025 int ecode2 = 0 ;
24026 PyObject * obj0 = 0 ;
24027 PyObject * obj1 = 0 ;
24028 char * kwnames[] = {
24029 (char *) "type",(char *) "winid", NULL
24030 };
24031
24032 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24033 if (obj0) {
24034 ecode1 = SWIG_AsVal_int(obj0, &val1);
24035 if (!SWIG_IsOK(ecode1)) {
24036 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CloseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24037 }
24038 arg1 = static_cast< wxEventType >(val1);
24039 }
24040 if (obj1) {
24041 ecode2 = SWIG_AsVal_int(obj1, &val2);
24042 if (!SWIG_IsOK(ecode2)) {
24043 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CloseEvent" "', expected argument " "2"" of type '" "int""'");
24044 }
24045 arg2 = static_cast< int >(val2);
24046 }
24047 {
24048 PyThreadState* __tstate = wxPyBeginAllowThreads();
24049 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
24050 wxPyEndAllowThreads(__tstate);
24051 if (PyErr_Occurred()) SWIG_fail;
24052 }
24053 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_NEW | 0 );
24054 return resultobj;
24055 fail:
24056 return NULL;
24057 }
24058
24059
24060 SWIGINTERN PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24061 PyObject *resultobj = 0;
24062 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24063 bool arg2 ;
24064 void *argp1 = 0 ;
24065 int res1 = 0 ;
24066 bool val2 ;
24067 int ecode2 = 0 ;
24068 PyObject * obj0 = 0 ;
24069 PyObject * obj1 = 0 ;
24070 char * kwnames[] = {
24071 (char *) "self",(char *) "logOff", NULL
24072 };
24073
24074 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) SWIG_fail;
24075 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24076 if (!SWIG_IsOK(res1)) {
24077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24078 }
24079 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24080 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24081 if (!SWIG_IsOK(ecode2)) {
24082 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "2"" of type '" "bool""'");
24083 }
24084 arg2 = static_cast< bool >(val2);
24085 {
24086 PyThreadState* __tstate = wxPyBeginAllowThreads();
24087 (arg1)->SetLoggingOff(arg2);
24088 wxPyEndAllowThreads(__tstate);
24089 if (PyErr_Occurred()) SWIG_fail;
24090 }
24091 resultobj = SWIG_Py_Void();
24092 return resultobj;
24093 fail:
24094 return NULL;
24095 }
24096
24097
24098 SWIGINTERN PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24099 PyObject *resultobj = 0;
24100 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24101 bool result;
24102 void *argp1 = 0 ;
24103 int res1 = 0 ;
24104 PyObject *swig_obj[1] ;
24105
24106 if (!args) SWIG_fail;
24107 swig_obj[0] = args;
24108 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24109 if (!SWIG_IsOK(res1)) {
24110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24111 }
24112 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24113 {
24114 PyThreadState* __tstate = wxPyBeginAllowThreads();
24115 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
24116 wxPyEndAllowThreads(__tstate);
24117 if (PyErr_Occurred()) SWIG_fail;
24118 }
24119 {
24120 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24121 }
24122 return resultobj;
24123 fail:
24124 return NULL;
24125 }
24126
24127
24128 SWIGINTERN PyObject *_wrap_CloseEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24129 PyObject *resultobj = 0;
24130 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24131 bool arg2 = (bool) true ;
24132 void *argp1 = 0 ;
24133 int res1 = 0 ;
24134 bool val2 ;
24135 int ecode2 = 0 ;
24136 PyObject * obj0 = 0 ;
24137 PyObject * obj1 = 0 ;
24138 char * kwnames[] = {
24139 (char *) "self",(char *) "veto", NULL
24140 };
24141
24142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) SWIG_fail;
24143 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24144 if (!SWIG_IsOK(res1)) {
24145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_Veto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24146 }
24147 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24148 if (obj1) {
24149 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24150 if (!SWIG_IsOK(ecode2)) {
24151 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_Veto" "', expected argument " "2"" of type '" "bool""'");
24152 }
24153 arg2 = static_cast< bool >(val2);
24154 }
24155 {
24156 PyThreadState* __tstate = wxPyBeginAllowThreads();
24157 (arg1)->Veto(arg2);
24158 wxPyEndAllowThreads(__tstate);
24159 if (PyErr_Occurred()) SWIG_fail;
24160 }
24161 resultobj = SWIG_Py_Void();
24162 return resultobj;
24163 fail:
24164 return NULL;
24165 }
24166
24167
24168 SWIGINTERN PyObject *_wrap_CloseEvent_GetVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24169 PyObject *resultobj = 0;
24170 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24171 bool result;
24172 void *argp1 = 0 ;
24173 int res1 = 0 ;
24174 PyObject *swig_obj[1] ;
24175
24176 if (!args) SWIG_fail;
24177 swig_obj[0] = args;
24178 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24179 if (!SWIG_IsOK(res1)) {
24180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24181 }
24182 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24183 {
24184 PyThreadState* __tstate = wxPyBeginAllowThreads();
24185 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
24186 wxPyEndAllowThreads(__tstate);
24187 if (PyErr_Occurred()) SWIG_fail;
24188 }
24189 {
24190 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24191 }
24192 return resultobj;
24193 fail:
24194 return NULL;
24195 }
24196
24197
24198 SWIGINTERN PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24199 PyObject *resultobj = 0;
24200 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24201 bool arg2 ;
24202 void *argp1 = 0 ;
24203 int res1 = 0 ;
24204 bool val2 ;
24205 int ecode2 = 0 ;
24206 PyObject * obj0 = 0 ;
24207 PyObject * obj1 = 0 ;
24208 char * kwnames[] = {
24209 (char *) "self",(char *) "canVeto", NULL
24210 };
24211
24212 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) SWIG_fail;
24213 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24214 if (!SWIG_IsOK(res1)) {
24215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24216 }
24217 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24218 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24219 if (!SWIG_IsOK(ecode2)) {
24220 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "2"" of type '" "bool""'");
24221 }
24222 arg2 = static_cast< bool >(val2);
24223 {
24224 PyThreadState* __tstate = wxPyBeginAllowThreads();
24225 (arg1)->SetCanVeto(arg2);
24226 wxPyEndAllowThreads(__tstate);
24227 if (PyErr_Occurred()) SWIG_fail;
24228 }
24229 resultobj = SWIG_Py_Void();
24230 return resultobj;
24231 fail:
24232 return NULL;
24233 }
24234
24235
24236 SWIGINTERN PyObject *_wrap_CloseEvent_CanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24237 PyObject *resultobj = 0;
24238 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24239 bool result;
24240 void *argp1 = 0 ;
24241 int res1 = 0 ;
24242 PyObject *swig_obj[1] ;
24243
24244 if (!args) SWIG_fail;
24245 swig_obj[0] = args;
24246 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24247 if (!SWIG_IsOK(res1)) {
24248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_CanVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24249 }
24250 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24251 {
24252 PyThreadState* __tstate = wxPyBeginAllowThreads();
24253 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
24254 wxPyEndAllowThreads(__tstate);
24255 if (PyErr_Occurred()) SWIG_fail;
24256 }
24257 {
24258 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24259 }
24260 return resultobj;
24261 fail:
24262 return NULL;
24263 }
24264
24265
24266 SWIGINTERN PyObject *CloseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24267 PyObject *obj;
24268 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24269 SWIG_TypeNewClientData(SWIGTYPE_p_wxCloseEvent, SWIG_NewClientData(obj));
24270 return SWIG_Py_Void();
24271 }
24272
24273 SWIGINTERN PyObject *CloseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24274 return SWIG_Python_InitShadowInstance(args);
24275 }
24276
24277 SWIGINTERN PyObject *_wrap_new_ShowEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24278 PyObject *resultobj = 0;
24279 int arg1 = (int) 0 ;
24280 bool arg2 = (bool) false ;
24281 wxShowEvent *result = 0 ;
24282 int val1 ;
24283 int ecode1 = 0 ;
24284 bool val2 ;
24285 int ecode2 = 0 ;
24286 PyObject * obj0 = 0 ;
24287 PyObject * obj1 = 0 ;
24288 char * kwnames[] = {
24289 (char *) "winid",(char *) "show", NULL
24290 };
24291
24292 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24293 if (obj0) {
24294 ecode1 = SWIG_AsVal_int(obj0, &val1);
24295 if (!SWIG_IsOK(ecode1)) {
24296 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ShowEvent" "', expected argument " "1"" of type '" "int""'");
24297 }
24298 arg1 = static_cast< int >(val1);
24299 }
24300 if (obj1) {
24301 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24302 if (!SWIG_IsOK(ecode2)) {
24303 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ShowEvent" "', expected argument " "2"" of type '" "bool""'");
24304 }
24305 arg2 = static_cast< bool >(val2);
24306 }
24307 {
24308 PyThreadState* __tstate = wxPyBeginAllowThreads();
24309 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
24310 wxPyEndAllowThreads(__tstate);
24311 if (PyErr_Occurred()) SWIG_fail;
24312 }
24313 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxShowEvent, SWIG_POINTER_NEW | 0 );
24314 return resultobj;
24315 fail:
24316 return NULL;
24317 }
24318
24319
24320 SWIGINTERN PyObject *_wrap_ShowEvent_SetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24321 PyObject *resultobj = 0;
24322 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24323 bool arg2 ;
24324 void *argp1 = 0 ;
24325 int res1 = 0 ;
24326 bool val2 ;
24327 int ecode2 = 0 ;
24328 PyObject * obj0 = 0 ;
24329 PyObject * obj1 = 0 ;
24330 char * kwnames[] = {
24331 (char *) "self",(char *) "show", NULL
24332 };
24333
24334 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) SWIG_fail;
24335 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24336 if (!SWIG_IsOK(res1)) {
24337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_SetShow" "', expected argument " "1"" of type '" "wxShowEvent *""'");
24338 }
24339 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24340 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24341 if (!SWIG_IsOK(ecode2)) {
24342 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShowEvent_SetShow" "', expected argument " "2"" of type '" "bool""'");
24343 }
24344 arg2 = static_cast< bool >(val2);
24345 {
24346 PyThreadState* __tstate = wxPyBeginAllowThreads();
24347 (arg1)->SetShow(arg2);
24348 wxPyEndAllowThreads(__tstate);
24349 if (PyErr_Occurred()) SWIG_fail;
24350 }
24351 resultobj = SWIG_Py_Void();
24352 return resultobj;
24353 fail:
24354 return NULL;
24355 }
24356
24357
24358 SWIGINTERN PyObject *_wrap_ShowEvent_GetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24359 PyObject *resultobj = 0;
24360 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24361 bool result;
24362 void *argp1 = 0 ;
24363 int res1 = 0 ;
24364 PyObject *swig_obj[1] ;
24365
24366 if (!args) SWIG_fail;
24367 swig_obj[0] = args;
24368 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24369 if (!SWIG_IsOK(res1)) {
24370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_GetShow" "', expected argument " "1"" of type '" "wxShowEvent const *""'");
24371 }
24372 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24373 {
24374 PyThreadState* __tstate = wxPyBeginAllowThreads();
24375 result = (bool)((wxShowEvent const *)arg1)->GetShow();
24376 wxPyEndAllowThreads(__tstate);
24377 if (PyErr_Occurred()) SWIG_fail;
24378 }
24379 {
24380 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24381 }
24382 return resultobj;
24383 fail:
24384 return NULL;
24385 }
24386
24387
24388 SWIGINTERN PyObject *ShowEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24389 PyObject *obj;
24390 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24391 SWIG_TypeNewClientData(SWIGTYPE_p_wxShowEvent, SWIG_NewClientData(obj));
24392 return SWIG_Py_Void();
24393 }
24394
24395 SWIGINTERN PyObject *ShowEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24396 return SWIG_Python_InitShadowInstance(args);
24397 }
24398
24399 SWIGINTERN PyObject *_wrap_new_IconizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24400 PyObject *resultobj = 0;
24401 int arg1 = (int) 0 ;
24402 bool arg2 = (bool) true ;
24403 wxIconizeEvent *result = 0 ;
24404 int val1 ;
24405 int ecode1 = 0 ;
24406 bool val2 ;
24407 int ecode2 = 0 ;
24408 PyObject * obj0 = 0 ;
24409 PyObject * obj1 = 0 ;
24410 char * kwnames[] = {
24411 (char *) "id",(char *) "iconized", NULL
24412 };
24413
24414 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24415 if (obj0) {
24416 ecode1 = SWIG_AsVal_int(obj0, &val1);
24417 if (!SWIG_IsOK(ecode1)) {
24418 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IconizeEvent" "', expected argument " "1"" of type '" "int""'");
24419 }
24420 arg1 = static_cast< int >(val1);
24421 }
24422 if (obj1) {
24423 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24424 if (!SWIG_IsOK(ecode2)) {
24425 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IconizeEvent" "', expected argument " "2"" of type '" "bool""'");
24426 }
24427 arg2 = static_cast< bool >(val2);
24428 }
24429 {
24430 PyThreadState* __tstate = wxPyBeginAllowThreads();
24431 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
24432 wxPyEndAllowThreads(__tstate);
24433 if (PyErr_Occurred()) SWIG_fail;
24434 }
24435 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_NEW | 0 );
24436 return resultobj;
24437 fail:
24438 return NULL;
24439 }
24440
24441
24442 SWIGINTERN PyObject *_wrap_IconizeEvent_Iconized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24443 PyObject *resultobj = 0;
24444 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
24445 bool result;
24446 void *argp1 = 0 ;
24447 int res1 = 0 ;
24448 PyObject *swig_obj[1] ;
24449
24450 if (!args) SWIG_fail;
24451 swig_obj[0] = args;
24452 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconizeEvent, 0 | 0 );
24453 if (!SWIG_IsOK(res1)) {
24454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconizeEvent_Iconized" "', expected argument " "1"" of type '" "wxIconizeEvent *""'");
24455 }
24456 arg1 = reinterpret_cast< wxIconizeEvent * >(argp1);
24457 {
24458 PyThreadState* __tstate = wxPyBeginAllowThreads();
24459 result = (bool)(arg1)->Iconized();
24460 wxPyEndAllowThreads(__tstate);
24461 if (PyErr_Occurred()) SWIG_fail;
24462 }
24463 {
24464 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24465 }
24466 return resultobj;
24467 fail:
24468 return NULL;
24469 }
24470
24471
24472 SWIGINTERN PyObject *IconizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24473 PyObject *obj;
24474 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24475 SWIG_TypeNewClientData(SWIGTYPE_p_wxIconizeEvent, SWIG_NewClientData(obj));
24476 return SWIG_Py_Void();
24477 }
24478
24479 SWIGINTERN PyObject *IconizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24480 return SWIG_Python_InitShadowInstance(args);
24481 }
24482
24483 SWIGINTERN PyObject *_wrap_new_MaximizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24484 PyObject *resultobj = 0;
24485 int arg1 = (int) 0 ;
24486 wxMaximizeEvent *result = 0 ;
24487 int val1 ;
24488 int ecode1 = 0 ;
24489 PyObject * obj0 = 0 ;
24490 char * kwnames[] = {
24491 (char *) "id", NULL
24492 };
24493
24494 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) SWIG_fail;
24495 if (obj0) {
24496 ecode1 = SWIG_AsVal_int(obj0, &val1);
24497 if (!SWIG_IsOK(ecode1)) {
24498 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MaximizeEvent" "', expected argument " "1"" of type '" "int""'");
24499 }
24500 arg1 = static_cast< int >(val1);
24501 }
24502 {
24503 PyThreadState* __tstate = wxPyBeginAllowThreads();
24504 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
24505 wxPyEndAllowThreads(__tstate);
24506 if (PyErr_Occurred()) SWIG_fail;
24507 }
24508 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMaximizeEvent, SWIG_POINTER_NEW | 0 );
24509 return resultobj;
24510 fail:
24511 return NULL;
24512 }
24513
24514
24515 SWIGINTERN PyObject *MaximizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24516 PyObject *obj;
24517 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24518 SWIG_TypeNewClientData(SWIGTYPE_p_wxMaximizeEvent, SWIG_NewClientData(obj));
24519 return SWIG_Py_Void();
24520 }
24521
24522 SWIGINTERN PyObject *MaximizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24523 return SWIG_Python_InitShadowInstance(args);
24524 }
24525
24526 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24527 PyObject *resultobj = 0;
24528 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24529 wxPoint result;
24530 void *argp1 = 0 ;
24531 int res1 = 0 ;
24532 PyObject *swig_obj[1] ;
24533
24534 if (!args) SWIG_fail;
24535 swig_obj[0] = args;
24536 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24537 if (!SWIG_IsOK(res1)) {
24538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetPosition" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24539 }
24540 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24541 {
24542 PyThreadState* __tstate = wxPyBeginAllowThreads();
24543 result = (arg1)->GetPosition();
24544 wxPyEndAllowThreads(__tstate);
24545 if (PyErr_Occurred()) SWIG_fail;
24546 }
24547 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
24548 return resultobj;
24549 fail:
24550 return NULL;
24551 }
24552
24553
24554 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24555 PyObject *resultobj = 0;
24556 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24557 int result;
24558 void *argp1 = 0 ;
24559 int res1 = 0 ;
24560 PyObject *swig_obj[1] ;
24561
24562 if (!args) SWIG_fail;
24563 swig_obj[0] = args;
24564 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24565 if (!SWIG_IsOK(res1)) {
24566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetNumberOfFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24567 }
24568 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24569 {
24570 PyThreadState* __tstate = wxPyBeginAllowThreads();
24571 result = (int)(arg1)->GetNumberOfFiles();
24572 wxPyEndAllowThreads(__tstate);
24573 if (PyErr_Occurred()) SWIG_fail;
24574 }
24575 resultobj = SWIG_From_int(static_cast< int >(result));
24576 return resultobj;
24577 fail:
24578 return NULL;
24579 }
24580
24581
24582 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24583 PyObject *resultobj = 0;
24584 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24585 PyObject *result = 0 ;
24586 void *argp1 = 0 ;
24587 int res1 = 0 ;
24588 PyObject *swig_obj[1] ;
24589
24590 if (!args) SWIG_fail;
24591 swig_obj[0] = args;
24592 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24593 if (!SWIG_IsOK(res1)) {
24594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24595 }
24596 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24597 {
24598 PyThreadState* __tstate = wxPyBeginAllowThreads();
24599 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
24600 wxPyEndAllowThreads(__tstate);
24601 if (PyErr_Occurred()) SWIG_fail;
24602 }
24603 resultobj = result;
24604 return resultobj;
24605 fail:
24606 return NULL;
24607 }
24608
24609
24610 SWIGINTERN PyObject *DropFilesEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24611 PyObject *obj;
24612 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24613 SWIG_TypeNewClientData(SWIGTYPE_p_wxDropFilesEvent, SWIG_NewClientData(obj));
24614 return SWIG_Py_Void();
24615 }
24616
24617 SWIGINTERN PyObject *_wrap_new_UpdateUIEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24618 PyObject *resultobj = 0;
24619 int arg1 = (int) 0 ;
24620 wxUpdateUIEvent *result = 0 ;
24621 int val1 ;
24622 int ecode1 = 0 ;
24623 PyObject * obj0 = 0 ;
24624 char * kwnames[] = {
24625 (char *) "commandId", NULL
24626 };
24627
24628 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) SWIG_fail;
24629 if (obj0) {
24630 ecode1 = SWIG_AsVal_int(obj0, &val1);
24631 if (!SWIG_IsOK(ecode1)) {
24632 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UpdateUIEvent" "', expected argument " "1"" of type '" "int""'");
24633 }
24634 arg1 = static_cast< int >(val1);
24635 }
24636 {
24637 PyThreadState* __tstate = wxPyBeginAllowThreads();
24638 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
24639 wxPyEndAllowThreads(__tstate);
24640 if (PyErr_Occurred()) SWIG_fail;
24641 }
24642 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_NEW | 0 );
24643 return resultobj;
24644 fail:
24645 return NULL;
24646 }
24647
24648
24649 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24650 PyObject *resultobj = 0;
24651 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24652 bool result;
24653 void *argp1 = 0 ;
24654 int res1 = 0 ;
24655 PyObject *swig_obj[1] ;
24656
24657 if (!args) SWIG_fail;
24658 swig_obj[0] = args;
24659 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24660 if (!SWIG_IsOK(res1)) {
24661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24662 }
24663 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24664 {
24665 PyThreadState* __tstate = wxPyBeginAllowThreads();
24666 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
24667 wxPyEndAllowThreads(__tstate);
24668 if (PyErr_Occurred()) SWIG_fail;
24669 }
24670 {
24671 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24672 }
24673 return resultobj;
24674 fail:
24675 return NULL;
24676 }
24677
24678
24679 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24680 PyObject *resultobj = 0;
24681 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24682 bool result;
24683 void *argp1 = 0 ;
24684 int res1 = 0 ;
24685 PyObject *swig_obj[1] ;
24686
24687 if (!args) SWIG_fail;
24688 swig_obj[0] = args;
24689 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24690 if (!SWIG_IsOK(res1)) {
24691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24692 }
24693 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24694 {
24695 PyThreadState* __tstate = wxPyBeginAllowThreads();
24696 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
24697 wxPyEndAllowThreads(__tstate);
24698 if (PyErr_Occurred()) SWIG_fail;
24699 }
24700 {
24701 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24702 }
24703 return resultobj;
24704 fail:
24705 return NULL;
24706 }
24707
24708
24709 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24710 PyObject *resultobj = 0;
24711 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24712 bool result;
24713 void *argp1 = 0 ;
24714 int res1 = 0 ;
24715 PyObject *swig_obj[1] ;
24716
24717 if (!args) SWIG_fail;
24718 swig_obj[0] = args;
24719 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24720 if (!SWIG_IsOK(res1)) {
24721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24722 }
24723 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24724 {
24725 PyThreadState* __tstate = wxPyBeginAllowThreads();
24726 result = (bool)((wxUpdateUIEvent const *)arg1)->GetShown();
24727 wxPyEndAllowThreads(__tstate);
24728 if (PyErr_Occurred()) SWIG_fail;
24729 }
24730 {
24731 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24732 }
24733 return resultobj;
24734 fail:
24735 return NULL;
24736 }
24737
24738
24739 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24740 PyObject *resultobj = 0;
24741 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24742 wxString result;
24743 void *argp1 = 0 ;
24744 int res1 = 0 ;
24745 PyObject *swig_obj[1] ;
24746
24747 if (!args) SWIG_fail;
24748 swig_obj[0] = args;
24749 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24750 if (!SWIG_IsOK(res1)) {
24751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24752 }
24753 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24754 {
24755 PyThreadState* __tstate = wxPyBeginAllowThreads();
24756 result = ((wxUpdateUIEvent const *)arg1)->GetText();
24757 wxPyEndAllowThreads(__tstate);
24758 if (PyErr_Occurred()) SWIG_fail;
24759 }
24760 {
24761 #if wxUSE_UNICODE
24762 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24763 #else
24764 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24765 #endif
24766 }
24767 return resultobj;
24768 fail:
24769 return NULL;
24770 }
24771
24772
24773 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24774 PyObject *resultobj = 0;
24775 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24776 bool result;
24777 void *argp1 = 0 ;
24778 int res1 = 0 ;
24779 PyObject *swig_obj[1] ;
24780
24781 if (!args) SWIG_fail;
24782 swig_obj[0] = args;
24783 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24784 if (!SWIG_IsOK(res1)) {
24785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24786 }
24787 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24788 {
24789 PyThreadState* __tstate = wxPyBeginAllowThreads();
24790 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
24791 wxPyEndAllowThreads(__tstate);
24792 if (PyErr_Occurred()) SWIG_fail;
24793 }
24794 {
24795 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24796 }
24797 return resultobj;
24798 fail:
24799 return NULL;
24800 }
24801
24802
24803 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24804 PyObject *resultobj = 0;
24805 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24806 bool result;
24807 void *argp1 = 0 ;
24808 int res1 = 0 ;
24809 PyObject *swig_obj[1] ;
24810
24811 if (!args) SWIG_fail;
24812 swig_obj[0] = args;
24813 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24814 if (!SWIG_IsOK(res1)) {
24815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24816 }
24817 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24818 {
24819 PyThreadState* __tstate = wxPyBeginAllowThreads();
24820 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
24821 wxPyEndAllowThreads(__tstate);
24822 if (PyErr_Occurred()) SWIG_fail;
24823 }
24824 {
24825 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24826 }
24827 return resultobj;
24828 fail:
24829 return NULL;
24830 }
24831
24832
24833 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24834 PyObject *resultobj = 0;
24835 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24836 bool result;
24837 void *argp1 = 0 ;
24838 int res1 = 0 ;
24839 PyObject *swig_obj[1] ;
24840
24841 if (!args) SWIG_fail;
24842 swig_obj[0] = args;
24843 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24844 if (!SWIG_IsOK(res1)) {
24845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24846 }
24847 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24848 {
24849 PyThreadState* __tstate = wxPyBeginAllowThreads();
24850 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
24851 wxPyEndAllowThreads(__tstate);
24852 if (PyErr_Occurred()) SWIG_fail;
24853 }
24854 {
24855 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24856 }
24857 return resultobj;
24858 fail:
24859 return NULL;
24860 }
24861
24862
24863 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24864 PyObject *resultobj = 0;
24865 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24866 bool result;
24867 void *argp1 = 0 ;
24868 int res1 = 0 ;
24869 PyObject *swig_obj[1] ;
24870
24871 if (!args) SWIG_fail;
24872 swig_obj[0] = args;
24873 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24874 if (!SWIG_IsOK(res1)) {
24875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24876 }
24877 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24878 {
24879 PyThreadState* __tstate = wxPyBeginAllowThreads();
24880 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetShown();
24881 wxPyEndAllowThreads(__tstate);
24882 if (PyErr_Occurred()) SWIG_fail;
24883 }
24884 {
24885 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24886 }
24887 return resultobj;
24888 fail:
24889 return NULL;
24890 }
24891
24892
24893 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24894 PyObject *resultobj = 0;
24895 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24896 bool arg2 ;
24897 void *argp1 = 0 ;
24898 int res1 = 0 ;
24899 bool val2 ;
24900 int ecode2 = 0 ;
24901 PyObject * obj0 = 0 ;
24902 PyObject * obj1 = 0 ;
24903 char * kwnames[] = {
24904 (char *) "self",(char *) "check", NULL
24905 };
24906
24907 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) SWIG_fail;
24908 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24909 if (!SWIG_IsOK(res1)) {
24910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Check" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
24911 }
24912 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24913 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24914 if (!SWIG_IsOK(ecode2)) {
24915 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Check" "', expected argument " "2"" of type '" "bool""'");
24916 }
24917 arg2 = static_cast< bool >(val2);
24918 {
24919 PyThreadState* __tstate = wxPyBeginAllowThreads();
24920 (arg1)->Check(arg2);
24921 wxPyEndAllowThreads(__tstate);
24922 if (PyErr_Occurred()) SWIG_fail;
24923 }
24924 resultobj = SWIG_Py_Void();
24925 return resultobj;
24926 fail:
24927 return NULL;
24928 }
24929
24930
24931 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24932 PyObject *resultobj = 0;
24933 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24934 bool arg2 ;
24935 void *argp1 = 0 ;
24936 int res1 = 0 ;
24937 bool val2 ;
24938 int ecode2 = 0 ;
24939 PyObject * obj0 = 0 ;
24940 PyObject * obj1 = 0 ;
24941 char * kwnames[] = {
24942 (char *) "self",(char *) "enable", NULL
24943 };
24944
24945 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
24946 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24947 if (!SWIG_IsOK(res1)) {
24948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Enable" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
24949 }
24950 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24951 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24952 if (!SWIG_IsOK(ecode2)) {
24953 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Enable" "', expected argument " "2"" of type '" "bool""'");
24954 }
24955 arg2 = static_cast< bool >(val2);
24956 {
24957 PyThreadState* __tstate = wxPyBeginAllowThreads();
24958 (arg1)->Enable(arg2);
24959 wxPyEndAllowThreads(__tstate);
24960 if (PyErr_Occurred()) SWIG_fail;
24961 }
24962 resultobj = SWIG_Py_Void();
24963 return resultobj;
24964 fail:
24965 return NULL;
24966 }
24967
24968
24969 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24970 PyObject *resultobj = 0;
24971 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24972 bool arg2 ;
24973 void *argp1 = 0 ;
24974 int res1 = 0 ;
24975 bool val2 ;
24976 int ecode2 = 0 ;
24977 PyObject * obj0 = 0 ;
24978 PyObject * obj1 = 0 ;
24979 char * kwnames[] = {
24980 (char *) "self",(char *) "show", NULL
24981 };
24982
24983 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Show",kwnames,&obj0,&obj1)) SWIG_fail;
24984 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24985 if (!SWIG_IsOK(res1)) {
24986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Show" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
24987 }
24988 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24989 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24990 if (!SWIG_IsOK(ecode2)) {
24991 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Show" "', expected argument " "2"" of type '" "bool""'");
24992 }
24993 arg2 = static_cast< bool >(val2);
24994 {
24995 PyThreadState* __tstate = wxPyBeginAllowThreads();
24996 (arg1)->Show(arg2);
24997 wxPyEndAllowThreads(__tstate);
24998 if (PyErr_Occurred()) SWIG_fail;
24999 }
25000 resultobj = SWIG_Py_Void();
25001 return resultobj;
25002 fail:
25003 return NULL;
25004 }
25005
25006
25007 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25008 PyObject *resultobj = 0;
25009 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25010 wxString *arg2 = 0 ;
25011 void *argp1 = 0 ;
25012 int res1 = 0 ;
25013 bool temp2 = false ;
25014 PyObject * obj0 = 0 ;
25015 PyObject * obj1 = 0 ;
25016 char * kwnames[] = {
25017 (char *) "self",(char *) "text", NULL
25018 };
25019
25020 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
25021 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25022 if (!SWIG_IsOK(res1)) {
25023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_SetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25024 }
25025 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25026 {
25027 arg2 = wxString_in_helper(obj1);
25028 if (arg2 == NULL) SWIG_fail;
25029 temp2 = true;
25030 }
25031 {
25032 PyThreadState* __tstate = wxPyBeginAllowThreads();
25033 (arg1)->SetText((wxString const &)*arg2);
25034 wxPyEndAllowThreads(__tstate);
25035 if (PyErr_Occurred()) SWIG_fail;
25036 }
25037 resultobj = SWIG_Py_Void();
25038 {
25039 if (temp2)
25040 delete arg2;
25041 }
25042 return resultobj;
25043 fail:
25044 {
25045 if (temp2)
25046 delete arg2;
25047 }
25048 return NULL;
25049 }
25050
25051
25052 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25053 PyObject *resultobj = 0;
25054 long arg1 ;
25055 long val1 ;
25056 int ecode1 = 0 ;
25057 PyObject * obj0 = 0 ;
25058 char * kwnames[] = {
25059 (char *) "updateInterval", NULL
25060 };
25061
25062 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) SWIG_fail;
25063 ecode1 = SWIG_AsVal_long(obj0, &val1);
25064 if (!SWIG_IsOK(ecode1)) {
25065 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetUpdateInterval" "', expected argument " "1"" of type '" "long""'");
25066 }
25067 arg1 = static_cast< long >(val1);
25068 {
25069 PyThreadState* __tstate = wxPyBeginAllowThreads();
25070 wxUpdateUIEvent::SetUpdateInterval(arg1);
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_GetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25082 PyObject *resultobj = 0;
25083 long result;
25084
25085 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetUpdateInterval",0,0,0)) SWIG_fail;
25086 {
25087 PyThreadState* __tstate = wxPyBeginAllowThreads();
25088 result = (long)wxUpdateUIEvent::GetUpdateInterval();
25089 wxPyEndAllowThreads(__tstate);
25090 if (PyErr_Occurred()) SWIG_fail;
25091 }
25092 resultobj = SWIG_From_long(static_cast< long >(result));
25093 return resultobj;
25094 fail:
25095 return NULL;
25096 }
25097
25098
25099 SWIGINTERN PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25100 PyObject *resultobj = 0;
25101 wxWindow *arg1 = (wxWindow *) 0 ;
25102 bool result;
25103 void *argp1 = 0 ;
25104 int res1 = 0 ;
25105 PyObject * obj0 = 0 ;
25106 char * kwnames[] = {
25107 (char *) "win", NULL
25108 };
25109
25110 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) SWIG_fail;
25111 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
25112 if (!SWIG_IsOK(res1)) {
25113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_CanUpdate" "', expected argument " "1"" of type '" "wxWindow *""'");
25114 }
25115 arg1 = reinterpret_cast< wxWindow * >(argp1);
25116 {
25117 PyThreadState* __tstate = wxPyBeginAllowThreads();
25118 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
25119 wxPyEndAllowThreads(__tstate);
25120 if (PyErr_Occurred()) SWIG_fail;
25121 }
25122 {
25123 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25124 }
25125 return resultobj;
25126 fail:
25127 return NULL;
25128 }
25129
25130
25131 SWIGINTERN PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25132 PyObject *resultobj = 0;
25133
25134 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_ResetUpdateTime",0,0,0)) SWIG_fail;
25135 {
25136 PyThreadState* __tstate = wxPyBeginAllowThreads();
25137 wxUpdateUIEvent::ResetUpdateTime();
25138 wxPyEndAllowThreads(__tstate);
25139 if (PyErr_Occurred()) SWIG_fail;
25140 }
25141 resultobj = SWIG_Py_Void();
25142 return resultobj;
25143 fail:
25144 return NULL;
25145 }
25146
25147
25148 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25149 PyObject *resultobj = 0;
25150 wxUpdateUIMode arg1 ;
25151 int val1 ;
25152 int ecode1 = 0 ;
25153 PyObject * obj0 = 0 ;
25154 char * kwnames[] = {
25155 (char *) "mode", NULL
25156 };
25157
25158 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) SWIG_fail;
25159 ecode1 = SWIG_AsVal_int(obj0, &val1);
25160 if (!SWIG_IsOK(ecode1)) {
25161 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetMode" "', expected argument " "1"" of type '" "wxUpdateUIMode""'");
25162 }
25163 arg1 = static_cast< wxUpdateUIMode >(val1);
25164 {
25165 PyThreadState* __tstate = wxPyBeginAllowThreads();
25166 wxUpdateUIEvent::SetMode(arg1);
25167 wxPyEndAllowThreads(__tstate);
25168 if (PyErr_Occurred()) SWIG_fail;
25169 }
25170 resultobj = SWIG_Py_Void();
25171 return resultobj;
25172 fail:
25173 return NULL;
25174 }
25175
25176
25177 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25178 PyObject *resultobj = 0;
25179 wxUpdateUIMode result;
25180
25181 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetMode",0,0,0)) SWIG_fail;
25182 {
25183 PyThreadState* __tstate = wxPyBeginAllowThreads();
25184 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
25185 wxPyEndAllowThreads(__tstate);
25186 if (PyErr_Occurred()) SWIG_fail;
25187 }
25188 resultobj = SWIG_From_int(static_cast< int >(result));
25189 return resultobj;
25190 fail:
25191 return NULL;
25192 }
25193
25194
25195 SWIGINTERN PyObject *UpdateUIEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25196 PyObject *obj;
25197 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25198 SWIG_TypeNewClientData(SWIGTYPE_p_wxUpdateUIEvent, SWIG_NewClientData(obj));
25199 return SWIG_Py_Void();
25200 }
25201
25202 SWIGINTERN PyObject *UpdateUIEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25203 return SWIG_Python_InitShadowInstance(args);
25204 }
25205
25206 SWIGINTERN PyObject *_wrap_new_SysColourChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25207 PyObject *resultobj = 0;
25208 wxSysColourChangedEvent *result = 0 ;
25209
25210 if (!SWIG_Python_UnpackTuple(args,"new_SysColourChangedEvent",0,0,0)) SWIG_fail;
25211 {
25212 PyThreadState* __tstate = wxPyBeginAllowThreads();
25213 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
25214 wxPyEndAllowThreads(__tstate);
25215 if (PyErr_Occurred()) SWIG_fail;
25216 }
25217 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSysColourChangedEvent, SWIG_POINTER_NEW | 0 );
25218 return resultobj;
25219 fail:
25220 return NULL;
25221 }
25222
25223
25224 SWIGINTERN PyObject *SysColourChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25225 PyObject *obj;
25226 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25227 SWIG_TypeNewClientData(SWIGTYPE_p_wxSysColourChangedEvent, SWIG_NewClientData(obj));
25228 return SWIG_Py_Void();
25229 }
25230
25231 SWIGINTERN PyObject *SysColourChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25232 return SWIG_Python_InitShadowInstance(args);
25233 }
25234
25235 SWIGINTERN PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25236 PyObject *resultobj = 0;
25237 int arg1 = (int) 0 ;
25238 wxWindow *arg2 = (wxWindow *) NULL ;
25239 wxMouseCaptureChangedEvent *result = 0 ;
25240 int val1 ;
25241 int ecode1 = 0 ;
25242 void *argp2 = 0 ;
25243 int res2 = 0 ;
25244 PyObject * obj0 = 0 ;
25245 PyObject * obj1 = 0 ;
25246 char * kwnames[] = {
25247 (char *) "winid",(char *) "gainedCapture", NULL
25248 };
25249
25250 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) SWIG_fail;
25251 if (obj0) {
25252 ecode1 = SWIG_AsVal_int(obj0, &val1);
25253 if (!SWIG_IsOK(ecode1)) {
25254 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "1"" of type '" "int""'");
25255 }
25256 arg1 = static_cast< int >(val1);
25257 }
25258 if (obj1) {
25259 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25260 if (!SWIG_IsOK(res2)) {
25261 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "2"" of type '" "wxWindow *""'");
25262 }
25263 arg2 = reinterpret_cast< wxWindow * >(argp2);
25264 }
25265 {
25266 PyThreadState* __tstate = wxPyBeginAllowThreads();
25267 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
25268 wxPyEndAllowThreads(__tstate);
25269 if (PyErr_Occurred()) SWIG_fail;
25270 }
25271 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_NEW | 0 );
25272 return resultobj;
25273 fail:
25274 return NULL;
25275 }
25276
25277
25278 SWIGINTERN PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25279 PyObject *resultobj = 0;
25280 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
25281 wxWindow *result = 0 ;
25282 void *argp1 = 0 ;
25283 int res1 = 0 ;
25284 PyObject *swig_obj[1] ;
25285
25286 if (!args) SWIG_fail;
25287 swig_obj[0] = args;
25288 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseCaptureChangedEvent, 0 | 0 );
25289 if (!SWIG_IsOK(res1)) {
25290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseCaptureChangedEvent_GetCapturedWindow" "', expected argument " "1"" of type '" "wxMouseCaptureChangedEvent const *""'");
25291 }
25292 arg1 = reinterpret_cast< wxMouseCaptureChangedEvent * >(argp1);
25293 {
25294 PyThreadState* __tstate = wxPyBeginAllowThreads();
25295 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
25296 wxPyEndAllowThreads(__tstate);
25297 if (PyErr_Occurred()) SWIG_fail;
25298 }
25299 {
25300 resultobj = wxPyMake_wxObject(result, (bool)0);
25301 }
25302 return resultobj;
25303 fail:
25304 return NULL;
25305 }
25306
25307
25308 SWIGINTERN PyObject *MouseCaptureChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25309 PyObject *obj;
25310 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25311 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_NewClientData(obj));
25312 return SWIG_Py_Void();
25313 }
25314
25315 SWIGINTERN PyObject *MouseCaptureChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25316 return SWIG_Python_InitShadowInstance(args);
25317 }
25318
25319 SWIGINTERN PyObject *_wrap_new_DisplayChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25320 PyObject *resultobj = 0;
25321 wxDisplayChangedEvent *result = 0 ;
25322
25323 if (!SWIG_Python_UnpackTuple(args,"new_DisplayChangedEvent",0,0,0)) SWIG_fail;
25324 {
25325 PyThreadState* __tstate = wxPyBeginAllowThreads();
25326 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
25327 wxPyEndAllowThreads(__tstate);
25328 if (PyErr_Occurred()) SWIG_fail;
25329 }
25330 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplayChangedEvent, SWIG_POINTER_NEW | 0 );
25331 return resultobj;
25332 fail:
25333 return NULL;
25334 }
25335
25336
25337 SWIGINTERN PyObject *DisplayChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25338 PyObject *obj;
25339 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25340 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplayChangedEvent, SWIG_NewClientData(obj));
25341 return SWIG_Py_Void();
25342 }
25343
25344 SWIGINTERN PyObject *DisplayChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25345 return SWIG_Python_InitShadowInstance(args);
25346 }
25347
25348 SWIGINTERN PyObject *_wrap_new_PaletteChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25349 PyObject *resultobj = 0;
25350 int arg1 = (int) 0 ;
25351 wxPaletteChangedEvent *result = 0 ;
25352 int val1 ;
25353 int ecode1 = 0 ;
25354 PyObject * obj0 = 0 ;
25355 char * kwnames[] = {
25356 (char *) "id", NULL
25357 };
25358
25359 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) SWIG_fail;
25360 if (obj0) {
25361 ecode1 = SWIG_AsVal_int(obj0, &val1);
25362 if (!SWIG_IsOK(ecode1)) {
25363 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaletteChangedEvent" "', expected argument " "1"" of type '" "int""'");
25364 }
25365 arg1 = static_cast< int >(val1);
25366 }
25367 {
25368 PyThreadState* __tstate = wxPyBeginAllowThreads();
25369 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
25370 wxPyEndAllowThreads(__tstate);
25371 if (PyErr_Occurred()) SWIG_fail;
25372 }
25373 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_NEW | 0 );
25374 return resultobj;
25375 fail:
25376 return NULL;
25377 }
25378
25379
25380 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25381 PyObject *resultobj = 0;
25382 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25383 wxWindow *arg2 = (wxWindow *) 0 ;
25384 void *argp1 = 0 ;
25385 int res1 = 0 ;
25386 void *argp2 = 0 ;
25387 int res2 = 0 ;
25388 PyObject * obj0 = 0 ;
25389 PyObject * obj1 = 0 ;
25390 char * kwnames[] = {
25391 (char *) "self",(char *) "win", NULL
25392 };
25393
25394 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) SWIG_fail;
25395 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25396 if (!SWIG_IsOK(res1)) {
25397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25398 }
25399 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25400 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25401 if (!SWIG_IsOK(res2)) {
25402 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
25403 }
25404 arg2 = reinterpret_cast< wxWindow * >(argp2);
25405 {
25406 PyThreadState* __tstate = wxPyBeginAllowThreads();
25407 (arg1)->SetChangedWindow(arg2);
25408 wxPyEndAllowThreads(__tstate);
25409 if (PyErr_Occurred()) SWIG_fail;
25410 }
25411 resultobj = SWIG_Py_Void();
25412 return resultobj;
25413 fail:
25414 return NULL;
25415 }
25416
25417
25418 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25419 PyObject *resultobj = 0;
25420 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25421 wxWindow *result = 0 ;
25422 void *argp1 = 0 ;
25423 int res1 = 0 ;
25424 PyObject *swig_obj[1] ;
25425
25426 if (!args) SWIG_fail;
25427 swig_obj[0] = args;
25428 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25429 if (!SWIG_IsOK(res1)) {
25430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_GetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25431 }
25432 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25433 {
25434 PyThreadState* __tstate = wxPyBeginAllowThreads();
25435 result = (wxWindow *)(arg1)->GetChangedWindow();
25436 wxPyEndAllowThreads(__tstate);
25437 if (PyErr_Occurred()) SWIG_fail;
25438 }
25439 {
25440 resultobj = wxPyMake_wxObject(result, (bool)0);
25441 }
25442 return resultobj;
25443 fail:
25444 return NULL;
25445 }
25446
25447
25448 SWIGINTERN PyObject *PaletteChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25449 PyObject *obj;
25450 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25451 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaletteChangedEvent, SWIG_NewClientData(obj));
25452 return SWIG_Py_Void();
25453 }
25454
25455 SWIGINTERN PyObject *PaletteChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25456 return SWIG_Python_InitShadowInstance(args);
25457 }
25458
25459 SWIGINTERN PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25460 PyObject *resultobj = 0;
25461 int arg1 = (int) 0 ;
25462 wxQueryNewPaletteEvent *result = 0 ;
25463 int val1 ;
25464 int ecode1 = 0 ;
25465 PyObject * obj0 = 0 ;
25466 char * kwnames[] = {
25467 (char *) "winid", NULL
25468 };
25469
25470 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) SWIG_fail;
25471 if (obj0) {
25472 ecode1 = SWIG_AsVal_int(obj0, &val1);
25473 if (!SWIG_IsOK(ecode1)) {
25474 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_QueryNewPaletteEvent" "', expected argument " "1"" of type '" "int""'");
25475 }
25476 arg1 = static_cast< int >(val1);
25477 }
25478 {
25479 PyThreadState* __tstate = wxPyBeginAllowThreads();
25480 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
25481 wxPyEndAllowThreads(__tstate);
25482 if (PyErr_Occurred()) SWIG_fail;
25483 }
25484 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_NEW | 0 );
25485 return resultobj;
25486 fail:
25487 return NULL;
25488 }
25489
25490
25491 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25492 PyObject *resultobj = 0;
25493 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
25494 bool arg2 ;
25495 void *argp1 = 0 ;
25496 int res1 = 0 ;
25497 bool val2 ;
25498 int ecode2 = 0 ;
25499 PyObject * obj0 = 0 ;
25500 PyObject * obj1 = 0 ;
25501 char * kwnames[] = {
25502 (char *) "self",(char *) "realized", NULL
25503 };
25504
25505 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) SWIG_fail;
25506 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
25507 if (!SWIG_IsOK(res1)) {
25508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent *""'");
25509 }
25510 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
25511 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25512 if (!SWIG_IsOK(ecode2)) {
25513 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "2"" of type '" "bool""'");
25514 }
25515 arg2 = static_cast< bool >(val2);
25516 {
25517 PyThreadState* __tstate = wxPyBeginAllowThreads();
25518 (arg1)->SetPaletteRealized(arg2);
25519 wxPyEndAllowThreads(__tstate);
25520 if (PyErr_Occurred()) SWIG_fail;
25521 }
25522 resultobj = SWIG_Py_Void();
25523 return resultobj;
25524 fail:
25525 return NULL;
25526 }
25527
25528
25529 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25530 PyObject *resultobj = 0;
25531 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
25532 bool result;
25533 void *argp1 = 0 ;
25534 int res1 = 0 ;
25535 PyObject *swig_obj[1] ;
25536
25537 if (!args) SWIG_fail;
25538 swig_obj[0] = args;
25539 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
25540 if (!SWIG_IsOK(res1)) {
25541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_GetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent const *""'");
25542 }
25543 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
25544 {
25545 PyThreadState* __tstate = wxPyBeginAllowThreads();
25546 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
25547 wxPyEndAllowThreads(__tstate);
25548 if (PyErr_Occurred()) SWIG_fail;
25549 }
25550 {
25551 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25552 }
25553 return resultobj;
25554 fail:
25555 return NULL;
25556 }
25557
25558
25559 SWIGINTERN PyObject *QueryNewPaletteEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25560 PyObject *obj;
25561 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25562 SWIG_TypeNewClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_NewClientData(obj));
25563 return SWIG_Py_Void();
25564 }
25565
25566 SWIGINTERN PyObject *QueryNewPaletteEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25567 return SWIG_Python_InitShadowInstance(args);
25568 }
25569
25570 SWIGINTERN PyObject *_wrap_new_NavigationKeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25571 PyObject *resultobj = 0;
25572 wxNavigationKeyEvent *result = 0 ;
25573
25574 if (!SWIG_Python_UnpackTuple(args,"new_NavigationKeyEvent",0,0,0)) SWIG_fail;
25575 {
25576 PyThreadState* __tstate = wxPyBeginAllowThreads();
25577 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
25578 wxPyEndAllowThreads(__tstate);
25579 if (PyErr_Occurred()) SWIG_fail;
25580 }
25581 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_NEW | 0 );
25582 return resultobj;
25583 fail:
25584 return NULL;
25585 }
25586
25587
25588 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25589 PyObject *resultobj = 0;
25590 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25591 bool result;
25592 void *argp1 = 0 ;
25593 int res1 = 0 ;
25594 PyObject *swig_obj[1] ;
25595
25596 if (!args) SWIG_fail;
25597 swig_obj[0] = args;
25598 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25599 if (!SWIG_IsOK(res1)) {
25600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25601 }
25602 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25603 {
25604 PyThreadState* __tstate = wxPyBeginAllowThreads();
25605 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
25606 wxPyEndAllowThreads(__tstate);
25607 if (PyErr_Occurred()) SWIG_fail;
25608 }
25609 {
25610 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25611 }
25612 return resultobj;
25613 fail:
25614 return NULL;
25615 }
25616
25617
25618 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25619 PyObject *resultobj = 0;
25620 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25621 bool arg2 ;
25622 void *argp1 = 0 ;
25623 int res1 = 0 ;
25624 bool val2 ;
25625 int ecode2 = 0 ;
25626 PyObject * obj0 = 0 ;
25627 PyObject * obj1 = 0 ;
25628 char * kwnames[] = {
25629 (char *) "self",(char *) "forward", NULL
25630 };
25631
25632 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) SWIG_fail;
25633 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25634 if (!SWIG_IsOK(res1)) {
25635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25636 }
25637 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25638 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25639 if (!SWIG_IsOK(ecode2)) {
25640 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "2"" of type '" "bool""'");
25641 }
25642 arg2 = static_cast< bool >(val2);
25643 {
25644 PyThreadState* __tstate = wxPyBeginAllowThreads();
25645 (arg1)->SetDirection(arg2);
25646 wxPyEndAllowThreads(__tstate);
25647 if (PyErr_Occurred()) SWIG_fail;
25648 }
25649 resultobj = SWIG_Py_Void();
25650 return resultobj;
25651 fail:
25652 return NULL;
25653 }
25654
25655
25656 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25657 PyObject *resultobj = 0;
25658 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25659 bool result;
25660 void *argp1 = 0 ;
25661 int res1 = 0 ;
25662 PyObject *swig_obj[1] ;
25663
25664 if (!args) SWIG_fail;
25665 swig_obj[0] = args;
25666 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25667 if (!SWIG_IsOK(res1)) {
25668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25669 }
25670 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25671 {
25672 PyThreadState* __tstate = wxPyBeginAllowThreads();
25673 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
25674 wxPyEndAllowThreads(__tstate);
25675 if (PyErr_Occurred()) SWIG_fail;
25676 }
25677 {
25678 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25679 }
25680 return resultobj;
25681 fail:
25682 return NULL;
25683 }
25684
25685
25686 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25687 PyObject *resultobj = 0;
25688 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25689 bool arg2 ;
25690 void *argp1 = 0 ;
25691 int res1 = 0 ;
25692 bool val2 ;
25693 int ecode2 = 0 ;
25694 PyObject * obj0 = 0 ;
25695 PyObject * obj1 = 0 ;
25696 char * kwnames[] = {
25697 (char *) "self",(char *) "ischange", NULL
25698 };
25699
25700 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) SWIG_fail;
25701 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25702 if (!SWIG_IsOK(res1)) {
25703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25704 }
25705 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25706 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25707 if (!SWIG_IsOK(ecode2)) {
25708 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "2"" of type '" "bool""'");
25709 }
25710 arg2 = static_cast< bool >(val2);
25711 {
25712 PyThreadState* __tstate = wxPyBeginAllowThreads();
25713 (arg1)->SetWindowChange(arg2);
25714 wxPyEndAllowThreads(__tstate);
25715 if (PyErr_Occurred()) SWIG_fail;
25716 }
25717 resultobj = SWIG_Py_Void();
25718 return resultobj;
25719 fail:
25720 return NULL;
25721 }
25722
25723
25724 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25725 PyObject *resultobj = 0;
25726 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25727 bool result;
25728 void *argp1 = 0 ;
25729 int res1 = 0 ;
25730 PyObject *swig_obj[1] ;
25731
25732 if (!args) SWIG_fail;
25733 swig_obj[0] = args;
25734 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25735 if (!SWIG_IsOK(res1)) {
25736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25737 }
25738 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25739 {
25740 PyThreadState* __tstate = wxPyBeginAllowThreads();
25741 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
25742 wxPyEndAllowThreads(__tstate);
25743 if (PyErr_Occurred()) SWIG_fail;
25744 }
25745 {
25746 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25747 }
25748 return resultobj;
25749 fail:
25750 return NULL;
25751 }
25752
25753
25754 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25755 PyObject *resultobj = 0;
25756 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25757 bool arg2 ;
25758 void *argp1 = 0 ;
25759 int res1 = 0 ;
25760 bool val2 ;
25761 int ecode2 = 0 ;
25762 PyObject * obj0 = 0 ;
25763 PyObject * obj1 = 0 ;
25764 char * kwnames[] = {
25765 (char *) "self",(char *) "bIs", NULL
25766 };
25767
25768 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) SWIG_fail;
25769 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25770 if (!SWIG_IsOK(res1)) {
25771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25772 }
25773 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25774 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25775 if (!SWIG_IsOK(ecode2)) {
25776 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "2"" of type '" "bool""'");
25777 }
25778 arg2 = static_cast< bool >(val2);
25779 {
25780 PyThreadState* __tstate = wxPyBeginAllowThreads();
25781 (arg1)->SetFromTab(arg2);
25782 wxPyEndAllowThreads(__tstate);
25783 if (PyErr_Occurred()) SWIG_fail;
25784 }
25785 resultobj = SWIG_Py_Void();
25786 return resultobj;
25787 fail:
25788 return NULL;
25789 }
25790
25791
25792 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25793 PyObject *resultobj = 0;
25794 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25795 long arg2 ;
25796 void *argp1 = 0 ;
25797 int res1 = 0 ;
25798 long val2 ;
25799 int ecode2 = 0 ;
25800 PyObject * obj0 = 0 ;
25801 PyObject * obj1 = 0 ;
25802 char * kwnames[] = {
25803 (char *) "self",(char *) "flags", NULL
25804 };
25805
25806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) SWIG_fail;
25807 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25808 if (!SWIG_IsOK(res1)) {
25809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25810 }
25811 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25812 ecode2 = SWIG_AsVal_long(obj1, &val2);
25813 if (!SWIG_IsOK(ecode2)) {
25814 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "2"" of type '" "long""'");
25815 }
25816 arg2 = static_cast< long >(val2);
25817 {
25818 PyThreadState* __tstate = wxPyBeginAllowThreads();
25819 (arg1)->SetFlags(arg2);
25820 wxPyEndAllowThreads(__tstate);
25821 if (PyErr_Occurred()) SWIG_fail;
25822 }
25823 resultobj = SWIG_Py_Void();
25824 return resultobj;
25825 fail:
25826 return NULL;
25827 }
25828
25829
25830 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25831 PyObject *resultobj = 0;
25832 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25833 wxWindow *result = 0 ;
25834 void *argp1 = 0 ;
25835 int res1 = 0 ;
25836 PyObject *swig_obj[1] ;
25837
25838 if (!args) SWIG_fail;
25839 swig_obj[0] = args;
25840 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25841 if (!SWIG_IsOK(res1)) {
25842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25843 }
25844 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25845 {
25846 PyThreadState* __tstate = wxPyBeginAllowThreads();
25847 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
25848 wxPyEndAllowThreads(__tstate);
25849 if (PyErr_Occurred()) SWIG_fail;
25850 }
25851 {
25852 resultobj = wxPyMake_wxObject(result, (bool)0);
25853 }
25854 return resultobj;
25855 fail:
25856 return NULL;
25857 }
25858
25859
25860 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25861 PyObject *resultobj = 0;
25862 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25863 wxWindow *arg2 = (wxWindow *) 0 ;
25864 void *argp1 = 0 ;
25865 int res1 = 0 ;
25866 void *argp2 = 0 ;
25867 int res2 = 0 ;
25868 PyObject * obj0 = 0 ;
25869 PyObject * obj1 = 0 ;
25870 char * kwnames[] = {
25871 (char *) "self",(char *) "win", NULL
25872 };
25873
25874 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) SWIG_fail;
25875 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25876 if (!SWIG_IsOK(res1)) {
25877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25878 }
25879 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25880 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25881 if (!SWIG_IsOK(res2)) {
25882 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "2"" of type '" "wxWindow *""'");
25883 }
25884 arg2 = reinterpret_cast< wxWindow * >(argp2);
25885 {
25886 PyThreadState* __tstate = wxPyBeginAllowThreads();
25887 (arg1)->SetCurrentFocus(arg2);
25888 wxPyEndAllowThreads(__tstate);
25889 if (PyErr_Occurred()) SWIG_fail;
25890 }
25891 resultobj = SWIG_Py_Void();
25892 return resultobj;
25893 fail:
25894 return NULL;
25895 }
25896
25897
25898 SWIGINTERN PyObject *NavigationKeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25899 PyObject *obj;
25900 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25901 SWIG_TypeNewClientData(SWIGTYPE_p_wxNavigationKeyEvent, SWIG_NewClientData(obj));
25902 return SWIG_Py_Void();
25903 }
25904
25905 SWIGINTERN PyObject *NavigationKeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25906 return SWIG_Python_InitShadowInstance(args);
25907 }
25908
25909 SWIGINTERN PyObject *_wrap_new_WindowCreateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25910 PyObject *resultobj = 0;
25911 wxWindow *arg1 = (wxWindow *) NULL ;
25912 wxWindowCreateEvent *result = 0 ;
25913 void *argp1 = 0 ;
25914 int res1 = 0 ;
25915 PyObject * obj0 = 0 ;
25916 char * kwnames[] = {
25917 (char *) "win", NULL
25918 };
25919
25920 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) SWIG_fail;
25921 if (obj0) {
25922 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
25923 if (!SWIG_IsOK(res1)) {
25924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowCreateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
25925 }
25926 arg1 = reinterpret_cast< wxWindow * >(argp1);
25927 }
25928 {
25929 PyThreadState* __tstate = wxPyBeginAllowThreads();
25930 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
25931 wxPyEndAllowThreads(__tstate);
25932 if (PyErr_Occurred()) SWIG_fail;
25933 }
25934 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_NEW | 0 );
25935 return resultobj;
25936 fail:
25937 return NULL;
25938 }
25939
25940
25941 SWIGINTERN PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25942 PyObject *resultobj = 0;
25943 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
25944 wxWindow *result = 0 ;
25945 void *argp1 = 0 ;
25946 int res1 = 0 ;
25947 PyObject *swig_obj[1] ;
25948
25949 if (!args) SWIG_fail;
25950 swig_obj[0] = args;
25951 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowCreateEvent, 0 | 0 );
25952 if (!SWIG_IsOK(res1)) {
25953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowCreateEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowCreateEvent const *""'");
25954 }
25955 arg1 = reinterpret_cast< wxWindowCreateEvent * >(argp1);
25956 {
25957 PyThreadState* __tstate = wxPyBeginAllowThreads();
25958 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
25959 wxPyEndAllowThreads(__tstate);
25960 if (PyErr_Occurred()) SWIG_fail;
25961 }
25962 {
25963 resultobj = wxPyMake_wxObject(result, (bool)0);
25964 }
25965 return resultobj;
25966 fail:
25967 return NULL;
25968 }
25969
25970
25971 SWIGINTERN PyObject *WindowCreateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25972 PyObject *obj;
25973 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25974 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowCreateEvent, SWIG_NewClientData(obj));
25975 return SWIG_Py_Void();
25976 }
25977
25978 SWIGINTERN PyObject *WindowCreateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25979 return SWIG_Python_InitShadowInstance(args);
25980 }
25981
25982 SWIGINTERN PyObject *_wrap_new_WindowDestroyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25983 PyObject *resultobj = 0;
25984 wxWindow *arg1 = (wxWindow *) NULL ;
25985 wxWindowDestroyEvent *result = 0 ;
25986 void *argp1 = 0 ;
25987 int res1 = 0 ;
25988 PyObject * obj0 = 0 ;
25989 char * kwnames[] = {
25990 (char *) "win", NULL
25991 };
25992
25993 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) SWIG_fail;
25994 if (obj0) {
25995 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
25996 if (!SWIG_IsOK(res1)) {
25997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDestroyEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
25998 }
25999 arg1 = reinterpret_cast< wxWindow * >(argp1);
26000 }
26001 {
26002 PyThreadState* __tstate = wxPyBeginAllowThreads();
26003 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
26004 wxPyEndAllowThreads(__tstate);
26005 if (PyErr_Occurred()) SWIG_fail;
26006 }
26007 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_NEW | 0 );
26008 return resultobj;
26009 fail:
26010 return NULL;
26011 }
26012
26013
26014 SWIGINTERN PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26015 PyObject *resultobj = 0;
26016 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
26017 wxWindow *result = 0 ;
26018 void *argp1 = 0 ;
26019 int res1 = 0 ;
26020 PyObject *swig_obj[1] ;
26021
26022 if (!args) SWIG_fail;
26023 swig_obj[0] = args;
26024 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDestroyEvent, 0 | 0 );
26025 if (!SWIG_IsOK(res1)) {
26026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowDestroyEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowDestroyEvent const *""'");
26027 }
26028 arg1 = reinterpret_cast< wxWindowDestroyEvent * >(argp1);
26029 {
26030 PyThreadState* __tstate = wxPyBeginAllowThreads();
26031 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
26032 wxPyEndAllowThreads(__tstate);
26033 if (PyErr_Occurred()) SWIG_fail;
26034 }
26035 {
26036 resultobj = wxPyMake_wxObject(result, (bool)0);
26037 }
26038 return resultobj;
26039 fail:
26040 return NULL;
26041 }
26042
26043
26044 SWIGINTERN PyObject *WindowDestroyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26045 PyObject *obj;
26046 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26047 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDestroyEvent, SWIG_NewClientData(obj));
26048 return SWIG_Py_Void();
26049 }
26050
26051 SWIGINTERN PyObject *WindowDestroyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26052 return SWIG_Python_InitShadowInstance(args);
26053 }
26054
26055 SWIGINTERN PyObject *_wrap_new_ContextMenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26056 PyObject *resultobj = 0;
26057 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26058 int arg2 = (int) 0 ;
26059 wxPoint const &arg3_defvalue = wxDefaultPosition ;
26060 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
26061 wxContextMenuEvent *result = 0 ;
26062 int val1 ;
26063 int ecode1 = 0 ;
26064 int val2 ;
26065 int ecode2 = 0 ;
26066 wxPoint temp3 ;
26067 PyObject * obj0 = 0 ;
26068 PyObject * obj1 = 0 ;
26069 PyObject * obj2 = 0 ;
26070 char * kwnames[] = {
26071 (char *) "type",(char *) "winid",(char *) "pt", NULL
26072 };
26073
26074 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26075 if (obj0) {
26076 ecode1 = SWIG_AsVal_int(obj0, &val1);
26077 if (!SWIG_IsOK(ecode1)) {
26078 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ContextMenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26079 }
26080 arg1 = static_cast< wxEventType >(val1);
26081 }
26082 if (obj1) {
26083 ecode2 = SWIG_AsVal_int(obj1, &val2);
26084 if (!SWIG_IsOK(ecode2)) {
26085 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ContextMenuEvent" "', expected argument " "2"" of type '" "int""'");
26086 }
26087 arg2 = static_cast< int >(val2);
26088 }
26089 if (obj2) {
26090 {
26091 arg3 = &temp3;
26092 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
26093 }
26094 }
26095 {
26096 PyThreadState* __tstate = wxPyBeginAllowThreads();
26097 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
26098 wxPyEndAllowThreads(__tstate);
26099 if (PyErr_Occurred()) SWIG_fail;
26100 }
26101 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_NEW | 0 );
26102 return resultobj;
26103 fail:
26104 return NULL;
26105 }
26106
26107
26108 SWIGINTERN PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26109 PyObject *resultobj = 0;
26110 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26111 wxPoint *result = 0 ;
26112 void *argp1 = 0 ;
26113 int res1 = 0 ;
26114 PyObject *swig_obj[1] ;
26115
26116 if (!args) SWIG_fail;
26117 swig_obj[0] = args;
26118 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26119 if (!SWIG_IsOK(res1)) {
26120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_GetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent const *""'");
26121 }
26122 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26123 {
26124 PyThreadState* __tstate = wxPyBeginAllowThreads();
26125 {
26126 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
26127 result = (wxPoint *) &_result_ref;
26128 }
26129 wxPyEndAllowThreads(__tstate);
26130 if (PyErr_Occurred()) SWIG_fail;
26131 }
26132 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, 0 | 0 );
26133 return resultobj;
26134 fail:
26135 return NULL;
26136 }
26137
26138
26139 SWIGINTERN PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26140 PyObject *resultobj = 0;
26141 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26142 wxPoint *arg2 = 0 ;
26143 void *argp1 = 0 ;
26144 int res1 = 0 ;
26145 wxPoint temp2 ;
26146 PyObject * obj0 = 0 ;
26147 PyObject * obj1 = 0 ;
26148 char * kwnames[] = {
26149 (char *) "self",(char *) "pos", NULL
26150 };
26151
26152 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
26153 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26154 if (!SWIG_IsOK(res1)) {
26155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_SetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent *""'");
26156 }
26157 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26158 {
26159 arg2 = &temp2;
26160 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
26161 }
26162 {
26163 PyThreadState* __tstate = wxPyBeginAllowThreads();
26164 (arg1)->SetPosition((wxPoint const &)*arg2);
26165 wxPyEndAllowThreads(__tstate);
26166 if (PyErr_Occurred()) SWIG_fail;
26167 }
26168 resultobj = SWIG_Py_Void();
26169 return resultobj;
26170 fail:
26171 return NULL;
26172 }
26173
26174
26175 SWIGINTERN PyObject *ContextMenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26176 PyObject *obj;
26177 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26178 SWIG_TypeNewClientData(SWIGTYPE_p_wxContextMenuEvent, SWIG_NewClientData(obj));
26179 return SWIG_Py_Void();
26180 }
26181
26182 SWIGINTERN PyObject *ContextMenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26183 return SWIG_Python_InitShadowInstance(args);
26184 }
26185
26186 SWIGINTERN PyObject *_wrap_new_IdleEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26187 PyObject *resultobj = 0;
26188 wxIdleEvent *result = 0 ;
26189
26190 if (!SWIG_Python_UnpackTuple(args,"new_IdleEvent",0,0,0)) SWIG_fail;
26191 {
26192 PyThreadState* __tstate = wxPyBeginAllowThreads();
26193 result = (wxIdleEvent *)new wxIdleEvent();
26194 wxPyEndAllowThreads(__tstate);
26195 if (PyErr_Occurred()) SWIG_fail;
26196 }
26197 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_NEW | 0 );
26198 return resultobj;
26199 fail:
26200 return NULL;
26201 }
26202
26203
26204 SWIGINTERN PyObject *_wrap_IdleEvent_RequestMore(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26205 PyObject *resultobj = 0;
26206 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26207 bool arg2 = (bool) true ;
26208 void *argp1 = 0 ;
26209 int res1 = 0 ;
26210 bool val2 ;
26211 int ecode2 = 0 ;
26212 PyObject * obj0 = 0 ;
26213 PyObject * obj1 = 0 ;
26214 char * kwnames[] = {
26215 (char *) "self",(char *) "needMore", NULL
26216 };
26217
26218 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) SWIG_fail;
26219 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26220 if (!SWIG_IsOK(res1)) {
26221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_RequestMore" "', expected argument " "1"" of type '" "wxIdleEvent *""'");
26222 }
26223 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26224 if (obj1) {
26225 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26226 if (!SWIG_IsOK(ecode2)) {
26227 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IdleEvent_RequestMore" "', expected argument " "2"" of type '" "bool""'");
26228 }
26229 arg2 = static_cast< bool >(val2);
26230 }
26231 {
26232 PyThreadState* __tstate = wxPyBeginAllowThreads();
26233 (arg1)->RequestMore(arg2);
26234 wxPyEndAllowThreads(__tstate);
26235 if (PyErr_Occurred()) SWIG_fail;
26236 }
26237 resultobj = SWIG_Py_Void();
26238 return resultobj;
26239 fail:
26240 return NULL;
26241 }
26242
26243
26244 SWIGINTERN PyObject *_wrap_IdleEvent_MoreRequested(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26245 PyObject *resultobj = 0;
26246 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26247 bool result;
26248 void *argp1 = 0 ;
26249 int res1 = 0 ;
26250 PyObject *swig_obj[1] ;
26251
26252 if (!args) SWIG_fail;
26253 swig_obj[0] = args;
26254 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26255 if (!SWIG_IsOK(res1)) {
26256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_MoreRequested" "', expected argument " "1"" of type '" "wxIdleEvent const *""'");
26257 }
26258 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26259 {
26260 PyThreadState* __tstate = wxPyBeginAllowThreads();
26261 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
26262 wxPyEndAllowThreads(__tstate);
26263 if (PyErr_Occurred()) SWIG_fail;
26264 }
26265 {
26266 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26267 }
26268 return resultobj;
26269 fail:
26270 return NULL;
26271 }
26272
26273
26274 SWIGINTERN PyObject *_wrap_IdleEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26275 PyObject *resultobj = 0;
26276 wxIdleMode arg1 ;
26277 int val1 ;
26278 int ecode1 = 0 ;
26279 PyObject * obj0 = 0 ;
26280 char * kwnames[] = {
26281 (char *) "mode", NULL
26282 };
26283
26284 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) SWIG_fail;
26285 ecode1 = SWIG_AsVal_int(obj0, &val1);
26286 if (!SWIG_IsOK(ecode1)) {
26287 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IdleEvent_SetMode" "', expected argument " "1"" of type '" "wxIdleMode""'");
26288 }
26289 arg1 = static_cast< wxIdleMode >(val1);
26290 {
26291 PyThreadState* __tstate = wxPyBeginAllowThreads();
26292 wxIdleEvent::SetMode(arg1);
26293 wxPyEndAllowThreads(__tstate);
26294 if (PyErr_Occurred()) SWIG_fail;
26295 }
26296 resultobj = SWIG_Py_Void();
26297 return resultobj;
26298 fail:
26299 return NULL;
26300 }
26301
26302
26303 SWIGINTERN PyObject *_wrap_IdleEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26304 PyObject *resultobj = 0;
26305 wxIdleMode result;
26306
26307 if (!SWIG_Python_UnpackTuple(args,"IdleEvent_GetMode",0,0,0)) SWIG_fail;
26308 {
26309 PyThreadState* __tstate = wxPyBeginAllowThreads();
26310 result = (wxIdleMode)wxIdleEvent::GetMode();
26311 wxPyEndAllowThreads(__tstate);
26312 if (PyErr_Occurred()) SWIG_fail;
26313 }
26314 resultobj = SWIG_From_int(static_cast< int >(result));
26315 return resultobj;
26316 fail:
26317 return NULL;
26318 }
26319
26320
26321 SWIGINTERN PyObject *_wrap_IdleEvent_CanSend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26322 PyObject *resultobj = 0;
26323 wxWindow *arg1 = (wxWindow *) 0 ;
26324 bool result;
26325 void *argp1 = 0 ;
26326 int res1 = 0 ;
26327 PyObject * obj0 = 0 ;
26328 char * kwnames[] = {
26329 (char *) "win", NULL
26330 };
26331
26332 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) SWIG_fail;
26333 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26334 if (!SWIG_IsOK(res1)) {
26335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_CanSend" "', expected argument " "1"" of type '" "wxWindow *""'");
26336 }
26337 arg1 = reinterpret_cast< wxWindow * >(argp1);
26338 {
26339 PyThreadState* __tstate = wxPyBeginAllowThreads();
26340 result = (bool)wxIdleEvent::CanSend(arg1);
26341 wxPyEndAllowThreads(__tstate);
26342 if (PyErr_Occurred()) SWIG_fail;
26343 }
26344 {
26345 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26346 }
26347 return resultobj;
26348 fail:
26349 return NULL;
26350 }
26351
26352
26353 SWIGINTERN PyObject *IdleEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26354 PyObject *obj;
26355 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26356 SWIG_TypeNewClientData(SWIGTYPE_p_wxIdleEvent, SWIG_NewClientData(obj));
26357 return SWIG_Py_Void();
26358 }
26359
26360 SWIGINTERN PyObject *IdleEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26361 return SWIG_Python_InitShadowInstance(args);
26362 }
26363
26364 SWIGINTERN PyObject *_wrap_new_ClipboardTextEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26365 PyObject *resultobj = 0;
26366 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26367 int arg2 = (int) 0 ;
26368 wxClipboardTextEvent *result = 0 ;
26369 int val1 ;
26370 int ecode1 = 0 ;
26371 int val2 ;
26372 int ecode2 = 0 ;
26373 PyObject * obj0 = 0 ;
26374 PyObject * obj1 = 0 ;
26375 char * kwnames[] = {
26376 (char *) "type",(char *) "winid", NULL
26377 };
26378
26379 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ClipboardTextEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26380 if (obj0) {
26381 ecode1 = SWIG_AsVal_int(obj0, &val1);
26382 if (!SWIG_IsOK(ecode1)) {
26383 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ClipboardTextEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26384 }
26385 arg1 = static_cast< wxEventType >(val1);
26386 }
26387 if (obj1) {
26388 ecode2 = SWIG_AsVal_int(obj1, &val2);
26389 if (!SWIG_IsOK(ecode2)) {
26390 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ClipboardTextEvent" "', expected argument " "2"" of type '" "int""'");
26391 }
26392 arg2 = static_cast< int >(val2);
26393 }
26394 {
26395 PyThreadState* __tstate = wxPyBeginAllowThreads();
26396 result = (wxClipboardTextEvent *)new wxClipboardTextEvent(arg1,arg2);
26397 wxPyEndAllowThreads(__tstate);
26398 if (PyErr_Occurred()) SWIG_fail;
26399 }
26400 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardTextEvent, SWIG_POINTER_NEW | 0 );
26401 return resultobj;
26402 fail:
26403 return NULL;
26404 }
26405
26406
26407 SWIGINTERN PyObject *ClipboardTextEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26408 PyObject *obj;
26409 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26410 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardTextEvent, SWIG_NewClientData(obj));
26411 return SWIG_Py_Void();
26412 }
26413
26414 SWIGINTERN PyObject *ClipboardTextEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26415 return SWIG_Python_InitShadowInstance(args);
26416 }
26417
26418 SWIGINTERN PyObject *_wrap_new_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26419 PyObject *resultobj = 0;
26420 int arg1 = (int) 0 ;
26421 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
26422 wxPyEvent *result = 0 ;
26423 int val1 ;
26424 int ecode1 = 0 ;
26425 int val2 ;
26426 int ecode2 = 0 ;
26427 PyObject * obj0 = 0 ;
26428 PyObject * obj1 = 0 ;
26429 char * kwnames[] = {
26430 (char *) "winid",(char *) "eventType", NULL
26431 };
26432
26433 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26434 if (obj0) {
26435 ecode1 = SWIG_AsVal_int(obj0, &val1);
26436 if (!SWIG_IsOK(ecode1)) {
26437 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyEvent" "', expected argument " "1"" of type '" "int""'");
26438 }
26439 arg1 = static_cast< int >(val1);
26440 }
26441 if (obj1) {
26442 ecode2 = SWIG_AsVal_int(obj1, &val2);
26443 if (!SWIG_IsOK(ecode2)) {
26444 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyEvent" "', expected argument " "2"" of type '" "wxEventType""'");
26445 }
26446 arg2 = static_cast< wxEventType >(val2);
26447 }
26448 {
26449 PyThreadState* __tstate = wxPyBeginAllowThreads();
26450 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
26451 wxPyEndAllowThreads(__tstate);
26452 if (PyErr_Occurred()) SWIG_fail;
26453 }
26454 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyEvent, SWIG_POINTER_NEW | 0 );
26455 return resultobj;
26456 fail:
26457 return NULL;
26458 }
26459
26460
26461 SWIGINTERN PyObject *_wrap_delete_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26462 PyObject *resultobj = 0;
26463 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26464 void *argp1 = 0 ;
26465 int res1 = 0 ;
26466 PyObject *swig_obj[1] ;
26467
26468 if (!args) SWIG_fail;
26469 swig_obj[0] = args;
26470 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, SWIG_POINTER_DISOWN | 0 );
26471 if (!SWIG_IsOK(res1)) {
26472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyEvent" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26473 }
26474 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26475 {
26476 PyThreadState* __tstate = wxPyBeginAllowThreads();
26477 delete arg1;
26478
26479 wxPyEndAllowThreads(__tstate);
26480 if (PyErr_Occurred()) SWIG_fail;
26481 }
26482 resultobj = SWIG_Py_Void();
26483 return resultobj;
26484 fail:
26485 return NULL;
26486 }
26487
26488
26489 SWIGINTERN PyObject *_wrap_PyEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26490 PyObject *resultobj = 0;
26491 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26492 PyObject *arg2 = (PyObject *) 0 ;
26493 void *argp1 = 0 ;
26494 int res1 = 0 ;
26495 PyObject * obj0 = 0 ;
26496 PyObject * obj1 = 0 ;
26497 char * kwnames[] = {
26498 (char *) "self",(char *) "self", NULL
26499 };
26500
26501 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
26502 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
26503 if (!SWIG_IsOK(res1)) {
26504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26505 }
26506 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26507 arg2 = obj1;
26508 {
26509 PyThreadState* __tstate = wxPyBeginAllowThreads();
26510 (arg1)->SetSelf(arg2);
26511 wxPyEndAllowThreads(__tstate);
26512 if (PyErr_Occurred()) SWIG_fail;
26513 }
26514 resultobj = SWIG_Py_Void();
26515 return resultobj;
26516 fail:
26517 return NULL;
26518 }
26519
26520
26521 SWIGINTERN PyObject *_wrap_PyEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26522 PyObject *resultobj = 0;
26523 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26524 PyObject *result = 0 ;
26525 void *argp1 = 0 ;
26526 int res1 = 0 ;
26527 PyObject *swig_obj[1] ;
26528
26529 if (!args) SWIG_fail;
26530 swig_obj[0] = args;
26531 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
26532 if (!SWIG_IsOK(res1)) {
26533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26534 }
26535 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26536 {
26537 PyThreadState* __tstate = wxPyBeginAllowThreads();
26538 result = (PyObject *)(arg1)->GetSelf();
26539 wxPyEndAllowThreads(__tstate);
26540 if (PyErr_Occurred()) SWIG_fail;
26541 }
26542 resultobj = result;
26543 return resultobj;
26544 fail:
26545 return NULL;
26546 }
26547
26548
26549 SWIGINTERN PyObject *PyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26550 PyObject *obj;
26551 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26552 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyEvent, SWIG_NewClientData(obj));
26553 return SWIG_Py_Void();
26554 }
26555
26556 SWIGINTERN PyObject *PyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26557 return SWIG_Python_InitShadowInstance(args);
26558 }
26559
26560 SWIGINTERN PyObject *_wrap_new_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26561 PyObject *resultobj = 0;
26562 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26563 int arg2 = (int) 0 ;
26564 wxPyCommandEvent *result = 0 ;
26565 int val1 ;
26566 int ecode1 = 0 ;
26567 int val2 ;
26568 int ecode2 = 0 ;
26569 PyObject * obj0 = 0 ;
26570 PyObject * obj1 = 0 ;
26571 char * kwnames[] = {
26572 (char *) "eventType",(char *) "id", NULL
26573 };
26574
26575 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26576 if (obj0) {
26577 ecode1 = SWIG_AsVal_int(obj0, &val1);
26578 if (!SWIG_IsOK(ecode1)) {
26579 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyCommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26580 }
26581 arg1 = static_cast< wxEventType >(val1);
26582 }
26583 if (obj1) {
26584 ecode2 = SWIG_AsVal_int(obj1, &val2);
26585 if (!SWIG_IsOK(ecode2)) {
26586 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyCommandEvent" "', expected argument " "2"" of type '" "int""'");
26587 }
26588 arg2 = static_cast< int >(val2);
26589 }
26590 {
26591 PyThreadState* __tstate = wxPyBeginAllowThreads();
26592 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
26593 wxPyEndAllowThreads(__tstate);
26594 if (PyErr_Occurred()) SWIG_fail;
26595 }
26596 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_NEW | 0 );
26597 return resultobj;
26598 fail:
26599 return NULL;
26600 }
26601
26602
26603 SWIGINTERN PyObject *_wrap_delete_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26604 PyObject *resultobj = 0;
26605 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26606 void *argp1 = 0 ;
26607 int res1 = 0 ;
26608 PyObject *swig_obj[1] ;
26609
26610 if (!args) SWIG_fail;
26611 swig_obj[0] = args;
26612 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_DISOWN | 0 );
26613 if (!SWIG_IsOK(res1)) {
26614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyCommandEvent" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26615 }
26616 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26617 {
26618 PyThreadState* __tstate = wxPyBeginAllowThreads();
26619 delete arg1;
26620
26621 wxPyEndAllowThreads(__tstate);
26622 if (PyErr_Occurred()) SWIG_fail;
26623 }
26624 resultobj = SWIG_Py_Void();
26625 return resultobj;
26626 fail:
26627 return NULL;
26628 }
26629
26630
26631 SWIGINTERN PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26632 PyObject *resultobj = 0;
26633 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26634 PyObject *arg2 = (PyObject *) 0 ;
26635 void *argp1 = 0 ;
26636 int res1 = 0 ;
26637 PyObject * obj0 = 0 ;
26638 PyObject * obj1 = 0 ;
26639 char * kwnames[] = {
26640 (char *) "self",(char *) "self", NULL
26641 };
26642
26643 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
26644 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
26645 if (!SWIG_IsOK(res1)) {
26646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26647 }
26648 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26649 arg2 = obj1;
26650 {
26651 PyThreadState* __tstate = wxPyBeginAllowThreads();
26652 (arg1)->SetSelf(arg2);
26653 wxPyEndAllowThreads(__tstate);
26654 if (PyErr_Occurred()) SWIG_fail;
26655 }
26656 resultobj = SWIG_Py_Void();
26657 return resultobj;
26658 fail:
26659 return NULL;
26660 }
26661
26662
26663 SWIGINTERN PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26664 PyObject *resultobj = 0;
26665 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26666 PyObject *result = 0 ;
26667 void *argp1 = 0 ;
26668 int res1 = 0 ;
26669 PyObject *swig_obj[1] ;
26670
26671 if (!args) SWIG_fail;
26672 swig_obj[0] = args;
26673 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
26674 if (!SWIG_IsOK(res1)) {
26675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26676 }
26677 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26678 {
26679 PyThreadState* __tstate = wxPyBeginAllowThreads();
26680 result = (PyObject *)(arg1)->GetSelf();
26681 wxPyEndAllowThreads(__tstate);
26682 if (PyErr_Occurred()) SWIG_fail;
26683 }
26684 resultobj = result;
26685 return resultobj;
26686 fail:
26687 return NULL;
26688 }
26689
26690
26691 SWIGINTERN PyObject *PyCommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26692 PyObject *obj;
26693 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26694 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyCommandEvent, SWIG_NewClientData(obj));
26695 return SWIG_Py_Void();
26696 }
26697
26698 SWIGINTERN PyObject *PyCommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26699 return SWIG_Python_InitShadowInstance(args);
26700 }
26701
26702 SWIGINTERN PyObject *_wrap_new_DateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26703 PyObject *resultobj = 0;
26704 wxWindow *arg1 = (wxWindow *) 0 ;
26705 wxDateTime *arg2 = 0 ;
26706 wxEventType arg3 ;
26707 wxDateEvent *result = 0 ;
26708 void *argp1 = 0 ;
26709 int res1 = 0 ;
26710 void *argp2 = 0 ;
26711 int res2 = 0 ;
26712 int val3 ;
26713 int ecode3 = 0 ;
26714 PyObject * obj0 = 0 ;
26715 PyObject * obj1 = 0 ;
26716 PyObject * obj2 = 0 ;
26717 char * kwnames[] = {
26718 (char *) "win",(char *) "dt",(char *) "type", NULL
26719 };
26720
26721 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26722 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26723 if (!SWIG_IsOK(res1)) {
26724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26725 }
26726 arg1 = reinterpret_cast< wxWindow * >(argp1);
26727 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26728 if (!SWIG_IsOK(res2)) {
26729 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26730 }
26731 if (!argp2) {
26732 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26733 }
26734 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26735 ecode3 = SWIG_AsVal_int(obj2, &val3);
26736 if (!SWIG_IsOK(ecode3)) {
26737 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateEvent" "', expected argument " "3"" of type '" "wxEventType""'");
26738 }
26739 arg3 = static_cast< wxEventType >(val3);
26740 {
26741 PyThreadState* __tstate = wxPyBeginAllowThreads();
26742 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
26743 wxPyEndAllowThreads(__tstate);
26744 if (PyErr_Occurred()) SWIG_fail;
26745 }
26746 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateEvent, SWIG_POINTER_NEW | 0 );
26747 return resultobj;
26748 fail:
26749 return NULL;
26750 }
26751
26752
26753 SWIGINTERN PyObject *_wrap_DateEvent_GetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26754 PyObject *resultobj = 0;
26755 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
26756 wxDateTime *result = 0 ;
26757 void *argp1 = 0 ;
26758 int res1 = 0 ;
26759 PyObject *swig_obj[1] ;
26760
26761 if (!args) SWIG_fail;
26762 swig_obj[0] = args;
26763 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
26764 if (!SWIG_IsOK(res1)) {
26765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_GetDate" "', expected argument " "1"" of type '" "wxDateEvent const *""'");
26766 }
26767 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
26768 {
26769 PyThreadState* __tstate = wxPyBeginAllowThreads();
26770 {
26771 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
26772 result = (wxDateTime *) &_result_ref;
26773 }
26774 wxPyEndAllowThreads(__tstate);
26775 if (PyErr_Occurred()) SWIG_fail;
26776 }
26777 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26778 return resultobj;
26779 fail:
26780 return NULL;
26781 }
26782
26783
26784 SWIGINTERN PyObject *_wrap_DateEvent_SetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26785 PyObject *resultobj = 0;
26786 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
26787 wxDateTime *arg2 = 0 ;
26788 void *argp1 = 0 ;
26789 int res1 = 0 ;
26790 void *argp2 = 0 ;
26791 int res2 = 0 ;
26792 PyObject * obj0 = 0 ;
26793 PyObject * obj1 = 0 ;
26794 char * kwnames[] = {
26795 (char *) "self",(char *) "date", NULL
26796 };
26797
26798 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) SWIG_fail;
26799 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
26800 if (!SWIG_IsOK(res1)) {
26801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_SetDate" "', expected argument " "1"" of type '" "wxDateEvent *""'");
26802 }
26803 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
26804 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26805 if (!SWIG_IsOK(res2)) {
26806 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26807 }
26808 if (!argp2) {
26809 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26810 }
26811 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26812 {
26813 PyThreadState* __tstate = wxPyBeginAllowThreads();
26814 (arg1)->SetDate((wxDateTime const &)*arg2);
26815 wxPyEndAllowThreads(__tstate);
26816 if (PyErr_Occurred()) SWIG_fail;
26817 }
26818 resultobj = SWIG_Py_Void();
26819 return resultobj;
26820 fail:
26821 return NULL;
26822 }
26823
26824
26825 SWIGINTERN PyObject *DateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26826 PyObject *obj;
26827 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26828 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateEvent, SWIG_NewClientData(obj));
26829 return SWIG_Py_Void();
26830 }
26831
26832 SWIGINTERN PyObject *DateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26833 return SWIG_Python_InitShadowInstance(args);
26834 }
26835
26836 SWIGINTERN PyObject *_wrap_new_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26837 PyObject *resultobj = 0;
26838 wxPyApp *result = 0 ;
26839
26840 if (!SWIG_Python_UnpackTuple(args,"new_PyApp",0,0,0)) SWIG_fail;
26841 {
26842 PyThreadState* __tstate = wxPyBeginAllowThreads();
26843 result = (wxPyApp *)new_wxPyApp();
26844 wxPyEndAllowThreads(__tstate);
26845 if (PyErr_Occurred()) SWIG_fail;
26846 }
26847 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyApp, SWIG_POINTER_NEW | 0 );
26848 return resultobj;
26849 fail:
26850 return NULL;
26851 }
26852
26853
26854 SWIGINTERN PyObject *_wrap_delete_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26855 PyObject *resultobj = 0;
26856 wxPyApp *arg1 = (wxPyApp *) 0 ;
26857 void *argp1 = 0 ;
26858 int res1 = 0 ;
26859 PyObject *swig_obj[1] ;
26860
26861 if (!args) SWIG_fail;
26862 swig_obj[0] = args;
26863 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, SWIG_POINTER_DISOWN | 0 );
26864 if (!SWIG_IsOK(res1)) {
26865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
26866 }
26867 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26868 {
26869 PyThreadState* __tstate = wxPyBeginAllowThreads();
26870 delete arg1;
26871
26872 wxPyEndAllowThreads(__tstate);
26873 if (PyErr_Occurred()) SWIG_fail;
26874 }
26875 resultobj = SWIG_Py_Void();
26876 return resultobj;
26877 fail:
26878 return NULL;
26879 }
26880
26881
26882 SWIGINTERN PyObject *_wrap_PyApp__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26883 PyObject *resultobj = 0;
26884 wxPyApp *arg1 = (wxPyApp *) 0 ;
26885 PyObject *arg2 = (PyObject *) 0 ;
26886 PyObject *arg3 = (PyObject *) 0 ;
26887 bool arg4 ;
26888 void *argp1 = 0 ;
26889 int res1 = 0 ;
26890 bool val4 ;
26891 int ecode4 = 0 ;
26892 PyObject * obj0 = 0 ;
26893 PyObject * obj1 = 0 ;
26894 PyObject * obj2 = 0 ;
26895 PyObject * obj3 = 0 ;
26896 char * kwnames[] = {
26897 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
26898 };
26899
26900 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
26901 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
26902 if (!SWIG_IsOK(res1)) {
26903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyApp *""'");
26904 }
26905 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26906 arg2 = obj1;
26907 arg3 = obj2;
26908 ecode4 = SWIG_AsVal_bool(obj3, &val4);
26909 if (!SWIG_IsOK(ecode4)) {
26910 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyApp__setCallbackInfo" "', expected argument " "4"" of type '" "bool""'");
26911 }
26912 arg4 = static_cast< bool >(val4);
26913 {
26914 PyThreadState* __tstate = wxPyBeginAllowThreads();
26915 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
26916 wxPyEndAllowThreads(__tstate);
26917 if (PyErr_Occurred()) SWIG_fail;
26918 }
26919 resultobj = SWIG_Py_Void();
26920 return resultobj;
26921 fail:
26922 return NULL;
26923 }
26924
26925
26926 SWIGINTERN PyObject *_wrap_PyApp_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26927 PyObject *resultobj = 0;
26928 wxPyApp *arg1 = (wxPyApp *) 0 ;
26929 wxString result;
26930 void *argp1 = 0 ;
26931 int res1 = 0 ;
26932 PyObject *swig_obj[1] ;
26933
26934 if (!args) SWIG_fail;
26935 swig_obj[0] = args;
26936 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
26937 if (!SWIG_IsOK(res1)) {
26938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAppName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
26939 }
26940 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26941 {
26942 PyThreadState* __tstate = wxPyBeginAllowThreads();
26943 result = ((wxPyApp const *)arg1)->GetAppName();
26944 wxPyEndAllowThreads(__tstate);
26945 if (PyErr_Occurred()) SWIG_fail;
26946 }
26947 {
26948 #if wxUSE_UNICODE
26949 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
26950 #else
26951 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
26952 #endif
26953 }
26954 return resultobj;
26955 fail:
26956 return NULL;
26957 }
26958
26959
26960 SWIGINTERN PyObject *_wrap_PyApp_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26961 PyObject *resultobj = 0;
26962 wxPyApp *arg1 = (wxPyApp *) 0 ;
26963 wxString *arg2 = 0 ;
26964 void *argp1 = 0 ;
26965 int res1 = 0 ;
26966 bool temp2 = false ;
26967 PyObject * obj0 = 0 ;
26968 PyObject * obj1 = 0 ;
26969 char * kwnames[] = {
26970 (char *) "self",(char *) "name", NULL
26971 };
26972
26973 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
26974 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
26975 if (!SWIG_IsOK(res1)) {
26976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAppName" "', expected argument " "1"" of type '" "wxPyApp *""'");
26977 }
26978 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26979 {
26980 arg2 = wxString_in_helper(obj1);
26981 if (arg2 == NULL) SWIG_fail;
26982 temp2 = true;
26983 }
26984 {
26985 PyThreadState* __tstate = wxPyBeginAllowThreads();
26986 (arg1)->SetAppName((wxString const &)*arg2);
26987 wxPyEndAllowThreads(__tstate);
26988 if (PyErr_Occurred()) SWIG_fail;
26989 }
26990 resultobj = SWIG_Py_Void();
26991 {
26992 if (temp2)
26993 delete arg2;
26994 }
26995 return resultobj;
26996 fail:
26997 {
26998 if (temp2)
26999 delete arg2;
27000 }
27001 return NULL;
27002 }
27003
27004
27005 SWIGINTERN PyObject *_wrap_PyApp_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27006 PyObject *resultobj = 0;
27007 wxPyApp *arg1 = (wxPyApp *) 0 ;
27008 wxString result;
27009 void *argp1 = 0 ;
27010 int res1 = 0 ;
27011 PyObject *swig_obj[1] ;
27012
27013 if (!args) SWIG_fail;
27014 swig_obj[0] = args;
27015 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27016 if (!SWIG_IsOK(res1)) {
27017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetClassName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27018 }
27019 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27020 {
27021 PyThreadState* __tstate = wxPyBeginAllowThreads();
27022 result = ((wxPyApp const *)arg1)->GetClassName();
27023 wxPyEndAllowThreads(__tstate);
27024 if (PyErr_Occurred()) SWIG_fail;
27025 }
27026 {
27027 #if wxUSE_UNICODE
27028 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27029 #else
27030 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27031 #endif
27032 }
27033 return resultobj;
27034 fail:
27035 return NULL;
27036 }
27037
27038
27039 SWIGINTERN PyObject *_wrap_PyApp_SetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27040 PyObject *resultobj = 0;
27041 wxPyApp *arg1 = (wxPyApp *) 0 ;
27042 wxString *arg2 = 0 ;
27043 void *argp1 = 0 ;
27044 int res1 = 0 ;
27045 bool temp2 = false ;
27046 PyObject * obj0 = 0 ;
27047 PyObject * obj1 = 0 ;
27048 char * kwnames[] = {
27049 (char *) "self",(char *) "name", NULL
27050 };
27051
27052 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) SWIG_fail;
27053 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27054 if (!SWIG_IsOK(res1)) {
27055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetClassName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27056 }
27057 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27058 {
27059 arg2 = wxString_in_helper(obj1);
27060 if (arg2 == NULL) SWIG_fail;
27061 temp2 = true;
27062 }
27063 {
27064 PyThreadState* __tstate = wxPyBeginAllowThreads();
27065 (arg1)->SetClassName((wxString const &)*arg2);
27066 wxPyEndAllowThreads(__tstate);
27067 if (PyErr_Occurred()) SWIG_fail;
27068 }
27069 resultobj = SWIG_Py_Void();
27070 {
27071 if (temp2)
27072 delete arg2;
27073 }
27074 return resultobj;
27075 fail:
27076 {
27077 if (temp2)
27078 delete arg2;
27079 }
27080 return NULL;
27081 }
27082
27083
27084 SWIGINTERN PyObject *_wrap_PyApp_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27085 PyObject *resultobj = 0;
27086 wxPyApp *arg1 = (wxPyApp *) 0 ;
27087 wxString *result = 0 ;
27088 void *argp1 = 0 ;
27089 int res1 = 0 ;
27090 PyObject *swig_obj[1] ;
27091
27092 if (!args) SWIG_fail;
27093 swig_obj[0] = args;
27094 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27095 if (!SWIG_IsOK(res1)) {
27096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetVendorName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27097 }
27098 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27099 {
27100 PyThreadState* __tstate = wxPyBeginAllowThreads();
27101 {
27102 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
27103 result = (wxString *) &_result_ref;
27104 }
27105 wxPyEndAllowThreads(__tstate);
27106 if (PyErr_Occurred()) SWIG_fail;
27107 }
27108 {
27109 #if wxUSE_UNICODE
27110 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
27111 #else
27112 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
27113 #endif
27114 }
27115 return resultobj;
27116 fail:
27117 return NULL;
27118 }
27119
27120
27121 SWIGINTERN PyObject *_wrap_PyApp_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27122 PyObject *resultobj = 0;
27123 wxPyApp *arg1 = (wxPyApp *) 0 ;
27124 wxString *arg2 = 0 ;
27125 void *argp1 = 0 ;
27126 int res1 = 0 ;
27127 bool temp2 = false ;
27128 PyObject * obj0 = 0 ;
27129 PyObject * obj1 = 0 ;
27130 char * kwnames[] = {
27131 (char *) "self",(char *) "name", NULL
27132 };
27133
27134 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
27135 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27136 if (!SWIG_IsOK(res1)) {
27137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetVendorName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27138 }
27139 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27140 {
27141 arg2 = wxString_in_helper(obj1);
27142 if (arg2 == NULL) SWIG_fail;
27143 temp2 = true;
27144 }
27145 {
27146 PyThreadState* __tstate = wxPyBeginAllowThreads();
27147 (arg1)->SetVendorName((wxString const &)*arg2);
27148 wxPyEndAllowThreads(__tstate);
27149 if (PyErr_Occurred()) SWIG_fail;
27150 }
27151 resultobj = SWIG_Py_Void();
27152 {
27153 if (temp2)
27154 delete arg2;
27155 }
27156 return resultobj;
27157 fail:
27158 {
27159 if (temp2)
27160 delete arg2;
27161 }
27162 return NULL;
27163 }
27164
27165
27166 SWIGINTERN PyObject *_wrap_PyApp_GetTraits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27167 PyObject *resultobj = 0;
27168 wxPyApp *arg1 = (wxPyApp *) 0 ;
27169 wxAppTraits *result = 0 ;
27170 void *argp1 = 0 ;
27171 int res1 = 0 ;
27172 PyObject *swig_obj[1] ;
27173
27174 if (!args) SWIG_fail;
27175 swig_obj[0] = args;
27176 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27177 if (!SWIG_IsOK(res1)) {
27178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTraits" "', expected argument " "1"" of type '" "wxPyApp *""'");
27179 }
27180 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27181 {
27182 PyThreadState* __tstate = wxPyBeginAllowThreads();
27183 result = (wxAppTraits *)(arg1)->GetTraits();
27184 wxPyEndAllowThreads(__tstate);
27185 if (PyErr_Occurred()) SWIG_fail;
27186 }
27187 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAppTraits, 0 | 0 );
27188 return resultobj;
27189 fail:
27190 return NULL;
27191 }
27192
27193
27194 SWIGINTERN PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27195 PyObject *resultobj = 0;
27196 wxPyApp *arg1 = (wxPyApp *) 0 ;
27197 void *argp1 = 0 ;
27198 int res1 = 0 ;
27199 PyObject *swig_obj[1] ;
27200
27201 if (!args) SWIG_fail;
27202 swig_obj[0] = args;
27203 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27204 if (!SWIG_IsOK(res1)) {
27205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27206 }
27207 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27208 {
27209 PyThreadState* __tstate = wxPyBeginAllowThreads();
27210 (arg1)->ProcessPendingEvents();
27211 wxPyEndAllowThreads(__tstate);
27212 if (PyErr_Occurred()) SWIG_fail;
27213 }
27214 resultobj = SWIG_Py_Void();
27215 return resultobj;
27216 fail:
27217 return NULL;
27218 }
27219
27220
27221 SWIGINTERN PyObject *_wrap_PyApp_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27222 PyObject *resultobj = 0;
27223 wxPyApp *arg1 = (wxPyApp *) 0 ;
27224 bool arg2 = (bool) false ;
27225 bool result;
27226 void *argp1 = 0 ;
27227 int res1 = 0 ;
27228 bool val2 ;
27229 int ecode2 = 0 ;
27230 PyObject * obj0 = 0 ;
27231 PyObject * obj1 = 0 ;
27232 char * kwnames[] = {
27233 (char *) "self",(char *) "onlyIfNeeded", NULL
27234 };
27235
27236 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) SWIG_fail;
27237 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27238 if (!SWIG_IsOK(res1)) {
27239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Yield" "', expected argument " "1"" of type '" "wxPyApp *""'");
27240 }
27241 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27242 if (obj1) {
27243 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27244 if (!SWIG_IsOK(ecode2)) {
27245 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_Yield" "', expected argument " "2"" of type '" "bool""'");
27246 }
27247 arg2 = static_cast< bool >(val2);
27248 }
27249 {
27250 PyThreadState* __tstate = wxPyBeginAllowThreads();
27251 result = (bool)(arg1)->Yield(arg2);
27252 wxPyEndAllowThreads(__tstate);
27253 if (PyErr_Occurred()) SWIG_fail;
27254 }
27255 {
27256 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27257 }
27258 return resultobj;
27259 fail:
27260 return NULL;
27261 }
27262
27263
27264 SWIGINTERN PyObject *_wrap_PyApp_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27265 PyObject *resultobj = 0;
27266 wxPyApp *arg1 = (wxPyApp *) 0 ;
27267 void *argp1 = 0 ;
27268 int res1 = 0 ;
27269 PyObject *swig_obj[1] ;
27270
27271 if (!args) SWIG_fail;
27272 swig_obj[0] = args;
27273 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27274 if (!SWIG_IsOK(res1)) {
27275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_WakeUpIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27276 }
27277 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27278 {
27279 PyThreadState* __tstate = wxPyBeginAllowThreads();
27280 (arg1)->WakeUpIdle();
27281 wxPyEndAllowThreads(__tstate);
27282 if (PyErr_Occurred()) SWIG_fail;
27283 }
27284 resultobj = SWIG_Py_Void();
27285 return resultobj;
27286 fail:
27287 return NULL;
27288 }
27289
27290
27291 SWIGINTERN PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27292 PyObject *resultobj = 0;
27293 bool result;
27294
27295 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsMainLoopRunning",0,0,0)) SWIG_fail;
27296 {
27297 PyThreadState* __tstate = wxPyBeginAllowThreads();
27298 result = (bool)wxPyApp::IsMainLoopRunning();
27299 wxPyEndAllowThreads(__tstate);
27300 if (PyErr_Occurred()) SWIG_fail;
27301 }
27302 {
27303 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27304 }
27305 return resultobj;
27306 fail:
27307 return NULL;
27308 }
27309
27310
27311 SWIGINTERN PyObject *_wrap_PyApp_MainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27312 PyObject *resultobj = 0;
27313 wxPyApp *arg1 = (wxPyApp *) 0 ;
27314 int result;
27315 void *argp1 = 0 ;
27316 int res1 = 0 ;
27317 PyObject *swig_obj[1] ;
27318
27319 if (!args) SWIG_fail;
27320 swig_obj[0] = args;
27321 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27322 if (!SWIG_IsOK(res1)) {
27323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_MainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27324 }
27325 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27326 {
27327 PyThreadState* __tstate = wxPyBeginAllowThreads();
27328 result = (int)(arg1)->MainLoop();
27329 wxPyEndAllowThreads(__tstate);
27330 if (PyErr_Occurred()) SWIG_fail;
27331 }
27332 resultobj = SWIG_From_int(static_cast< int >(result));
27333 return resultobj;
27334 fail:
27335 return NULL;
27336 }
27337
27338
27339 SWIGINTERN PyObject *_wrap_PyApp_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27340 PyObject *resultobj = 0;
27341 wxPyApp *arg1 = (wxPyApp *) 0 ;
27342 void *argp1 = 0 ;
27343 int res1 = 0 ;
27344 PyObject *swig_obj[1] ;
27345
27346 if (!args) SWIG_fail;
27347 swig_obj[0] = args;
27348 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27349 if (!SWIG_IsOK(res1)) {
27350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Exit" "', expected argument " "1"" of type '" "wxPyApp *""'");
27351 }
27352 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27353 {
27354 PyThreadState* __tstate = wxPyBeginAllowThreads();
27355 (arg1)->Exit();
27356 wxPyEndAllowThreads(__tstate);
27357 if (PyErr_Occurred()) SWIG_fail;
27358 }
27359 resultobj = SWIG_Py_Void();
27360 return resultobj;
27361 fail:
27362 return NULL;
27363 }
27364
27365
27366 SWIGINTERN PyObject *_wrap_PyApp_ExitMainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27367 PyObject *resultobj = 0;
27368 wxPyApp *arg1 = (wxPyApp *) 0 ;
27369 void *argp1 = 0 ;
27370 int res1 = 0 ;
27371 PyObject *swig_obj[1] ;
27372
27373 if (!args) SWIG_fail;
27374 swig_obj[0] = args;
27375 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27376 if (!SWIG_IsOK(res1)) {
27377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ExitMainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27378 }
27379 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27380 {
27381 PyThreadState* __tstate = wxPyBeginAllowThreads();
27382 (arg1)->ExitMainLoop();
27383 wxPyEndAllowThreads(__tstate);
27384 if (PyErr_Occurred()) SWIG_fail;
27385 }
27386 resultobj = SWIG_Py_Void();
27387 return resultobj;
27388 fail:
27389 return NULL;
27390 }
27391
27392
27393 SWIGINTERN PyObject *_wrap_PyApp_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27394 PyObject *resultobj = 0;
27395 wxPyApp *arg1 = (wxPyApp *) 0 ;
27396 bool result;
27397 void *argp1 = 0 ;
27398 int res1 = 0 ;
27399 PyObject *swig_obj[1] ;
27400
27401 if (!args) SWIG_fail;
27402 swig_obj[0] = args;
27403 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27404 if (!SWIG_IsOK(res1)) {
27405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Pending" "', expected argument " "1"" of type '" "wxPyApp *""'");
27406 }
27407 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27408 {
27409 PyThreadState* __tstate = wxPyBeginAllowThreads();
27410 result = (bool)(arg1)->Pending();
27411 wxPyEndAllowThreads(__tstate);
27412 if (PyErr_Occurred()) SWIG_fail;
27413 }
27414 {
27415 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27416 }
27417 return resultobj;
27418 fail:
27419 return NULL;
27420 }
27421
27422
27423 SWIGINTERN PyObject *_wrap_PyApp_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27424 PyObject *resultobj = 0;
27425 wxPyApp *arg1 = (wxPyApp *) 0 ;
27426 bool result;
27427 void *argp1 = 0 ;
27428 int res1 = 0 ;
27429 PyObject *swig_obj[1] ;
27430
27431 if (!args) SWIG_fail;
27432 swig_obj[0] = args;
27433 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27434 if (!SWIG_IsOK(res1)) {
27435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Dispatch" "', expected argument " "1"" of type '" "wxPyApp *""'");
27436 }
27437 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27438 {
27439 PyThreadState* __tstate = wxPyBeginAllowThreads();
27440 result = (bool)(arg1)->Dispatch();
27441 wxPyEndAllowThreads(__tstate);
27442 if (PyErr_Occurred()) SWIG_fail;
27443 }
27444 {
27445 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27446 }
27447 return resultobj;
27448 fail:
27449 return NULL;
27450 }
27451
27452
27453 SWIGINTERN PyObject *_wrap_PyApp_ProcessIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27454 PyObject *resultobj = 0;
27455 wxPyApp *arg1 = (wxPyApp *) 0 ;
27456 bool result;
27457 void *argp1 = 0 ;
27458 int res1 = 0 ;
27459 PyObject *swig_obj[1] ;
27460
27461 if (!args) SWIG_fail;
27462 swig_obj[0] = args;
27463 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27464 if (!SWIG_IsOK(res1)) {
27465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27466 }
27467 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27468 {
27469 PyThreadState* __tstate = wxPyBeginAllowThreads();
27470 result = (bool)(arg1)->ProcessIdle();
27471 wxPyEndAllowThreads(__tstate);
27472 if (PyErr_Occurred()) SWIG_fail;
27473 }
27474 {
27475 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27476 }
27477 return resultobj;
27478 fail:
27479 return NULL;
27480 }
27481
27482
27483 SWIGINTERN PyObject *_wrap_PyApp_SendIdleEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27484 PyObject *resultobj = 0;
27485 wxPyApp *arg1 = (wxPyApp *) 0 ;
27486 wxWindow *arg2 = (wxWindow *) 0 ;
27487 wxIdleEvent *arg3 = 0 ;
27488 bool result;
27489 void *argp1 = 0 ;
27490 int res1 = 0 ;
27491 void *argp2 = 0 ;
27492 int res2 = 0 ;
27493 void *argp3 = 0 ;
27494 int res3 = 0 ;
27495 PyObject * obj0 = 0 ;
27496 PyObject * obj1 = 0 ;
27497 PyObject * obj2 = 0 ;
27498 char * kwnames[] = {
27499 (char *) "self",(char *) "win",(char *) "event", NULL
27500 };
27501
27502 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27503 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27504 if (!SWIG_IsOK(res1)) {
27505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SendIdleEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27506 }
27507 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27508 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27509 if (!SWIG_IsOK(res2)) {
27510 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SendIdleEvents" "', expected argument " "2"" of type '" "wxWindow *""'");
27511 }
27512 arg2 = reinterpret_cast< wxWindow * >(argp2);
27513 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIdleEvent, 0 );
27514 if (!SWIG_IsOK(res3)) {
27515 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27516 }
27517 if (!argp3) {
27518 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27519 }
27520 arg3 = reinterpret_cast< wxIdleEvent * >(argp3);
27521 {
27522 PyThreadState* __tstate = wxPyBeginAllowThreads();
27523 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
27524 wxPyEndAllowThreads(__tstate);
27525 if (PyErr_Occurred()) SWIG_fail;
27526 }
27527 {
27528 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27529 }
27530 return resultobj;
27531 fail:
27532 return NULL;
27533 }
27534
27535
27536 SWIGINTERN PyObject *_wrap_PyApp_IsActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27537 PyObject *resultobj = 0;
27538 wxPyApp *arg1 = (wxPyApp *) 0 ;
27539 bool result;
27540 void *argp1 = 0 ;
27541 int res1 = 0 ;
27542 PyObject *swig_obj[1] ;
27543
27544 if (!args) SWIG_fail;
27545 swig_obj[0] = args;
27546 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27547 if (!SWIG_IsOK(res1)) {
27548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_IsActive" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27549 }
27550 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27551 {
27552 PyThreadState* __tstate = wxPyBeginAllowThreads();
27553 result = (bool)((wxPyApp const *)arg1)->IsActive();
27554 wxPyEndAllowThreads(__tstate);
27555 if (PyErr_Occurred()) SWIG_fail;
27556 }
27557 {
27558 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27559 }
27560 return resultobj;
27561 fail:
27562 return NULL;
27563 }
27564
27565
27566 SWIGINTERN PyObject *_wrap_PyApp_SetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27567 PyObject *resultobj = 0;
27568 wxPyApp *arg1 = (wxPyApp *) 0 ;
27569 wxWindow *arg2 = (wxWindow *) 0 ;
27570 void *argp1 = 0 ;
27571 int res1 = 0 ;
27572 void *argp2 = 0 ;
27573 int res2 = 0 ;
27574 PyObject * obj0 = 0 ;
27575 PyObject * obj1 = 0 ;
27576 char * kwnames[] = {
27577 (char *) "self",(char *) "win", NULL
27578 };
27579
27580 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) SWIG_fail;
27581 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27582 if (!SWIG_IsOK(res1)) {
27583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetTopWindow" "', expected argument " "1"" of type '" "wxPyApp *""'");
27584 }
27585 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27586 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27587 if (!SWIG_IsOK(res2)) {
27588 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SetTopWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
27589 }
27590 arg2 = reinterpret_cast< wxWindow * >(argp2);
27591 {
27592 PyThreadState* __tstate = wxPyBeginAllowThreads();
27593 (arg1)->SetTopWindow(arg2);
27594 wxPyEndAllowThreads(__tstate);
27595 if (PyErr_Occurred()) SWIG_fail;
27596 }
27597 resultobj = SWIG_Py_Void();
27598 return resultobj;
27599 fail:
27600 return NULL;
27601 }
27602
27603
27604 SWIGINTERN PyObject *_wrap_PyApp_GetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27605 PyObject *resultobj = 0;
27606 wxPyApp *arg1 = (wxPyApp *) 0 ;
27607 wxWindow *result = 0 ;
27608 void *argp1 = 0 ;
27609 int res1 = 0 ;
27610 PyObject *swig_obj[1] ;
27611
27612 if (!args) SWIG_fail;
27613 swig_obj[0] = args;
27614 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27615 if (!SWIG_IsOK(res1)) {
27616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTopWindow" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27617 }
27618 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27619 {
27620 PyThreadState* __tstate = wxPyBeginAllowThreads();
27621 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
27622 wxPyEndAllowThreads(__tstate);
27623 if (PyErr_Occurred()) SWIG_fail;
27624 }
27625 {
27626 resultobj = wxPyMake_wxObject(result, (bool)0);
27627 }
27628 return resultobj;
27629 fail:
27630 return NULL;
27631 }
27632
27633
27634 SWIGINTERN PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27635 PyObject *resultobj = 0;
27636 wxPyApp *arg1 = (wxPyApp *) 0 ;
27637 bool arg2 ;
27638 void *argp1 = 0 ;
27639 int res1 = 0 ;
27640 bool val2 ;
27641 int ecode2 = 0 ;
27642 PyObject * obj0 = 0 ;
27643 PyObject * obj1 = 0 ;
27644 char * kwnames[] = {
27645 (char *) "self",(char *) "flag", NULL
27646 };
27647
27648 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) SWIG_fail;
27649 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27650 if (!SWIG_IsOK(res1)) {
27651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp *""'");
27652 }
27653 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27654 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27655 if (!SWIG_IsOK(ecode2)) {
27656 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "2"" of type '" "bool""'");
27657 }
27658 arg2 = static_cast< bool >(val2);
27659 {
27660 PyThreadState* __tstate = wxPyBeginAllowThreads();
27661 (arg1)->SetExitOnFrameDelete(arg2);
27662 wxPyEndAllowThreads(__tstate);
27663 if (PyErr_Occurred()) SWIG_fail;
27664 }
27665 resultobj = SWIG_Py_Void();
27666 return resultobj;
27667 fail:
27668 return NULL;
27669 }
27670
27671
27672 SWIGINTERN PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27673 PyObject *resultobj = 0;
27674 wxPyApp *arg1 = (wxPyApp *) 0 ;
27675 bool result;
27676 void *argp1 = 0 ;
27677 int res1 = 0 ;
27678 PyObject *swig_obj[1] ;
27679
27680 if (!args) SWIG_fail;
27681 swig_obj[0] = args;
27682 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27683 if (!SWIG_IsOK(res1)) {
27684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27685 }
27686 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27687 {
27688 PyThreadState* __tstate = wxPyBeginAllowThreads();
27689 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
27690 wxPyEndAllowThreads(__tstate);
27691 if (PyErr_Occurred()) SWIG_fail;
27692 }
27693 {
27694 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27695 }
27696 return resultobj;
27697 fail:
27698 return NULL;
27699 }
27700
27701
27702 SWIGINTERN PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27703 PyObject *resultobj = 0;
27704 wxPyApp *arg1 = (wxPyApp *) 0 ;
27705 bool arg2 ;
27706 void *argp1 = 0 ;
27707 int res1 = 0 ;
27708 bool val2 ;
27709 int ecode2 = 0 ;
27710 PyObject * obj0 = 0 ;
27711 PyObject * obj1 = 0 ;
27712 char * kwnames[] = {
27713 (char *) "self",(char *) "flag", NULL
27714 };
27715
27716 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) SWIG_fail;
27717 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27718 if (!SWIG_IsOK(res1)) {
27719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp *""'");
27720 }
27721 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27722 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27723 if (!SWIG_IsOK(ecode2)) {
27724 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "2"" of type '" "bool""'");
27725 }
27726 arg2 = static_cast< bool >(val2);
27727 {
27728 PyThreadState* __tstate = wxPyBeginAllowThreads();
27729 (arg1)->SetUseBestVisual(arg2);
27730 wxPyEndAllowThreads(__tstate);
27731 if (PyErr_Occurred()) SWIG_fail;
27732 }
27733 resultobj = SWIG_Py_Void();
27734 return resultobj;
27735 fail:
27736 return NULL;
27737 }
27738
27739
27740 SWIGINTERN PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27741 PyObject *resultobj = 0;
27742 wxPyApp *arg1 = (wxPyApp *) 0 ;
27743 bool result;
27744 void *argp1 = 0 ;
27745 int res1 = 0 ;
27746 PyObject *swig_obj[1] ;
27747
27748 if (!args) SWIG_fail;
27749 swig_obj[0] = args;
27750 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27751 if (!SWIG_IsOK(res1)) {
27752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27753 }
27754 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27755 {
27756 PyThreadState* __tstate = wxPyBeginAllowThreads();
27757 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
27758 wxPyEndAllowThreads(__tstate);
27759 if (PyErr_Occurred()) SWIG_fail;
27760 }
27761 {
27762 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27763 }
27764 return resultobj;
27765 fail:
27766 return NULL;
27767 }
27768
27769
27770 SWIGINTERN PyObject *_wrap_PyApp_SetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27771 PyObject *resultobj = 0;
27772 wxPyApp *arg1 = (wxPyApp *) 0 ;
27773 int arg2 ;
27774 void *argp1 = 0 ;
27775 int res1 = 0 ;
27776 int val2 ;
27777 int ecode2 = 0 ;
27778 PyObject * obj0 = 0 ;
27779 PyObject * obj1 = 0 ;
27780 char * kwnames[] = {
27781 (char *) "self",(char *) "mode", NULL
27782 };
27783
27784 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) SWIG_fail;
27785 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27786 if (!SWIG_IsOK(res1)) {
27787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetPrintMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
27788 }
27789 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27790 ecode2 = SWIG_AsVal_int(obj1, &val2);
27791 if (!SWIG_IsOK(ecode2)) {
27792 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetPrintMode" "', expected argument " "2"" of type '" "int""'");
27793 }
27794 arg2 = static_cast< int >(val2);
27795 {
27796 PyThreadState* __tstate = wxPyBeginAllowThreads();
27797 (arg1)->SetPrintMode(arg2);
27798 wxPyEndAllowThreads(__tstate);
27799 if (PyErr_Occurred()) SWIG_fail;
27800 }
27801 resultobj = SWIG_Py_Void();
27802 return resultobj;
27803 fail:
27804 return NULL;
27805 }
27806
27807
27808 SWIGINTERN PyObject *_wrap_PyApp_GetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27809 PyObject *resultobj = 0;
27810 wxPyApp *arg1 = (wxPyApp *) 0 ;
27811 int result;
27812 void *argp1 = 0 ;
27813 int res1 = 0 ;
27814 PyObject *swig_obj[1] ;
27815
27816 if (!args) SWIG_fail;
27817 swig_obj[0] = args;
27818 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27819 if (!SWIG_IsOK(res1)) {
27820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetPrintMode" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27821 }
27822 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27823 {
27824 PyThreadState* __tstate = wxPyBeginAllowThreads();
27825 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
27826 wxPyEndAllowThreads(__tstate);
27827 if (PyErr_Occurred()) SWIG_fail;
27828 }
27829 resultobj = SWIG_From_int(static_cast< int >(result));
27830 return resultobj;
27831 fail:
27832 return NULL;
27833 }
27834
27835
27836 SWIGINTERN PyObject *_wrap_PyApp_SetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27837 PyObject *resultobj = 0;
27838 wxPyApp *arg1 = (wxPyApp *) 0 ;
27839 int arg2 ;
27840 void *argp1 = 0 ;
27841 int res1 = 0 ;
27842 int val2 ;
27843 int ecode2 = 0 ;
27844 PyObject * obj0 = 0 ;
27845 PyObject * obj1 = 0 ;
27846 char * kwnames[] = {
27847 (char *) "self",(char *) "mode", NULL
27848 };
27849
27850 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) SWIG_fail;
27851 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27852 if (!SWIG_IsOK(res1)) {
27853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
27854 }
27855 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27856 ecode2 = SWIG_AsVal_int(obj1, &val2);
27857 if (!SWIG_IsOK(ecode2)) {
27858 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetAssertMode" "', expected argument " "2"" of type '" "int""'");
27859 }
27860 arg2 = static_cast< int >(val2);
27861 {
27862 PyThreadState* __tstate = wxPyBeginAllowThreads();
27863 (arg1)->SetAssertMode(arg2);
27864 wxPyEndAllowThreads(__tstate);
27865 if (PyErr_Occurred()) SWIG_fail;
27866 }
27867 resultobj = SWIG_Py_Void();
27868 return resultobj;
27869 fail:
27870 return NULL;
27871 }
27872
27873
27874 SWIGINTERN PyObject *_wrap_PyApp_GetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27875 PyObject *resultobj = 0;
27876 wxPyApp *arg1 = (wxPyApp *) 0 ;
27877 int result;
27878 void *argp1 = 0 ;
27879 int res1 = 0 ;
27880 PyObject *swig_obj[1] ;
27881
27882 if (!args) SWIG_fail;
27883 swig_obj[0] = args;
27884 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27885 if (!SWIG_IsOK(res1)) {
27886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
27887 }
27888 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27889 {
27890 PyThreadState* __tstate = wxPyBeginAllowThreads();
27891 result = (int)(arg1)->GetAssertMode();
27892 wxPyEndAllowThreads(__tstate);
27893 if (PyErr_Occurred()) SWIG_fail;
27894 }
27895 resultobj = SWIG_From_int(static_cast< int >(result));
27896 return resultobj;
27897 fail:
27898 return NULL;
27899 }
27900
27901
27902 SWIGINTERN PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27903 PyObject *resultobj = 0;
27904 bool result;
27905
27906 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacSupportPCMenuShortcuts",0,0,0)) SWIG_fail;
27907 {
27908 PyThreadState* __tstate = wxPyBeginAllowThreads();
27909 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
27910 wxPyEndAllowThreads(__tstate);
27911 if (PyErr_Occurred()) SWIG_fail;
27912 }
27913 {
27914 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27915 }
27916 return resultobj;
27917 fail:
27918 return NULL;
27919 }
27920
27921
27922 SWIGINTERN PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27923 PyObject *resultobj = 0;
27924 long result;
27925
27926 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacAboutMenuItemId",0,0,0)) SWIG_fail;
27927 {
27928 PyThreadState* __tstate = wxPyBeginAllowThreads();
27929 result = (long)wxPyApp::GetMacAboutMenuItemId();
27930 wxPyEndAllowThreads(__tstate);
27931 if (PyErr_Occurred()) SWIG_fail;
27932 }
27933 resultobj = SWIG_From_long(static_cast< long >(result));
27934 return resultobj;
27935 fail:
27936 return NULL;
27937 }
27938
27939
27940 SWIGINTERN PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27941 PyObject *resultobj = 0;
27942 long result;
27943
27944 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacPreferencesMenuItemId",0,0,0)) SWIG_fail;
27945 {
27946 PyThreadState* __tstate = wxPyBeginAllowThreads();
27947 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
27948 wxPyEndAllowThreads(__tstate);
27949 if (PyErr_Occurred()) SWIG_fail;
27950 }
27951 resultobj = SWIG_From_long(static_cast< long >(result));
27952 return resultobj;
27953 fail:
27954 return NULL;
27955 }
27956
27957
27958 SWIGINTERN PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27959 PyObject *resultobj = 0;
27960 long result;
27961
27962 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacExitMenuItemId",0,0,0)) SWIG_fail;
27963 {
27964 PyThreadState* __tstate = wxPyBeginAllowThreads();
27965 result = (long)wxPyApp::GetMacExitMenuItemId();
27966 wxPyEndAllowThreads(__tstate);
27967 if (PyErr_Occurred()) SWIG_fail;
27968 }
27969 resultobj = SWIG_From_long(static_cast< long >(result));
27970 return resultobj;
27971 fail:
27972 return NULL;
27973 }
27974
27975
27976 SWIGINTERN PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27977 PyObject *resultobj = 0;
27978 wxString result;
27979
27980 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacHelpMenuTitleName",0,0,0)) SWIG_fail;
27981 {
27982 PyThreadState* __tstate = wxPyBeginAllowThreads();
27983 result = wxPyApp::GetMacHelpMenuTitleName();
27984 wxPyEndAllowThreads(__tstate);
27985 if (PyErr_Occurred()) SWIG_fail;
27986 }
27987 {
27988 #if wxUSE_UNICODE
27989 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27990 #else
27991 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27992 #endif
27993 }
27994 return resultobj;
27995 fail:
27996 return NULL;
27997 }
27998
27999
28000 SWIGINTERN PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28001 PyObject *resultobj = 0;
28002 bool arg1 ;
28003 bool val1 ;
28004 int ecode1 = 0 ;
28005 PyObject * obj0 = 0 ;
28006 char * kwnames[] = {
28007 (char *) "val", NULL
28008 };
28009
28010 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) SWIG_fail;
28011 ecode1 = SWIG_AsVal_bool(obj0, &val1);
28012 if (!SWIG_IsOK(ecode1)) {
28013 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacSupportPCMenuShortcuts" "', expected argument " "1"" of type '" "bool""'");
28014 }
28015 arg1 = static_cast< bool >(val1);
28016 {
28017 PyThreadState* __tstate = wxPyBeginAllowThreads();
28018 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
28019 wxPyEndAllowThreads(__tstate);
28020 if (PyErr_Occurred()) SWIG_fail;
28021 }
28022 resultobj = SWIG_Py_Void();
28023 return resultobj;
28024 fail:
28025 return NULL;
28026 }
28027
28028
28029 SWIGINTERN PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28030 PyObject *resultobj = 0;
28031 long arg1 ;
28032 long val1 ;
28033 int ecode1 = 0 ;
28034 PyObject * obj0 = 0 ;
28035 char * kwnames[] = {
28036 (char *) "val", NULL
28037 };
28038
28039 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) SWIG_fail;
28040 ecode1 = SWIG_AsVal_long(obj0, &val1);
28041 if (!SWIG_IsOK(ecode1)) {
28042 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacAboutMenuItemId" "', expected argument " "1"" of type '" "long""'");
28043 }
28044 arg1 = static_cast< long >(val1);
28045 {
28046 PyThreadState* __tstate = wxPyBeginAllowThreads();
28047 wxPyApp::SetMacAboutMenuItemId(arg1);
28048 wxPyEndAllowThreads(__tstate);
28049 if (PyErr_Occurred()) SWIG_fail;
28050 }
28051 resultobj = SWIG_Py_Void();
28052 return resultobj;
28053 fail:
28054 return NULL;
28055 }
28056
28057
28058 SWIGINTERN PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28059 PyObject *resultobj = 0;
28060 long arg1 ;
28061 long val1 ;
28062 int ecode1 = 0 ;
28063 PyObject * obj0 = 0 ;
28064 char * kwnames[] = {
28065 (char *) "val", NULL
28066 };
28067
28068 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) SWIG_fail;
28069 ecode1 = SWIG_AsVal_long(obj0, &val1);
28070 if (!SWIG_IsOK(ecode1)) {
28071 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacPreferencesMenuItemId" "', expected argument " "1"" of type '" "long""'");
28072 }
28073 arg1 = static_cast< long >(val1);
28074 {
28075 PyThreadState* __tstate = wxPyBeginAllowThreads();
28076 wxPyApp::SetMacPreferencesMenuItemId(arg1);
28077 wxPyEndAllowThreads(__tstate);
28078 if (PyErr_Occurred()) SWIG_fail;
28079 }
28080 resultobj = SWIG_Py_Void();
28081 return resultobj;
28082 fail:
28083 return NULL;
28084 }
28085
28086
28087 SWIGINTERN PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28088 PyObject *resultobj = 0;
28089 long arg1 ;
28090 long val1 ;
28091 int ecode1 = 0 ;
28092 PyObject * obj0 = 0 ;
28093 char * kwnames[] = {
28094 (char *) "val", NULL
28095 };
28096
28097 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) SWIG_fail;
28098 ecode1 = SWIG_AsVal_long(obj0, &val1);
28099 if (!SWIG_IsOK(ecode1)) {
28100 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacExitMenuItemId" "', expected argument " "1"" of type '" "long""'");
28101 }
28102 arg1 = static_cast< long >(val1);
28103 {
28104 PyThreadState* __tstate = wxPyBeginAllowThreads();
28105 wxPyApp::SetMacExitMenuItemId(arg1);
28106 wxPyEndAllowThreads(__tstate);
28107 if (PyErr_Occurred()) SWIG_fail;
28108 }
28109 resultobj = SWIG_Py_Void();
28110 return resultobj;
28111 fail:
28112 return NULL;
28113 }
28114
28115
28116 SWIGINTERN PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28117 PyObject *resultobj = 0;
28118 wxString *arg1 = 0 ;
28119 bool temp1 = false ;
28120 PyObject * obj0 = 0 ;
28121 char * kwnames[] = {
28122 (char *) "val", NULL
28123 };
28124
28125 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) SWIG_fail;
28126 {
28127 arg1 = wxString_in_helper(obj0);
28128 if (arg1 == NULL) SWIG_fail;
28129 temp1 = true;
28130 }
28131 {
28132 PyThreadState* __tstate = wxPyBeginAllowThreads();
28133 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
28134 wxPyEndAllowThreads(__tstate);
28135 if (PyErr_Occurred()) SWIG_fail;
28136 }
28137 resultobj = SWIG_Py_Void();
28138 {
28139 if (temp1)
28140 delete arg1;
28141 }
28142 return resultobj;
28143 fail:
28144 {
28145 if (temp1)
28146 delete arg1;
28147 }
28148 return NULL;
28149 }
28150
28151
28152 SWIGINTERN PyObject *_wrap_PyApp__BootstrapApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28153 PyObject *resultobj = 0;
28154 wxPyApp *arg1 = (wxPyApp *) 0 ;
28155 void *argp1 = 0 ;
28156 int res1 = 0 ;
28157 PyObject *swig_obj[1] ;
28158
28159 if (!args) SWIG_fail;
28160 swig_obj[0] = args;
28161 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28162 if (!SWIG_IsOK(res1)) {
28163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__BootstrapApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
28164 }
28165 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28166 {
28167 PyThreadState* __tstate = wxPyBeginAllowThreads();
28168 (arg1)->_BootstrapApp();
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_GetComCtl32Version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28180 PyObject *resultobj = 0;
28181 int result;
28182
28183 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetComCtl32Version",0,0,0)) SWIG_fail;
28184 {
28185 PyThreadState* __tstate = wxPyBeginAllowThreads();
28186 result = (int)wxPyApp::GetComCtl32Version();
28187 wxPyEndAllowThreads(__tstate);
28188 if (PyErr_Occurred()) SWIG_fail;
28189 }
28190 resultobj = SWIG_From_int(static_cast< int >(result));
28191 return resultobj;
28192 fail:
28193 return NULL;
28194 }
28195
28196
28197 SWIGINTERN PyObject *PyApp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28198 PyObject *obj;
28199 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28200 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyApp, SWIG_NewClientData(obj));
28201 return SWIG_Py_Void();
28202 }
28203
28204 SWIGINTERN PyObject *PyApp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28205 return SWIG_Python_InitShadowInstance(args);
28206 }
28207
28208 SWIGINTERN PyObject *_wrap_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28209 PyObject *resultobj = 0;
28210
28211 if (!SWIG_Python_UnpackTuple(args,"Exit",0,0,0)) SWIG_fail;
28212 {
28213 PyThreadState* __tstate = wxPyBeginAllowThreads();
28214 wxExit();
28215 wxPyEndAllowThreads(__tstate);
28216 if (PyErr_Occurred()) SWIG_fail;
28217 }
28218 resultobj = SWIG_Py_Void();
28219 return resultobj;
28220 fail:
28221 return NULL;
28222 }
28223
28224
28225 SWIGINTERN PyObject *_wrap_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28226 PyObject *resultobj = 0;
28227 bool result;
28228
28229 if (!SWIG_Python_UnpackTuple(args,"Yield",0,0,0)) SWIG_fail;
28230 {
28231 PyThreadState* __tstate = wxPyBeginAllowThreads();
28232 result = (bool)wxYield();
28233 wxPyEndAllowThreads(__tstate);
28234 if (PyErr_Occurred()) SWIG_fail;
28235 }
28236 {
28237 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28238 }
28239 return resultobj;
28240 fail:
28241 return NULL;
28242 }
28243
28244
28245 SWIGINTERN PyObject *_wrap_YieldIfNeeded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28246 PyObject *resultobj = 0;
28247 bool result;
28248
28249 if (!SWIG_Python_UnpackTuple(args,"YieldIfNeeded",0,0,0)) SWIG_fail;
28250 {
28251 PyThreadState* __tstate = wxPyBeginAllowThreads();
28252 result = (bool)wxYieldIfNeeded();
28253 wxPyEndAllowThreads(__tstate);
28254 if (PyErr_Occurred()) SWIG_fail;
28255 }
28256 {
28257 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28258 }
28259 return resultobj;
28260 fail:
28261 return NULL;
28262 }
28263
28264
28265 SWIGINTERN PyObject *_wrap_SafeYield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28266 PyObject *resultobj = 0;
28267 wxWindow *arg1 = (wxWindow *) NULL ;
28268 bool arg2 = (bool) false ;
28269 bool result;
28270 void *argp1 = 0 ;
28271 int res1 = 0 ;
28272 bool val2 ;
28273 int ecode2 = 0 ;
28274 PyObject * obj0 = 0 ;
28275 PyObject * obj1 = 0 ;
28276 char * kwnames[] = {
28277 (char *) "win",(char *) "onlyIfNeeded", NULL
28278 };
28279
28280 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) SWIG_fail;
28281 if (obj0) {
28282 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
28283 if (!SWIG_IsOK(res1)) {
28284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SafeYield" "', expected argument " "1"" of type '" "wxWindow *""'");
28285 }
28286 arg1 = reinterpret_cast< wxWindow * >(argp1);
28287 }
28288 if (obj1) {
28289 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28290 if (!SWIG_IsOK(ecode2)) {
28291 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SafeYield" "', expected argument " "2"" of type '" "bool""'");
28292 }
28293 arg2 = static_cast< bool >(val2);
28294 }
28295 {
28296 PyThreadState* __tstate = wxPyBeginAllowThreads();
28297 result = (bool)wxSafeYield(arg1,arg2);
28298 wxPyEndAllowThreads(__tstate);
28299 if (PyErr_Occurred()) SWIG_fail;
28300 }
28301 {
28302 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28303 }
28304 return resultobj;
28305 fail:
28306 return NULL;
28307 }
28308
28309
28310 SWIGINTERN PyObject *_wrap_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28311 PyObject *resultobj = 0;
28312
28313 if (!SWIG_Python_UnpackTuple(args,"WakeUpIdle",0,0,0)) SWIG_fail;
28314 {
28315 PyThreadState* __tstate = wxPyBeginAllowThreads();
28316 wxWakeUpIdle();
28317 wxPyEndAllowThreads(__tstate);
28318 if (PyErr_Occurred()) SWIG_fail;
28319 }
28320 resultobj = SWIG_Py_Void();
28321 return resultobj;
28322 fail:
28323 return NULL;
28324 }
28325
28326
28327 SWIGINTERN PyObject *_wrap_PostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28328 PyObject *resultobj = 0;
28329 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
28330 wxEvent *arg2 = 0 ;
28331 void *argp1 = 0 ;
28332 int res1 = 0 ;
28333 void *argp2 = 0 ;
28334 int res2 = 0 ;
28335 PyObject * obj0 = 0 ;
28336 PyObject * obj1 = 0 ;
28337 char * kwnames[] = {
28338 (char *) "dest",(char *) "event", NULL
28339 };
28340
28341 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) SWIG_fail;
28342 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
28343 if (!SWIG_IsOK(res1)) {
28344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
28345 }
28346 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
28347 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
28348 if (!SWIG_IsOK(res2)) {
28349 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28350 }
28351 if (!argp2) {
28352 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28353 }
28354 arg2 = reinterpret_cast< wxEvent * >(argp2);
28355 {
28356 PyThreadState* __tstate = wxPyBeginAllowThreads();
28357 wxPostEvent(arg1,*arg2);
28358 wxPyEndAllowThreads(__tstate);
28359 if (PyErr_Occurred()) SWIG_fail;
28360 }
28361 resultobj = SWIG_Py_Void();
28362 return resultobj;
28363 fail:
28364 return NULL;
28365 }
28366
28367
28368 SWIGINTERN PyObject *_wrap_App_CleanUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28369 PyObject *resultobj = 0;
28370
28371 if (!SWIG_Python_UnpackTuple(args,"App_CleanUp",0,0,0)) SWIG_fail;
28372 {
28373 PyThreadState* __tstate = wxPyBeginAllowThreads();
28374 wxApp_CleanUp();
28375 wxPyEndAllowThreads(__tstate);
28376 if (PyErr_Occurred()) SWIG_fail;
28377 }
28378 resultobj = SWIG_Py_Void();
28379 return resultobj;
28380 fail:
28381 return NULL;
28382 }
28383
28384
28385 SWIGINTERN PyObject *_wrap_GetApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28386 PyObject *resultobj = 0;
28387 wxPyApp *result = 0 ;
28388
28389 if (!SWIG_Python_UnpackTuple(args,"GetApp",0,0,0)) SWIG_fail;
28390 {
28391 PyThreadState* __tstate = wxPyBeginAllowThreads();
28392 result = (wxPyApp *)wxPyGetApp();
28393 wxPyEndAllowThreads(__tstate);
28394 if (PyErr_Occurred()) SWIG_fail;
28395 }
28396 {
28397 resultobj = wxPyMake_wxObject(result, 0);
28398 }
28399 return resultobj;
28400 fail:
28401 return NULL;
28402 }
28403
28404
28405 SWIGINTERN PyObject *_wrap_SetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28406 PyObject *resultobj = 0;
28407 char *arg1 = (char *) 0 ;
28408 int res1 ;
28409 char *buf1 = 0 ;
28410 int alloc1 = 0 ;
28411 PyObject * obj0 = 0 ;
28412 char * kwnames[] = {
28413 (char *) "encoding", NULL
28414 };
28415
28416 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) SWIG_fail;
28417 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
28418 if (!SWIG_IsOK(res1)) {
28419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetDefaultPyEncoding" "', expected argument " "1"" of type '" "char const *""'");
28420 }
28421 arg1 = buf1;
28422 {
28423 PyThreadState* __tstate = wxPyBeginAllowThreads();
28424 wxSetDefaultPyEncoding((char const *)arg1);
28425 wxPyEndAllowThreads(__tstate);
28426 if (PyErr_Occurred()) SWIG_fail;
28427 }
28428 resultobj = SWIG_Py_Void();
28429 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28430 return resultobj;
28431 fail:
28432 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28433 return NULL;
28434 }
28435
28436
28437 SWIGINTERN PyObject *_wrap_GetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28438 PyObject *resultobj = 0;
28439 char *result = 0 ;
28440
28441 if (!SWIG_Python_UnpackTuple(args,"GetDefaultPyEncoding",0,0,0)) SWIG_fail;
28442 {
28443 PyThreadState* __tstate = wxPyBeginAllowThreads();
28444 result = (char *)wxGetDefaultPyEncoding();
28445 wxPyEndAllowThreads(__tstate);
28446 if (PyErr_Occurred()) SWIG_fail;
28447 }
28448 resultobj = SWIG_FromCharPtr(result);
28449 return resultobj;
28450 fail:
28451 return NULL;
28452 }
28453
28454
28455 SWIGINTERN PyObject *_wrap_new_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28456 PyObject *resultobj = 0;
28457 wxEventLoop *result = 0 ;
28458
28459 if (!SWIG_Python_UnpackTuple(args,"new_EventLoop",0,0,0)) SWIG_fail;
28460 {
28461 PyThreadState* __tstate = wxPyBeginAllowThreads();
28462 result = (wxEventLoop *)new wxEventLoop();
28463 wxPyEndAllowThreads(__tstate);
28464 if (PyErr_Occurred()) SWIG_fail;
28465 }
28466 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, SWIG_POINTER_NEW | 0 );
28467 return resultobj;
28468 fail:
28469 return NULL;
28470 }
28471
28472
28473 SWIGINTERN PyObject *_wrap_delete_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28474 PyObject *resultobj = 0;
28475 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28476 void *argp1 = 0 ;
28477 int res1 = 0 ;
28478 PyObject *swig_obj[1] ;
28479
28480 if (!args) SWIG_fail;
28481 swig_obj[0] = args;
28482 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, SWIG_POINTER_DISOWN | 0 );
28483 if (!SWIG_IsOK(res1)) {
28484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoop" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28485 }
28486 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28487 {
28488 PyThreadState* __tstate = wxPyBeginAllowThreads();
28489 delete arg1;
28490
28491 wxPyEndAllowThreads(__tstate);
28492 if (PyErr_Occurred()) SWIG_fail;
28493 }
28494 resultobj = SWIG_Py_Void();
28495 return resultobj;
28496 fail:
28497 return NULL;
28498 }
28499
28500
28501 SWIGINTERN PyObject *_wrap_EventLoop_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28502 PyObject *resultobj = 0;
28503 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28504 int result;
28505 void *argp1 = 0 ;
28506 int res1 = 0 ;
28507 PyObject *swig_obj[1] ;
28508
28509 if (!args) SWIG_fail;
28510 swig_obj[0] = args;
28511 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28512 if (!SWIG_IsOK(res1)) {
28513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Run" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28514 }
28515 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28516 {
28517 PyThreadState* __tstate = wxPyBeginAllowThreads();
28518 result = (int)(arg1)->Run();
28519 wxPyEndAllowThreads(__tstate);
28520 if (PyErr_Occurred()) SWIG_fail;
28521 }
28522 resultobj = SWIG_From_int(static_cast< int >(result));
28523 return resultobj;
28524 fail:
28525 return NULL;
28526 }
28527
28528
28529 SWIGINTERN PyObject *_wrap_EventLoop_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28530 PyObject *resultobj = 0;
28531 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28532 int arg2 = (int) 0 ;
28533 void *argp1 = 0 ;
28534 int res1 = 0 ;
28535 int val2 ;
28536 int ecode2 = 0 ;
28537 PyObject * obj0 = 0 ;
28538 PyObject * obj1 = 0 ;
28539 char * kwnames[] = {
28540 (char *) "self",(char *) "rc", NULL
28541 };
28542
28543 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) SWIG_fail;
28544 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28545 if (!SWIG_IsOK(res1)) {
28546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Exit" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28547 }
28548 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28549 if (obj1) {
28550 ecode2 = SWIG_AsVal_int(obj1, &val2);
28551 if (!SWIG_IsOK(ecode2)) {
28552 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventLoop_Exit" "', expected argument " "2"" of type '" "int""'");
28553 }
28554 arg2 = static_cast< int >(val2);
28555 }
28556 {
28557 PyThreadState* __tstate = wxPyBeginAllowThreads();
28558 (arg1)->Exit(arg2);
28559 wxPyEndAllowThreads(__tstate);
28560 if (PyErr_Occurred()) SWIG_fail;
28561 }
28562 resultobj = SWIG_Py_Void();
28563 return resultobj;
28564 fail:
28565 return NULL;
28566 }
28567
28568
28569 SWIGINTERN PyObject *_wrap_EventLoop_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28570 PyObject *resultobj = 0;
28571 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28572 bool result;
28573 void *argp1 = 0 ;
28574 int res1 = 0 ;
28575 PyObject *swig_obj[1] ;
28576
28577 if (!args) SWIG_fail;
28578 swig_obj[0] = args;
28579 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28580 if (!SWIG_IsOK(res1)) {
28581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Pending" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
28582 }
28583 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28584 {
28585 PyThreadState* __tstate = wxPyBeginAllowThreads();
28586 result = (bool)((wxEventLoop const *)arg1)->Pending();
28587 wxPyEndAllowThreads(__tstate);
28588 if (PyErr_Occurred()) SWIG_fail;
28589 }
28590 {
28591 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28592 }
28593 return resultobj;
28594 fail:
28595 return NULL;
28596 }
28597
28598
28599 SWIGINTERN PyObject *_wrap_EventLoop_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28600 PyObject *resultobj = 0;
28601 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28602 bool result;
28603 void *argp1 = 0 ;
28604 int res1 = 0 ;
28605 PyObject *swig_obj[1] ;
28606
28607 if (!args) SWIG_fail;
28608 swig_obj[0] = args;
28609 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28610 if (!SWIG_IsOK(res1)) {
28611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Dispatch" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28612 }
28613 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28614 {
28615 PyThreadState* __tstate = wxPyBeginAllowThreads();
28616 result = (bool)(arg1)->Dispatch();
28617 wxPyEndAllowThreads(__tstate);
28618 if (PyErr_Occurred()) SWIG_fail;
28619 }
28620 {
28621 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28622 }
28623 return resultobj;
28624 fail:
28625 return NULL;
28626 }
28627
28628
28629 SWIGINTERN PyObject *_wrap_EventLoop_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28630 PyObject *resultobj = 0;
28631 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28632 bool result;
28633 void *argp1 = 0 ;
28634 int res1 = 0 ;
28635 PyObject *swig_obj[1] ;
28636
28637 if (!args) SWIG_fail;
28638 swig_obj[0] = args;
28639 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28640 if (!SWIG_IsOK(res1)) {
28641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_IsRunning" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
28642 }
28643 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28644 {
28645 PyThreadState* __tstate = wxPyBeginAllowThreads();
28646 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
28647 wxPyEndAllowThreads(__tstate);
28648 if (PyErr_Occurred()) SWIG_fail;
28649 }
28650 {
28651 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28652 }
28653 return resultobj;
28654 fail:
28655 return NULL;
28656 }
28657
28658
28659 SWIGINTERN PyObject *_wrap_EventLoop_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28660 PyObject *resultobj = 0;
28661 wxEventLoop *result = 0 ;
28662
28663 if (!SWIG_Python_UnpackTuple(args,"EventLoop_GetActive",0,0,0)) SWIG_fail;
28664 {
28665 PyThreadState* __tstate = wxPyBeginAllowThreads();
28666 result = (wxEventLoop *)wxEventLoop::GetActive();
28667 wxPyEndAllowThreads(__tstate);
28668 if (PyErr_Occurred()) SWIG_fail;
28669 }
28670 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, 0 | 0 );
28671 return resultobj;
28672 fail:
28673 return NULL;
28674 }
28675
28676
28677 SWIGINTERN PyObject *_wrap_EventLoop_SetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28678 PyObject *resultobj = 0;
28679 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28680 void *argp1 = 0 ;
28681 int res1 = 0 ;
28682 PyObject * obj0 = 0 ;
28683 char * kwnames[] = {
28684 (char *) "loop", NULL
28685 };
28686
28687 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) SWIG_fail;
28688 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28689 if (!SWIG_IsOK(res1)) {
28690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_SetActive" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28691 }
28692 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28693 {
28694 PyThreadState* __tstate = wxPyBeginAllowThreads();
28695 wxEventLoop::SetActive(arg1);
28696 wxPyEndAllowThreads(__tstate);
28697 if (PyErr_Occurred()) SWIG_fail;
28698 }
28699 resultobj = SWIG_Py_Void();
28700 return resultobj;
28701 fail:
28702 return NULL;
28703 }
28704
28705
28706 SWIGINTERN PyObject *EventLoop_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28707 PyObject *obj;
28708 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28709 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoop, SWIG_NewClientData(obj));
28710 return SWIG_Py_Void();
28711 }
28712
28713 SWIGINTERN PyObject *EventLoop_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28714 return SWIG_Python_InitShadowInstance(args);
28715 }
28716
28717 SWIGINTERN PyObject *_wrap_new_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28718 PyObject *resultobj = 0;
28719 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28720 wxEventLoopActivator *result = 0 ;
28721 void *argp1 = 0 ;
28722 int res1 = 0 ;
28723 PyObject * obj0 = 0 ;
28724 char * kwnames[] = {
28725 (char *) "evtLoop", NULL
28726 };
28727
28728 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_EventLoopActivator",kwnames,&obj0)) SWIG_fail;
28729 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28730 if (!SWIG_IsOK(res1)) {
28731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28732 }
28733 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28734 {
28735 PyThreadState* __tstate = wxPyBeginAllowThreads();
28736 result = (wxEventLoopActivator *)new wxEventLoopActivator(arg1);
28737 wxPyEndAllowThreads(__tstate);
28738 if (PyErr_Occurred()) SWIG_fail;
28739 }
28740 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_NEW | 0 );
28741 return resultobj;
28742 fail:
28743 return NULL;
28744 }
28745
28746
28747 SWIGINTERN PyObject *_wrap_delete_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28748 PyObject *resultobj = 0;
28749 wxEventLoopActivator *arg1 = (wxEventLoopActivator *) 0 ;
28750 void *argp1 = 0 ;
28751 int res1 = 0 ;
28752 PyObject *swig_obj[1] ;
28753
28754 if (!args) SWIG_fail;
28755 swig_obj[0] = args;
28756 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_DISOWN | 0 );
28757 if (!SWIG_IsOK(res1)) {
28758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoopActivator *""'");
28759 }
28760 arg1 = reinterpret_cast< wxEventLoopActivator * >(argp1);
28761 {
28762 PyThreadState* __tstate = wxPyBeginAllowThreads();
28763 delete arg1;
28764
28765 wxPyEndAllowThreads(__tstate);
28766 if (PyErr_Occurred()) SWIG_fail;
28767 }
28768 resultobj = SWIG_Py_Void();
28769 return resultobj;
28770 fail:
28771 return NULL;
28772 }
28773
28774
28775 SWIGINTERN PyObject *EventLoopActivator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28776 PyObject *obj;
28777 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28778 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoopActivator, SWIG_NewClientData(obj));
28779 return SWIG_Py_Void();
28780 }
28781
28782 SWIGINTERN PyObject *EventLoopActivator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28783 return SWIG_Python_InitShadowInstance(args);
28784 }
28785
28786 SWIGINTERN PyObject *_wrap_new_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28787 PyObject *resultobj = 0;
28788 int arg1 = (int) 0 ;
28789 int arg2 = (int) 0 ;
28790 int arg3 = (int) 0 ;
28791 wxAcceleratorEntry *result = 0 ;
28792 int val1 ;
28793 int ecode1 = 0 ;
28794 int val2 ;
28795 int ecode2 = 0 ;
28796 int val3 ;
28797 int ecode3 = 0 ;
28798 PyObject * obj0 = 0 ;
28799 PyObject * obj1 = 0 ;
28800 PyObject * obj2 = 0 ;
28801 char * kwnames[] = {
28802 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
28803 };
28804
28805 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
28806 if (obj0) {
28807 ecode1 = SWIG_AsVal_int(obj0, &val1);
28808 if (!SWIG_IsOK(ecode1)) {
28809 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AcceleratorEntry" "', expected argument " "1"" of type '" "int""'");
28810 }
28811 arg1 = static_cast< int >(val1);
28812 }
28813 if (obj1) {
28814 ecode2 = SWIG_AsVal_int(obj1, &val2);
28815 if (!SWIG_IsOK(ecode2)) {
28816 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AcceleratorEntry" "', expected argument " "2"" of type '" "int""'");
28817 }
28818 arg2 = static_cast< int >(val2);
28819 }
28820 if (obj2) {
28821 ecode3 = SWIG_AsVal_int(obj2, &val3);
28822 if (!SWIG_IsOK(ecode3)) {
28823 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AcceleratorEntry" "', expected argument " "3"" of type '" "int""'");
28824 }
28825 arg3 = static_cast< int >(val3);
28826 }
28827 {
28828 PyThreadState* __tstate = wxPyBeginAllowThreads();
28829 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
28830 wxPyEndAllowThreads(__tstate);
28831 if (PyErr_Occurred()) SWIG_fail;
28832 }
28833 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_NEW | 0 );
28834 return resultobj;
28835 fail:
28836 return NULL;
28837 }
28838
28839
28840 SWIGINTERN PyObject *_wrap_delete_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28841 PyObject *resultobj = 0;
28842 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28843 void *argp1 = 0 ;
28844 int res1 = 0 ;
28845 PyObject *swig_obj[1] ;
28846
28847 if (!args) SWIG_fail;
28848 swig_obj[0] = args;
28849 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_DISOWN | 0 );
28850 if (!SWIG_IsOK(res1)) {
28851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorEntry" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28852 }
28853 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28854 {
28855 PyThreadState* __tstate = wxPyBeginAllowThreads();
28856 delete arg1;
28857
28858 wxPyEndAllowThreads(__tstate);
28859 if (PyErr_Occurred()) SWIG_fail;
28860 }
28861 resultobj = SWIG_Py_Void();
28862 return resultobj;
28863 fail:
28864 return NULL;
28865 }
28866
28867
28868 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28869 PyObject *resultobj = 0;
28870 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28871 int arg2 ;
28872 int arg3 ;
28873 int arg4 ;
28874 void *argp1 = 0 ;
28875 int res1 = 0 ;
28876 int val2 ;
28877 int ecode2 = 0 ;
28878 int val3 ;
28879 int ecode3 = 0 ;
28880 int val4 ;
28881 int ecode4 = 0 ;
28882 PyObject * obj0 = 0 ;
28883 PyObject * obj1 = 0 ;
28884 PyObject * obj2 = 0 ;
28885 PyObject * obj3 = 0 ;
28886 char * kwnames[] = {
28887 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
28888 };
28889
28890 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
28891 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
28892 if (!SWIG_IsOK(res1)) {
28893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_Set" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28894 }
28895 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28896 ecode2 = SWIG_AsVal_int(obj1, &val2);
28897 if (!SWIG_IsOK(ecode2)) {
28898 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AcceleratorEntry_Set" "', expected argument " "2"" of type '" "int""'");
28899 }
28900 arg2 = static_cast< int >(val2);
28901 ecode3 = SWIG_AsVal_int(obj2, &val3);
28902 if (!SWIG_IsOK(ecode3)) {
28903 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AcceleratorEntry_Set" "', expected argument " "3"" of type '" "int""'");
28904 }
28905 arg3 = static_cast< int >(val3);
28906 ecode4 = SWIG_AsVal_int(obj3, &val4);
28907 if (!SWIG_IsOK(ecode4)) {
28908 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AcceleratorEntry_Set" "', expected argument " "4"" of type '" "int""'");
28909 }
28910 arg4 = static_cast< int >(val4);
28911 {
28912 PyThreadState* __tstate = wxPyBeginAllowThreads();
28913 (arg1)->Set(arg2,arg3,arg4);
28914 wxPyEndAllowThreads(__tstate);
28915 if (PyErr_Occurred()) SWIG_fail;
28916 }
28917 resultobj = SWIG_Py_Void();
28918 return resultobj;
28919 fail:
28920 return NULL;
28921 }
28922
28923
28924 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28925 PyObject *resultobj = 0;
28926 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28927 int result;
28928 void *argp1 = 0 ;
28929 int res1 = 0 ;
28930 PyObject *swig_obj[1] ;
28931
28932 if (!args) SWIG_fail;
28933 swig_obj[0] = args;
28934 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
28935 if (!SWIG_IsOK(res1)) {
28936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetFlags" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28937 }
28938 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28939 {
28940 PyThreadState* __tstate = wxPyBeginAllowThreads();
28941 result = (int)(arg1)->GetFlags();
28942 wxPyEndAllowThreads(__tstate);
28943 if (PyErr_Occurred()) SWIG_fail;
28944 }
28945 resultobj = SWIG_From_int(static_cast< int >(result));
28946 return resultobj;
28947 fail:
28948 return NULL;
28949 }
28950
28951
28952 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28953 PyObject *resultobj = 0;
28954 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28955 int result;
28956 void *argp1 = 0 ;
28957 int res1 = 0 ;
28958 PyObject *swig_obj[1] ;
28959
28960 if (!args) SWIG_fail;
28961 swig_obj[0] = args;
28962 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
28963 if (!SWIG_IsOK(res1)) {
28964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetKeyCode" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28965 }
28966 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28967 {
28968 PyThreadState* __tstate = wxPyBeginAllowThreads();
28969 result = (int)(arg1)->GetKeyCode();
28970 wxPyEndAllowThreads(__tstate);
28971 if (PyErr_Occurred()) SWIG_fail;
28972 }
28973 resultobj = SWIG_From_int(static_cast< int >(result));
28974 return resultobj;
28975 fail:
28976 return NULL;
28977 }
28978
28979
28980 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28981 PyObject *resultobj = 0;
28982 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28983 int result;
28984 void *argp1 = 0 ;
28985 int res1 = 0 ;
28986 PyObject *swig_obj[1] ;
28987
28988 if (!args) SWIG_fail;
28989 swig_obj[0] = args;
28990 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
28991 if (!SWIG_IsOK(res1)) {
28992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetCommand" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28993 }
28994 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28995 {
28996 PyThreadState* __tstate = wxPyBeginAllowThreads();
28997 result = (int)(arg1)->GetCommand();
28998 wxPyEndAllowThreads(__tstate);
28999 if (PyErr_Occurred()) SWIG_fail;
29000 }
29001 resultobj = SWIG_From_int(static_cast< int >(result));
29002 return resultobj;
29003 fail:
29004 return NULL;
29005 }
29006
29007
29008 SWIGINTERN PyObject *AcceleratorEntry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29009 PyObject *obj;
29010 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29011 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorEntry, SWIG_NewClientData(obj));
29012 return SWIG_Py_Void();
29013 }
29014
29015 SWIGINTERN PyObject *AcceleratorEntry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29016 return SWIG_Python_InitShadowInstance(args);
29017 }
29018
29019 SWIGINTERN PyObject *_wrap_new_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29020 PyObject *resultobj = 0;
29021 int arg1 ;
29022 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
29023 wxAcceleratorTable *result = 0 ;
29024 PyObject * obj0 = 0 ;
29025 char * kwnames[] = {
29026 (char *) "n", NULL
29027 };
29028
29029 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) SWIG_fail;
29030 {
29031 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
29032 if (arg2) arg1 = PyList_Size(obj0);
29033 else arg1 = 0;
29034 }
29035 {
29036 PyThreadState* __tstate = wxPyBeginAllowThreads();
29037 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
29038 wxPyEndAllowThreads(__tstate);
29039 if (PyErr_Occurred()) SWIG_fail;
29040 }
29041 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_NEW | 0 );
29042 return resultobj;
29043 fail:
29044 return NULL;
29045 }
29046
29047
29048 SWIGINTERN PyObject *_wrap_delete_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29049 PyObject *resultobj = 0;
29050 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
29051 void *argp1 = 0 ;
29052 int res1 = 0 ;
29053 PyObject *swig_obj[1] ;
29054
29055 if (!args) SWIG_fail;
29056 swig_obj[0] = args;
29057 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_DISOWN | 0 );
29058 if (!SWIG_IsOK(res1)) {
29059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorTable" "', expected argument " "1"" of type '" "wxAcceleratorTable *""'");
29060 }
29061 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
29062 {
29063 PyThreadState* __tstate = wxPyBeginAllowThreads();
29064 delete arg1;
29065
29066 wxPyEndAllowThreads(__tstate);
29067 if (PyErr_Occurred()) SWIG_fail;
29068 }
29069 resultobj = SWIG_Py_Void();
29070 return resultobj;
29071 fail:
29072 return NULL;
29073 }
29074
29075
29076 SWIGINTERN PyObject *_wrap_AcceleratorTable_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29077 PyObject *resultobj = 0;
29078 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
29079 bool result;
29080 void *argp1 = 0 ;
29081 int res1 = 0 ;
29082 PyObject *swig_obj[1] ;
29083
29084 if (!args) SWIG_fail;
29085 swig_obj[0] = args;
29086 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
29087 if (!SWIG_IsOK(res1)) {
29088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorTable_Ok" "', expected argument " "1"" of type '" "wxAcceleratorTable const *""'");
29089 }
29090 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
29091 {
29092 PyThreadState* __tstate = wxPyBeginAllowThreads();
29093 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
29094 wxPyEndAllowThreads(__tstate);
29095 if (PyErr_Occurred()) SWIG_fail;
29096 }
29097 {
29098 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29099 }
29100 return resultobj;
29101 fail:
29102 return NULL;
29103 }
29104
29105
29106 SWIGINTERN PyObject *AcceleratorTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29107 PyObject *obj;
29108 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29109 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorTable, SWIG_NewClientData(obj));
29110 return SWIG_Py_Void();
29111 }
29112
29113 SWIGINTERN PyObject *AcceleratorTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29114 return SWIG_Python_InitShadowInstance(args);
29115 }
29116
29117 SWIGINTERN int NullAcceleratorTable_set(PyObject *) {
29118 SWIG_Error(SWIG_AttributeError,"Variable NullAcceleratorTable is read-only.");
29119 return 1;
29120 }
29121
29122
29123 SWIGINTERN PyObject *NullAcceleratorTable_get(void) {
29124 PyObject *pyobj = 0;
29125
29126 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0 );
29127 return pyobj;
29128 }
29129
29130
29131 SWIGINTERN PyObject *_wrap_GetAccelFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29132 PyObject *resultobj = 0;
29133 wxString *arg1 = 0 ;
29134 wxAcceleratorEntry *result = 0 ;
29135 bool temp1 = false ;
29136 PyObject * obj0 = 0 ;
29137 char * kwnames[] = {
29138 (char *) "label", NULL
29139 };
29140
29141 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) SWIG_fail;
29142 {
29143 arg1 = wxString_in_helper(obj0);
29144 if (arg1 == NULL) SWIG_fail;
29145 temp1 = true;
29146 }
29147 {
29148 PyThreadState* __tstate = wxPyBeginAllowThreads();
29149 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
29150 wxPyEndAllowThreads(__tstate);
29151 if (PyErr_Occurred()) SWIG_fail;
29152 }
29153 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29154 {
29155 if (temp1)
29156 delete arg1;
29157 }
29158 return resultobj;
29159 fail:
29160 {
29161 if (temp1)
29162 delete arg1;
29163 }
29164 return NULL;
29165 }
29166
29167
29168 SWIGINTERN int PanelNameStr_set(PyObject *) {
29169 SWIG_Error(SWIG_AttributeError,"Variable PanelNameStr is read-only.");
29170 return 1;
29171 }
29172
29173
29174 SWIGINTERN PyObject *PanelNameStr_get(void) {
29175 PyObject *pyobj = 0;
29176
29177 {
29178 #if wxUSE_UNICODE
29179 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29180 #else
29181 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29182 #endif
29183 }
29184 return pyobj;
29185 }
29186
29187
29188 SWIGINTERN PyObject *_wrap_new_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29189 PyObject *resultobj = 0;
29190 wxVisualAttributes *result = 0 ;
29191
29192 if (!SWIG_Python_UnpackTuple(args,"new_VisualAttributes",0,0,0)) SWIG_fail;
29193 {
29194 PyThreadState* __tstate = wxPyBeginAllowThreads();
29195 result = (wxVisualAttributes *)new_wxVisualAttributes();
29196 wxPyEndAllowThreads(__tstate);
29197 if (PyErr_Occurred()) SWIG_fail;
29198 }
29199 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_NEW | 0 );
29200 return resultobj;
29201 fail:
29202 return NULL;
29203 }
29204
29205
29206 SWIGINTERN PyObject *_wrap_delete_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29207 PyObject *resultobj = 0;
29208 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29209 void *argp1 = 0 ;
29210 int res1 = 0 ;
29211 PyObject *swig_obj[1] ;
29212
29213 if (!args) SWIG_fail;
29214 swig_obj[0] = args;
29215 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_DISOWN | 0 );
29216 if (!SWIG_IsOK(res1)) {
29217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VisualAttributes" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29218 }
29219 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29220 {
29221 PyThreadState* __tstate = wxPyBeginAllowThreads();
29222 delete_wxVisualAttributes(arg1);
29223
29224 wxPyEndAllowThreads(__tstate);
29225 if (PyErr_Occurred()) SWIG_fail;
29226 }
29227 resultobj = SWIG_Py_Void();
29228 return resultobj;
29229 fail:
29230 return NULL;
29231 }
29232
29233
29234 SWIGINTERN PyObject *_wrap_VisualAttributes_font_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29235 PyObject *resultobj = 0;
29236 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29237 wxFont *arg2 = (wxFont *) 0 ;
29238 void *argp1 = 0 ;
29239 int res1 = 0 ;
29240 void *argp2 = 0 ;
29241 int res2 = 0 ;
29242 PyObject *swig_obj[2] ;
29243
29244 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_font_set",2,2,swig_obj)) SWIG_fail;
29245 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29246 if (!SWIG_IsOK(res1)) {
29247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29248 }
29249 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29250 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
29251 if (!SWIG_IsOK(res2)) {
29252 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_font_set" "', expected argument " "2"" of type '" "wxFont *""'");
29253 }
29254 arg2 = reinterpret_cast< wxFont * >(argp2);
29255 if (arg1) (arg1)->font = *arg2;
29256
29257 resultobj = SWIG_Py_Void();
29258 return resultobj;
29259 fail:
29260 return NULL;
29261 }
29262
29263
29264 SWIGINTERN PyObject *_wrap_VisualAttributes_font_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29265 PyObject *resultobj = 0;
29266 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29267 wxFont *result = 0 ;
29268 void *argp1 = 0 ;
29269 int res1 = 0 ;
29270 PyObject *swig_obj[1] ;
29271
29272 if (!args) SWIG_fail;
29273 swig_obj[0] = args;
29274 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29275 if (!SWIG_IsOK(res1)) {
29276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29277 }
29278 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29279 result = (wxFont *)& ((arg1)->font);
29280 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, 0 | 0 );
29281 return resultobj;
29282 fail:
29283 return NULL;
29284 }
29285
29286
29287 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29288 PyObject *resultobj = 0;
29289 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29290 wxColour *arg2 = (wxColour *) 0 ;
29291 void *argp1 = 0 ;
29292 int res1 = 0 ;
29293 void *argp2 = 0 ;
29294 int res2 = 0 ;
29295 PyObject *swig_obj[2] ;
29296
29297 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colFg_set",2,2,swig_obj)) SWIG_fail;
29298 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29299 if (!SWIG_IsOK(res1)) {
29300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29301 }
29302 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29303 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29304 if (!SWIG_IsOK(res2)) {
29305 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colFg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29306 }
29307 arg2 = reinterpret_cast< wxColour * >(argp2);
29308 if (arg1) (arg1)->colFg = *arg2;
29309
29310 resultobj = SWIG_Py_Void();
29311 return resultobj;
29312 fail:
29313 return NULL;
29314 }
29315
29316
29317 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29318 PyObject *resultobj = 0;
29319 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29320 wxColour *result = 0 ;
29321 void *argp1 = 0 ;
29322 int res1 = 0 ;
29323 PyObject *swig_obj[1] ;
29324
29325 if (!args) SWIG_fail;
29326 swig_obj[0] = args;
29327 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29328 if (!SWIG_IsOK(res1)) {
29329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29330 }
29331 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29332 result = (wxColour *)& ((arg1)->colFg);
29333 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29334 return resultobj;
29335 fail:
29336 return NULL;
29337 }
29338
29339
29340 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29341 PyObject *resultobj = 0;
29342 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29343 wxColour *arg2 = (wxColour *) 0 ;
29344 void *argp1 = 0 ;
29345 int res1 = 0 ;
29346 void *argp2 = 0 ;
29347 int res2 = 0 ;
29348 PyObject *swig_obj[2] ;
29349
29350 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colBg_set",2,2,swig_obj)) SWIG_fail;
29351 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29352 if (!SWIG_IsOK(res1)) {
29353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29354 }
29355 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29356 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29357 if (!SWIG_IsOK(res2)) {
29358 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colBg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29359 }
29360 arg2 = reinterpret_cast< wxColour * >(argp2);
29361 if (arg1) (arg1)->colBg = *arg2;
29362
29363 resultobj = SWIG_Py_Void();
29364 return resultobj;
29365 fail:
29366 return NULL;
29367 }
29368
29369
29370 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29371 PyObject *resultobj = 0;
29372 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29373 wxColour *result = 0 ;
29374 void *argp1 = 0 ;
29375 int res1 = 0 ;
29376 PyObject *swig_obj[1] ;
29377
29378 if (!args) SWIG_fail;
29379 swig_obj[0] = args;
29380 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29381 if (!SWIG_IsOK(res1)) {
29382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29383 }
29384 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29385 result = (wxColour *)& ((arg1)->colBg);
29386 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29387 return resultobj;
29388 fail:
29389 return NULL;
29390 }
29391
29392
29393 SWIGINTERN PyObject *VisualAttributes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29394 PyObject *obj;
29395 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29396 SWIG_TypeNewClientData(SWIGTYPE_p_wxVisualAttributes, SWIG_NewClientData(obj));
29397 return SWIG_Py_Void();
29398 }
29399
29400 SWIGINTERN PyObject *VisualAttributes_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29401 return SWIG_Python_InitShadowInstance(args);
29402 }
29403
29404 SWIGINTERN PyObject *_wrap_new_Window(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29405 PyObject *resultobj = 0;
29406 wxWindow *arg1 = (wxWindow *) 0 ;
29407 int arg2 = (int) (int)-1 ;
29408 wxPoint const &arg3_defvalue = wxDefaultPosition ;
29409 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
29410 wxSize const &arg4_defvalue = wxDefaultSize ;
29411 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
29412 long arg5 = (long) 0 ;
29413 wxString const &arg6_defvalue = wxPyPanelNameStr ;
29414 wxString *arg6 = (wxString *) &arg6_defvalue ;
29415 wxWindow *result = 0 ;
29416 void *argp1 = 0 ;
29417 int res1 = 0 ;
29418 int val2 ;
29419 int ecode2 = 0 ;
29420 wxPoint temp3 ;
29421 wxSize temp4 ;
29422 long val5 ;
29423 int ecode5 = 0 ;
29424 bool temp6 = false ;
29425 PyObject * obj0 = 0 ;
29426 PyObject * obj1 = 0 ;
29427 PyObject * obj2 = 0 ;
29428 PyObject * obj3 = 0 ;
29429 PyObject * obj4 = 0 ;
29430 PyObject * obj5 = 0 ;
29431 char * kwnames[] = {
29432 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
29433 };
29434
29435 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
29436 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29437 if (!SWIG_IsOK(res1)) {
29438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Window" "', expected argument " "1"" of type '" "wxWindow *""'");
29439 }
29440 arg1 = reinterpret_cast< wxWindow * >(argp1);
29441 if (obj1) {
29442 ecode2 = SWIG_AsVal_int(obj1, &val2);
29443 if (!SWIG_IsOK(ecode2)) {
29444 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Window" "', expected argument " "2"" of type '" "int""'");
29445 }
29446 arg2 = static_cast< int >(val2);
29447 }
29448 if (obj2) {
29449 {
29450 arg3 = &temp3;
29451 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
29452 }
29453 }
29454 if (obj3) {
29455 {
29456 arg4 = &temp4;
29457 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
29458 }
29459 }
29460 if (obj4) {
29461 ecode5 = SWIG_AsVal_long(obj4, &val5);
29462 if (!SWIG_IsOK(ecode5)) {
29463 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Window" "', expected argument " "5"" of type '" "long""'");
29464 }
29465 arg5 = static_cast< long >(val5);
29466 }
29467 if (obj5) {
29468 {
29469 arg6 = wxString_in_helper(obj5);
29470 if (arg6 == NULL) SWIG_fail;
29471 temp6 = true;
29472 }
29473 }
29474 {
29475 if (!wxPyCheckForApp()) SWIG_fail;
29476 PyThreadState* __tstate = wxPyBeginAllowThreads();
29477 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
29478 wxPyEndAllowThreads(__tstate);
29479 if (PyErr_Occurred()) SWIG_fail;
29480 }
29481 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_NEW | 0 );
29482 {
29483 if (temp6)
29484 delete arg6;
29485 }
29486 return resultobj;
29487 fail:
29488 {
29489 if (temp6)
29490 delete arg6;
29491 }
29492 return NULL;
29493 }
29494
29495
29496 SWIGINTERN PyObject *_wrap_new_PreWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29497 PyObject *resultobj = 0;
29498 wxWindow *result = 0 ;
29499
29500 if (!SWIG_Python_UnpackTuple(args,"new_PreWindow",0,0,0)) SWIG_fail;
29501 {
29502 if (!wxPyCheckForApp()) SWIG_fail;
29503 PyThreadState* __tstate = wxPyBeginAllowThreads();
29504 result = (wxWindow *)new wxWindow();
29505 wxPyEndAllowThreads(__tstate);
29506 if (PyErr_Occurred()) SWIG_fail;
29507 }
29508 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_OWN | 0 );
29509 return resultobj;
29510 fail:
29511 return NULL;
29512 }
29513
29514
29515 SWIGINTERN PyObject *_wrap_Window_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29516 PyObject *resultobj = 0;
29517 wxWindow *arg1 = (wxWindow *) 0 ;
29518 wxWindow *arg2 = (wxWindow *) 0 ;
29519 int arg3 = (int) (int)-1 ;
29520 wxPoint const &arg4_defvalue = wxDefaultPosition ;
29521 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
29522 wxSize const &arg5_defvalue = wxDefaultSize ;
29523 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
29524 long arg6 = (long) 0 ;
29525 wxString const &arg7_defvalue = wxPyPanelNameStr ;
29526 wxString *arg7 = (wxString *) &arg7_defvalue ;
29527 bool result;
29528 void *argp1 = 0 ;
29529 int res1 = 0 ;
29530 void *argp2 = 0 ;
29531 int res2 = 0 ;
29532 int val3 ;
29533 int ecode3 = 0 ;
29534 wxPoint temp4 ;
29535 wxSize temp5 ;
29536 long val6 ;
29537 int ecode6 = 0 ;
29538 bool temp7 = false ;
29539 PyObject * obj0 = 0 ;
29540 PyObject * obj1 = 0 ;
29541 PyObject * obj2 = 0 ;
29542 PyObject * obj3 = 0 ;
29543 PyObject * obj4 = 0 ;
29544 PyObject * obj5 = 0 ;
29545 PyObject * obj6 = 0 ;
29546 char * kwnames[] = {
29547 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
29548 };
29549
29550 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
29551 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29552 if (!SWIG_IsOK(res1)) {
29553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Create" "', expected argument " "1"" of type '" "wxWindow *""'");
29554 }
29555 arg1 = reinterpret_cast< wxWindow * >(argp1);
29556 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
29557 if (!SWIG_IsOK(res2)) {
29558 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
29559 }
29560 arg2 = reinterpret_cast< wxWindow * >(argp2);
29561 if (obj2) {
29562 ecode3 = SWIG_AsVal_int(obj2, &val3);
29563 if (!SWIG_IsOK(ecode3)) {
29564 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Create" "', expected argument " "3"" of type '" "int""'");
29565 }
29566 arg3 = static_cast< int >(val3);
29567 }
29568 if (obj3) {
29569 {
29570 arg4 = &temp4;
29571 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
29572 }
29573 }
29574 if (obj4) {
29575 {
29576 arg5 = &temp5;
29577 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
29578 }
29579 }
29580 if (obj5) {
29581 ecode6 = SWIG_AsVal_long(obj5, &val6);
29582 if (!SWIG_IsOK(ecode6)) {
29583 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_Create" "', expected argument " "6"" of type '" "long""'");
29584 }
29585 arg6 = static_cast< long >(val6);
29586 }
29587 if (obj6) {
29588 {
29589 arg7 = wxString_in_helper(obj6);
29590 if (arg7 == NULL) SWIG_fail;
29591 temp7 = true;
29592 }
29593 }
29594 {
29595 PyThreadState* __tstate = wxPyBeginAllowThreads();
29596 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
29597 wxPyEndAllowThreads(__tstate);
29598 if (PyErr_Occurred()) SWIG_fail;
29599 }
29600 {
29601 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29602 }
29603 {
29604 if (temp7)
29605 delete arg7;
29606 }
29607 return resultobj;
29608 fail:
29609 {
29610 if (temp7)
29611 delete arg7;
29612 }
29613 return NULL;
29614 }
29615
29616
29617 SWIGINTERN PyObject *_wrap_Window_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29618 PyObject *resultobj = 0;
29619 wxWindow *arg1 = (wxWindow *) 0 ;
29620 bool arg2 = (bool) false ;
29621 bool result;
29622 void *argp1 = 0 ;
29623 int res1 = 0 ;
29624 bool val2 ;
29625 int ecode2 = 0 ;
29626 PyObject * obj0 = 0 ;
29627 PyObject * obj1 = 0 ;
29628 char * kwnames[] = {
29629 (char *) "self",(char *) "force", NULL
29630 };
29631
29632 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) SWIG_fail;
29633 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29634 if (!SWIG_IsOK(res1)) {
29635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Close" "', expected argument " "1"" of type '" "wxWindow *""'");
29636 }
29637 arg1 = reinterpret_cast< wxWindow * >(argp1);
29638 if (obj1) {
29639 ecode2 = SWIG_AsVal_bool(obj1, &val2);
29640 if (!SWIG_IsOK(ecode2)) {
29641 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Close" "', expected argument " "2"" of type '" "bool""'");
29642 }
29643 arg2 = static_cast< bool >(val2);
29644 }
29645 {
29646 PyThreadState* __tstate = wxPyBeginAllowThreads();
29647 result = (bool)(arg1)->Close(arg2);
29648 wxPyEndAllowThreads(__tstate);
29649 if (PyErr_Occurred()) SWIG_fail;
29650 }
29651 {
29652 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29653 }
29654 return resultobj;
29655 fail:
29656 return NULL;
29657 }
29658
29659
29660 SWIGINTERN PyObject *_wrap_Window_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29661 PyObject *resultobj = 0;
29662 wxWindow *arg1 = (wxWindow *) 0 ;
29663 bool result;
29664 void *argp1 = 0 ;
29665 int res1 = 0 ;
29666 PyObject *swig_obj[1] ;
29667
29668 if (!args) SWIG_fail;
29669 swig_obj[0] = args;
29670 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29671 if (!SWIG_IsOK(res1)) {
29672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Destroy" "', expected argument " "1"" of type '" "wxWindow *""'");
29673 }
29674 arg1 = reinterpret_cast< wxWindow * >(argp1);
29675 {
29676 PyThreadState* __tstate = wxPyBeginAllowThreads();
29677 result = (bool)(arg1)->Destroy();
29678 wxPyEndAllowThreads(__tstate);
29679 if (PyErr_Occurred()) SWIG_fail;
29680 }
29681 {
29682 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29683 }
29684 return resultobj;
29685 fail:
29686 return NULL;
29687 }
29688
29689
29690 SWIGINTERN PyObject *_wrap_Window_DestroyChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29691 PyObject *resultobj = 0;
29692 wxWindow *arg1 = (wxWindow *) 0 ;
29693 bool result;
29694 void *argp1 = 0 ;
29695 int res1 = 0 ;
29696 PyObject *swig_obj[1] ;
29697
29698 if (!args) SWIG_fail;
29699 swig_obj[0] = args;
29700 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29701 if (!SWIG_IsOK(res1)) {
29702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DestroyChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
29703 }
29704 arg1 = reinterpret_cast< wxWindow * >(argp1);
29705 {
29706 PyThreadState* __tstate = wxPyBeginAllowThreads();
29707 result = (bool)(arg1)->DestroyChildren();
29708 wxPyEndAllowThreads(__tstate);
29709 if (PyErr_Occurred()) SWIG_fail;
29710 }
29711 {
29712 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29713 }
29714 return resultobj;
29715 fail:
29716 return NULL;
29717 }
29718
29719
29720 SWIGINTERN PyObject *_wrap_Window_IsBeingDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29721 PyObject *resultobj = 0;
29722 wxWindow *arg1 = (wxWindow *) 0 ;
29723 bool result;
29724 void *argp1 = 0 ;
29725 int res1 = 0 ;
29726 PyObject *swig_obj[1] ;
29727
29728 if (!args) SWIG_fail;
29729 swig_obj[0] = args;
29730 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29731 if (!SWIG_IsOK(res1)) {
29732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsBeingDeleted" "', expected argument " "1"" of type '" "wxWindow const *""'");
29733 }
29734 arg1 = reinterpret_cast< wxWindow * >(argp1);
29735 {
29736 PyThreadState* __tstate = wxPyBeginAllowThreads();
29737 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
29738 wxPyEndAllowThreads(__tstate);
29739 if (PyErr_Occurred()) SWIG_fail;
29740 }
29741 {
29742 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29743 }
29744 return resultobj;
29745 fail:
29746 return NULL;
29747 }
29748
29749
29750 SWIGINTERN PyObject *_wrap_Window_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29751 PyObject *resultobj = 0;
29752 wxWindow *arg1 = (wxWindow *) 0 ;
29753 wxString *arg2 = 0 ;
29754 void *argp1 = 0 ;
29755 int res1 = 0 ;
29756 bool temp2 = false ;
29757 PyObject * obj0 = 0 ;
29758 PyObject * obj1 = 0 ;
29759 char * kwnames[] = {
29760 (char *) "self",(char *) "label", NULL
29761 };
29762
29763 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
29764 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29765 if (!SWIG_IsOK(res1)) {
29766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLabel" "', expected argument " "1"" of type '" "wxWindow *""'");
29767 }
29768 arg1 = reinterpret_cast< wxWindow * >(argp1);
29769 {
29770 arg2 = wxString_in_helper(obj1);
29771 if (arg2 == NULL) SWIG_fail;
29772 temp2 = true;
29773 }
29774 {
29775 PyThreadState* __tstate = wxPyBeginAllowThreads();
29776 (arg1)->SetLabel((wxString const &)*arg2);
29777 wxPyEndAllowThreads(__tstate);
29778 if (PyErr_Occurred()) SWIG_fail;
29779 }
29780 resultobj = SWIG_Py_Void();
29781 {
29782 if (temp2)
29783 delete arg2;
29784 }
29785 return resultobj;
29786 fail:
29787 {
29788 if (temp2)
29789 delete arg2;
29790 }
29791 return NULL;
29792 }
29793
29794
29795 SWIGINTERN PyObject *_wrap_Window_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29796 PyObject *resultobj = 0;
29797 wxWindow *arg1 = (wxWindow *) 0 ;
29798 wxString result;
29799 void *argp1 = 0 ;
29800 int res1 = 0 ;
29801 PyObject *swig_obj[1] ;
29802
29803 if (!args) SWIG_fail;
29804 swig_obj[0] = args;
29805 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29806 if (!SWIG_IsOK(res1)) {
29807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLabel" "', expected argument " "1"" of type '" "wxWindow const *""'");
29808 }
29809 arg1 = reinterpret_cast< wxWindow * >(argp1);
29810 {
29811 PyThreadState* __tstate = wxPyBeginAllowThreads();
29812 result = ((wxWindow const *)arg1)->GetLabel();
29813 wxPyEndAllowThreads(__tstate);
29814 if (PyErr_Occurred()) SWIG_fail;
29815 }
29816 {
29817 #if wxUSE_UNICODE
29818 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
29819 #else
29820 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
29821 #endif
29822 }
29823 return resultobj;
29824 fail:
29825 return NULL;
29826 }
29827
29828
29829 SWIGINTERN PyObject *_wrap_Window_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29830 PyObject *resultobj = 0;
29831 wxWindow *arg1 = (wxWindow *) 0 ;
29832 wxString *arg2 = 0 ;
29833 void *argp1 = 0 ;
29834 int res1 = 0 ;
29835 bool temp2 = false ;
29836 PyObject * obj0 = 0 ;
29837 PyObject * obj1 = 0 ;
29838 char * kwnames[] = {
29839 (char *) "self",(char *) "name", NULL
29840 };
29841
29842 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
29843 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29844 if (!SWIG_IsOK(res1)) {
29845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetName" "', expected argument " "1"" of type '" "wxWindow *""'");
29846 }
29847 arg1 = reinterpret_cast< wxWindow * >(argp1);
29848 {
29849 arg2 = wxString_in_helper(obj1);
29850 if (arg2 == NULL) SWIG_fail;
29851 temp2 = true;
29852 }
29853 {
29854 PyThreadState* __tstate = wxPyBeginAllowThreads();
29855 (arg1)->SetName((wxString const &)*arg2);
29856 wxPyEndAllowThreads(__tstate);
29857 if (PyErr_Occurred()) SWIG_fail;
29858 }
29859 resultobj = SWIG_Py_Void();
29860 {
29861 if (temp2)
29862 delete arg2;
29863 }
29864 return resultobj;
29865 fail:
29866 {
29867 if (temp2)
29868 delete arg2;
29869 }
29870 return NULL;
29871 }
29872
29873
29874 SWIGINTERN PyObject *_wrap_Window_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29875 PyObject *resultobj = 0;
29876 wxWindow *arg1 = (wxWindow *) 0 ;
29877 wxString result;
29878 void *argp1 = 0 ;
29879 int res1 = 0 ;
29880 PyObject *swig_obj[1] ;
29881
29882 if (!args) SWIG_fail;
29883 swig_obj[0] = args;
29884 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29885 if (!SWIG_IsOK(res1)) {
29886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetName" "', expected argument " "1"" of type '" "wxWindow const *""'");
29887 }
29888 arg1 = reinterpret_cast< wxWindow * >(argp1);
29889 {
29890 PyThreadState* __tstate = wxPyBeginAllowThreads();
29891 result = ((wxWindow const *)arg1)->GetName();
29892 wxPyEndAllowThreads(__tstate);
29893 if (PyErr_Occurred()) SWIG_fail;
29894 }
29895 {
29896 #if wxUSE_UNICODE
29897 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
29898 #else
29899 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
29900 #endif
29901 }
29902 return resultobj;
29903 fail:
29904 return NULL;
29905 }
29906
29907
29908 SWIGINTERN PyObject *_wrap_Window_SetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29909 PyObject *resultobj = 0;
29910 wxWindow *arg1 = (wxWindow *) 0 ;
29911 wxWindowVariant arg2 ;
29912 void *argp1 = 0 ;
29913 int res1 = 0 ;
29914 int val2 ;
29915 int ecode2 = 0 ;
29916 PyObject * obj0 = 0 ;
29917 PyObject * obj1 = 0 ;
29918 char * kwnames[] = {
29919 (char *) "self",(char *) "variant", NULL
29920 };
29921
29922 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) SWIG_fail;
29923 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29924 if (!SWIG_IsOK(res1)) {
29925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowVariant" "', expected argument " "1"" of type '" "wxWindow *""'");
29926 }
29927 arg1 = reinterpret_cast< wxWindow * >(argp1);
29928 ecode2 = SWIG_AsVal_int(obj1, &val2);
29929 if (!SWIG_IsOK(ecode2)) {
29930 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowVariant" "', expected argument " "2"" of type '" "wxWindowVariant""'");
29931 }
29932 arg2 = static_cast< wxWindowVariant >(val2);
29933 {
29934 PyThreadState* __tstate = wxPyBeginAllowThreads();
29935 (arg1)->SetWindowVariant(arg2);
29936 wxPyEndAllowThreads(__tstate);
29937 if (PyErr_Occurred()) SWIG_fail;
29938 }
29939 resultobj = SWIG_Py_Void();
29940 return resultobj;
29941 fail:
29942 return NULL;
29943 }
29944
29945
29946 SWIGINTERN PyObject *_wrap_Window_GetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29947 PyObject *resultobj = 0;
29948 wxWindow *arg1 = (wxWindow *) 0 ;
29949 wxWindowVariant result;
29950 void *argp1 = 0 ;
29951 int res1 = 0 ;
29952 PyObject *swig_obj[1] ;
29953
29954 if (!args) SWIG_fail;
29955 swig_obj[0] = args;
29956 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29957 if (!SWIG_IsOK(res1)) {
29958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowVariant" "', expected argument " "1"" of type '" "wxWindow const *""'");
29959 }
29960 arg1 = reinterpret_cast< wxWindow * >(argp1);
29961 {
29962 PyThreadState* __tstate = wxPyBeginAllowThreads();
29963 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
29964 wxPyEndAllowThreads(__tstate);
29965 if (PyErr_Occurred()) SWIG_fail;
29966 }
29967 resultobj = SWIG_From_int(static_cast< int >(result));
29968 return resultobj;
29969 fail:
29970 return NULL;
29971 }
29972
29973
29974 SWIGINTERN PyObject *_wrap_Window_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29975 PyObject *resultobj = 0;
29976 wxWindow *arg1 = (wxWindow *) 0 ;
29977 int arg2 ;
29978 void *argp1 = 0 ;
29979 int res1 = 0 ;
29980 int val2 ;
29981 int ecode2 = 0 ;
29982 PyObject * obj0 = 0 ;
29983 PyObject * obj1 = 0 ;
29984 char * kwnames[] = {
29985 (char *) "self",(char *) "winid", NULL
29986 };
29987
29988 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
29989 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29990 if (!SWIG_IsOK(res1)) {
29991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetId" "', expected argument " "1"" of type '" "wxWindow *""'");
29992 }
29993 arg1 = reinterpret_cast< wxWindow * >(argp1);
29994 ecode2 = SWIG_AsVal_int(obj1, &val2);
29995 if (!SWIG_IsOK(ecode2)) {
29996 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetId" "', expected argument " "2"" of type '" "int""'");
29997 }
29998 arg2 = static_cast< int >(val2);
29999 {
30000 PyThreadState* __tstate = wxPyBeginAllowThreads();
30001 (arg1)->SetId(arg2);
30002 wxPyEndAllowThreads(__tstate);
30003 if (PyErr_Occurred()) SWIG_fail;
30004 }
30005 resultobj = SWIG_Py_Void();
30006 return resultobj;
30007 fail:
30008 return NULL;
30009 }
30010
30011
30012 SWIGINTERN PyObject *_wrap_Window_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30013 PyObject *resultobj = 0;
30014 wxWindow *arg1 = (wxWindow *) 0 ;
30015 int result;
30016 void *argp1 = 0 ;
30017 int res1 = 0 ;
30018 PyObject *swig_obj[1] ;
30019
30020 if (!args) SWIG_fail;
30021 swig_obj[0] = args;
30022 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30023 if (!SWIG_IsOK(res1)) {
30024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetId" "', expected argument " "1"" of type '" "wxWindow const *""'");
30025 }
30026 arg1 = reinterpret_cast< wxWindow * >(argp1);
30027 {
30028 PyThreadState* __tstate = wxPyBeginAllowThreads();
30029 result = (int)((wxWindow const *)arg1)->GetId();
30030 wxPyEndAllowThreads(__tstate);
30031 if (PyErr_Occurred()) SWIG_fail;
30032 }
30033 resultobj = SWIG_From_int(static_cast< int >(result));
30034 return resultobj;
30035 fail:
30036 return NULL;
30037 }
30038
30039
30040 SWIGINTERN PyObject *_wrap_Window_NewControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30041 PyObject *resultobj = 0;
30042 int result;
30043
30044 if (!SWIG_Python_UnpackTuple(args,"Window_NewControlId",0,0,0)) SWIG_fail;
30045 {
30046 PyThreadState* __tstate = wxPyBeginAllowThreads();
30047 result = (int)wxWindow::NewControlId();
30048 wxPyEndAllowThreads(__tstate);
30049 if (PyErr_Occurred()) SWIG_fail;
30050 }
30051 resultobj = SWIG_From_int(static_cast< int >(result));
30052 return resultobj;
30053 fail:
30054 return NULL;
30055 }
30056
30057
30058 SWIGINTERN PyObject *_wrap_Window_NextControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30059 PyObject *resultobj = 0;
30060 int arg1 ;
30061 int result;
30062 int val1 ;
30063 int ecode1 = 0 ;
30064 PyObject * obj0 = 0 ;
30065 char * kwnames[] = {
30066 (char *) "winid", NULL
30067 };
30068
30069 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) SWIG_fail;
30070 ecode1 = SWIG_AsVal_int(obj0, &val1);
30071 if (!SWIG_IsOK(ecode1)) {
30072 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_NextControlId" "', expected argument " "1"" of type '" "int""'");
30073 }
30074 arg1 = static_cast< int >(val1);
30075 {
30076 PyThreadState* __tstate = wxPyBeginAllowThreads();
30077 result = (int)wxWindow::NextControlId(arg1);
30078 wxPyEndAllowThreads(__tstate);
30079 if (PyErr_Occurred()) SWIG_fail;
30080 }
30081 resultobj = SWIG_From_int(static_cast< int >(result));
30082 return resultobj;
30083 fail:
30084 return NULL;
30085 }
30086
30087
30088 SWIGINTERN PyObject *_wrap_Window_PrevControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30089 PyObject *resultobj = 0;
30090 int arg1 ;
30091 int result;
30092 int val1 ;
30093 int ecode1 = 0 ;
30094 PyObject * obj0 = 0 ;
30095 char * kwnames[] = {
30096 (char *) "winid", NULL
30097 };
30098
30099 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) SWIG_fail;
30100 ecode1 = SWIG_AsVal_int(obj0, &val1);
30101 if (!SWIG_IsOK(ecode1)) {
30102 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_PrevControlId" "', expected argument " "1"" of type '" "int""'");
30103 }
30104 arg1 = static_cast< int >(val1);
30105 {
30106 PyThreadState* __tstate = wxPyBeginAllowThreads();
30107 result = (int)wxWindow::PrevControlId(arg1);
30108 wxPyEndAllowThreads(__tstate);
30109 if (PyErr_Occurred()) SWIG_fail;
30110 }
30111 resultobj = SWIG_From_int(static_cast< int >(result));
30112 return resultobj;
30113 fail:
30114 return NULL;
30115 }
30116
30117
30118 SWIGINTERN PyObject *_wrap_Window_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30119 PyObject *resultobj = 0;
30120 wxWindow *arg1 = (wxWindow *) 0 ;
30121 wxSize *arg2 = 0 ;
30122 void *argp1 = 0 ;
30123 int res1 = 0 ;
30124 wxSize temp2 ;
30125 PyObject * obj0 = 0 ;
30126 PyObject * obj1 = 0 ;
30127 char * kwnames[] = {
30128 (char *) "self",(char *) "size", NULL
30129 };
30130
30131 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
30132 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30133 if (!SWIG_IsOK(res1)) {
30134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30135 }
30136 arg1 = reinterpret_cast< wxWindow * >(argp1);
30137 {
30138 arg2 = &temp2;
30139 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30140 }
30141 {
30142 PyThreadState* __tstate = wxPyBeginAllowThreads();
30143 (arg1)->SetSize((wxSize const &)*arg2);
30144 wxPyEndAllowThreads(__tstate);
30145 if (PyErr_Occurred()) SWIG_fail;
30146 }
30147 resultobj = SWIG_Py_Void();
30148 return resultobj;
30149 fail:
30150 return NULL;
30151 }
30152
30153
30154 SWIGINTERN PyObject *_wrap_Window_SetDimensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30155 PyObject *resultobj = 0;
30156 wxWindow *arg1 = (wxWindow *) 0 ;
30157 int arg2 ;
30158 int arg3 ;
30159 int arg4 ;
30160 int arg5 ;
30161 int arg6 = (int) wxSIZE_AUTO ;
30162 void *argp1 = 0 ;
30163 int res1 = 0 ;
30164 int val2 ;
30165 int ecode2 = 0 ;
30166 int val3 ;
30167 int ecode3 = 0 ;
30168 int val4 ;
30169 int ecode4 = 0 ;
30170 int val5 ;
30171 int ecode5 = 0 ;
30172 int val6 ;
30173 int ecode6 = 0 ;
30174 PyObject * obj0 = 0 ;
30175 PyObject * obj1 = 0 ;
30176 PyObject * obj2 = 0 ;
30177 PyObject * obj3 = 0 ;
30178 PyObject * obj4 = 0 ;
30179 PyObject * obj5 = 0 ;
30180 char * kwnames[] = {
30181 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
30182 };
30183
30184 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
30185 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30186 if (!SWIG_IsOK(res1)) {
30187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDimensions" "', expected argument " "1"" of type '" "wxWindow *""'");
30188 }
30189 arg1 = reinterpret_cast< wxWindow * >(argp1);
30190 ecode2 = SWIG_AsVal_int(obj1, &val2);
30191 if (!SWIG_IsOK(ecode2)) {
30192 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDimensions" "', expected argument " "2"" of type '" "int""'");
30193 }
30194 arg2 = static_cast< int >(val2);
30195 ecode3 = SWIG_AsVal_int(obj2, &val3);
30196 if (!SWIG_IsOK(ecode3)) {
30197 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetDimensions" "', expected argument " "3"" of type '" "int""'");
30198 }
30199 arg3 = static_cast< int >(val3);
30200 ecode4 = SWIG_AsVal_int(obj3, &val4);
30201 if (!SWIG_IsOK(ecode4)) {
30202 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetDimensions" "', expected argument " "4"" of type '" "int""'");
30203 }
30204 arg4 = static_cast< int >(val4);
30205 ecode5 = SWIG_AsVal_int(obj4, &val5);
30206 if (!SWIG_IsOK(ecode5)) {
30207 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetDimensions" "', expected argument " "5"" of type '" "int""'");
30208 }
30209 arg5 = static_cast< int >(val5);
30210 if (obj5) {
30211 ecode6 = SWIG_AsVal_int(obj5, &val6);
30212 if (!SWIG_IsOK(ecode6)) {
30213 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetDimensions" "', expected argument " "6"" of type '" "int""'");
30214 }
30215 arg6 = static_cast< int >(val6);
30216 }
30217 {
30218 PyThreadState* __tstate = wxPyBeginAllowThreads();
30219 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
30220 wxPyEndAllowThreads(__tstate);
30221 if (PyErr_Occurred()) SWIG_fail;
30222 }
30223 resultobj = SWIG_Py_Void();
30224 return resultobj;
30225 fail:
30226 return NULL;
30227 }
30228
30229
30230 SWIGINTERN PyObject *_wrap_Window_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30231 PyObject *resultobj = 0;
30232 wxWindow *arg1 = (wxWindow *) 0 ;
30233 wxRect *arg2 = 0 ;
30234 int arg3 = (int) wxSIZE_AUTO ;
30235 void *argp1 = 0 ;
30236 int res1 = 0 ;
30237 wxRect temp2 ;
30238 int val3 ;
30239 int ecode3 = 0 ;
30240 PyObject * obj0 = 0 ;
30241 PyObject * obj1 = 0 ;
30242 PyObject * obj2 = 0 ;
30243 char * kwnames[] = {
30244 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
30245 };
30246
30247 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30248 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30249 if (!SWIG_IsOK(res1)) {
30250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetRect" "', expected argument " "1"" of type '" "wxWindow *""'");
30251 }
30252 arg1 = reinterpret_cast< wxWindow * >(argp1);
30253 {
30254 arg2 = &temp2;
30255 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30256 }
30257 if (obj2) {
30258 ecode3 = SWIG_AsVal_int(obj2, &val3);
30259 if (!SWIG_IsOK(ecode3)) {
30260 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetRect" "', expected argument " "3"" of type '" "int""'");
30261 }
30262 arg3 = static_cast< int >(val3);
30263 }
30264 {
30265 PyThreadState* __tstate = wxPyBeginAllowThreads();
30266 (arg1)->SetSize((wxRect const &)*arg2,arg3);
30267 wxPyEndAllowThreads(__tstate);
30268 if (PyErr_Occurred()) SWIG_fail;
30269 }
30270 resultobj = SWIG_Py_Void();
30271 return resultobj;
30272 fail:
30273 return NULL;
30274 }
30275
30276
30277 SWIGINTERN PyObject *_wrap_Window_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30278 PyObject *resultobj = 0;
30279 wxWindow *arg1 = (wxWindow *) 0 ;
30280 int arg2 ;
30281 int arg3 ;
30282 void *argp1 = 0 ;
30283 int res1 = 0 ;
30284 int val2 ;
30285 int ecode2 = 0 ;
30286 int val3 ;
30287 int ecode3 = 0 ;
30288 PyObject * obj0 = 0 ;
30289 PyObject * obj1 = 0 ;
30290 PyObject * obj2 = 0 ;
30291 char * kwnames[] = {
30292 (char *) "self",(char *) "width",(char *) "height", NULL
30293 };
30294
30295 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30296 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30297 if (!SWIG_IsOK(res1)) {
30298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
30299 }
30300 arg1 = reinterpret_cast< wxWindow * >(argp1);
30301 ecode2 = SWIG_AsVal_int(obj1, &val2);
30302 if (!SWIG_IsOK(ecode2)) {
30303 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
30304 }
30305 arg2 = static_cast< int >(val2);
30306 ecode3 = SWIG_AsVal_int(obj2, &val3);
30307 if (!SWIG_IsOK(ecode3)) {
30308 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
30309 }
30310 arg3 = static_cast< int >(val3);
30311 {
30312 PyThreadState* __tstate = wxPyBeginAllowThreads();
30313 (arg1)->SetSize(arg2,arg3);
30314 wxPyEndAllowThreads(__tstate);
30315 if (PyErr_Occurred()) SWIG_fail;
30316 }
30317 resultobj = SWIG_Py_Void();
30318 return resultobj;
30319 fail:
30320 return NULL;
30321 }
30322
30323
30324 SWIGINTERN PyObject *_wrap_Window_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30325 PyObject *resultobj = 0;
30326 wxWindow *arg1 = (wxWindow *) 0 ;
30327 wxPoint *arg2 = 0 ;
30328 int arg3 = (int) wxSIZE_USE_EXISTING ;
30329 void *argp1 = 0 ;
30330 int res1 = 0 ;
30331 wxPoint temp2 ;
30332 int val3 ;
30333 int ecode3 = 0 ;
30334 PyObject * obj0 = 0 ;
30335 PyObject * obj1 = 0 ;
30336 PyObject * obj2 = 0 ;
30337 char * kwnames[] = {
30338 (char *) "self",(char *) "pt",(char *) "flags", NULL
30339 };
30340
30341 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30342 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30343 if (!SWIG_IsOK(res1)) {
30344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Move" "', expected argument " "1"" of type '" "wxWindow *""'");
30345 }
30346 arg1 = reinterpret_cast< wxWindow * >(argp1);
30347 {
30348 arg2 = &temp2;
30349 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30350 }
30351 if (obj2) {
30352 ecode3 = SWIG_AsVal_int(obj2, &val3);
30353 if (!SWIG_IsOK(ecode3)) {
30354 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Move" "', expected argument " "3"" of type '" "int""'");
30355 }
30356 arg3 = static_cast< int >(val3);
30357 }
30358 {
30359 PyThreadState* __tstate = wxPyBeginAllowThreads();
30360 (arg1)->Move((wxPoint const &)*arg2,arg3);
30361 wxPyEndAllowThreads(__tstate);
30362 if (PyErr_Occurred()) SWIG_fail;
30363 }
30364 resultobj = SWIG_Py_Void();
30365 return resultobj;
30366 fail:
30367 return NULL;
30368 }
30369
30370
30371 SWIGINTERN PyObject *_wrap_Window_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30372 PyObject *resultobj = 0;
30373 wxWindow *arg1 = (wxWindow *) 0 ;
30374 int arg2 ;
30375 int arg3 ;
30376 int arg4 = (int) wxSIZE_USE_EXISTING ;
30377 void *argp1 = 0 ;
30378 int res1 = 0 ;
30379 int val2 ;
30380 int ecode2 = 0 ;
30381 int val3 ;
30382 int ecode3 = 0 ;
30383 int val4 ;
30384 int ecode4 = 0 ;
30385 PyObject * obj0 = 0 ;
30386 PyObject * obj1 = 0 ;
30387 PyObject * obj2 = 0 ;
30388 PyObject * obj3 = 0 ;
30389 char * kwnames[] = {
30390 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
30391 };
30392
30393 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30394 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30395 if (!SWIG_IsOK(res1)) {
30396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveXY" "', expected argument " "1"" of type '" "wxWindow *""'");
30397 }
30398 arg1 = reinterpret_cast< wxWindow * >(argp1);
30399 ecode2 = SWIG_AsVal_int(obj1, &val2);
30400 if (!SWIG_IsOK(ecode2)) {
30401 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MoveXY" "', expected argument " "2"" of type '" "int""'");
30402 }
30403 arg2 = static_cast< int >(val2);
30404 ecode3 = SWIG_AsVal_int(obj2, &val3);
30405 if (!SWIG_IsOK(ecode3)) {
30406 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_MoveXY" "', expected argument " "3"" of type '" "int""'");
30407 }
30408 arg3 = static_cast< int >(val3);
30409 if (obj3) {
30410 ecode4 = SWIG_AsVal_int(obj3, &val4);
30411 if (!SWIG_IsOK(ecode4)) {
30412 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_MoveXY" "', expected argument " "4"" of type '" "int""'");
30413 }
30414 arg4 = static_cast< int >(val4);
30415 }
30416 {
30417 PyThreadState* __tstate = wxPyBeginAllowThreads();
30418 (arg1)->Move(arg2,arg3,arg4);
30419 wxPyEndAllowThreads(__tstate);
30420 if (PyErr_Occurred()) SWIG_fail;
30421 }
30422 resultobj = SWIG_Py_Void();
30423 return resultobj;
30424 fail:
30425 return NULL;
30426 }
30427
30428
30429 SWIGINTERN PyObject *_wrap_Window_SetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30430 PyObject *resultobj = 0;
30431 wxWindow *arg1 = (wxWindow *) 0 ;
30432 wxSize const &arg2_defvalue = wxDefaultSize ;
30433 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
30434 void *argp1 = 0 ;
30435 int res1 = 0 ;
30436 wxSize temp2 ;
30437 PyObject * obj0 = 0 ;
30438 PyObject * obj1 = 0 ;
30439 char * kwnames[] = {
30440 (char *) "self",(char *) "size", NULL
30441 };
30442
30443 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) SWIG_fail;
30444 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30445 if (!SWIG_IsOK(res1)) {
30446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30447 }
30448 arg1 = reinterpret_cast< wxWindow * >(argp1);
30449 if (obj1) {
30450 {
30451 arg2 = &temp2;
30452 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30453 }
30454 }
30455 {
30456 PyThreadState* __tstate = wxPyBeginAllowThreads();
30457 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
30458 wxPyEndAllowThreads(__tstate);
30459 if (PyErr_Occurred()) SWIG_fail;
30460 }
30461 resultobj = SWIG_Py_Void();
30462 return resultobj;
30463 fail:
30464 return NULL;
30465 }
30466
30467
30468 SWIGINTERN PyObject *_wrap_Window_Raise(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30469 PyObject *resultobj = 0;
30470 wxWindow *arg1 = (wxWindow *) 0 ;
30471 void *argp1 = 0 ;
30472 int res1 = 0 ;
30473 PyObject *swig_obj[1] ;
30474
30475 if (!args) SWIG_fail;
30476 swig_obj[0] = args;
30477 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30478 if (!SWIG_IsOK(res1)) {
30479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Raise" "', expected argument " "1"" of type '" "wxWindow *""'");
30480 }
30481 arg1 = reinterpret_cast< wxWindow * >(argp1);
30482 {
30483 PyThreadState* __tstate = wxPyBeginAllowThreads();
30484 (arg1)->Raise();
30485 wxPyEndAllowThreads(__tstate);
30486 if (PyErr_Occurred()) SWIG_fail;
30487 }
30488 resultobj = SWIG_Py_Void();
30489 return resultobj;
30490 fail:
30491 return NULL;
30492 }
30493
30494
30495 SWIGINTERN PyObject *_wrap_Window_Lower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30496 PyObject *resultobj = 0;
30497 wxWindow *arg1 = (wxWindow *) 0 ;
30498 void *argp1 = 0 ;
30499 int res1 = 0 ;
30500 PyObject *swig_obj[1] ;
30501
30502 if (!args) SWIG_fail;
30503 swig_obj[0] = args;
30504 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30505 if (!SWIG_IsOK(res1)) {
30506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Lower" "', expected argument " "1"" of type '" "wxWindow *""'");
30507 }
30508 arg1 = reinterpret_cast< wxWindow * >(argp1);
30509 {
30510 PyThreadState* __tstate = wxPyBeginAllowThreads();
30511 (arg1)->Lower();
30512 wxPyEndAllowThreads(__tstate);
30513 if (PyErr_Occurred()) SWIG_fail;
30514 }
30515 resultobj = SWIG_Py_Void();
30516 return resultobj;
30517 fail:
30518 return NULL;
30519 }
30520
30521
30522 SWIGINTERN PyObject *_wrap_Window_SetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30523 PyObject *resultobj = 0;
30524 wxWindow *arg1 = (wxWindow *) 0 ;
30525 wxSize *arg2 = 0 ;
30526 void *argp1 = 0 ;
30527 int res1 = 0 ;
30528 wxSize temp2 ;
30529 PyObject * obj0 = 0 ;
30530 PyObject * obj1 = 0 ;
30531 char * kwnames[] = {
30532 (char *) "self",(char *) "size", NULL
30533 };
30534
30535 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) SWIG_fail;
30536 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30537 if (!SWIG_IsOK(res1)) {
30538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30539 }
30540 arg1 = reinterpret_cast< wxWindow * >(argp1);
30541 {
30542 arg2 = &temp2;
30543 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30544 }
30545 {
30546 PyThreadState* __tstate = wxPyBeginAllowThreads();
30547 (arg1)->SetClientSize((wxSize const &)*arg2);
30548 wxPyEndAllowThreads(__tstate);
30549 if (PyErr_Occurred()) SWIG_fail;
30550 }
30551 resultobj = SWIG_Py_Void();
30552 return resultobj;
30553 fail:
30554 return NULL;
30555 }
30556
30557
30558 SWIGINTERN PyObject *_wrap_Window_SetClientSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30559 PyObject *resultobj = 0;
30560 wxWindow *arg1 = (wxWindow *) 0 ;
30561 int arg2 ;
30562 int arg3 ;
30563 void *argp1 = 0 ;
30564 int res1 = 0 ;
30565 int val2 ;
30566 int ecode2 = 0 ;
30567 int val3 ;
30568 int ecode3 = 0 ;
30569 PyObject * obj0 = 0 ;
30570 PyObject * obj1 = 0 ;
30571 PyObject * obj2 = 0 ;
30572 char * kwnames[] = {
30573 (char *) "self",(char *) "width",(char *) "height", NULL
30574 };
30575
30576 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30577 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30578 if (!SWIG_IsOK(res1)) {
30579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
30580 }
30581 arg1 = reinterpret_cast< wxWindow * >(argp1);
30582 ecode2 = SWIG_AsVal_int(obj1, &val2);
30583 if (!SWIG_IsOK(ecode2)) {
30584 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetClientSizeWH" "', expected argument " "2"" of type '" "int""'");
30585 }
30586 arg2 = static_cast< int >(val2);
30587 ecode3 = SWIG_AsVal_int(obj2, &val3);
30588 if (!SWIG_IsOK(ecode3)) {
30589 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetClientSizeWH" "', expected argument " "3"" of type '" "int""'");
30590 }
30591 arg3 = static_cast< int >(val3);
30592 {
30593 PyThreadState* __tstate = wxPyBeginAllowThreads();
30594 (arg1)->SetClientSize(arg2,arg3);
30595 wxPyEndAllowThreads(__tstate);
30596 if (PyErr_Occurred()) SWIG_fail;
30597 }
30598 resultobj = SWIG_Py_Void();
30599 return resultobj;
30600 fail:
30601 return NULL;
30602 }
30603
30604
30605 SWIGINTERN PyObject *_wrap_Window_SetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30606 PyObject *resultobj = 0;
30607 wxWindow *arg1 = (wxWindow *) 0 ;
30608 wxRect *arg2 = 0 ;
30609 void *argp1 = 0 ;
30610 int res1 = 0 ;
30611 wxRect temp2 ;
30612 PyObject * obj0 = 0 ;
30613 PyObject * obj1 = 0 ;
30614 char * kwnames[] = {
30615 (char *) "self",(char *) "rect", NULL
30616 };
30617
30618 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) SWIG_fail;
30619 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30620 if (!SWIG_IsOK(res1)) {
30621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientRect" "', expected argument " "1"" of type '" "wxWindow *""'");
30622 }
30623 arg1 = reinterpret_cast< wxWindow * >(argp1);
30624 {
30625 arg2 = &temp2;
30626 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30627 }
30628 {
30629 PyThreadState* __tstate = wxPyBeginAllowThreads();
30630 (arg1)->SetClientSize((wxRect const &)*arg2);
30631 wxPyEndAllowThreads(__tstate);
30632 if (PyErr_Occurred()) SWIG_fail;
30633 }
30634 resultobj = SWIG_Py_Void();
30635 return resultobj;
30636 fail:
30637 return NULL;
30638 }
30639
30640
30641 SWIGINTERN PyObject *_wrap_Window_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30642 PyObject *resultobj = 0;
30643 wxWindow *arg1 = (wxWindow *) 0 ;
30644 wxPoint result;
30645 void *argp1 = 0 ;
30646 int res1 = 0 ;
30647 PyObject *swig_obj[1] ;
30648
30649 if (!args) SWIG_fail;
30650 swig_obj[0] = args;
30651 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30652 if (!SWIG_IsOK(res1)) {
30653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
30654 }
30655 arg1 = reinterpret_cast< wxWindow * >(argp1);
30656 {
30657 PyThreadState* __tstate = wxPyBeginAllowThreads();
30658 result = ((wxWindow const *)arg1)->GetPosition();
30659 wxPyEndAllowThreads(__tstate);
30660 if (PyErr_Occurred()) SWIG_fail;
30661 }
30662 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
30663 return resultobj;
30664 fail:
30665 return NULL;
30666 }
30667
30668
30669 SWIGINTERN PyObject *_wrap_Window_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30670 PyObject *resultobj = 0;
30671 wxWindow *arg1 = (wxWindow *) 0 ;
30672 int *arg2 = (int *) 0 ;
30673 int *arg3 = (int *) 0 ;
30674 void *argp1 = 0 ;
30675 int res1 = 0 ;
30676 int temp2 ;
30677 int res2 = SWIG_TMPOBJ ;
30678 int temp3 ;
30679 int res3 = SWIG_TMPOBJ ;
30680 PyObject *swig_obj[1] ;
30681
30682 arg2 = &temp2;
30683 arg3 = &temp3;
30684 if (!args) SWIG_fail;
30685 swig_obj[0] = args;
30686 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30687 if (!SWIG_IsOK(res1)) {
30688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30689 }
30690 arg1 = reinterpret_cast< wxWindow * >(argp1);
30691 {
30692 PyThreadState* __tstate = wxPyBeginAllowThreads();
30693 ((wxWindow const *)arg1)->GetPosition(arg2,arg3);
30694 wxPyEndAllowThreads(__tstate);
30695 if (PyErr_Occurred()) SWIG_fail;
30696 }
30697 resultobj = SWIG_Py_Void();
30698 if (SWIG_IsTmpObj(res2)) {
30699 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30700 } else {
30701 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30702 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30703 }
30704 if (SWIG_IsTmpObj(res3)) {
30705 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30706 } else {
30707 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30708 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30709 }
30710 return resultobj;
30711 fail:
30712 return NULL;
30713 }
30714
30715
30716 SWIGINTERN PyObject *_wrap_Window_GetScreenPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30717 PyObject *resultobj = 0;
30718 wxWindow *arg1 = (wxWindow *) 0 ;
30719 wxPoint result;
30720 void *argp1 = 0 ;
30721 int res1 = 0 ;
30722 PyObject *swig_obj[1] ;
30723
30724 if (!args) SWIG_fail;
30725 swig_obj[0] = args;
30726 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30727 if (!SWIG_IsOK(res1)) {
30728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
30729 }
30730 arg1 = reinterpret_cast< wxWindow * >(argp1);
30731 {
30732 PyThreadState* __tstate = wxPyBeginAllowThreads();
30733 result = ((wxWindow const *)arg1)->GetScreenPosition();
30734 wxPyEndAllowThreads(__tstate);
30735 if (PyErr_Occurred()) SWIG_fail;
30736 }
30737 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
30738 return resultobj;
30739 fail:
30740 return NULL;
30741 }
30742
30743
30744 SWIGINTERN PyObject *_wrap_Window_GetScreenPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30745 PyObject *resultobj = 0;
30746 wxWindow *arg1 = (wxWindow *) 0 ;
30747 int *arg2 = (int *) 0 ;
30748 int *arg3 = (int *) 0 ;
30749 void *argp1 = 0 ;
30750 int res1 = 0 ;
30751 int temp2 ;
30752 int res2 = SWIG_TMPOBJ ;
30753 int temp3 ;
30754 int res3 = SWIG_TMPOBJ ;
30755 PyObject *swig_obj[1] ;
30756
30757 arg2 = &temp2;
30758 arg3 = &temp3;
30759 if (!args) SWIG_fail;
30760 swig_obj[0] = args;
30761 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30762 if (!SWIG_IsOK(res1)) {
30763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30764 }
30765 arg1 = reinterpret_cast< wxWindow * >(argp1);
30766 {
30767 PyThreadState* __tstate = wxPyBeginAllowThreads();
30768 ((wxWindow const *)arg1)->GetScreenPosition(arg2,arg3);
30769 wxPyEndAllowThreads(__tstate);
30770 if (PyErr_Occurred()) SWIG_fail;
30771 }
30772 resultobj = SWIG_Py_Void();
30773 if (SWIG_IsTmpObj(res2)) {
30774 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30775 } else {
30776 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30777 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30778 }
30779 if (SWIG_IsTmpObj(res3)) {
30780 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30781 } else {
30782 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30783 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30784 }
30785 return resultobj;
30786 fail:
30787 return NULL;
30788 }
30789
30790
30791 SWIGINTERN PyObject *_wrap_Window_GetScreenRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30792 PyObject *resultobj = 0;
30793 wxWindow *arg1 = (wxWindow *) 0 ;
30794 wxRect 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_GetScreenRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
30804 }
30805 arg1 = reinterpret_cast< wxWindow * >(argp1);
30806 {
30807 PyThreadState* __tstate = wxPyBeginAllowThreads();
30808 result = ((wxWindow const *)arg1)->GetScreenRect();
30809 wxPyEndAllowThreads(__tstate);
30810 if (PyErr_Occurred()) SWIG_fail;
30811 }
30812 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
30813 return resultobj;
30814 fail:
30815 return NULL;
30816 }
30817
30818
30819 SWIGINTERN PyObject *_wrap_Window_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30820 PyObject *resultobj = 0;
30821 wxWindow *arg1 = (wxWindow *) 0 ;
30822 wxSize result;
30823 void *argp1 = 0 ;
30824 int res1 = 0 ;
30825 PyObject *swig_obj[1] ;
30826
30827 if (!args) SWIG_fail;
30828 swig_obj[0] = args;
30829 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30830 if (!SWIG_IsOK(res1)) {
30831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
30832 }
30833 arg1 = reinterpret_cast< wxWindow * >(argp1);
30834 {
30835 PyThreadState* __tstate = wxPyBeginAllowThreads();
30836 result = ((wxWindow const *)arg1)->GetSize();
30837 wxPyEndAllowThreads(__tstate);
30838 if (PyErr_Occurred()) SWIG_fail;
30839 }
30840 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
30841 return resultobj;
30842 fail:
30843 return NULL;
30844 }
30845
30846
30847 SWIGINTERN PyObject *_wrap_Window_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30848 PyObject *resultobj = 0;
30849 wxWindow *arg1 = (wxWindow *) 0 ;
30850 int *arg2 = (int *) 0 ;
30851 int *arg3 = (int *) 0 ;
30852 void *argp1 = 0 ;
30853 int res1 = 0 ;
30854 int temp2 ;
30855 int res2 = SWIG_TMPOBJ ;
30856 int temp3 ;
30857 int res3 = SWIG_TMPOBJ ;
30858 PyObject *swig_obj[1] ;
30859
30860 arg2 = &temp2;
30861 arg3 = &temp3;
30862 if (!args) SWIG_fail;
30863 swig_obj[0] = args;
30864 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30865 if (!SWIG_IsOK(res1)) {
30866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30867 }
30868 arg1 = reinterpret_cast< wxWindow * >(argp1);
30869 {
30870 PyThreadState* __tstate = wxPyBeginAllowThreads();
30871 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
30872 wxPyEndAllowThreads(__tstate);
30873 if (PyErr_Occurred()) SWIG_fail;
30874 }
30875 resultobj = SWIG_Py_Void();
30876 if (SWIG_IsTmpObj(res2)) {
30877 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30878 } else {
30879 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30880 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30881 }
30882 if (SWIG_IsTmpObj(res3)) {
30883 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30884 } else {
30885 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30886 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30887 }
30888 return resultobj;
30889 fail:
30890 return NULL;
30891 }
30892
30893
30894 SWIGINTERN PyObject *_wrap_Window_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30895 PyObject *resultobj = 0;
30896 wxWindow *arg1 = (wxWindow *) 0 ;
30897 wxRect result;
30898 void *argp1 = 0 ;
30899 int res1 = 0 ;
30900 PyObject *swig_obj[1] ;
30901
30902 if (!args) SWIG_fail;
30903 swig_obj[0] = args;
30904 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30905 if (!SWIG_IsOK(res1)) {
30906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
30907 }
30908 arg1 = reinterpret_cast< wxWindow * >(argp1);
30909 {
30910 PyThreadState* __tstate = wxPyBeginAllowThreads();
30911 result = ((wxWindow const *)arg1)->GetRect();
30912 wxPyEndAllowThreads(__tstate);
30913 if (PyErr_Occurred()) SWIG_fail;
30914 }
30915 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
30916 return resultobj;
30917 fail:
30918 return NULL;
30919 }
30920
30921
30922 SWIGINTERN PyObject *_wrap_Window_GetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30923 PyObject *resultobj = 0;
30924 wxWindow *arg1 = (wxWindow *) 0 ;
30925 wxSize result;
30926 void *argp1 = 0 ;
30927 int res1 = 0 ;
30928 PyObject *swig_obj[1] ;
30929
30930 if (!args) SWIG_fail;
30931 swig_obj[0] = args;
30932 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30933 if (!SWIG_IsOK(res1)) {
30934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
30935 }
30936 arg1 = reinterpret_cast< wxWindow * >(argp1);
30937 {
30938 PyThreadState* __tstate = wxPyBeginAllowThreads();
30939 result = ((wxWindow const *)arg1)->GetClientSize();
30940 wxPyEndAllowThreads(__tstate);
30941 if (PyErr_Occurred()) SWIG_fail;
30942 }
30943 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
30944 return resultobj;
30945 fail:
30946 return NULL;
30947 }
30948
30949
30950 SWIGINTERN PyObject *_wrap_Window_GetClientSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30951 PyObject *resultobj = 0;
30952 wxWindow *arg1 = (wxWindow *) 0 ;
30953 int *arg2 = (int *) 0 ;
30954 int *arg3 = (int *) 0 ;
30955 void *argp1 = 0 ;
30956 int res1 = 0 ;
30957 int temp2 ;
30958 int res2 = SWIG_TMPOBJ ;
30959 int temp3 ;
30960 int res3 = SWIG_TMPOBJ ;
30961 PyObject *swig_obj[1] ;
30962
30963 arg2 = &temp2;
30964 arg3 = &temp3;
30965 if (!args) SWIG_fail;
30966 swig_obj[0] = args;
30967 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30968 if (!SWIG_IsOK(res1)) {
30969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30970 }
30971 arg1 = reinterpret_cast< wxWindow * >(argp1);
30972 {
30973 PyThreadState* __tstate = wxPyBeginAllowThreads();
30974 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
30975 wxPyEndAllowThreads(__tstate);
30976 if (PyErr_Occurred()) SWIG_fail;
30977 }
30978 resultobj = SWIG_Py_Void();
30979 if (SWIG_IsTmpObj(res2)) {
30980 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30981 } else {
30982 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30983 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30984 }
30985 if (SWIG_IsTmpObj(res3)) {
30986 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30987 } else {
30988 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30989 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30990 }
30991 return resultobj;
30992 fail:
30993 return NULL;
30994 }
30995
30996
30997 SWIGINTERN PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30998 PyObject *resultobj = 0;
30999 wxWindow *arg1 = (wxWindow *) 0 ;
31000 wxPoint result;
31001 void *argp1 = 0 ;
31002 int res1 = 0 ;
31003 PyObject *swig_obj[1] ;
31004
31005 if (!args) SWIG_fail;
31006 swig_obj[0] = args;
31007 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31008 if (!SWIG_IsOK(res1)) {
31009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientAreaOrigin" "', expected argument " "1"" of type '" "wxWindow const *""'");
31010 }
31011 arg1 = reinterpret_cast< wxWindow * >(argp1);
31012 {
31013 PyThreadState* __tstate = wxPyBeginAllowThreads();
31014 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
31015 wxPyEndAllowThreads(__tstate);
31016 if (PyErr_Occurred()) SWIG_fail;
31017 }
31018 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
31019 return resultobj;
31020 fail:
31021 return NULL;
31022 }
31023
31024
31025 SWIGINTERN PyObject *_wrap_Window_GetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31026 PyObject *resultobj = 0;
31027 wxWindow *arg1 = (wxWindow *) 0 ;
31028 wxRect result;
31029 void *argp1 = 0 ;
31030 int res1 = 0 ;
31031 PyObject *swig_obj[1] ;
31032
31033 if (!args) SWIG_fail;
31034 swig_obj[0] = args;
31035 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31036 if (!SWIG_IsOK(res1)) {
31037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
31038 }
31039 arg1 = reinterpret_cast< wxWindow * >(argp1);
31040 {
31041 PyThreadState* __tstate = wxPyBeginAllowThreads();
31042 result = ((wxWindow const *)arg1)->GetClientRect();
31043 wxPyEndAllowThreads(__tstate);
31044 if (PyErr_Occurred()) SWIG_fail;
31045 }
31046 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
31047 return resultobj;
31048 fail:
31049 return NULL;
31050 }
31051
31052
31053 SWIGINTERN PyObject *_wrap_Window_GetBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31054 PyObject *resultobj = 0;
31055 wxWindow *arg1 = (wxWindow *) 0 ;
31056 wxSize result;
31057 void *argp1 = 0 ;
31058 int res1 = 0 ;
31059 PyObject *swig_obj[1] ;
31060
31061 if (!args) SWIG_fail;
31062 swig_obj[0] = args;
31063 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31064 if (!SWIG_IsOK(res1)) {
31065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31066 }
31067 arg1 = reinterpret_cast< wxWindow * >(argp1);
31068 {
31069 PyThreadState* __tstate = wxPyBeginAllowThreads();
31070 result = ((wxWindow const *)arg1)->GetBestSize();
31071 wxPyEndAllowThreads(__tstate);
31072 if (PyErr_Occurred()) SWIG_fail;
31073 }
31074 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31075 return resultobj;
31076 fail:
31077 return NULL;
31078 }
31079
31080
31081 SWIGINTERN PyObject *_wrap_Window_GetBestSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31082 PyObject *resultobj = 0;
31083 wxWindow *arg1 = (wxWindow *) 0 ;
31084 int *arg2 = (int *) 0 ;
31085 int *arg3 = (int *) 0 ;
31086 void *argp1 = 0 ;
31087 int res1 = 0 ;
31088 int temp2 ;
31089 int res2 = SWIG_TMPOBJ ;
31090 int temp3 ;
31091 int res3 = SWIG_TMPOBJ ;
31092 PyObject *swig_obj[1] ;
31093
31094 arg2 = &temp2;
31095 arg3 = &temp3;
31096 if (!args) SWIG_fail;
31097 swig_obj[0] = args;
31098 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31099 if (!SWIG_IsOK(res1)) {
31100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31101 }
31102 arg1 = reinterpret_cast< wxWindow * >(argp1);
31103 {
31104 PyThreadState* __tstate = wxPyBeginAllowThreads();
31105 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
31106 wxPyEndAllowThreads(__tstate);
31107 if (PyErr_Occurred()) SWIG_fail;
31108 }
31109 resultobj = SWIG_Py_Void();
31110 if (SWIG_IsTmpObj(res2)) {
31111 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31112 } else {
31113 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31114 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31115 }
31116 if (SWIG_IsTmpObj(res3)) {
31117 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31118 } else {
31119 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31120 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31121 }
31122 return resultobj;
31123 fail:
31124 return NULL;
31125 }
31126
31127
31128 SWIGINTERN PyObject *_wrap_Window_InvalidateBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31129 PyObject *resultobj = 0;
31130 wxWindow *arg1 = (wxWindow *) 0 ;
31131 void *argp1 = 0 ;
31132 int res1 = 0 ;
31133 PyObject *swig_obj[1] ;
31134
31135 if (!args) SWIG_fail;
31136 swig_obj[0] = args;
31137 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31138 if (!SWIG_IsOK(res1)) {
31139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InvalidateBestSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31140 }
31141 arg1 = reinterpret_cast< wxWindow * >(argp1);
31142 {
31143 PyThreadState* __tstate = wxPyBeginAllowThreads();
31144 (arg1)->InvalidateBestSize();
31145 wxPyEndAllowThreads(__tstate);
31146 if (PyErr_Occurred()) SWIG_fail;
31147 }
31148 resultobj = SWIG_Py_Void();
31149 return resultobj;
31150 fail:
31151 return NULL;
31152 }
31153
31154
31155 SWIGINTERN PyObject *_wrap_Window_CacheBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31156 PyObject *resultobj = 0;
31157 wxWindow *arg1 = (wxWindow *) 0 ;
31158 wxSize *arg2 = 0 ;
31159 void *argp1 = 0 ;
31160 int res1 = 0 ;
31161 wxSize temp2 ;
31162 PyObject * obj0 = 0 ;
31163 PyObject * obj1 = 0 ;
31164 char * kwnames[] = {
31165 (char *) "self",(char *) "size", NULL
31166 };
31167
31168 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) SWIG_fail;
31169 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31170 if (!SWIG_IsOK(res1)) {
31171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CacheBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31172 }
31173 arg1 = reinterpret_cast< wxWindow * >(argp1);
31174 {
31175 arg2 = &temp2;
31176 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31177 }
31178 {
31179 PyThreadState* __tstate = wxPyBeginAllowThreads();
31180 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
31181 wxPyEndAllowThreads(__tstate);
31182 if (PyErr_Occurred()) SWIG_fail;
31183 }
31184 resultobj = SWIG_Py_Void();
31185 return resultobj;
31186 fail:
31187 return NULL;
31188 }
31189
31190
31191 SWIGINTERN PyObject *_wrap_Window_GetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31192 PyObject *resultobj = 0;
31193 wxWindow *arg1 = (wxWindow *) 0 ;
31194 wxSize result;
31195 void *argp1 = 0 ;
31196 int res1 = 0 ;
31197 PyObject *swig_obj[1] ;
31198
31199 if (!args) SWIG_fail;
31200 swig_obj[0] = args;
31201 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31202 if (!SWIG_IsOK(res1)) {
31203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31204 }
31205 arg1 = reinterpret_cast< wxWindow * >(argp1);
31206 {
31207 PyThreadState* __tstate = wxPyBeginAllowThreads();
31208 result = ((wxWindow const *)arg1)->GetBestFittingSize();
31209 wxPyEndAllowThreads(__tstate);
31210 if (PyErr_Occurred()) SWIG_fail;
31211 }
31212 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31213 return resultobj;
31214 fail:
31215 return NULL;
31216 }
31217
31218
31219 SWIGINTERN PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31220 PyObject *resultobj = 0;
31221 wxWindow *arg1 = (wxWindow *) 0 ;
31222 wxSize result;
31223 void *argp1 = 0 ;
31224 int res1 = 0 ;
31225 PyObject *swig_obj[1] ;
31226
31227 if (!args) SWIG_fail;
31228 swig_obj[0] = args;
31229 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31230 if (!SWIG_IsOK(res1)) {
31231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAdjustedBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31232 }
31233 arg1 = reinterpret_cast< wxWindow * >(argp1);
31234 {
31235 PyThreadState* __tstate = wxPyBeginAllowThreads();
31236 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
31237 wxPyEndAllowThreads(__tstate);
31238 if (PyErr_Occurred()) SWIG_fail;
31239 }
31240 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31241 return resultobj;
31242 fail:
31243 return NULL;
31244 }
31245
31246
31247 SWIGINTERN PyObject *_wrap_Window_Center(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31248 PyObject *resultobj = 0;
31249 wxWindow *arg1 = (wxWindow *) 0 ;
31250 int arg2 = (int) wxBOTH ;
31251 void *argp1 = 0 ;
31252 int res1 = 0 ;
31253 int val2 ;
31254 int ecode2 = 0 ;
31255 PyObject * obj0 = 0 ;
31256 PyObject * obj1 = 0 ;
31257 char * kwnames[] = {
31258 (char *) "self",(char *) "direction", NULL
31259 };
31260
31261 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) SWIG_fail;
31262 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31263 if (!SWIG_IsOK(res1)) {
31264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Center" "', expected argument " "1"" of type '" "wxWindow *""'");
31265 }
31266 arg1 = reinterpret_cast< wxWindow * >(argp1);
31267 if (obj1) {
31268 ecode2 = SWIG_AsVal_int(obj1, &val2);
31269 if (!SWIG_IsOK(ecode2)) {
31270 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Center" "', expected argument " "2"" of type '" "int""'");
31271 }
31272 arg2 = static_cast< int >(val2);
31273 }
31274 {
31275 PyThreadState* __tstate = wxPyBeginAllowThreads();
31276 (arg1)->Center(arg2);
31277 wxPyEndAllowThreads(__tstate);
31278 if (PyErr_Occurred()) SWIG_fail;
31279 }
31280 resultobj = SWIG_Py_Void();
31281 return resultobj;
31282 fail:
31283 return NULL;
31284 }
31285
31286
31287 SWIGINTERN PyObject *_wrap_Window_CenterOnParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31288 PyObject *resultobj = 0;
31289 wxWindow *arg1 = (wxWindow *) 0 ;
31290 int arg2 = (int) wxBOTH ;
31291 void *argp1 = 0 ;
31292 int res1 = 0 ;
31293 int val2 ;
31294 int ecode2 = 0 ;
31295 PyObject * obj0 = 0 ;
31296 PyObject * obj1 = 0 ;
31297 char * kwnames[] = {
31298 (char *) "self",(char *) "dir", NULL
31299 };
31300
31301 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) SWIG_fail;
31302 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31303 if (!SWIG_IsOK(res1)) {
31304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CenterOnParent" "', expected argument " "1"" of type '" "wxWindow *""'");
31305 }
31306 arg1 = reinterpret_cast< wxWindow * >(argp1);
31307 if (obj1) {
31308 ecode2 = SWIG_AsVal_int(obj1, &val2);
31309 if (!SWIG_IsOK(ecode2)) {
31310 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_CenterOnParent" "', expected argument " "2"" of type '" "int""'");
31311 }
31312 arg2 = static_cast< int >(val2);
31313 }
31314 {
31315 PyThreadState* __tstate = wxPyBeginAllowThreads();
31316 (arg1)->CenterOnParent(arg2);
31317 wxPyEndAllowThreads(__tstate);
31318 if (PyErr_Occurred()) SWIG_fail;
31319 }
31320 resultobj = SWIG_Py_Void();
31321 return resultobj;
31322 fail:
31323 return NULL;
31324 }
31325
31326
31327 SWIGINTERN PyObject *_wrap_Window_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31328 PyObject *resultobj = 0;
31329 wxWindow *arg1 = (wxWindow *) 0 ;
31330 void *argp1 = 0 ;
31331 int res1 = 0 ;
31332 PyObject *swig_obj[1] ;
31333
31334 if (!args) SWIG_fail;
31335 swig_obj[0] = args;
31336 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31337 if (!SWIG_IsOK(res1)) {
31338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Fit" "', expected argument " "1"" of type '" "wxWindow *""'");
31339 }
31340 arg1 = reinterpret_cast< wxWindow * >(argp1);
31341 {
31342 PyThreadState* __tstate = wxPyBeginAllowThreads();
31343 (arg1)->Fit();
31344 wxPyEndAllowThreads(__tstate);
31345 if (PyErr_Occurred()) SWIG_fail;
31346 }
31347 resultobj = SWIG_Py_Void();
31348 return resultobj;
31349 fail:
31350 return NULL;
31351 }
31352
31353
31354 SWIGINTERN PyObject *_wrap_Window_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31355 PyObject *resultobj = 0;
31356 wxWindow *arg1 = (wxWindow *) 0 ;
31357 void *argp1 = 0 ;
31358 int res1 = 0 ;
31359 PyObject *swig_obj[1] ;
31360
31361 if (!args) SWIG_fail;
31362 swig_obj[0] = args;
31363 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31364 if (!SWIG_IsOK(res1)) {
31365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FitInside" "', expected argument " "1"" of type '" "wxWindow *""'");
31366 }
31367 arg1 = reinterpret_cast< wxWindow * >(argp1);
31368 {
31369 PyThreadState* __tstate = wxPyBeginAllowThreads();
31370 (arg1)->FitInside();
31371 wxPyEndAllowThreads(__tstate);
31372 if (PyErr_Occurred()) SWIG_fail;
31373 }
31374 resultobj = SWIG_Py_Void();
31375 return resultobj;
31376 fail:
31377 return NULL;
31378 }
31379
31380
31381 SWIGINTERN PyObject *_wrap_Window_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31382 PyObject *resultobj = 0;
31383 wxWindow *arg1 = (wxWindow *) 0 ;
31384 int arg2 ;
31385 int arg3 ;
31386 int arg4 = (int) -1 ;
31387 int arg5 = (int) -1 ;
31388 int arg6 = (int) -1 ;
31389 int arg7 = (int) -1 ;
31390 void *argp1 = 0 ;
31391 int res1 = 0 ;
31392 int val2 ;
31393 int ecode2 = 0 ;
31394 int val3 ;
31395 int ecode3 = 0 ;
31396 int val4 ;
31397 int ecode4 = 0 ;
31398 int val5 ;
31399 int ecode5 = 0 ;
31400 int val6 ;
31401 int ecode6 = 0 ;
31402 int val7 ;
31403 int ecode7 = 0 ;
31404 PyObject * obj0 = 0 ;
31405 PyObject * obj1 = 0 ;
31406 PyObject * obj2 = 0 ;
31407 PyObject * obj3 = 0 ;
31408 PyObject * obj4 = 0 ;
31409 PyObject * obj5 = 0 ;
31410 PyObject * obj6 = 0 ;
31411 char * kwnames[] = {
31412 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
31413 };
31414
31415 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
31416 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31417 if (!SWIG_IsOK(res1)) {
31418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
31419 }
31420 arg1 = reinterpret_cast< wxWindow * >(argp1);
31421 ecode2 = SWIG_AsVal_int(obj1, &val2);
31422 if (!SWIG_IsOK(ecode2)) {
31423 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeHints" "', expected argument " "2"" of type '" "int""'");
31424 }
31425 arg2 = static_cast< int >(val2);
31426 ecode3 = SWIG_AsVal_int(obj2, &val3);
31427 if (!SWIG_IsOK(ecode3)) {
31428 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeHints" "', expected argument " "3"" of type '" "int""'");
31429 }
31430 arg3 = static_cast< int >(val3);
31431 if (obj3) {
31432 ecode4 = SWIG_AsVal_int(obj3, &val4);
31433 if (!SWIG_IsOK(ecode4)) {
31434 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetSizeHints" "', expected argument " "4"" of type '" "int""'");
31435 }
31436 arg4 = static_cast< int >(val4);
31437 }
31438 if (obj4) {
31439 ecode5 = SWIG_AsVal_int(obj4, &val5);
31440 if (!SWIG_IsOK(ecode5)) {
31441 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetSizeHints" "', expected argument " "5"" of type '" "int""'");
31442 }
31443 arg5 = static_cast< int >(val5);
31444 }
31445 if (obj5) {
31446 ecode6 = SWIG_AsVal_int(obj5, &val6);
31447 if (!SWIG_IsOK(ecode6)) {
31448 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetSizeHints" "', expected argument " "6"" of type '" "int""'");
31449 }
31450 arg6 = static_cast< int >(val6);
31451 }
31452 if (obj6) {
31453 ecode7 = SWIG_AsVal_int(obj6, &val7);
31454 if (!SWIG_IsOK(ecode7)) {
31455 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Window_SetSizeHints" "', expected argument " "7"" of type '" "int""'");
31456 }
31457 arg7 = static_cast< int >(val7);
31458 }
31459 {
31460 PyThreadState* __tstate = wxPyBeginAllowThreads();
31461 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
31462 wxPyEndAllowThreads(__tstate);
31463 if (PyErr_Occurred()) SWIG_fail;
31464 }
31465 resultobj = SWIG_Py_Void();
31466 return resultobj;
31467 fail:
31468 return NULL;
31469 }
31470
31471
31472 SWIGINTERN PyObject *_wrap_Window_SetSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31473 PyObject *resultobj = 0;
31474 wxWindow *arg1 = (wxWindow *) 0 ;
31475 wxSize *arg2 = 0 ;
31476 wxSize const &arg3_defvalue = wxDefaultSize ;
31477 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
31478 wxSize const &arg4_defvalue = wxDefaultSize ;
31479 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
31480 void *argp1 = 0 ;
31481 int res1 = 0 ;
31482 wxSize temp2 ;
31483 wxSize temp3 ;
31484 wxSize temp4 ;
31485 PyObject * obj0 = 0 ;
31486 PyObject * obj1 = 0 ;
31487 PyObject * obj2 = 0 ;
31488 PyObject * obj3 = 0 ;
31489 char * kwnames[] = {
31490 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
31491 };
31492
31493 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
31494 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31495 if (!SWIG_IsOK(res1)) {
31496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
31497 }
31498 arg1 = reinterpret_cast< wxWindow * >(argp1);
31499 {
31500 arg2 = &temp2;
31501 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31502 }
31503 if (obj2) {
31504 {
31505 arg3 = &temp3;
31506 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
31507 }
31508 }
31509 if (obj3) {
31510 {
31511 arg4 = &temp4;
31512 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
31513 }
31514 }
31515 {
31516 PyThreadState* __tstate = wxPyBeginAllowThreads();
31517 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
31518 wxPyEndAllowThreads(__tstate);
31519 if (PyErr_Occurred()) SWIG_fail;
31520 }
31521 resultobj = SWIG_Py_Void();
31522 return resultobj;
31523 fail:
31524 return NULL;
31525 }
31526
31527
31528 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31529 PyObject *resultobj = 0;
31530 wxWindow *arg1 = (wxWindow *) 0 ;
31531 int arg2 ;
31532 int arg3 ;
31533 int arg4 = (int) -1 ;
31534 int arg5 = (int) -1 ;
31535 void *argp1 = 0 ;
31536 int res1 = 0 ;
31537 int val2 ;
31538 int ecode2 = 0 ;
31539 int val3 ;
31540 int ecode3 = 0 ;
31541 int val4 ;
31542 int ecode4 = 0 ;
31543 int val5 ;
31544 int ecode5 = 0 ;
31545 PyObject * obj0 = 0 ;
31546 PyObject * obj1 = 0 ;
31547 PyObject * obj2 = 0 ;
31548 PyObject * obj3 = 0 ;
31549 PyObject * obj4 = 0 ;
31550 char * kwnames[] = {
31551 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
31552 };
31553
31554 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
31555 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31556 if (!SWIG_IsOK(res1)) {
31557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
31558 }
31559 arg1 = reinterpret_cast< wxWindow * >(argp1);
31560 ecode2 = SWIG_AsVal_int(obj1, &val2);
31561 if (!SWIG_IsOK(ecode2)) {
31562 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "2"" of type '" "int""'");
31563 }
31564 arg2 = static_cast< int >(val2);
31565 ecode3 = SWIG_AsVal_int(obj2, &val3);
31566 if (!SWIG_IsOK(ecode3)) {
31567 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "3"" of type '" "int""'");
31568 }
31569 arg3 = static_cast< int >(val3);
31570 if (obj3) {
31571 ecode4 = SWIG_AsVal_int(obj3, &val4);
31572 if (!SWIG_IsOK(ecode4)) {
31573 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "4"" of type '" "int""'");
31574 }
31575 arg4 = static_cast< int >(val4);
31576 }
31577 if (obj4) {
31578 ecode5 = SWIG_AsVal_int(obj4, &val5);
31579 if (!SWIG_IsOK(ecode5)) {
31580 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "5"" of type '" "int""'");
31581 }
31582 arg5 = static_cast< int >(val5);
31583 }
31584 {
31585 PyThreadState* __tstate = wxPyBeginAllowThreads();
31586 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
31587 wxPyEndAllowThreads(__tstate);
31588 if (PyErr_Occurred()) SWIG_fail;
31589 }
31590 resultobj = SWIG_Py_Void();
31591 return resultobj;
31592 fail:
31593 return NULL;
31594 }
31595
31596
31597 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31598 PyObject *resultobj = 0;
31599 wxWindow *arg1 = (wxWindow *) 0 ;
31600 wxSize *arg2 = 0 ;
31601 wxSize const &arg3_defvalue = wxDefaultSize ;
31602 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
31603 void *argp1 = 0 ;
31604 int res1 = 0 ;
31605 wxSize temp2 ;
31606 wxSize temp3 ;
31607 PyObject * obj0 = 0 ;
31608 PyObject * obj1 = 0 ;
31609 PyObject * obj2 = 0 ;
31610 char * kwnames[] = {
31611 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
31612 };
31613
31614 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31615 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31616 if (!SWIG_IsOK(res1)) {
31617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
31618 }
31619 arg1 = reinterpret_cast< wxWindow * >(argp1);
31620 {
31621 arg2 = &temp2;
31622 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31623 }
31624 if (obj2) {
31625 {
31626 arg3 = &temp3;
31627 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
31628 }
31629 }
31630 {
31631 PyThreadState* __tstate = wxPyBeginAllowThreads();
31632 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
31633 wxPyEndAllowThreads(__tstate);
31634 if (PyErr_Occurred()) SWIG_fail;
31635 }
31636 resultobj = SWIG_Py_Void();
31637 return resultobj;
31638 fail:
31639 return NULL;
31640 }
31641
31642
31643 SWIGINTERN PyObject *_wrap_Window_GetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31644 PyObject *resultobj = 0;
31645 wxWindow *arg1 = (wxWindow *) 0 ;
31646 wxSize result;
31647 void *argp1 = 0 ;
31648 int res1 = 0 ;
31649 PyObject *swig_obj[1] ;
31650
31651 if (!args) SWIG_fail;
31652 swig_obj[0] = args;
31653 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31654 if (!SWIG_IsOK(res1)) {
31655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31656 }
31657 arg1 = reinterpret_cast< wxWindow * >(argp1);
31658 {
31659 PyThreadState* __tstate = wxPyBeginAllowThreads();
31660 result = ((wxWindow const *)arg1)->GetMaxSize();
31661 wxPyEndAllowThreads(__tstate);
31662 if (PyErr_Occurred()) SWIG_fail;
31663 }
31664 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31665 return resultobj;
31666 fail:
31667 return NULL;
31668 }
31669
31670
31671 SWIGINTERN PyObject *_wrap_Window_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31672 PyObject *resultobj = 0;
31673 wxWindow *arg1 = (wxWindow *) 0 ;
31674 wxSize result;
31675 void *argp1 = 0 ;
31676 int res1 = 0 ;
31677 PyObject *swig_obj[1] ;
31678
31679 if (!args) SWIG_fail;
31680 swig_obj[0] = args;
31681 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31682 if (!SWIG_IsOK(res1)) {
31683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31684 }
31685 arg1 = reinterpret_cast< wxWindow * >(argp1);
31686 {
31687 PyThreadState* __tstate = wxPyBeginAllowThreads();
31688 result = ((wxWindow const *)arg1)->GetMinSize();
31689 wxPyEndAllowThreads(__tstate);
31690 if (PyErr_Occurred()) SWIG_fail;
31691 }
31692 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31693 return resultobj;
31694 fail:
31695 return NULL;
31696 }
31697
31698
31699 SWIGINTERN PyObject *_wrap_Window_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31700 PyObject *resultobj = 0;
31701 wxWindow *arg1 = (wxWindow *) 0 ;
31702 wxSize *arg2 = 0 ;
31703 void *argp1 = 0 ;
31704 int res1 = 0 ;
31705 wxSize temp2 ;
31706 PyObject * obj0 = 0 ;
31707 PyObject * obj1 = 0 ;
31708 char * kwnames[] = {
31709 (char *) "self",(char *) "minSize", NULL
31710 };
31711
31712 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
31713 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31714 if (!SWIG_IsOK(res1)) {
31715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMinSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31716 }
31717 arg1 = reinterpret_cast< wxWindow * >(argp1);
31718 {
31719 arg2 = &temp2;
31720 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31721 }
31722 {
31723 PyThreadState* __tstate = wxPyBeginAllowThreads();
31724 (arg1)->SetMinSize((wxSize const &)*arg2);
31725 wxPyEndAllowThreads(__tstate);
31726 if (PyErr_Occurred()) SWIG_fail;
31727 }
31728 resultobj = SWIG_Py_Void();
31729 return resultobj;
31730 fail:
31731 return NULL;
31732 }
31733
31734
31735 SWIGINTERN PyObject *_wrap_Window_SetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31736 PyObject *resultobj = 0;
31737 wxWindow *arg1 = (wxWindow *) 0 ;
31738 wxSize *arg2 = 0 ;
31739 void *argp1 = 0 ;
31740 int res1 = 0 ;
31741 wxSize temp2 ;
31742 PyObject * obj0 = 0 ;
31743 PyObject * obj1 = 0 ;
31744 char * kwnames[] = {
31745 (char *) "self",(char *) "maxSize", NULL
31746 };
31747
31748 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) SWIG_fail;
31749 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31750 if (!SWIG_IsOK(res1)) {
31751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMaxSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31752 }
31753 arg1 = reinterpret_cast< wxWindow * >(argp1);
31754 {
31755 arg2 = &temp2;
31756 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31757 }
31758 {
31759 PyThreadState* __tstate = wxPyBeginAllowThreads();
31760 (arg1)->SetMaxSize((wxSize const &)*arg2);
31761 wxPyEndAllowThreads(__tstate);
31762 if (PyErr_Occurred()) SWIG_fail;
31763 }
31764 resultobj = SWIG_Py_Void();
31765 return resultobj;
31766 fail:
31767 return NULL;
31768 }
31769
31770
31771 SWIGINTERN PyObject *_wrap_Window_GetMinWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31772 PyObject *resultobj = 0;
31773 wxWindow *arg1 = (wxWindow *) 0 ;
31774 int result;
31775 void *argp1 = 0 ;
31776 int res1 = 0 ;
31777 PyObject *swig_obj[1] ;
31778
31779 if (!args) SWIG_fail;
31780 swig_obj[0] = args;
31781 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31782 if (!SWIG_IsOK(res1)) {
31783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
31784 }
31785 arg1 = reinterpret_cast< wxWindow * >(argp1);
31786 {
31787 PyThreadState* __tstate = wxPyBeginAllowThreads();
31788 result = (int)((wxWindow const *)arg1)->GetMinWidth();
31789 wxPyEndAllowThreads(__tstate);
31790 if (PyErr_Occurred()) SWIG_fail;
31791 }
31792 resultobj = SWIG_From_int(static_cast< int >(result));
31793 return resultobj;
31794 fail:
31795 return NULL;
31796 }
31797
31798
31799 SWIGINTERN PyObject *_wrap_Window_GetMinHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31800 PyObject *resultobj = 0;
31801 wxWindow *arg1 = (wxWindow *) 0 ;
31802 int result;
31803 void *argp1 = 0 ;
31804 int res1 = 0 ;
31805 PyObject *swig_obj[1] ;
31806
31807 if (!args) SWIG_fail;
31808 swig_obj[0] = args;
31809 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31810 if (!SWIG_IsOK(res1)) {
31811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
31812 }
31813 arg1 = reinterpret_cast< wxWindow * >(argp1);
31814 {
31815 PyThreadState* __tstate = wxPyBeginAllowThreads();
31816 result = (int)((wxWindow const *)arg1)->GetMinHeight();
31817 wxPyEndAllowThreads(__tstate);
31818 if (PyErr_Occurred()) SWIG_fail;
31819 }
31820 resultobj = SWIG_From_int(static_cast< int >(result));
31821 return resultobj;
31822 fail:
31823 return NULL;
31824 }
31825
31826
31827 SWIGINTERN PyObject *_wrap_Window_GetMaxWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31828 PyObject *resultobj = 0;
31829 wxWindow *arg1 = (wxWindow *) 0 ;
31830 int result;
31831 void *argp1 = 0 ;
31832 int res1 = 0 ;
31833 PyObject *swig_obj[1] ;
31834
31835 if (!args) SWIG_fail;
31836 swig_obj[0] = args;
31837 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31838 if (!SWIG_IsOK(res1)) {
31839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
31840 }
31841 arg1 = reinterpret_cast< wxWindow * >(argp1);
31842 {
31843 PyThreadState* __tstate = wxPyBeginAllowThreads();
31844 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
31845 wxPyEndAllowThreads(__tstate);
31846 if (PyErr_Occurred()) SWIG_fail;
31847 }
31848 resultobj = SWIG_From_int(static_cast< int >(result));
31849 return resultobj;
31850 fail:
31851 return NULL;
31852 }
31853
31854
31855 SWIGINTERN PyObject *_wrap_Window_GetMaxHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31856 PyObject *resultobj = 0;
31857 wxWindow *arg1 = (wxWindow *) 0 ;
31858 int result;
31859 void *argp1 = 0 ;
31860 int res1 = 0 ;
31861 PyObject *swig_obj[1] ;
31862
31863 if (!args) SWIG_fail;
31864 swig_obj[0] = args;
31865 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31866 if (!SWIG_IsOK(res1)) {
31867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
31868 }
31869 arg1 = reinterpret_cast< wxWindow * >(argp1);
31870 {
31871 PyThreadState* __tstate = wxPyBeginAllowThreads();
31872 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
31873 wxPyEndAllowThreads(__tstate);
31874 if (PyErr_Occurred()) SWIG_fail;
31875 }
31876 resultobj = SWIG_From_int(static_cast< int >(result));
31877 return resultobj;
31878 fail:
31879 return NULL;
31880 }
31881
31882
31883 SWIGINTERN PyObject *_wrap_Window_SetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31884 PyObject *resultobj = 0;
31885 wxWindow *arg1 = (wxWindow *) 0 ;
31886 wxSize *arg2 = 0 ;
31887 void *argp1 = 0 ;
31888 int res1 = 0 ;
31889 wxSize temp2 ;
31890 PyObject * obj0 = 0 ;
31891 PyObject * obj1 = 0 ;
31892 char * kwnames[] = {
31893 (char *) "self",(char *) "size", NULL
31894 };
31895
31896 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) SWIG_fail;
31897 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31898 if (!SWIG_IsOK(res1)) {
31899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31900 }
31901 arg1 = reinterpret_cast< wxWindow * >(argp1);
31902 {
31903 arg2 = &temp2;
31904 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31905 }
31906 {
31907 PyThreadState* __tstate = wxPyBeginAllowThreads();
31908 (arg1)->SetVirtualSize((wxSize const &)*arg2);
31909 wxPyEndAllowThreads(__tstate);
31910 if (PyErr_Occurred()) SWIG_fail;
31911 }
31912 resultobj = SWIG_Py_Void();
31913 return resultobj;
31914 fail:
31915 return NULL;
31916 }
31917
31918
31919 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31920 PyObject *resultobj = 0;
31921 wxWindow *arg1 = (wxWindow *) 0 ;
31922 int arg2 ;
31923 int arg3 ;
31924 void *argp1 = 0 ;
31925 int res1 = 0 ;
31926 int val2 ;
31927 int ecode2 = 0 ;
31928 int val3 ;
31929 int ecode3 = 0 ;
31930 PyObject * obj0 = 0 ;
31931 PyObject * obj1 = 0 ;
31932 PyObject * obj2 = 0 ;
31933 char * kwnames[] = {
31934 (char *) "self",(char *) "w",(char *) "h", NULL
31935 };
31936
31937 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31938 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31939 if (!SWIG_IsOK(res1)) {
31940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
31941 }
31942 arg1 = reinterpret_cast< wxWindow * >(argp1);
31943 ecode2 = SWIG_AsVal_int(obj1, &val2);
31944 if (!SWIG_IsOK(ecode2)) {
31945 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "2"" of type '" "int""'");
31946 }
31947 arg2 = static_cast< int >(val2);
31948 ecode3 = SWIG_AsVal_int(obj2, &val3);
31949 if (!SWIG_IsOK(ecode3)) {
31950 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "3"" of type '" "int""'");
31951 }
31952 arg3 = static_cast< int >(val3);
31953 {
31954 PyThreadState* __tstate = wxPyBeginAllowThreads();
31955 (arg1)->SetVirtualSize(arg2,arg3);
31956 wxPyEndAllowThreads(__tstate);
31957 if (PyErr_Occurred()) SWIG_fail;
31958 }
31959 resultobj = SWIG_Py_Void();
31960 return resultobj;
31961 fail:
31962 return NULL;
31963 }
31964
31965
31966 SWIGINTERN PyObject *_wrap_Window_GetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31967 PyObject *resultobj = 0;
31968 wxWindow *arg1 = (wxWindow *) 0 ;
31969 wxSize result;
31970 void *argp1 = 0 ;
31971 int res1 = 0 ;
31972 PyObject *swig_obj[1] ;
31973
31974 if (!args) SWIG_fail;
31975 swig_obj[0] = args;
31976 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31977 if (!SWIG_IsOK(res1)) {
31978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31979 }
31980 arg1 = reinterpret_cast< wxWindow * >(argp1);
31981 {
31982 PyThreadState* __tstate = wxPyBeginAllowThreads();
31983 result = ((wxWindow const *)arg1)->GetVirtualSize();
31984 wxPyEndAllowThreads(__tstate);
31985 if (PyErr_Occurred()) SWIG_fail;
31986 }
31987 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31988 return resultobj;
31989 fail:
31990 return NULL;
31991 }
31992
31993
31994 SWIGINTERN PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31995 PyObject *resultobj = 0;
31996 wxWindow *arg1 = (wxWindow *) 0 ;
31997 int *arg2 = (int *) 0 ;
31998 int *arg3 = (int *) 0 ;
31999 void *argp1 = 0 ;
32000 int res1 = 0 ;
32001 int temp2 ;
32002 int res2 = SWIG_TMPOBJ ;
32003 int temp3 ;
32004 int res3 = SWIG_TMPOBJ ;
32005 PyObject *swig_obj[1] ;
32006
32007 arg2 = &temp2;
32008 arg3 = &temp3;
32009 if (!args) SWIG_fail;
32010 swig_obj[0] = args;
32011 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32012 if (!SWIG_IsOK(res1)) {
32013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
32014 }
32015 arg1 = reinterpret_cast< wxWindow * >(argp1);
32016 {
32017 PyThreadState* __tstate = wxPyBeginAllowThreads();
32018 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
32019 wxPyEndAllowThreads(__tstate);
32020 if (PyErr_Occurred()) SWIG_fail;
32021 }
32022 resultobj = SWIG_Py_Void();
32023 if (SWIG_IsTmpObj(res2)) {
32024 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
32025 } else {
32026 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32027 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
32028 }
32029 if (SWIG_IsTmpObj(res3)) {
32030 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
32031 } else {
32032 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32033 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
32034 }
32035 return resultobj;
32036 fail:
32037 return NULL;
32038 }
32039
32040
32041 SWIGINTERN PyObject *_wrap_Window_GetBestVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32042 PyObject *resultobj = 0;
32043 wxWindow *arg1 = (wxWindow *) 0 ;
32044 wxSize result;
32045 void *argp1 = 0 ;
32046 int res1 = 0 ;
32047 PyObject *swig_obj[1] ;
32048
32049 if (!args) SWIG_fail;
32050 swig_obj[0] = args;
32051 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32052 if (!SWIG_IsOK(res1)) {
32053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32054 }
32055 arg1 = reinterpret_cast< wxWindow * >(argp1);
32056 {
32057 PyThreadState* __tstate = wxPyBeginAllowThreads();
32058 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
32059 wxPyEndAllowThreads(__tstate);
32060 if (PyErr_Occurred()) SWIG_fail;
32061 }
32062 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32063 return resultobj;
32064 fail:
32065 return NULL;
32066 }
32067
32068
32069 SWIGINTERN PyObject *_wrap_Window_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32070 PyObject *resultobj = 0;
32071 wxWindow *arg1 = (wxWindow *) 0 ;
32072 bool arg2 = (bool) true ;
32073 bool result;
32074 void *argp1 = 0 ;
32075 int res1 = 0 ;
32076 bool val2 ;
32077 int ecode2 = 0 ;
32078 PyObject * obj0 = 0 ;
32079 PyObject * obj1 = 0 ;
32080 char * kwnames[] = {
32081 (char *) "self",(char *) "show", NULL
32082 };
32083
32084 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) SWIG_fail;
32085 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32086 if (!SWIG_IsOK(res1)) {
32087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Show" "', expected argument " "1"" of type '" "wxWindow *""'");
32088 }
32089 arg1 = reinterpret_cast< wxWindow * >(argp1);
32090 if (obj1) {
32091 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32092 if (!SWIG_IsOK(ecode2)) {
32093 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Show" "', expected argument " "2"" of type '" "bool""'");
32094 }
32095 arg2 = static_cast< bool >(val2);
32096 }
32097 {
32098 PyThreadState* __tstate = wxPyBeginAllowThreads();
32099 result = (bool)(arg1)->Show(arg2);
32100 wxPyEndAllowThreads(__tstate);
32101 if (PyErr_Occurred()) SWIG_fail;
32102 }
32103 {
32104 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32105 }
32106 return resultobj;
32107 fail:
32108 return NULL;
32109 }
32110
32111
32112 SWIGINTERN PyObject *_wrap_Window_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32113 PyObject *resultobj = 0;
32114 wxWindow *arg1 = (wxWindow *) 0 ;
32115 bool result;
32116 void *argp1 = 0 ;
32117 int res1 = 0 ;
32118 PyObject *swig_obj[1] ;
32119
32120 if (!args) SWIG_fail;
32121 swig_obj[0] = args;
32122 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32123 if (!SWIG_IsOK(res1)) {
32124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Hide" "', expected argument " "1"" of type '" "wxWindow *""'");
32125 }
32126 arg1 = reinterpret_cast< wxWindow * >(argp1);
32127 {
32128 PyThreadState* __tstate = wxPyBeginAllowThreads();
32129 result = (bool)(arg1)->Hide();
32130 wxPyEndAllowThreads(__tstate);
32131 if (PyErr_Occurred()) SWIG_fail;
32132 }
32133 {
32134 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32135 }
32136 return resultobj;
32137 fail:
32138 return NULL;
32139 }
32140
32141
32142 SWIGINTERN PyObject *_wrap_Window_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32143 PyObject *resultobj = 0;
32144 wxWindow *arg1 = (wxWindow *) 0 ;
32145 bool arg2 = (bool) true ;
32146 bool result;
32147 void *argp1 = 0 ;
32148 int res1 = 0 ;
32149 bool val2 ;
32150 int ecode2 = 0 ;
32151 PyObject * obj0 = 0 ;
32152 PyObject * obj1 = 0 ;
32153 char * kwnames[] = {
32154 (char *) "self",(char *) "enable", NULL
32155 };
32156
32157 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
32158 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32159 if (!SWIG_IsOK(res1)) {
32160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Enable" "', expected argument " "1"" of type '" "wxWindow *""'");
32161 }
32162 arg1 = reinterpret_cast< wxWindow * >(argp1);
32163 if (obj1) {
32164 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32165 if (!SWIG_IsOK(ecode2)) {
32166 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Enable" "', expected argument " "2"" of type '" "bool""'");
32167 }
32168 arg2 = static_cast< bool >(val2);
32169 }
32170 {
32171 PyThreadState* __tstate = wxPyBeginAllowThreads();
32172 result = (bool)(arg1)->Enable(arg2);
32173 wxPyEndAllowThreads(__tstate);
32174 if (PyErr_Occurred()) SWIG_fail;
32175 }
32176 {
32177 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32178 }
32179 return resultobj;
32180 fail:
32181 return NULL;
32182 }
32183
32184
32185 SWIGINTERN PyObject *_wrap_Window_Disable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32186 PyObject *resultobj = 0;
32187 wxWindow *arg1 = (wxWindow *) 0 ;
32188 bool result;
32189 void *argp1 = 0 ;
32190 int res1 = 0 ;
32191 PyObject *swig_obj[1] ;
32192
32193 if (!args) SWIG_fail;
32194 swig_obj[0] = args;
32195 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32196 if (!SWIG_IsOK(res1)) {
32197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Disable" "', expected argument " "1"" of type '" "wxWindow *""'");
32198 }
32199 arg1 = reinterpret_cast< wxWindow * >(argp1);
32200 {
32201 PyThreadState* __tstate = wxPyBeginAllowThreads();
32202 result = (bool)(arg1)->Disable();
32203 wxPyEndAllowThreads(__tstate);
32204 if (PyErr_Occurred()) SWIG_fail;
32205 }
32206 {
32207 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32208 }
32209 return resultobj;
32210 fail:
32211 return NULL;
32212 }
32213
32214
32215 SWIGINTERN PyObject *_wrap_Window_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32216 PyObject *resultobj = 0;
32217 wxWindow *arg1 = (wxWindow *) 0 ;
32218 bool result;
32219 void *argp1 = 0 ;
32220 int res1 = 0 ;
32221 PyObject *swig_obj[1] ;
32222
32223 if (!args) SWIG_fail;
32224 swig_obj[0] = args;
32225 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32226 if (!SWIG_IsOK(res1)) {
32227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShown" "', expected argument " "1"" of type '" "wxWindow const *""'");
32228 }
32229 arg1 = reinterpret_cast< wxWindow * >(argp1);
32230 {
32231 PyThreadState* __tstate = wxPyBeginAllowThreads();
32232 result = (bool)((wxWindow const *)arg1)->IsShown();
32233 wxPyEndAllowThreads(__tstate);
32234 if (PyErr_Occurred()) SWIG_fail;
32235 }
32236 {
32237 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32238 }
32239 return resultobj;
32240 fail:
32241 return NULL;
32242 }
32243
32244
32245 SWIGINTERN PyObject *_wrap_Window_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32246 PyObject *resultobj = 0;
32247 wxWindow *arg1 = (wxWindow *) 0 ;
32248 bool result;
32249 void *argp1 = 0 ;
32250 int res1 = 0 ;
32251 PyObject *swig_obj[1] ;
32252
32253 if (!args) SWIG_fail;
32254 swig_obj[0] = args;
32255 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32256 if (!SWIG_IsOK(res1)) {
32257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
32258 }
32259 arg1 = reinterpret_cast< wxWindow * >(argp1);
32260 {
32261 PyThreadState* __tstate = wxPyBeginAllowThreads();
32262 result = (bool)((wxWindow const *)arg1)->IsEnabled();
32263 wxPyEndAllowThreads(__tstate);
32264 if (PyErr_Occurred()) SWIG_fail;
32265 }
32266 {
32267 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32268 }
32269 return resultobj;
32270 fail:
32271 return NULL;
32272 }
32273
32274
32275 SWIGINTERN PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32276 PyObject *resultobj = 0;
32277 wxWindow *arg1 = (wxWindow *) 0 ;
32278 long arg2 ;
32279 void *argp1 = 0 ;
32280 int res1 = 0 ;
32281 long val2 ;
32282 int ecode2 = 0 ;
32283 PyObject * obj0 = 0 ;
32284 PyObject * obj1 = 0 ;
32285 char * kwnames[] = {
32286 (char *) "self",(char *) "style", NULL
32287 };
32288
32289 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) SWIG_fail;
32290 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32291 if (!SWIG_IsOK(res1)) {
32292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow *""'");
32293 }
32294 arg1 = reinterpret_cast< wxWindow * >(argp1);
32295 ecode2 = SWIG_AsVal_long(obj1, &val2);
32296 if (!SWIG_IsOK(ecode2)) {
32297 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "2"" of type '" "long""'");
32298 }
32299 arg2 = static_cast< long >(val2);
32300 {
32301 PyThreadState* __tstate = wxPyBeginAllowThreads();
32302 (arg1)->SetWindowStyleFlag(arg2);
32303 wxPyEndAllowThreads(__tstate);
32304 if (PyErr_Occurred()) SWIG_fail;
32305 }
32306 resultobj = SWIG_Py_Void();
32307 return resultobj;
32308 fail:
32309 return NULL;
32310 }
32311
32312
32313 SWIGINTERN PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32314 PyObject *resultobj = 0;
32315 wxWindow *arg1 = (wxWindow *) 0 ;
32316 long result;
32317 void *argp1 = 0 ;
32318 int res1 = 0 ;
32319 PyObject *swig_obj[1] ;
32320
32321 if (!args) SWIG_fail;
32322 swig_obj[0] = args;
32323 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32324 if (!SWIG_IsOK(res1)) {
32325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
32326 }
32327 arg1 = reinterpret_cast< wxWindow * >(argp1);
32328 {
32329 PyThreadState* __tstate = wxPyBeginAllowThreads();
32330 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
32331 wxPyEndAllowThreads(__tstate);
32332 if (PyErr_Occurred()) SWIG_fail;
32333 }
32334 resultobj = SWIG_From_long(static_cast< long >(result));
32335 return resultobj;
32336 fail:
32337 return NULL;
32338 }
32339
32340
32341 SWIGINTERN PyObject *_wrap_Window_HasFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32342 PyObject *resultobj = 0;
32343 wxWindow *arg1 = (wxWindow *) 0 ;
32344 int arg2 ;
32345 bool result;
32346 void *argp1 = 0 ;
32347 int res1 = 0 ;
32348 int val2 ;
32349 int ecode2 = 0 ;
32350 PyObject * obj0 = 0 ;
32351 PyObject * obj1 = 0 ;
32352 char * kwnames[] = {
32353 (char *) "self",(char *) "flag", NULL
32354 };
32355
32356 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) SWIG_fail;
32357 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32358 if (!SWIG_IsOK(res1)) {
32359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
32360 }
32361 arg1 = reinterpret_cast< wxWindow * >(argp1);
32362 ecode2 = SWIG_AsVal_int(obj1, &val2);
32363 if (!SWIG_IsOK(ecode2)) {
32364 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasFlag" "', expected argument " "2"" of type '" "int""'");
32365 }
32366 arg2 = static_cast< int >(val2);
32367 {
32368 PyThreadState* __tstate = wxPyBeginAllowThreads();
32369 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
32370 wxPyEndAllowThreads(__tstate);
32371 if (PyErr_Occurred()) SWIG_fail;
32372 }
32373 {
32374 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32375 }
32376 return resultobj;
32377 fail:
32378 return NULL;
32379 }
32380
32381
32382 SWIGINTERN PyObject *_wrap_Window_IsRetained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32383 PyObject *resultobj = 0;
32384 wxWindow *arg1 = (wxWindow *) 0 ;
32385 bool result;
32386 void *argp1 = 0 ;
32387 int res1 = 0 ;
32388 PyObject *swig_obj[1] ;
32389
32390 if (!args) SWIG_fail;
32391 swig_obj[0] = args;
32392 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32393 if (!SWIG_IsOK(res1)) {
32394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsRetained" "', expected argument " "1"" of type '" "wxWindow const *""'");
32395 }
32396 arg1 = reinterpret_cast< wxWindow * >(argp1);
32397 {
32398 PyThreadState* __tstate = wxPyBeginAllowThreads();
32399 result = (bool)((wxWindow const *)arg1)->IsRetained();
32400 wxPyEndAllowThreads(__tstate);
32401 if (PyErr_Occurred()) SWIG_fail;
32402 }
32403 {
32404 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32405 }
32406 return resultobj;
32407 fail:
32408 return NULL;
32409 }
32410
32411
32412 SWIGINTERN PyObject *_wrap_Window_SetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32413 PyObject *resultobj = 0;
32414 wxWindow *arg1 = (wxWindow *) 0 ;
32415 long arg2 ;
32416 void *argp1 = 0 ;
32417 int res1 = 0 ;
32418 long val2 ;
32419 int ecode2 = 0 ;
32420 PyObject * obj0 = 0 ;
32421 PyObject * obj1 = 0 ;
32422 char * kwnames[] = {
32423 (char *) "self",(char *) "exStyle", NULL
32424 };
32425
32426 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) SWIG_fail;
32427 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32428 if (!SWIG_IsOK(res1)) {
32429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetExtraStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
32430 }
32431 arg1 = reinterpret_cast< wxWindow * >(argp1);
32432 ecode2 = SWIG_AsVal_long(obj1, &val2);
32433 if (!SWIG_IsOK(ecode2)) {
32434 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetExtraStyle" "', expected argument " "2"" of type '" "long""'");
32435 }
32436 arg2 = static_cast< long >(val2);
32437 {
32438 PyThreadState* __tstate = wxPyBeginAllowThreads();
32439 (arg1)->SetExtraStyle(arg2);
32440 wxPyEndAllowThreads(__tstate);
32441 if (PyErr_Occurred()) SWIG_fail;
32442 }
32443 resultobj = SWIG_Py_Void();
32444 return resultobj;
32445 fail:
32446 return NULL;
32447 }
32448
32449
32450 SWIGINTERN PyObject *_wrap_Window_GetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32451 PyObject *resultobj = 0;
32452 wxWindow *arg1 = (wxWindow *) 0 ;
32453 long result;
32454 void *argp1 = 0 ;
32455 int res1 = 0 ;
32456 PyObject *swig_obj[1] ;
32457
32458 if (!args) SWIG_fail;
32459 swig_obj[0] = args;
32460 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32461 if (!SWIG_IsOK(res1)) {
32462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetExtraStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
32463 }
32464 arg1 = reinterpret_cast< wxWindow * >(argp1);
32465 {
32466 PyThreadState* __tstate = wxPyBeginAllowThreads();
32467 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
32468 wxPyEndAllowThreads(__tstate);
32469 if (PyErr_Occurred()) SWIG_fail;
32470 }
32471 resultobj = SWIG_From_long(static_cast< long >(result));
32472 return resultobj;
32473 fail:
32474 return NULL;
32475 }
32476
32477
32478 SWIGINTERN PyObject *_wrap_Window_MakeModal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32479 PyObject *resultobj = 0;
32480 wxWindow *arg1 = (wxWindow *) 0 ;
32481 bool arg2 = (bool) true ;
32482 void *argp1 = 0 ;
32483 int res1 = 0 ;
32484 bool val2 ;
32485 int ecode2 = 0 ;
32486 PyObject * obj0 = 0 ;
32487 PyObject * obj1 = 0 ;
32488 char * kwnames[] = {
32489 (char *) "self",(char *) "modal", NULL
32490 };
32491
32492 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) SWIG_fail;
32493 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32494 if (!SWIG_IsOK(res1)) {
32495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MakeModal" "', expected argument " "1"" of type '" "wxWindow *""'");
32496 }
32497 arg1 = reinterpret_cast< wxWindow * >(argp1);
32498 if (obj1) {
32499 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32500 if (!SWIG_IsOK(ecode2)) {
32501 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MakeModal" "', expected argument " "2"" of type '" "bool""'");
32502 }
32503 arg2 = static_cast< bool >(val2);
32504 }
32505 {
32506 PyThreadState* __tstate = wxPyBeginAllowThreads();
32507 (arg1)->MakeModal(arg2);
32508 wxPyEndAllowThreads(__tstate);
32509 if (PyErr_Occurred()) SWIG_fail;
32510 }
32511 resultobj = SWIG_Py_Void();
32512 return resultobj;
32513 fail:
32514 return NULL;
32515 }
32516
32517
32518 SWIGINTERN PyObject *_wrap_Window_SetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32519 PyObject *resultobj = 0;
32520 wxWindow *arg1 = (wxWindow *) 0 ;
32521 bool arg2 ;
32522 void *argp1 = 0 ;
32523 int res1 = 0 ;
32524 bool val2 ;
32525 int ecode2 = 0 ;
32526 PyObject * obj0 = 0 ;
32527 PyObject * obj1 = 0 ;
32528 char * kwnames[] = {
32529 (char *) "self",(char *) "enableTheme", NULL
32530 };
32531
32532 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
32533 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32534 if (!SWIG_IsOK(res1)) {
32535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow *""'");
32536 }
32537 arg1 = reinterpret_cast< wxWindow * >(argp1);
32538 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32539 if (!SWIG_IsOK(ecode2)) {
32540 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetThemeEnabled" "', expected argument " "2"" of type '" "bool""'");
32541 }
32542 arg2 = static_cast< bool >(val2);
32543 {
32544 PyThreadState* __tstate = wxPyBeginAllowThreads();
32545 (arg1)->SetThemeEnabled(arg2);
32546 wxPyEndAllowThreads(__tstate);
32547 if (PyErr_Occurred()) SWIG_fail;
32548 }
32549 resultobj = SWIG_Py_Void();
32550 return resultobj;
32551 fail:
32552 return NULL;
32553 }
32554
32555
32556 SWIGINTERN PyObject *_wrap_Window_GetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32557 PyObject *resultobj = 0;
32558 wxWindow *arg1 = (wxWindow *) 0 ;
32559 bool result;
32560 void *argp1 = 0 ;
32561 int res1 = 0 ;
32562 PyObject *swig_obj[1] ;
32563
32564 if (!args) SWIG_fail;
32565 swig_obj[0] = args;
32566 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32567 if (!SWIG_IsOK(res1)) {
32568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
32569 }
32570 arg1 = reinterpret_cast< wxWindow * >(argp1);
32571 {
32572 PyThreadState* __tstate = wxPyBeginAllowThreads();
32573 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
32574 wxPyEndAllowThreads(__tstate);
32575 if (PyErr_Occurred()) SWIG_fail;
32576 }
32577 {
32578 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32579 }
32580 return resultobj;
32581 fail:
32582 return NULL;
32583 }
32584
32585
32586 SWIGINTERN PyObject *_wrap_Window_SetFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32587 PyObject *resultobj = 0;
32588 wxWindow *arg1 = (wxWindow *) 0 ;
32589 void *argp1 = 0 ;
32590 int res1 = 0 ;
32591 PyObject *swig_obj[1] ;
32592
32593 if (!args) SWIG_fail;
32594 swig_obj[0] = args;
32595 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32596 if (!SWIG_IsOK(res1)) {
32597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocus" "', expected argument " "1"" of type '" "wxWindow *""'");
32598 }
32599 arg1 = reinterpret_cast< wxWindow * >(argp1);
32600 {
32601 PyThreadState* __tstate = wxPyBeginAllowThreads();
32602 (arg1)->SetFocus();
32603 wxPyEndAllowThreads(__tstate);
32604 if (PyErr_Occurred()) SWIG_fail;
32605 }
32606 resultobj = SWIG_Py_Void();
32607 return resultobj;
32608 fail:
32609 return NULL;
32610 }
32611
32612
32613 SWIGINTERN PyObject *_wrap_Window_SetFocusFromKbd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32614 PyObject *resultobj = 0;
32615 wxWindow *arg1 = (wxWindow *) 0 ;
32616 void *argp1 = 0 ;
32617 int res1 = 0 ;
32618 PyObject *swig_obj[1] ;
32619
32620 if (!args) SWIG_fail;
32621 swig_obj[0] = args;
32622 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32623 if (!SWIG_IsOK(res1)) {
32624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocusFromKbd" "', expected argument " "1"" of type '" "wxWindow *""'");
32625 }
32626 arg1 = reinterpret_cast< wxWindow * >(argp1);
32627 {
32628 PyThreadState* __tstate = wxPyBeginAllowThreads();
32629 (arg1)->SetFocusFromKbd();
32630 wxPyEndAllowThreads(__tstate);
32631 if (PyErr_Occurred()) SWIG_fail;
32632 }
32633 resultobj = SWIG_Py_Void();
32634 return resultobj;
32635 fail:
32636 return NULL;
32637 }
32638
32639
32640 SWIGINTERN PyObject *_wrap_Window_FindFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32641 PyObject *resultobj = 0;
32642 wxWindow *result = 0 ;
32643
32644 if (!SWIG_Python_UnpackTuple(args,"Window_FindFocus",0,0,0)) SWIG_fail;
32645 {
32646 if (!wxPyCheckForApp()) SWIG_fail;
32647 PyThreadState* __tstate = wxPyBeginAllowThreads();
32648 result = (wxWindow *)wxWindow::FindFocus();
32649 wxPyEndAllowThreads(__tstate);
32650 if (PyErr_Occurred()) SWIG_fail;
32651 }
32652 {
32653 resultobj = wxPyMake_wxObject(result, 0);
32654 }
32655 return resultobj;
32656 fail:
32657 return NULL;
32658 }
32659
32660
32661 SWIGINTERN PyObject *_wrap_Window_AcceptsFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32662 PyObject *resultobj = 0;
32663 wxWindow *arg1 = (wxWindow *) 0 ;
32664 bool result;
32665 void *argp1 = 0 ;
32666 int res1 = 0 ;
32667 PyObject *swig_obj[1] ;
32668
32669 if (!args) SWIG_fail;
32670 swig_obj[0] = args;
32671 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32672 if (!SWIG_IsOK(res1)) {
32673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
32674 }
32675 arg1 = reinterpret_cast< wxWindow * >(argp1);
32676 {
32677 PyThreadState* __tstate = wxPyBeginAllowThreads();
32678 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
32679 wxPyEndAllowThreads(__tstate);
32680 if (PyErr_Occurred()) SWIG_fail;
32681 }
32682 {
32683 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32684 }
32685 return resultobj;
32686 fail:
32687 return NULL;
32688 }
32689
32690
32691 SWIGINTERN PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32692 PyObject *resultobj = 0;
32693 wxWindow *arg1 = (wxWindow *) 0 ;
32694 bool result;
32695 void *argp1 = 0 ;
32696 int res1 = 0 ;
32697 PyObject *swig_obj[1] ;
32698
32699 if (!args) SWIG_fail;
32700 swig_obj[0] = args;
32701 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32702 if (!SWIG_IsOK(res1)) {
32703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
32704 }
32705 arg1 = reinterpret_cast< wxWindow * >(argp1);
32706 {
32707 PyThreadState* __tstate = wxPyBeginAllowThreads();
32708 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
32709 wxPyEndAllowThreads(__tstate);
32710 if (PyErr_Occurred()) SWIG_fail;
32711 }
32712 {
32713 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32714 }
32715 return resultobj;
32716 fail:
32717 return NULL;
32718 }
32719
32720
32721 SWIGINTERN PyObject *_wrap_Window_GetDefaultItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32722 PyObject *resultobj = 0;
32723 wxWindow *arg1 = (wxWindow *) 0 ;
32724 wxWindow *result = 0 ;
32725 void *argp1 = 0 ;
32726 int res1 = 0 ;
32727 PyObject *swig_obj[1] ;
32728
32729 if (!args) SWIG_fail;
32730 swig_obj[0] = args;
32731 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32732 if (!SWIG_IsOK(res1)) {
32733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultItem" "', expected argument " "1"" of type '" "wxWindow const *""'");
32734 }
32735 arg1 = reinterpret_cast< wxWindow * >(argp1);
32736 {
32737 PyThreadState* __tstate = wxPyBeginAllowThreads();
32738 result = (wxWindow *)((wxWindow const *)arg1)->GetDefaultItem();
32739 wxPyEndAllowThreads(__tstate);
32740 if (PyErr_Occurred()) SWIG_fail;
32741 }
32742 {
32743 resultobj = wxPyMake_wxObject(result, 0);
32744 }
32745 return resultobj;
32746 fail:
32747 return NULL;
32748 }
32749
32750
32751 SWIGINTERN PyObject *_wrap_Window_SetDefaultItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32752 PyObject *resultobj = 0;
32753 wxWindow *arg1 = (wxWindow *) 0 ;
32754 wxWindow *arg2 = (wxWindow *) 0 ;
32755 wxWindow *result = 0 ;
32756 void *argp1 = 0 ;
32757 int res1 = 0 ;
32758 void *argp2 = 0 ;
32759 int res2 = 0 ;
32760 PyObject * obj0 = 0 ;
32761 PyObject * obj1 = 0 ;
32762 char * kwnames[] = {
32763 (char *) "self",(char *) "child", NULL
32764 };
32765
32766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDefaultItem",kwnames,&obj0,&obj1)) SWIG_fail;
32767 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32768 if (!SWIG_IsOK(res1)) {
32769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDefaultItem" "', expected argument " "1"" of type '" "wxWindow *""'");
32770 }
32771 arg1 = reinterpret_cast< wxWindow * >(argp1);
32772 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32773 if (!SWIG_IsOK(res2)) {
32774 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDefaultItem" "', expected argument " "2"" of type '" "wxWindow *""'");
32775 }
32776 arg2 = reinterpret_cast< wxWindow * >(argp2);
32777 {
32778 PyThreadState* __tstate = wxPyBeginAllowThreads();
32779 result = (wxWindow *)(arg1)->SetDefaultItem(arg2);
32780 wxPyEndAllowThreads(__tstate);
32781 if (PyErr_Occurred()) SWIG_fail;
32782 }
32783 {
32784 resultobj = wxPyMake_wxObject(result, 0);
32785 }
32786 return resultobj;
32787 fail:
32788 return NULL;
32789 }
32790
32791
32792 SWIGINTERN PyObject *_wrap_Window_SetTmpDefaultItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32793 PyObject *resultobj = 0;
32794 wxWindow *arg1 = (wxWindow *) 0 ;
32795 wxWindow *arg2 = (wxWindow *) 0 ;
32796 void *argp1 = 0 ;
32797 int res1 = 0 ;
32798 void *argp2 = 0 ;
32799 int res2 = 0 ;
32800 PyObject * obj0 = 0 ;
32801 PyObject * obj1 = 0 ;
32802 char * kwnames[] = {
32803 (char *) "self",(char *) "win", NULL
32804 };
32805
32806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTmpDefaultItem",kwnames,&obj0,&obj1)) SWIG_fail;
32807 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32808 if (!SWIG_IsOK(res1)) {
32809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetTmpDefaultItem" "', expected argument " "1"" of type '" "wxWindow *""'");
32810 }
32811 arg1 = reinterpret_cast< wxWindow * >(argp1);
32812 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32813 if (!SWIG_IsOK(res2)) {
32814 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetTmpDefaultItem" "', expected argument " "2"" of type '" "wxWindow *""'");
32815 }
32816 arg2 = reinterpret_cast< wxWindow * >(argp2);
32817 {
32818 PyThreadState* __tstate = wxPyBeginAllowThreads();
32819 (arg1)->SetTmpDefaultItem(arg2);
32820 wxPyEndAllowThreads(__tstate);
32821 if (PyErr_Occurred()) SWIG_fail;
32822 }
32823 resultobj = SWIG_Py_Void();
32824 return resultobj;
32825 fail:
32826 return NULL;
32827 }
32828
32829
32830 SWIGINTERN PyObject *_wrap_Window_Navigate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32831 PyObject *resultobj = 0;
32832 wxWindow *arg1 = (wxWindow *) 0 ;
32833 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
32834 bool result;
32835 void *argp1 = 0 ;
32836 int res1 = 0 ;
32837 int val2 ;
32838 int ecode2 = 0 ;
32839 PyObject * obj0 = 0 ;
32840 PyObject * obj1 = 0 ;
32841 char * kwnames[] = {
32842 (char *) "self",(char *) "flags", NULL
32843 };
32844
32845 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) SWIG_fail;
32846 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32847 if (!SWIG_IsOK(res1)) {
32848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Navigate" "', expected argument " "1"" of type '" "wxWindow *""'");
32849 }
32850 arg1 = reinterpret_cast< wxWindow * >(argp1);
32851 if (obj1) {
32852 ecode2 = SWIG_AsVal_int(obj1, &val2);
32853 if (!SWIG_IsOK(ecode2)) {
32854 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Navigate" "', expected argument " "2"" of type '" "int""'");
32855 }
32856 arg2 = static_cast< int >(val2);
32857 }
32858 {
32859 PyThreadState* __tstate = wxPyBeginAllowThreads();
32860 result = (bool)(arg1)->Navigate(arg2);
32861 wxPyEndAllowThreads(__tstate);
32862 if (PyErr_Occurred()) SWIG_fail;
32863 }
32864 {
32865 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32866 }
32867 return resultobj;
32868 fail:
32869 return NULL;
32870 }
32871
32872
32873 SWIGINTERN PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32874 PyObject *resultobj = 0;
32875 wxWindow *arg1 = (wxWindow *) 0 ;
32876 wxWindow *arg2 = (wxWindow *) 0 ;
32877 void *argp1 = 0 ;
32878 int res1 = 0 ;
32879 void *argp2 = 0 ;
32880 int res2 = 0 ;
32881 PyObject * obj0 = 0 ;
32882 PyObject * obj1 = 0 ;
32883 char * kwnames[] = {
32884 (char *) "self",(char *) "win", NULL
32885 };
32886
32887 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
32888 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32889 if (!SWIG_IsOK(res1)) {
32890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
32891 }
32892 arg1 = reinterpret_cast< wxWindow * >(argp1);
32893 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32894 if (!SWIG_IsOK(res2)) {
32895 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
32896 }
32897 arg2 = reinterpret_cast< wxWindow * >(argp2);
32898 {
32899 PyThreadState* __tstate = wxPyBeginAllowThreads();
32900 (arg1)->MoveAfterInTabOrder(arg2);
32901 wxPyEndAllowThreads(__tstate);
32902 if (PyErr_Occurred()) SWIG_fail;
32903 }
32904 resultobj = SWIG_Py_Void();
32905 return resultobj;
32906 fail:
32907 return NULL;
32908 }
32909
32910
32911 SWIGINTERN PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32912 PyObject *resultobj = 0;
32913 wxWindow *arg1 = (wxWindow *) 0 ;
32914 wxWindow *arg2 = (wxWindow *) 0 ;
32915 void *argp1 = 0 ;
32916 int res1 = 0 ;
32917 void *argp2 = 0 ;
32918 int res2 = 0 ;
32919 PyObject * obj0 = 0 ;
32920 PyObject * obj1 = 0 ;
32921 char * kwnames[] = {
32922 (char *) "self",(char *) "win", NULL
32923 };
32924
32925 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
32926 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32927 if (!SWIG_IsOK(res1)) {
32928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
32929 }
32930 arg1 = reinterpret_cast< wxWindow * >(argp1);
32931 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32932 if (!SWIG_IsOK(res2)) {
32933 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
32934 }
32935 arg2 = reinterpret_cast< wxWindow * >(argp2);
32936 {
32937 PyThreadState* __tstate = wxPyBeginAllowThreads();
32938 (arg1)->MoveBeforeInTabOrder(arg2);
32939 wxPyEndAllowThreads(__tstate);
32940 if (PyErr_Occurred()) SWIG_fail;
32941 }
32942 resultobj = SWIG_Py_Void();
32943 return resultobj;
32944 fail:
32945 return NULL;
32946 }
32947
32948
32949 SWIGINTERN PyObject *_wrap_Window_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32950 PyObject *resultobj = 0;
32951 wxWindow *arg1 = (wxWindow *) 0 ;
32952 PyObject *result = 0 ;
32953 void *argp1 = 0 ;
32954 int res1 = 0 ;
32955 PyObject *swig_obj[1] ;
32956
32957 if (!args) SWIG_fail;
32958 swig_obj[0] = args;
32959 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32960 if (!SWIG_IsOK(res1)) {
32961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
32962 }
32963 arg1 = reinterpret_cast< wxWindow * >(argp1);
32964 {
32965 PyThreadState* __tstate = wxPyBeginAllowThreads();
32966 result = (PyObject *)wxWindow_GetChildren(arg1);
32967 wxPyEndAllowThreads(__tstate);
32968 if (PyErr_Occurred()) SWIG_fail;
32969 }
32970 resultobj = result;
32971 return resultobj;
32972 fail:
32973 return NULL;
32974 }
32975
32976
32977 SWIGINTERN PyObject *_wrap_Window_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32978 PyObject *resultobj = 0;
32979 wxWindow *arg1 = (wxWindow *) 0 ;
32980 wxWindow *result = 0 ;
32981 void *argp1 = 0 ;
32982 int res1 = 0 ;
32983 PyObject *swig_obj[1] ;
32984
32985 if (!args) SWIG_fail;
32986 swig_obj[0] = args;
32987 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32988 if (!SWIG_IsOK(res1)) {
32989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
32990 }
32991 arg1 = reinterpret_cast< wxWindow * >(argp1);
32992 {
32993 PyThreadState* __tstate = wxPyBeginAllowThreads();
32994 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
32995 wxPyEndAllowThreads(__tstate);
32996 if (PyErr_Occurred()) SWIG_fail;
32997 }
32998 {
32999 resultobj = wxPyMake_wxObject(result, 0);
33000 }
33001 return resultobj;
33002 fail:
33003 return NULL;
33004 }
33005
33006
33007 SWIGINTERN PyObject *_wrap_Window_GetGrandParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33008 PyObject *resultobj = 0;
33009 wxWindow *arg1 = (wxWindow *) 0 ;
33010 wxWindow *result = 0 ;
33011 void *argp1 = 0 ;
33012 int res1 = 0 ;
33013 PyObject *swig_obj[1] ;
33014
33015 if (!args) SWIG_fail;
33016 swig_obj[0] = args;
33017 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33018 if (!SWIG_IsOK(res1)) {
33019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetGrandParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
33020 }
33021 arg1 = reinterpret_cast< wxWindow * >(argp1);
33022 {
33023 PyThreadState* __tstate = wxPyBeginAllowThreads();
33024 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
33025 wxPyEndAllowThreads(__tstate);
33026 if (PyErr_Occurred()) SWIG_fail;
33027 }
33028 {
33029 resultobj = wxPyMake_wxObject(result, 0);
33030 }
33031 return resultobj;
33032 fail:
33033 return NULL;
33034 }
33035
33036
33037 SWIGINTERN PyObject *_wrap_Window_IsTopLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33038 PyObject *resultobj = 0;
33039 wxWindow *arg1 = (wxWindow *) 0 ;
33040 bool result;
33041 void *argp1 = 0 ;
33042 int res1 = 0 ;
33043 PyObject *swig_obj[1] ;
33044
33045 if (!args) SWIG_fail;
33046 swig_obj[0] = args;
33047 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33048 if (!SWIG_IsOK(res1)) {
33049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsTopLevel" "', expected argument " "1"" of type '" "wxWindow const *""'");
33050 }
33051 arg1 = reinterpret_cast< wxWindow * >(argp1);
33052 {
33053 PyThreadState* __tstate = wxPyBeginAllowThreads();
33054 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
33055 wxPyEndAllowThreads(__tstate);
33056 if (PyErr_Occurred()) SWIG_fail;
33057 }
33058 {
33059 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33060 }
33061 return resultobj;
33062 fail:
33063 return NULL;
33064 }
33065
33066
33067 SWIGINTERN PyObject *_wrap_Window_Reparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33068 PyObject *resultobj = 0;
33069 wxWindow *arg1 = (wxWindow *) 0 ;
33070 wxWindow *arg2 = (wxWindow *) 0 ;
33071 bool result;
33072 void *argp1 = 0 ;
33073 int res1 = 0 ;
33074 void *argp2 = 0 ;
33075 int res2 = 0 ;
33076 PyObject * obj0 = 0 ;
33077 PyObject * obj1 = 0 ;
33078 char * kwnames[] = {
33079 (char *) "self",(char *) "newParent", NULL
33080 };
33081
33082 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) SWIG_fail;
33083 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33084 if (!SWIG_IsOK(res1)) {
33085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Reparent" "', expected argument " "1"" of type '" "wxWindow *""'");
33086 }
33087 arg1 = reinterpret_cast< wxWindow * >(argp1);
33088 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33089 if (!SWIG_IsOK(res2)) {
33090 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Reparent" "', expected argument " "2"" of type '" "wxWindow *""'");
33091 }
33092 arg2 = reinterpret_cast< wxWindow * >(argp2);
33093 {
33094 PyThreadState* __tstate = wxPyBeginAllowThreads();
33095 result = (bool)(arg1)->Reparent(arg2);
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_AddChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33109 PyObject *resultobj = 0;
33110 wxWindow *arg1 = (wxWindow *) 0 ;
33111 wxWindow *arg2 = (wxWindow *) 0 ;
33112 void *argp1 = 0 ;
33113 int res1 = 0 ;
33114 void *argp2 = 0 ;
33115 int res2 = 0 ;
33116 PyObject * obj0 = 0 ;
33117 PyObject * obj1 = 0 ;
33118 char * kwnames[] = {
33119 (char *) "self",(char *) "child", NULL
33120 };
33121
33122 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) SWIG_fail;
33123 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33124 if (!SWIG_IsOK(res1)) {
33125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AddChild" "', expected argument " "1"" of type '" "wxWindow *""'");
33126 }
33127 arg1 = reinterpret_cast< wxWindow * >(argp1);
33128 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33129 if (!SWIG_IsOK(res2)) {
33130 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_AddChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33131 }
33132 arg2 = reinterpret_cast< wxWindow * >(argp2);
33133 {
33134 PyThreadState* __tstate = wxPyBeginAllowThreads();
33135 (arg1)->AddChild(arg2);
33136 wxPyEndAllowThreads(__tstate);
33137 if (PyErr_Occurred()) SWIG_fail;
33138 }
33139 resultobj = SWIG_Py_Void();
33140 return resultobj;
33141 fail:
33142 return NULL;
33143 }
33144
33145
33146 SWIGINTERN PyObject *_wrap_Window_RemoveChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33147 PyObject *resultobj = 0;
33148 wxWindow *arg1 = (wxWindow *) 0 ;
33149 wxWindow *arg2 = (wxWindow *) 0 ;
33150 void *argp1 = 0 ;
33151 int res1 = 0 ;
33152 void *argp2 = 0 ;
33153 int res2 = 0 ;
33154 PyObject * obj0 = 0 ;
33155 PyObject * obj1 = 0 ;
33156 char * kwnames[] = {
33157 (char *) "self",(char *) "child", NULL
33158 };
33159
33160 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) SWIG_fail;
33161 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33162 if (!SWIG_IsOK(res1)) {
33163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveChild" "', expected argument " "1"" of type '" "wxWindow *""'");
33164 }
33165 arg1 = reinterpret_cast< wxWindow * >(argp1);
33166 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33167 if (!SWIG_IsOK(res2)) {
33168 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33169 }
33170 arg2 = reinterpret_cast< wxWindow * >(argp2);
33171 {
33172 PyThreadState* __tstate = wxPyBeginAllowThreads();
33173 (arg1)->RemoveChild(arg2);
33174 wxPyEndAllowThreads(__tstate);
33175 if (PyErr_Occurred()) SWIG_fail;
33176 }
33177 resultobj = SWIG_Py_Void();
33178 return resultobj;
33179 fail:
33180 return NULL;
33181 }
33182
33183
33184 SWIGINTERN PyObject *_wrap_Window_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33185 PyObject *resultobj = 0;
33186 wxWindow *arg1 = (wxWindow *) 0 ;
33187 long arg2 ;
33188 wxWindow *result = 0 ;
33189 void *argp1 = 0 ;
33190 int res1 = 0 ;
33191 long val2 ;
33192 int ecode2 = 0 ;
33193 PyObject * obj0 = 0 ;
33194 PyObject * obj1 = 0 ;
33195 char * kwnames[] = {
33196 (char *) "self",(char *) "winid", NULL
33197 };
33198
33199 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
33200 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33201 if (!SWIG_IsOK(res1)) {
33202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowById" "', expected argument " "1"" of type '" "wxWindow *""'");
33203 }
33204 arg1 = reinterpret_cast< wxWindow * >(argp1);
33205 ecode2 = SWIG_AsVal_long(obj1, &val2);
33206 if (!SWIG_IsOK(ecode2)) {
33207 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FindWindowById" "', expected argument " "2"" of type '" "long""'");
33208 }
33209 arg2 = static_cast< long >(val2);
33210 {
33211 PyThreadState* __tstate = wxPyBeginAllowThreads();
33212 result = (wxWindow *)(arg1)->FindWindow(arg2);
33213 wxPyEndAllowThreads(__tstate);
33214 if (PyErr_Occurred()) SWIG_fail;
33215 }
33216 {
33217 resultobj = wxPyMake_wxObject(result, 0);
33218 }
33219 return resultobj;
33220 fail:
33221 return NULL;
33222 }
33223
33224
33225 SWIGINTERN PyObject *_wrap_Window_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33226 PyObject *resultobj = 0;
33227 wxWindow *arg1 = (wxWindow *) 0 ;
33228 wxString *arg2 = 0 ;
33229 wxWindow *result = 0 ;
33230 void *argp1 = 0 ;
33231 int res1 = 0 ;
33232 bool temp2 = false ;
33233 PyObject * obj0 = 0 ;
33234 PyObject * obj1 = 0 ;
33235 char * kwnames[] = {
33236 (char *) "self",(char *) "name", NULL
33237 };
33238
33239 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",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_FindWindowByName" "', expected argument " "1"" of type '" "wxWindow *""'");
33243 }
33244 arg1 = reinterpret_cast< wxWindow * >(argp1);
33245 {
33246 arg2 = wxString_in_helper(obj1);
33247 if (arg2 == NULL) SWIG_fail;
33248 temp2 = true;
33249 }
33250 {
33251 PyThreadState* __tstate = wxPyBeginAllowThreads();
33252 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
33253 wxPyEndAllowThreads(__tstate);
33254 if (PyErr_Occurred()) SWIG_fail;
33255 }
33256 {
33257 resultobj = wxPyMake_wxObject(result, 0);
33258 }
33259 {
33260 if (temp2)
33261 delete arg2;
33262 }
33263 return resultobj;
33264 fail:
33265 {
33266 if (temp2)
33267 delete arg2;
33268 }
33269 return NULL;
33270 }
33271
33272
33273 SWIGINTERN PyObject *_wrap_Window_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33274 PyObject *resultobj = 0;
33275 wxWindow *arg1 = (wxWindow *) 0 ;
33276 wxEvtHandler *result = 0 ;
33277 void *argp1 = 0 ;
33278 int res1 = 0 ;
33279 PyObject *swig_obj[1] ;
33280
33281 if (!args) SWIG_fail;
33282 swig_obj[0] = args;
33283 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33284 if (!SWIG_IsOK(res1)) {
33285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEventHandler" "', expected argument " "1"" of type '" "wxWindow const *""'");
33286 }
33287 arg1 = reinterpret_cast< wxWindow * >(argp1);
33288 {
33289 PyThreadState* __tstate = wxPyBeginAllowThreads();
33290 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
33291 wxPyEndAllowThreads(__tstate);
33292 if (PyErr_Occurred()) SWIG_fail;
33293 }
33294 {
33295 resultobj = wxPyMake_wxObject(result, 0);
33296 }
33297 return resultobj;
33298 fail:
33299 return NULL;
33300 }
33301
33302
33303 SWIGINTERN PyObject *_wrap_Window_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33304 PyObject *resultobj = 0;
33305 wxWindow *arg1 = (wxWindow *) 0 ;
33306 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33307 void *argp1 = 0 ;
33308 int res1 = 0 ;
33309 void *argp2 = 0 ;
33310 int res2 = 0 ;
33311 PyObject * obj0 = 0 ;
33312 PyObject * obj1 = 0 ;
33313 char * kwnames[] = {
33314 (char *) "self",(char *) "handler", NULL
33315 };
33316
33317 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33318 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33319 if (!SWIG_IsOK(res1)) {
33320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33321 }
33322 arg1 = reinterpret_cast< wxWindow * >(argp1);
33323 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33324 if (!SWIG_IsOK(res2)) {
33325 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33326 }
33327 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33328 {
33329 PyThreadState* __tstate = wxPyBeginAllowThreads();
33330 (arg1)->SetEventHandler(arg2);
33331 wxPyEndAllowThreads(__tstate);
33332 if (PyErr_Occurred()) SWIG_fail;
33333 }
33334 resultobj = SWIG_Py_Void();
33335 return resultobj;
33336 fail:
33337 return NULL;
33338 }
33339
33340
33341 SWIGINTERN PyObject *_wrap_Window_PushEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33342 PyObject *resultobj = 0;
33343 wxWindow *arg1 = (wxWindow *) 0 ;
33344 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33345 void *argp1 = 0 ;
33346 int res1 = 0 ;
33347 void *argp2 = 0 ;
33348 int res2 = 0 ;
33349 PyObject * obj0 = 0 ;
33350 PyObject * obj1 = 0 ;
33351 char * kwnames[] = {
33352 (char *) "self",(char *) "handler", NULL
33353 };
33354
33355 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33356 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33357 if (!SWIG_IsOK(res1)) {
33358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PushEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33359 }
33360 arg1 = reinterpret_cast< wxWindow * >(argp1);
33361 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33362 if (!SWIG_IsOK(res2)) {
33363 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PushEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33364 }
33365 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33366 {
33367 PyThreadState* __tstate = wxPyBeginAllowThreads();
33368 (arg1)->PushEventHandler(arg2);
33369 wxPyEndAllowThreads(__tstate);
33370 if (PyErr_Occurred()) SWIG_fail;
33371 }
33372 resultobj = SWIG_Py_Void();
33373 return resultobj;
33374 fail:
33375 return NULL;
33376 }
33377
33378
33379 SWIGINTERN PyObject *_wrap_Window_PopEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33380 PyObject *resultobj = 0;
33381 wxWindow *arg1 = (wxWindow *) 0 ;
33382 bool arg2 = (bool) false ;
33383 wxEvtHandler *result = 0 ;
33384 void *argp1 = 0 ;
33385 int res1 = 0 ;
33386 bool val2 ;
33387 int ecode2 = 0 ;
33388 PyObject * obj0 = 0 ;
33389 PyObject * obj1 = 0 ;
33390 char * kwnames[] = {
33391 (char *) "self",(char *) "deleteHandler", NULL
33392 };
33393
33394 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33395 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33396 if (!SWIG_IsOK(res1)) {
33397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33398 }
33399 arg1 = reinterpret_cast< wxWindow * >(argp1);
33400 if (obj1) {
33401 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33402 if (!SWIG_IsOK(ecode2)) {
33403 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_PopEventHandler" "', expected argument " "2"" of type '" "bool""'");
33404 }
33405 arg2 = static_cast< bool >(val2);
33406 }
33407 {
33408 PyThreadState* __tstate = wxPyBeginAllowThreads();
33409 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
33410 wxPyEndAllowThreads(__tstate);
33411 if (PyErr_Occurred()) SWIG_fail;
33412 }
33413 {
33414 resultobj = wxPyMake_wxObject(result, 0);
33415 }
33416 return resultobj;
33417 fail:
33418 return NULL;
33419 }
33420
33421
33422 SWIGINTERN PyObject *_wrap_Window_RemoveEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33423 PyObject *resultobj = 0;
33424 wxWindow *arg1 = (wxWindow *) 0 ;
33425 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33426 bool result;
33427 void *argp1 = 0 ;
33428 int res1 = 0 ;
33429 void *argp2 = 0 ;
33430 int res2 = 0 ;
33431 PyObject * obj0 = 0 ;
33432 PyObject * obj1 = 0 ;
33433 char * kwnames[] = {
33434 (char *) "self",(char *) "handler", NULL
33435 };
33436
33437 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33438 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33439 if (!SWIG_IsOK(res1)) {
33440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33441 }
33442 arg1 = reinterpret_cast< wxWindow * >(argp1);
33443 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33444 if (!SWIG_IsOK(res2)) {
33445 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33446 }
33447 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33448 {
33449 PyThreadState* __tstate = wxPyBeginAllowThreads();
33450 result = (bool)(arg1)->RemoveEventHandler(arg2);
33451 wxPyEndAllowThreads(__tstate);
33452 if (PyErr_Occurred()) SWIG_fail;
33453 }
33454 {
33455 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33456 }
33457 return resultobj;
33458 fail:
33459 return NULL;
33460 }
33461
33462
33463 SWIGINTERN PyObject *_wrap_Window_SetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33464 PyObject *resultobj = 0;
33465 wxWindow *arg1 = (wxWindow *) 0 ;
33466 wxValidator *arg2 = 0 ;
33467 void *argp1 = 0 ;
33468 int res1 = 0 ;
33469 void *argp2 = 0 ;
33470 int res2 = 0 ;
33471 PyObject * obj0 = 0 ;
33472 PyObject * obj1 = 0 ;
33473 char * kwnames[] = {
33474 (char *) "self",(char *) "validator", NULL
33475 };
33476
33477 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) SWIG_fail;
33478 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33479 if (!SWIG_IsOK(res1)) {
33480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
33481 }
33482 arg1 = reinterpret_cast< wxWindow * >(argp1);
33483 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxValidator, 0 | 0);
33484 if (!SWIG_IsOK(res2)) {
33485 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
33486 }
33487 if (!argp2) {
33488 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
33489 }
33490 arg2 = reinterpret_cast< wxValidator * >(argp2);
33491 {
33492 PyThreadState* __tstate = wxPyBeginAllowThreads();
33493 (arg1)->SetValidator((wxValidator const &)*arg2);
33494 wxPyEndAllowThreads(__tstate);
33495 if (PyErr_Occurred()) SWIG_fail;
33496 }
33497 resultobj = SWIG_Py_Void();
33498 return resultobj;
33499 fail:
33500 return NULL;
33501 }
33502
33503
33504 SWIGINTERN PyObject *_wrap_Window_GetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33505 PyObject *resultobj = 0;
33506 wxWindow *arg1 = (wxWindow *) 0 ;
33507 wxValidator *result = 0 ;
33508 void *argp1 = 0 ;
33509 int res1 = 0 ;
33510 PyObject *swig_obj[1] ;
33511
33512 if (!args) SWIG_fail;
33513 swig_obj[0] = args;
33514 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33515 if (!SWIG_IsOK(res1)) {
33516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
33517 }
33518 arg1 = reinterpret_cast< wxWindow * >(argp1);
33519 {
33520 PyThreadState* __tstate = wxPyBeginAllowThreads();
33521 result = (wxValidator *)(arg1)->GetValidator();
33522 wxPyEndAllowThreads(__tstate);
33523 if (PyErr_Occurred()) SWIG_fail;
33524 }
33525 {
33526 resultobj = wxPyMake_wxObject(result, (bool)0);
33527 }
33528 return resultobj;
33529 fail:
33530 return NULL;
33531 }
33532
33533
33534 SWIGINTERN PyObject *_wrap_Window_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33535 PyObject *resultobj = 0;
33536 wxWindow *arg1 = (wxWindow *) 0 ;
33537 bool result;
33538 void *argp1 = 0 ;
33539 int res1 = 0 ;
33540 PyObject *swig_obj[1] ;
33541
33542 if (!args) SWIG_fail;
33543 swig_obj[0] = args;
33544 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33545 if (!SWIG_IsOK(res1)) {
33546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Validate" "', expected argument " "1"" of type '" "wxWindow *""'");
33547 }
33548 arg1 = reinterpret_cast< wxWindow * >(argp1);
33549 {
33550 PyThreadState* __tstate = wxPyBeginAllowThreads();
33551 result = (bool)(arg1)->Validate();
33552 wxPyEndAllowThreads(__tstate);
33553 if (PyErr_Occurred()) SWIG_fail;
33554 }
33555 {
33556 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33557 }
33558 return resultobj;
33559 fail:
33560 return NULL;
33561 }
33562
33563
33564 SWIGINTERN PyObject *_wrap_Window_TransferDataToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33565 PyObject *resultobj = 0;
33566 wxWindow *arg1 = (wxWindow *) 0 ;
33567 bool result;
33568 void *argp1 = 0 ;
33569 int res1 = 0 ;
33570 PyObject *swig_obj[1] ;
33571
33572 if (!args) SWIG_fail;
33573 swig_obj[0] = args;
33574 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33575 if (!SWIG_IsOK(res1)) {
33576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataToWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
33577 }
33578 arg1 = reinterpret_cast< wxWindow * >(argp1);
33579 {
33580 PyThreadState* __tstate = wxPyBeginAllowThreads();
33581 result = (bool)(arg1)->TransferDataToWindow();
33582 wxPyEndAllowThreads(__tstate);
33583 if (PyErr_Occurred()) SWIG_fail;
33584 }
33585 {
33586 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33587 }
33588 return resultobj;
33589 fail:
33590 return NULL;
33591 }
33592
33593
33594 SWIGINTERN PyObject *_wrap_Window_TransferDataFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33595 PyObject *resultobj = 0;
33596 wxWindow *arg1 = (wxWindow *) 0 ;
33597 bool result;
33598 void *argp1 = 0 ;
33599 int res1 = 0 ;
33600 PyObject *swig_obj[1] ;
33601
33602 if (!args) SWIG_fail;
33603 swig_obj[0] = args;
33604 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33605 if (!SWIG_IsOK(res1)) {
33606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
33607 }
33608 arg1 = reinterpret_cast< wxWindow * >(argp1);
33609 {
33610 PyThreadState* __tstate = wxPyBeginAllowThreads();
33611 result = (bool)(arg1)->TransferDataFromWindow();
33612 wxPyEndAllowThreads(__tstate);
33613 if (PyErr_Occurred()) SWIG_fail;
33614 }
33615 {
33616 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33617 }
33618 return resultobj;
33619 fail:
33620 return NULL;
33621 }
33622
33623
33624 SWIGINTERN PyObject *_wrap_Window_InitDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33625 PyObject *resultobj = 0;
33626 wxWindow *arg1 = (wxWindow *) 0 ;
33627 void *argp1 = 0 ;
33628 int res1 = 0 ;
33629 PyObject *swig_obj[1] ;
33630
33631 if (!args) SWIG_fail;
33632 swig_obj[0] = args;
33633 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33634 if (!SWIG_IsOK(res1)) {
33635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InitDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
33636 }
33637 arg1 = reinterpret_cast< wxWindow * >(argp1);
33638 {
33639 PyThreadState* __tstate = wxPyBeginAllowThreads();
33640 (arg1)->InitDialog();
33641 wxPyEndAllowThreads(__tstate);
33642 if (PyErr_Occurred()) SWIG_fail;
33643 }
33644 resultobj = SWIG_Py_Void();
33645 return resultobj;
33646 fail:
33647 return NULL;
33648 }
33649
33650
33651 SWIGINTERN PyObject *_wrap_Window_SetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33652 PyObject *resultobj = 0;
33653 wxWindow *arg1 = (wxWindow *) 0 ;
33654 wxAcceleratorTable *arg2 = 0 ;
33655 void *argp1 = 0 ;
33656 int res1 = 0 ;
33657 void *argp2 = 0 ;
33658 int res2 = 0 ;
33659 PyObject * obj0 = 0 ;
33660 PyObject * obj1 = 0 ;
33661 char * kwnames[] = {
33662 (char *) "self",(char *) "accel", NULL
33663 };
33664
33665 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) SWIG_fail;
33666 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33667 if (!SWIG_IsOK(res1)) {
33668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
33669 }
33670 arg1 = reinterpret_cast< wxWindow * >(argp1);
33671 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAcceleratorTable, 0 | 0);
33672 if (!SWIG_IsOK(res2)) {
33673 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
33674 }
33675 if (!argp2) {
33676 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
33677 }
33678 arg2 = reinterpret_cast< wxAcceleratorTable * >(argp2);
33679 {
33680 PyThreadState* __tstate = wxPyBeginAllowThreads();
33681 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
33682 wxPyEndAllowThreads(__tstate);
33683 if (PyErr_Occurred()) SWIG_fail;
33684 }
33685 resultobj = SWIG_Py_Void();
33686 return resultobj;
33687 fail:
33688 return NULL;
33689 }
33690
33691
33692 SWIGINTERN PyObject *_wrap_Window_GetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33693 PyObject *resultobj = 0;
33694 wxWindow *arg1 = (wxWindow *) 0 ;
33695 wxAcceleratorTable *result = 0 ;
33696 void *argp1 = 0 ;
33697 int res1 = 0 ;
33698 PyObject *swig_obj[1] ;
33699
33700 if (!args) SWIG_fail;
33701 swig_obj[0] = args;
33702 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33703 if (!SWIG_IsOK(res1)) {
33704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
33705 }
33706 arg1 = reinterpret_cast< wxWindow * >(argp1);
33707 {
33708 PyThreadState* __tstate = wxPyBeginAllowThreads();
33709 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
33710 wxPyEndAllowThreads(__tstate);
33711 if (PyErr_Occurred()) SWIG_fail;
33712 }
33713 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
33714 return resultobj;
33715 fail:
33716 return NULL;
33717 }
33718
33719
33720 SWIGINTERN PyObject *_wrap_Window_RegisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33721 PyObject *resultobj = 0;
33722 wxWindow *arg1 = (wxWindow *) 0 ;
33723 int arg2 ;
33724 int arg3 ;
33725 int arg4 ;
33726 bool result;
33727 void *argp1 = 0 ;
33728 int res1 = 0 ;
33729 int val2 ;
33730 int ecode2 = 0 ;
33731 int val3 ;
33732 int ecode3 = 0 ;
33733 int val4 ;
33734 int ecode4 = 0 ;
33735 PyObject * obj0 = 0 ;
33736 PyObject * obj1 = 0 ;
33737 PyObject * obj2 = 0 ;
33738 PyObject * obj3 = 0 ;
33739 char * kwnames[] = {
33740 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
33741 };
33742
33743 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33744 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33745 if (!SWIG_IsOK(res1)) {
33746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RegisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
33747 }
33748 arg1 = reinterpret_cast< wxWindow * >(argp1);
33749 ecode2 = SWIG_AsVal_int(obj1, &val2);
33750 if (!SWIG_IsOK(ecode2)) {
33751 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_RegisterHotKey" "', expected argument " "2"" of type '" "int""'");
33752 }
33753 arg2 = static_cast< int >(val2);
33754 ecode3 = SWIG_AsVal_int(obj2, &val3);
33755 if (!SWIG_IsOK(ecode3)) {
33756 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RegisterHotKey" "', expected argument " "3"" of type '" "int""'");
33757 }
33758 arg3 = static_cast< int >(val3);
33759 ecode4 = SWIG_AsVal_int(obj3, &val4);
33760 if (!SWIG_IsOK(ecode4)) {
33761 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_RegisterHotKey" "', expected argument " "4"" of type '" "int""'");
33762 }
33763 arg4 = static_cast< int >(val4);
33764 {
33765 PyThreadState* __tstate = wxPyBeginAllowThreads();
33766 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
33767 wxPyEndAllowThreads(__tstate);
33768 if (PyErr_Occurred()) SWIG_fail;
33769 }
33770 {
33771 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33772 }
33773 return resultobj;
33774 fail:
33775 return NULL;
33776 }
33777
33778
33779 SWIGINTERN PyObject *_wrap_Window_UnregisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33780 PyObject *resultobj = 0;
33781 wxWindow *arg1 = (wxWindow *) 0 ;
33782 int arg2 ;
33783 bool result;
33784 void *argp1 = 0 ;
33785 int res1 = 0 ;
33786 int val2 ;
33787 int ecode2 = 0 ;
33788 PyObject * obj0 = 0 ;
33789 PyObject * obj1 = 0 ;
33790 char * kwnames[] = {
33791 (char *) "self",(char *) "hotkeyId", NULL
33792 };
33793
33794 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) SWIG_fail;
33795 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33796 if (!SWIG_IsOK(res1)) {
33797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UnregisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
33798 }
33799 arg1 = reinterpret_cast< wxWindow * >(argp1);
33800 ecode2 = SWIG_AsVal_int(obj1, &val2);
33801 if (!SWIG_IsOK(ecode2)) {
33802 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UnregisterHotKey" "', expected argument " "2"" of type '" "int""'");
33803 }
33804 arg2 = static_cast< int >(val2);
33805 {
33806 PyThreadState* __tstate = wxPyBeginAllowThreads();
33807 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
33808 wxPyEndAllowThreads(__tstate);
33809 if (PyErr_Occurred()) SWIG_fail;
33810 }
33811 {
33812 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33813 }
33814 return resultobj;
33815 fail:
33816 return NULL;
33817 }
33818
33819
33820 SWIGINTERN PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33821 PyObject *resultobj = 0;
33822 wxWindow *arg1 = (wxWindow *) 0 ;
33823 wxPoint *arg2 = 0 ;
33824 wxPoint result;
33825 void *argp1 = 0 ;
33826 int res1 = 0 ;
33827 wxPoint temp2 ;
33828 PyObject * obj0 = 0 ;
33829 PyObject * obj1 = 0 ;
33830 char * kwnames[] = {
33831 (char *) "self",(char *) "pt", NULL
33832 };
33833
33834 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
33835 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33836 if (!SWIG_IsOK(res1)) {
33837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogPointToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
33838 }
33839 arg1 = reinterpret_cast< wxWindow * >(argp1);
33840 {
33841 arg2 = &temp2;
33842 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
33843 }
33844 {
33845 PyThreadState* __tstate = wxPyBeginAllowThreads();
33846 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
33847 wxPyEndAllowThreads(__tstate);
33848 if (PyErr_Occurred()) SWIG_fail;
33849 }
33850 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
33851 return resultobj;
33852 fail:
33853 return NULL;
33854 }
33855
33856
33857 SWIGINTERN PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33858 PyObject *resultobj = 0;
33859 wxWindow *arg1 = (wxWindow *) 0 ;
33860 wxSize *arg2 = 0 ;
33861 wxSize result;
33862 void *argp1 = 0 ;
33863 int res1 = 0 ;
33864 wxSize temp2 ;
33865 PyObject * obj0 = 0 ;
33866 PyObject * obj1 = 0 ;
33867 char * kwnames[] = {
33868 (char *) "self",(char *) "sz", NULL
33869 };
33870
33871 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
33872 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33873 if (!SWIG_IsOK(res1)) {
33874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogSizeToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
33875 }
33876 arg1 = reinterpret_cast< wxWindow * >(argp1);
33877 {
33878 arg2 = &temp2;
33879 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33880 }
33881 {
33882 PyThreadState* __tstate = wxPyBeginAllowThreads();
33883 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
33884 wxPyEndAllowThreads(__tstate);
33885 if (PyErr_Occurred()) SWIG_fail;
33886 }
33887 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
33888 return resultobj;
33889 fail:
33890 return NULL;
33891 }
33892
33893
33894 SWIGINTERN PyObject *_wrap_Window_DLG_PNT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33895 PyObject *resultobj = 0;
33896 wxWindow *arg1 = (wxWindow *) 0 ;
33897 wxPoint *arg2 = 0 ;
33898 wxPoint result;
33899 void *argp1 = 0 ;
33900 int res1 = 0 ;
33901 wxPoint temp2 ;
33902 PyObject * obj0 = 0 ;
33903 PyObject * obj1 = 0 ;
33904 char * kwnames[] = {
33905 (char *) "self",(char *) "pt", NULL
33906 };
33907
33908 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) SWIG_fail;
33909 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33910 if (!SWIG_IsOK(res1)) {
33911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_PNT" "', expected argument " "1"" of type '" "wxWindow *""'");
33912 }
33913 arg1 = reinterpret_cast< wxWindow * >(argp1);
33914 {
33915 arg2 = &temp2;
33916 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
33917 }
33918 {
33919 PyThreadState* __tstate = wxPyBeginAllowThreads();
33920 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
33921 wxPyEndAllowThreads(__tstate);
33922 if (PyErr_Occurred()) SWIG_fail;
33923 }
33924 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
33925 return resultobj;
33926 fail:
33927 return NULL;
33928 }
33929
33930
33931 SWIGINTERN PyObject *_wrap_Window_DLG_SZE(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33932 PyObject *resultobj = 0;
33933 wxWindow *arg1 = (wxWindow *) 0 ;
33934 wxSize *arg2 = 0 ;
33935 wxSize result;
33936 void *argp1 = 0 ;
33937 int res1 = 0 ;
33938 wxSize temp2 ;
33939 PyObject * obj0 = 0 ;
33940 PyObject * obj1 = 0 ;
33941 char * kwnames[] = {
33942 (char *) "self",(char *) "sz", NULL
33943 };
33944
33945 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) SWIG_fail;
33946 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33947 if (!SWIG_IsOK(res1)) {
33948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_SZE" "', expected argument " "1"" of type '" "wxWindow *""'");
33949 }
33950 arg1 = reinterpret_cast< wxWindow * >(argp1);
33951 {
33952 arg2 = &temp2;
33953 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33954 }
33955 {
33956 PyThreadState* __tstate = wxPyBeginAllowThreads();
33957 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
33958 wxPyEndAllowThreads(__tstate);
33959 if (PyErr_Occurred()) SWIG_fail;
33960 }
33961 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
33962 return resultobj;
33963 fail:
33964 return NULL;
33965 }
33966
33967
33968 SWIGINTERN PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33969 PyObject *resultobj = 0;
33970 wxWindow *arg1 = (wxWindow *) 0 ;
33971 wxPoint *arg2 = 0 ;
33972 wxPoint result;
33973 void *argp1 = 0 ;
33974 int res1 = 0 ;
33975 wxPoint temp2 ;
33976 PyObject * obj0 = 0 ;
33977 PyObject * obj1 = 0 ;
33978 char * kwnames[] = {
33979 (char *) "self",(char *) "pt", NULL
33980 };
33981
33982 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
33983 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33984 if (!SWIG_IsOK(res1)) {
33985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelPointToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
33986 }
33987 arg1 = reinterpret_cast< wxWindow * >(argp1);
33988 {
33989 arg2 = &temp2;
33990 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
33991 }
33992 {
33993 PyThreadState* __tstate = wxPyBeginAllowThreads();
33994 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
33995 wxPyEndAllowThreads(__tstate);
33996 if (PyErr_Occurred()) SWIG_fail;
33997 }
33998 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
33999 return resultobj;
34000 fail:
34001 return NULL;
34002 }
34003
34004
34005 SWIGINTERN PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34006 PyObject *resultobj = 0;
34007 wxWindow *arg1 = (wxWindow *) 0 ;
34008 wxSize *arg2 = 0 ;
34009 wxSize result;
34010 void *argp1 = 0 ;
34011 int res1 = 0 ;
34012 wxSize temp2 ;
34013 PyObject * obj0 = 0 ;
34014 PyObject * obj1 = 0 ;
34015 char * kwnames[] = {
34016 (char *) "self",(char *) "sz", NULL
34017 };
34018
34019 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
34020 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34021 if (!SWIG_IsOK(res1)) {
34022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelSizeToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
34023 }
34024 arg1 = reinterpret_cast< wxWindow * >(argp1);
34025 {
34026 arg2 = &temp2;
34027 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34028 }
34029 {
34030 PyThreadState* __tstate = wxPyBeginAllowThreads();
34031 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
34032 wxPyEndAllowThreads(__tstate);
34033 if (PyErr_Occurred()) SWIG_fail;
34034 }
34035 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34036 return resultobj;
34037 fail:
34038 return NULL;
34039 }
34040
34041
34042 SWIGINTERN PyObject *_wrap_Window_WarpPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34043 PyObject *resultobj = 0;
34044 wxWindow *arg1 = (wxWindow *) 0 ;
34045 int arg2 ;
34046 int arg3 ;
34047 void *argp1 = 0 ;
34048 int res1 = 0 ;
34049 int val2 ;
34050 int ecode2 = 0 ;
34051 int val3 ;
34052 int ecode3 = 0 ;
34053 PyObject * obj0 = 0 ;
34054 PyObject * obj1 = 0 ;
34055 PyObject * obj2 = 0 ;
34056 char * kwnames[] = {
34057 (char *) "self",(char *) "x",(char *) "y", NULL
34058 };
34059
34060 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34061 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34062 if (!SWIG_IsOK(res1)) {
34063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_WarpPointer" "', expected argument " "1"" of type '" "wxWindow *""'");
34064 }
34065 arg1 = reinterpret_cast< wxWindow * >(argp1);
34066 ecode2 = SWIG_AsVal_int(obj1, &val2);
34067 if (!SWIG_IsOK(ecode2)) {
34068 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_WarpPointer" "', expected argument " "2"" of type '" "int""'");
34069 }
34070 arg2 = static_cast< int >(val2);
34071 ecode3 = SWIG_AsVal_int(obj2, &val3);
34072 if (!SWIG_IsOK(ecode3)) {
34073 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_WarpPointer" "', expected argument " "3"" of type '" "int""'");
34074 }
34075 arg3 = static_cast< int >(val3);
34076 {
34077 PyThreadState* __tstate = wxPyBeginAllowThreads();
34078 (arg1)->WarpPointer(arg2,arg3);
34079 wxPyEndAllowThreads(__tstate);
34080 if (PyErr_Occurred()) SWIG_fail;
34081 }
34082 resultobj = SWIG_Py_Void();
34083 return resultobj;
34084 fail:
34085 return NULL;
34086 }
34087
34088
34089 SWIGINTERN PyObject *_wrap_Window_CaptureMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34090 PyObject *resultobj = 0;
34091 wxWindow *arg1 = (wxWindow *) 0 ;
34092 void *argp1 = 0 ;
34093 int res1 = 0 ;
34094 PyObject *swig_obj[1] ;
34095
34096 if (!args) SWIG_fail;
34097 swig_obj[0] = args;
34098 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34099 if (!SWIG_IsOK(res1)) {
34100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CaptureMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
34101 }
34102 arg1 = reinterpret_cast< wxWindow * >(argp1);
34103 {
34104 PyThreadState* __tstate = wxPyBeginAllowThreads();
34105 (arg1)->CaptureMouse();
34106 wxPyEndAllowThreads(__tstate);
34107 if (PyErr_Occurred()) SWIG_fail;
34108 }
34109 resultobj = SWIG_Py_Void();
34110 return resultobj;
34111 fail:
34112 return NULL;
34113 }
34114
34115
34116 SWIGINTERN PyObject *_wrap_Window_ReleaseMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34117 PyObject *resultobj = 0;
34118 wxWindow *arg1 = (wxWindow *) 0 ;
34119 void *argp1 = 0 ;
34120 int res1 = 0 ;
34121 PyObject *swig_obj[1] ;
34122
34123 if (!args) SWIG_fail;
34124 swig_obj[0] = args;
34125 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34126 if (!SWIG_IsOK(res1)) {
34127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ReleaseMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
34128 }
34129 arg1 = reinterpret_cast< wxWindow * >(argp1);
34130 {
34131 PyThreadState* __tstate = wxPyBeginAllowThreads();
34132 (arg1)->ReleaseMouse();
34133 wxPyEndAllowThreads(__tstate);
34134 if (PyErr_Occurred()) SWIG_fail;
34135 }
34136 resultobj = SWIG_Py_Void();
34137 return resultobj;
34138 fail:
34139 return NULL;
34140 }
34141
34142
34143 SWIGINTERN PyObject *_wrap_Window_GetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34144 PyObject *resultobj = 0;
34145 wxWindow *result = 0 ;
34146
34147 if (!SWIG_Python_UnpackTuple(args,"Window_GetCapture",0,0,0)) SWIG_fail;
34148 {
34149 if (!wxPyCheckForApp()) SWIG_fail;
34150 PyThreadState* __tstate = wxPyBeginAllowThreads();
34151 result = (wxWindow *)wxWindow::GetCapture();
34152 wxPyEndAllowThreads(__tstate);
34153 if (PyErr_Occurred()) SWIG_fail;
34154 }
34155 {
34156 resultobj = wxPyMake_wxObject(result, 0);
34157 }
34158 return resultobj;
34159 fail:
34160 return NULL;
34161 }
34162
34163
34164 SWIGINTERN PyObject *_wrap_Window_HasCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34165 PyObject *resultobj = 0;
34166 wxWindow *arg1 = (wxWindow *) 0 ;
34167 bool result;
34168 void *argp1 = 0 ;
34169 int res1 = 0 ;
34170 PyObject *swig_obj[1] ;
34171
34172 if (!args) SWIG_fail;
34173 swig_obj[0] = args;
34174 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34175 if (!SWIG_IsOK(res1)) {
34176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasCapture" "', expected argument " "1"" of type '" "wxWindow const *""'");
34177 }
34178 arg1 = reinterpret_cast< wxWindow * >(argp1);
34179 {
34180 PyThreadState* __tstate = wxPyBeginAllowThreads();
34181 result = (bool)((wxWindow const *)arg1)->HasCapture();
34182 wxPyEndAllowThreads(__tstate);
34183 if (PyErr_Occurred()) SWIG_fail;
34184 }
34185 {
34186 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34187 }
34188 return resultobj;
34189 fail:
34190 return NULL;
34191 }
34192
34193
34194 SWIGINTERN PyObject *_wrap_Window_Refresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34195 PyObject *resultobj = 0;
34196 wxWindow *arg1 = (wxWindow *) 0 ;
34197 bool arg2 = (bool) true ;
34198 wxRect *arg3 = (wxRect *) NULL ;
34199 void *argp1 = 0 ;
34200 int res1 = 0 ;
34201 bool val2 ;
34202 int ecode2 = 0 ;
34203 void *argp3 = 0 ;
34204 int res3 = 0 ;
34205 PyObject * obj0 = 0 ;
34206 PyObject * obj1 = 0 ;
34207 PyObject * obj2 = 0 ;
34208 char * kwnames[] = {
34209 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
34210 };
34211
34212 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34213 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34214 if (!SWIG_IsOK(res1)) {
34215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Refresh" "', expected argument " "1"" of type '" "wxWindow *""'");
34216 }
34217 arg1 = reinterpret_cast< wxWindow * >(argp1);
34218 if (obj1) {
34219 ecode2 = SWIG_AsVal_bool(obj1, &val2);
34220 if (!SWIG_IsOK(ecode2)) {
34221 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Refresh" "', expected argument " "2"" of type '" "bool""'");
34222 }
34223 arg2 = static_cast< bool >(val2);
34224 }
34225 if (obj2) {
34226 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxRect, 0 | 0 );
34227 if (!SWIG_IsOK(res3)) {
34228 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_Refresh" "', expected argument " "3"" of type '" "wxRect const *""'");
34229 }
34230 arg3 = reinterpret_cast< wxRect * >(argp3);
34231 }
34232 {
34233 PyThreadState* __tstate = wxPyBeginAllowThreads();
34234 (arg1)->Refresh(arg2,(wxRect const *)arg3);
34235 wxPyEndAllowThreads(__tstate);
34236 if (PyErr_Occurred()) SWIG_fail;
34237 }
34238 resultobj = SWIG_Py_Void();
34239 return resultobj;
34240 fail:
34241 return NULL;
34242 }
34243
34244
34245 SWIGINTERN PyObject *_wrap_Window_RefreshRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34246 PyObject *resultobj = 0;
34247 wxWindow *arg1 = (wxWindow *) 0 ;
34248 wxRect *arg2 = 0 ;
34249 bool arg3 = (bool) true ;
34250 void *argp1 = 0 ;
34251 int res1 = 0 ;
34252 wxRect temp2 ;
34253 bool val3 ;
34254 int ecode3 = 0 ;
34255 PyObject * obj0 = 0 ;
34256 PyObject * obj1 = 0 ;
34257 PyObject * obj2 = 0 ;
34258 char * kwnames[] = {
34259 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
34260 };
34261
34262 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34263 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34264 if (!SWIG_IsOK(res1)) {
34265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RefreshRect" "', expected argument " "1"" of type '" "wxWindow *""'");
34266 }
34267 arg1 = reinterpret_cast< wxWindow * >(argp1);
34268 {
34269 arg2 = &temp2;
34270 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34271 }
34272 if (obj2) {
34273 ecode3 = SWIG_AsVal_bool(obj2, &val3);
34274 if (!SWIG_IsOK(ecode3)) {
34275 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RefreshRect" "', expected argument " "3"" of type '" "bool""'");
34276 }
34277 arg3 = static_cast< bool >(val3);
34278 }
34279 {
34280 PyThreadState* __tstate = wxPyBeginAllowThreads();
34281 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
34282 wxPyEndAllowThreads(__tstate);
34283 if (PyErr_Occurred()) SWIG_fail;
34284 }
34285 resultobj = SWIG_Py_Void();
34286 return resultobj;
34287 fail:
34288 return NULL;
34289 }
34290
34291
34292 SWIGINTERN PyObject *_wrap_Window_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34293 PyObject *resultobj = 0;
34294 wxWindow *arg1 = (wxWindow *) 0 ;
34295 void *argp1 = 0 ;
34296 int res1 = 0 ;
34297 PyObject *swig_obj[1] ;
34298
34299 if (!args) SWIG_fail;
34300 swig_obj[0] = args;
34301 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34302 if (!SWIG_IsOK(res1)) {
34303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Update" "', expected argument " "1"" of type '" "wxWindow *""'");
34304 }
34305 arg1 = reinterpret_cast< wxWindow * >(argp1);
34306 {
34307 PyThreadState* __tstate = wxPyBeginAllowThreads();
34308 (arg1)->Update();
34309 wxPyEndAllowThreads(__tstate);
34310 if (PyErr_Occurred()) SWIG_fail;
34311 }
34312 resultobj = SWIG_Py_Void();
34313 return resultobj;
34314 fail:
34315 return NULL;
34316 }
34317
34318
34319 SWIGINTERN PyObject *_wrap_Window_ClearBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34320 PyObject *resultobj = 0;
34321 wxWindow *arg1 = (wxWindow *) 0 ;
34322 void *argp1 = 0 ;
34323 int res1 = 0 ;
34324 PyObject *swig_obj[1] ;
34325
34326 if (!args) SWIG_fail;
34327 swig_obj[0] = args;
34328 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34329 if (!SWIG_IsOK(res1)) {
34330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClearBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
34331 }
34332 arg1 = reinterpret_cast< wxWindow * >(argp1);
34333 {
34334 PyThreadState* __tstate = wxPyBeginAllowThreads();
34335 (arg1)->ClearBackground();
34336 wxPyEndAllowThreads(__tstate);
34337 if (PyErr_Occurred()) SWIG_fail;
34338 }
34339 resultobj = SWIG_Py_Void();
34340 return resultobj;
34341 fail:
34342 return NULL;
34343 }
34344
34345
34346 SWIGINTERN PyObject *_wrap_Window_Freeze(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34347 PyObject *resultobj = 0;
34348 wxWindow *arg1 = (wxWindow *) 0 ;
34349 void *argp1 = 0 ;
34350 int res1 = 0 ;
34351 PyObject *swig_obj[1] ;
34352
34353 if (!args) SWIG_fail;
34354 swig_obj[0] = args;
34355 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34356 if (!SWIG_IsOK(res1)) {
34357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Freeze" "', expected argument " "1"" of type '" "wxWindow *""'");
34358 }
34359 arg1 = reinterpret_cast< wxWindow * >(argp1);
34360 {
34361 PyThreadState* __tstate = wxPyBeginAllowThreads();
34362 (arg1)->Freeze();
34363 wxPyEndAllowThreads(__tstate);
34364 if (PyErr_Occurred()) SWIG_fail;
34365 }
34366 resultobj = SWIG_Py_Void();
34367 return resultobj;
34368 fail:
34369 return NULL;
34370 }
34371
34372
34373 SWIGINTERN PyObject *_wrap_Window_Thaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34374 PyObject *resultobj = 0;
34375 wxWindow *arg1 = (wxWindow *) 0 ;
34376 void *argp1 = 0 ;
34377 int res1 = 0 ;
34378 PyObject *swig_obj[1] ;
34379
34380 if (!args) SWIG_fail;
34381 swig_obj[0] = args;
34382 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34383 if (!SWIG_IsOK(res1)) {
34384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Thaw" "', expected argument " "1"" of type '" "wxWindow *""'");
34385 }
34386 arg1 = reinterpret_cast< wxWindow * >(argp1);
34387 {
34388 PyThreadState* __tstate = wxPyBeginAllowThreads();
34389 (arg1)->Thaw();
34390 wxPyEndAllowThreads(__tstate);
34391 if (PyErr_Occurred()) SWIG_fail;
34392 }
34393 resultobj = SWIG_Py_Void();
34394 return resultobj;
34395 fail:
34396 return NULL;
34397 }
34398
34399
34400 SWIGINTERN PyObject *_wrap_Window_PrepareDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34401 PyObject *resultobj = 0;
34402 wxWindow *arg1 = (wxWindow *) 0 ;
34403 wxDC *arg2 = 0 ;
34404 void *argp1 = 0 ;
34405 int res1 = 0 ;
34406 void *argp2 = 0 ;
34407 int res2 = 0 ;
34408 PyObject * obj0 = 0 ;
34409 PyObject * obj1 = 0 ;
34410 char * kwnames[] = {
34411 (char *) "self",(char *) "dc", NULL
34412 };
34413
34414 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) SWIG_fail;
34415 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34416 if (!SWIG_IsOK(res1)) {
34417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PrepareDC" "', expected argument " "1"" of type '" "wxWindow *""'");
34418 }
34419 arg1 = reinterpret_cast< wxWindow * >(argp1);
34420 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
34421 if (!SWIG_IsOK(res2)) {
34422 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
34423 }
34424 if (!argp2) {
34425 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
34426 }
34427 arg2 = reinterpret_cast< wxDC * >(argp2);
34428 {
34429 PyThreadState* __tstate = wxPyBeginAllowThreads();
34430 (arg1)->PrepareDC(*arg2);
34431 wxPyEndAllowThreads(__tstate);
34432 if (PyErr_Occurred()) SWIG_fail;
34433 }
34434 resultobj = SWIG_Py_Void();
34435 return resultobj;
34436 fail:
34437 return NULL;
34438 }
34439
34440
34441 SWIGINTERN PyObject *_wrap_Window_GetUpdateRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34442 PyObject *resultobj = 0;
34443 wxWindow *arg1 = (wxWindow *) 0 ;
34444 wxRegion *result = 0 ;
34445 void *argp1 = 0 ;
34446 int res1 = 0 ;
34447 PyObject *swig_obj[1] ;
34448
34449 if (!args) SWIG_fail;
34450 swig_obj[0] = args;
34451 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34452 if (!SWIG_IsOK(res1)) {
34453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateRegion" "', expected argument " "1"" of type '" "wxWindow *""'");
34454 }
34455 arg1 = reinterpret_cast< wxWindow * >(argp1);
34456 {
34457 PyThreadState* __tstate = wxPyBeginAllowThreads();
34458 {
34459 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
34460 result = (wxRegion *) &_result_ref;
34461 }
34462 wxPyEndAllowThreads(__tstate);
34463 if (PyErr_Occurred()) SWIG_fail;
34464 }
34465 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, 0 | 0 );
34466 return resultobj;
34467 fail:
34468 return NULL;
34469 }
34470
34471
34472 SWIGINTERN PyObject *_wrap_Window_GetUpdateClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34473 PyObject *resultobj = 0;
34474 wxWindow *arg1 = (wxWindow *) 0 ;
34475 wxRect result;
34476 void *argp1 = 0 ;
34477 int res1 = 0 ;
34478 PyObject *swig_obj[1] ;
34479
34480 if (!args) SWIG_fail;
34481 swig_obj[0] = args;
34482 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34483 if (!SWIG_IsOK(res1)) {
34484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34485 }
34486 arg1 = reinterpret_cast< wxWindow * >(argp1);
34487 {
34488 PyThreadState* __tstate = wxPyBeginAllowThreads();
34489 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
34490 wxPyEndAllowThreads(__tstate);
34491 if (PyErr_Occurred()) SWIG_fail;
34492 }
34493 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34494 return resultobj;
34495 fail:
34496 return NULL;
34497 }
34498
34499
34500 SWIGINTERN PyObject *_wrap_Window_IsExposed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34501 PyObject *resultobj = 0;
34502 wxWindow *arg1 = (wxWindow *) 0 ;
34503 int arg2 ;
34504 int arg3 ;
34505 int arg4 = (int) 1 ;
34506 int arg5 = (int) 1 ;
34507 bool result;
34508 void *argp1 = 0 ;
34509 int res1 = 0 ;
34510 int val2 ;
34511 int ecode2 = 0 ;
34512 int val3 ;
34513 int ecode3 = 0 ;
34514 int val4 ;
34515 int ecode4 = 0 ;
34516 int val5 ;
34517 int ecode5 = 0 ;
34518 PyObject * obj0 = 0 ;
34519 PyObject * obj1 = 0 ;
34520 PyObject * obj2 = 0 ;
34521 PyObject * obj3 = 0 ;
34522 PyObject * obj4 = 0 ;
34523 char * kwnames[] = {
34524 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
34525 };
34526
34527 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
34528 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34529 if (!SWIG_IsOK(res1)) {
34530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposed" "', expected argument " "1"" of type '" "wxWindow const *""'");
34531 }
34532 arg1 = reinterpret_cast< wxWindow * >(argp1);
34533 ecode2 = SWIG_AsVal_int(obj1, &val2);
34534 if (!SWIG_IsOK(ecode2)) {
34535 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_IsExposed" "', expected argument " "2"" of type '" "int""'");
34536 }
34537 arg2 = static_cast< int >(val2);
34538 ecode3 = SWIG_AsVal_int(obj2, &val3);
34539 if (!SWIG_IsOK(ecode3)) {
34540 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_IsExposed" "', expected argument " "3"" of type '" "int""'");
34541 }
34542 arg3 = static_cast< int >(val3);
34543 if (obj3) {
34544 ecode4 = SWIG_AsVal_int(obj3, &val4);
34545 if (!SWIG_IsOK(ecode4)) {
34546 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_IsExposed" "', expected argument " "4"" of type '" "int""'");
34547 }
34548 arg4 = static_cast< int >(val4);
34549 }
34550 if (obj4) {
34551 ecode5 = SWIG_AsVal_int(obj4, &val5);
34552 if (!SWIG_IsOK(ecode5)) {
34553 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_IsExposed" "', expected argument " "5"" of type '" "int""'");
34554 }
34555 arg5 = static_cast< int >(val5);
34556 }
34557 {
34558 PyThreadState* __tstate = wxPyBeginAllowThreads();
34559 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
34560 wxPyEndAllowThreads(__tstate);
34561 if (PyErr_Occurred()) SWIG_fail;
34562 }
34563 {
34564 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34565 }
34566 return resultobj;
34567 fail:
34568 return NULL;
34569 }
34570
34571
34572 SWIGINTERN PyObject *_wrap_Window_IsExposedPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34573 PyObject *resultobj = 0;
34574 wxWindow *arg1 = (wxWindow *) 0 ;
34575 wxPoint *arg2 = 0 ;
34576 bool result;
34577 void *argp1 = 0 ;
34578 int res1 = 0 ;
34579 wxPoint temp2 ;
34580 PyObject * obj0 = 0 ;
34581 PyObject * obj1 = 0 ;
34582 char * kwnames[] = {
34583 (char *) "self",(char *) "pt", NULL
34584 };
34585
34586 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) SWIG_fail;
34587 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34588 if (!SWIG_IsOK(res1)) {
34589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
34590 }
34591 arg1 = reinterpret_cast< wxWindow * >(argp1);
34592 {
34593 arg2 = &temp2;
34594 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34595 }
34596 {
34597 PyThreadState* __tstate = wxPyBeginAllowThreads();
34598 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
34599 wxPyEndAllowThreads(__tstate);
34600 if (PyErr_Occurred()) SWIG_fail;
34601 }
34602 {
34603 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34604 }
34605 return resultobj;
34606 fail:
34607 return NULL;
34608 }
34609
34610
34611 SWIGINTERN PyObject *_wrap_Window_IsExposedRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34612 PyObject *resultobj = 0;
34613 wxWindow *arg1 = (wxWindow *) 0 ;
34614 wxRect *arg2 = 0 ;
34615 bool result;
34616 void *argp1 = 0 ;
34617 int res1 = 0 ;
34618 wxRect temp2 ;
34619 PyObject * obj0 = 0 ;
34620 PyObject * obj1 = 0 ;
34621 char * kwnames[] = {
34622 (char *) "self",(char *) "rect", NULL
34623 };
34624
34625 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) SWIG_fail;
34626 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34627 if (!SWIG_IsOK(res1)) {
34628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34629 }
34630 arg1 = reinterpret_cast< wxWindow * >(argp1);
34631 {
34632 arg2 = &temp2;
34633 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34634 }
34635 {
34636 PyThreadState* __tstate = wxPyBeginAllowThreads();
34637 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
34638 wxPyEndAllowThreads(__tstate);
34639 if (PyErr_Occurred()) SWIG_fail;
34640 }
34641 {
34642 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34643 }
34644 return resultobj;
34645 fail:
34646 return NULL;
34647 }
34648
34649
34650 SWIGINTERN PyObject *_wrap_Window_GetDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34651 PyObject *resultobj = 0;
34652 wxWindow *arg1 = (wxWindow *) 0 ;
34653 SwigValueWrapper<wxVisualAttributes > result;
34654 void *argp1 = 0 ;
34655 int res1 = 0 ;
34656 PyObject *swig_obj[1] ;
34657
34658 if (!args) SWIG_fail;
34659 swig_obj[0] = args;
34660 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34661 if (!SWIG_IsOK(res1)) {
34662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultAttributes" "', expected argument " "1"" of type '" "wxWindow const *""'");
34663 }
34664 arg1 = reinterpret_cast< wxWindow * >(argp1);
34665 {
34666 PyThreadState* __tstate = wxPyBeginAllowThreads();
34667 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
34668 wxPyEndAllowThreads(__tstate);
34669 if (PyErr_Occurred()) SWIG_fail;
34670 }
34671 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
34672 return resultobj;
34673 fail:
34674 return NULL;
34675 }
34676
34677
34678 SWIGINTERN PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34679 PyObject *resultobj = 0;
34680 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
34681 SwigValueWrapper<wxVisualAttributes > result;
34682 int val1 ;
34683 int ecode1 = 0 ;
34684 PyObject * obj0 = 0 ;
34685 char * kwnames[] = {
34686 (char *) "variant", NULL
34687 };
34688
34689 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
34690 if (obj0) {
34691 ecode1 = SWIG_AsVal_int(obj0, &val1);
34692 if (!SWIG_IsOK(ecode1)) {
34693 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
34694 }
34695 arg1 = static_cast< wxWindowVariant >(val1);
34696 }
34697 {
34698 if (!wxPyCheckForApp()) SWIG_fail;
34699 PyThreadState* __tstate = wxPyBeginAllowThreads();
34700 result = wxWindow::GetClassDefaultAttributes(arg1);
34701 wxPyEndAllowThreads(__tstate);
34702 if (PyErr_Occurred()) SWIG_fail;
34703 }
34704 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
34705 return resultobj;
34706 fail:
34707 return NULL;
34708 }
34709
34710
34711 SWIGINTERN PyObject *_wrap_Window_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34712 PyObject *resultobj = 0;
34713 wxWindow *arg1 = (wxWindow *) 0 ;
34714 wxColour *arg2 = 0 ;
34715 bool result;
34716 void *argp1 = 0 ;
34717 int res1 = 0 ;
34718 wxColour temp2 ;
34719 PyObject * obj0 = 0 ;
34720 PyObject * obj1 = 0 ;
34721 char * kwnames[] = {
34722 (char *) "self",(char *) "colour", NULL
34723 };
34724
34725 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34726 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34727 if (!SWIG_IsOK(res1)) {
34728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34729 }
34730 arg1 = reinterpret_cast< wxWindow * >(argp1);
34731 {
34732 arg2 = &temp2;
34733 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34734 }
34735 {
34736 PyThreadState* __tstate = wxPyBeginAllowThreads();
34737 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
34738 wxPyEndAllowThreads(__tstate);
34739 if (PyErr_Occurred()) SWIG_fail;
34740 }
34741 {
34742 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34743 }
34744 return resultobj;
34745 fail:
34746 return NULL;
34747 }
34748
34749
34750 SWIGINTERN PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34751 PyObject *resultobj = 0;
34752 wxWindow *arg1 = (wxWindow *) 0 ;
34753 wxColour *arg2 = 0 ;
34754 void *argp1 = 0 ;
34755 int res1 = 0 ;
34756 wxColour temp2 ;
34757 PyObject * obj0 = 0 ;
34758 PyObject * obj1 = 0 ;
34759 char * kwnames[] = {
34760 (char *) "self",(char *) "colour", NULL
34761 };
34762
34763 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34764 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34765 if (!SWIG_IsOK(res1)) {
34766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34767 }
34768 arg1 = reinterpret_cast< wxWindow * >(argp1);
34769 {
34770 arg2 = &temp2;
34771 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34772 }
34773 {
34774 PyThreadState* __tstate = wxPyBeginAllowThreads();
34775 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
34776 wxPyEndAllowThreads(__tstate);
34777 if (PyErr_Occurred()) SWIG_fail;
34778 }
34779 resultobj = SWIG_Py_Void();
34780 return resultobj;
34781 fail:
34782 return NULL;
34783 }
34784
34785
34786 SWIGINTERN PyObject *_wrap_Window_SetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34787 PyObject *resultobj = 0;
34788 wxWindow *arg1 = (wxWindow *) 0 ;
34789 wxColour *arg2 = 0 ;
34790 bool result;
34791 void *argp1 = 0 ;
34792 int res1 = 0 ;
34793 wxColour temp2 ;
34794 PyObject * obj0 = 0 ;
34795 PyObject * obj1 = 0 ;
34796 char * kwnames[] = {
34797 (char *) "self",(char *) "colour", NULL
34798 };
34799
34800 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34801 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34802 if (!SWIG_IsOK(res1)) {
34803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34804 }
34805 arg1 = reinterpret_cast< wxWindow * >(argp1);
34806 {
34807 arg2 = &temp2;
34808 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34809 }
34810 {
34811 PyThreadState* __tstate = wxPyBeginAllowThreads();
34812 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
34813 wxPyEndAllowThreads(__tstate);
34814 if (PyErr_Occurred()) SWIG_fail;
34815 }
34816 {
34817 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34818 }
34819 return resultobj;
34820 fail:
34821 return NULL;
34822 }
34823
34824
34825 SWIGINTERN PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34826 PyObject *resultobj = 0;
34827 wxWindow *arg1 = (wxWindow *) 0 ;
34828 wxColour *arg2 = 0 ;
34829 void *argp1 = 0 ;
34830 int res1 = 0 ;
34831 wxColour temp2 ;
34832 PyObject * obj0 = 0 ;
34833 PyObject * obj1 = 0 ;
34834 char * kwnames[] = {
34835 (char *) "self",(char *) "colour", NULL
34836 };
34837
34838 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34839 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34840 if (!SWIG_IsOK(res1)) {
34841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34842 }
34843 arg1 = reinterpret_cast< wxWindow * >(argp1);
34844 {
34845 arg2 = &temp2;
34846 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34847 }
34848 {
34849 PyThreadState* __tstate = wxPyBeginAllowThreads();
34850 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
34851 wxPyEndAllowThreads(__tstate);
34852 if (PyErr_Occurred()) SWIG_fail;
34853 }
34854 resultobj = SWIG_Py_Void();
34855 return resultobj;
34856 fail:
34857 return NULL;
34858 }
34859
34860
34861 SWIGINTERN PyObject *_wrap_Window_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34862 PyObject *resultobj = 0;
34863 wxWindow *arg1 = (wxWindow *) 0 ;
34864 wxColour result;
34865 void *argp1 = 0 ;
34866 int res1 = 0 ;
34867 PyObject *swig_obj[1] ;
34868
34869 if (!args) SWIG_fail;
34870 swig_obj[0] = args;
34871 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34872 if (!SWIG_IsOK(res1)) {
34873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
34874 }
34875 arg1 = reinterpret_cast< wxWindow * >(argp1);
34876 {
34877 PyThreadState* __tstate = wxPyBeginAllowThreads();
34878 result = ((wxWindow const *)arg1)->GetBackgroundColour();
34879 wxPyEndAllowThreads(__tstate);
34880 if (PyErr_Occurred()) SWIG_fail;
34881 }
34882 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
34883 return resultobj;
34884 fail:
34885 return NULL;
34886 }
34887
34888
34889 SWIGINTERN PyObject *_wrap_Window_GetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34890 PyObject *resultobj = 0;
34891 wxWindow *arg1 = (wxWindow *) 0 ;
34892 wxColour result;
34893 void *argp1 = 0 ;
34894 int res1 = 0 ;
34895 PyObject *swig_obj[1] ;
34896
34897 if (!args) SWIG_fail;
34898 swig_obj[0] = args;
34899 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34900 if (!SWIG_IsOK(res1)) {
34901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetForegroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
34902 }
34903 arg1 = reinterpret_cast< wxWindow * >(argp1);
34904 {
34905 PyThreadState* __tstate = wxPyBeginAllowThreads();
34906 result = ((wxWindow const *)arg1)->GetForegroundColour();
34907 wxPyEndAllowThreads(__tstate);
34908 if (PyErr_Occurred()) SWIG_fail;
34909 }
34910 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
34911 return resultobj;
34912 fail:
34913 return NULL;
34914 }
34915
34916
34917 SWIGINTERN PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34918 PyObject *resultobj = 0;
34919 wxWindow *arg1 = (wxWindow *) 0 ;
34920 bool result;
34921 void *argp1 = 0 ;
34922 int res1 = 0 ;
34923 PyObject *swig_obj[1] ;
34924
34925 if (!args) SWIG_fail;
34926 swig_obj[0] = args;
34927 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34928 if (!SWIG_IsOK(res1)) {
34929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritsBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
34930 }
34931 arg1 = reinterpret_cast< wxWindow * >(argp1);
34932 {
34933 PyThreadState* __tstate = wxPyBeginAllowThreads();
34934 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
34935 wxPyEndAllowThreads(__tstate);
34936 if (PyErr_Occurred()) SWIG_fail;
34937 }
34938 {
34939 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34940 }
34941 return resultobj;
34942 fail:
34943 return NULL;
34944 }
34945
34946
34947 SWIGINTERN PyObject *_wrap_Window_UseBgCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34948 PyObject *resultobj = 0;
34949 wxWindow *arg1 = (wxWindow *) 0 ;
34950 bool result;
34951 void *argp1 = 0 ;
34952 int res1 = 0 ;
34953 PyObject *swig_obj[1] ;
34954
34955 if (!args) SWIG_fail;
34956 swig_obj[0] = args;
34957 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34958 if (!SWIG_IsOK(res1)) {
34959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UseBgCol" "', expected argument " "1"" of type '" "wxWindow const *""'");
34960 }
34961 arg1 = reinterpret_cast< wxWindow * >(argp1);
34962 {
34963 PyThreadState* __tstate = wxPyBeginAllowThreads();
34964 result = (bool)((wxWindow const *)arg1)->UseBgCol();
34965 wxPyEndAllowThreads(__tstate);
34966 if (PyErr_Occurred()) SWIG_fail;
34967 }
34968 {
34969 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34970 }
34971 return resultobj;
34972 fail:
34973 return NULL;
34974 }
34975
34976
34977 SWIGINTERN PyObject *_wrap_Window_SetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34978 PyObject *resultobj = 0;
34979 wxWindow *arg1 = (wxWindow *) 0 ;
34980 wxBackgroundStyle arg2 ;
34981 bool result;
34982 void *argp1 = 0 ;
34983 int res1 = 0 ;
34984 int val2 ;
34985 int ecode2 = 0 ;
34986 PyObject * obj0 = 0 ;
34987 PyObject * obj1 = 0 ;
34988 char * kwnames[] = {
34989 (char *) "self",(char *) "style", NULL
34990 };
34991
34992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) SWIG_fail;
34993 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34994 if (!SWIG_IsOK(res1)) {
34995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
34996 }
34997 arg1 = reinterpret_cast< wxWindow * >(argp1);
34998 ecode2 = SWIG_AsVal_int(obj1, &val2);
34999 if (!SWIG_IsOK(ecode2)) {
35000 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetBackgroundStyle" "', expected argument " "2"" of type '" "wxBackgroundStyle""'");
35001 }
35002 arg2 = static_cast< wxBackgroundStyle >(val2);
35003 {
35004 PyThreadState* __tstate = wxPyBeginAllowThreads();
35005 result = (bool)(arg1)->SetBackgroundStyle(arg2);
35006 wxPyEndAllowThreads(__tstate);
35007 if (PyErr_Occurred()) SWIG_fail;
35008 }
35009 {
35010 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35011 }
35012 return resultobj;
35013 fail:
35014 return NULL;
35015 }
35016
35017
35018 SWIGINTERN PyObject *_wrap_Window_GetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35019 PyObject *resultobj = 0;
35020 wxWindow *arg1 = (wxWindow *) 0 ;
35021 wxBackgroundStyle result;
35022 void *argp1 = 0 ;
35023 int res1 = 0 ;
35024 PyObject *swig_obj[1] ;
35025
35026 if (!args) SWIG_fail;
35027 swig_obj[0] = args;
35028 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35029 if (!SWIG_IsOK(res1)) {
35030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
35031 }
35032 arg1 = reinterpret_cast< wxWindow * >(argp1);
35033 {
35034 PyThreadState* __tstate = wxPyBeginAllowThreads();
35035 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
35036 wxPyEndAllowThreads(__tstate);
35037 if (PyErr_Occurred()) SWIG_fail;
35038 }
35039 resultobj = SWIG_From_int(static_cast< int >(result));
35040 return resultobj;
35041 fail:
35042 return NULL;
35043 }
35044
35045
35046 SWIGINTERN PyObject *_wrap_Window_HasTransparentBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35047 PyObject *resultobj = 0;
35048 wxWindow *arg1 = (wxWindow *) 0 ;
35049 bool result;
35050 void *argp1 = 0 ;
35051 int res1 = 0 ;
35052 PyObject *swig_obj[1] ;
35053
35054 if (!args) SWIG_fail;
35055 swig_obj[0] = args;
35056 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35057 if (!SWIG_IsOK(res1)) {
35058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasTransparentBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
35059 }
35060 arg1 = reinterpret_cast< wxWindow * >(argp1);
35061 {
35062 PyThreadState* __tstate = wxPyBeginAllowThreads();
35063 result = (bool)(arg1)->HasTransparentBackground();
35064 wxPyEndAllowThreads(__tstate);
35065 if (PyErr_Occurred()) SWIG_fail;
35066 }
35067 {
35068 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35069 }
35070 return resultobj;
35071 fail:
35072 return NULL;
35073 }
35074
35075
35076 SWIGINTERN PyObject *_wrap_Window_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35077 PyObject *resultobj = 0;
35078 wxWindow *arg1 = (wxWindow *) 0 ;
35079 wxCursor *arg2 = 0 ;
35080 bool result;
35081 void *argp1 = 0 ;
35082 int res1 = 0 ;
35083 void *argp2 = 0 ;
35084 int res2 = 0 ;
35085 PyObject * obj0 = 0 ;
35086 PyObject * obj1 = 0 ;
35087 char * kwnames[] = {
35088 (char *) "self",(char *) "cursor", NULL
35089 };
35090
35091 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
35092 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35093 if (!SWIG_IsOK(res1)) {
35094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
35095 }
35096 arg1 = reinterpret_cast< wxWindow * >(argp1);
35097 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
35098 if (!SWIG_IsOK(res2)) {
35099 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
35100 }
35101 if (!argp2) {
35102 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
35103 }
35104 arg2 = reinterpret_cast< wxCursor * >(argp2);
35105 {
35106 PyThreadState* __tstate = wxPyBeginAllowThreads();
35107 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
35108 wxPyEndAllowThreads(__tstate);
35109 if (PyErr_Occurred()) SWIG_fail;
35110 }
35111 {
35112 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35113 }
35114 return resultobj;
35115 fail:
35116 return NULL;
35117 }
35118
35119
35120 SWIGINTERN PyObject *_wrap_Window_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35121 PyObject *resultobj = 0;
35122 wxWindow *arg1 = (wxWindow *) 0 ;
35123 wxCursor result;
35124 void *argp1 = 0 ;
35125 int res1 = 0 ;
35126 PyObject *swig_obj[1] ;
35127
35128 if (!args) SWIG_fail;
35129 swig_obj[0] = args;
35130 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35131 if (!SWIG_IsOK(res1)) {
35132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
35133 }
35134 arg1 = reinterpret_cast< wxWindow * >(argp1);
35135 {
35136 PyThreadState* __tstate = wxPyBeginAllowThreads();
35137 result = (arg1)->GetCursor();
35138 wxPyEndAllowThreads(__tstate);
35139 if (PyErr_Occurred()) SWIG_fail;
35140 }
35141 resultobj = SWIG_NewPointerObj((new wxCursor(static_cast< const wxCursor& >(result))), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );
35142 return resultobj;
35143 fail:
35144 return NULL;
35145 }
35146
35147
35148 SWIGINTERN PyObject *_wrap_Window_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35149 PyObject *resultobj = 0;
35150 wxWindow *arg1 = (wxWindow *) 0 ;
35151 wxFont *arg2 = 0 ;
35152 bool result;
35153 void *argp1 = 0 ;
35154 int res1 = 0 ;
35155 void *argp2 = 0 ;
35156 int res2 = 0 ;
35157 PyObject * obj0 = 0 ;
35158 PyObject * obj1 = 0 ;
35159 char * kwnames[] = {
35160 (char *) "self",(char *) "font", NULL
35161 };
35162
35163 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
35164 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35165 if (!SWIG_IsOK(res1)) {
35166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35167 }
35168 arg1 = reinterpret_cast< wxWindow * >(argp1);
35169 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
35170 if (!SWIG_IsOK(res2)) {
35171 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35172 }
35173 if (!argp2) {
35174 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35175 }
35176 arg2 = reinterpret_cast< wxFont * >(argp2);
35177 {
35178 PyThreadState* __tstate = wxPyBeginAllowThreads();
35179 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
35180 wxPyEndAllowThreads(__tstate);
35181 if (PyErr_Occurred()) SWIG_fail;
35182 }
35183 {
35184 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35185 }
35186 return resultobj;
35187 fail:
35188 return NULL;
35189 }
35190
35191
35192 SWIGINTERN PyObject *_wrap_Window_SetOwnFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35193 PyObject *resultobj = 0;
35194 wxWindow *arg1 = (wxWindow *) 0 ;
35195 wxFont *arg2 = 0 ;
35196 void *argp1 = 0 ;
35197 int res1 = 0 ;
35198 void *argp2 = 0 ;
35199 int res2 = 0 ;
35200 PyObject * obj0 = 0 ;
35201 PyObject * obj1 = 0 ;
35202 char * kwnames[] = {
35203 (char *) "self",(char *) "font", NULL
35204 };
35205
35206 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) SWIG_fail;
35207 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35208 if (!SWIG_IsOK(res1)) {
35209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35210 }
35211 arg1 = reinterpret_cast< wxWindow * >(argp1);
35212 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
35213 if (!SWIG_IsOK(res2)) {
35214 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35215 }
35216 if (!argp2) {
35217 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35218 }
35219 arg2 = reinterpret_cast< wxFont * >(argp2);
35220 {
35221 PyThreadState* __tstate = wxPyBeginAllowThreads();
35222 (arg1)->SetOwnFont((wxFont const &)*arg2);
35223 wxPyEndAllowThreads(__tstate);
35224 if (PyErr_Occurred()) SWIG_fail;
35225 }
35226 resultobj = SWIG_Py_Void();
35227 return resultobj;
35228 fail:
35229 return NULL;
35230 }
35231
35232
35233 SWIGINTERN PyObject *_wrap_Window_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35234 PyObject *resultobj = 0;
35235 wxWindow *arg1 = (wxWindow *) 0 ;
35236 wxFont result;
35237 void *argp1 = 0 ;
35238 int res1 = 0 ;
35239 PyObject *swig_obj[1] ;
35240
35241 if (!args) SWIG_fail;
35242 swig_obj[0] = args;
35243 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35244 if (!SWIG_IsOK(res1)) {
35245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35246 }
35247 arg1 = reinterpret_cast< wxWindow * >(argp1);
35248 {
35249 PyThreadState* __tstate = wxPyBeginAllowThreads();
35250 result = (arg1)->GetFont();
35251 wxPyEndAllowThreads(__tstate);
35252 if (PyErr_Occurred()) SWIG_fail;
35253 }
35254 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
35255 return resultobj;
35256 fail:
35257 return NULL;
35258 }
35259
35260
35261 SWIGINTERN PyObject *_wrap_Window_SetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35262 PyObject *resultobj = 0;
35263 wxWindow *arg1 = (wxWindow *) 0 ;
35264 wxCaret *arg2 = (wxCaret *) 0 ;
35265 void *argp1 = 0 ;
35266 int res1 = 0 ;
35267 int res2 = 0 ;
35268 PyObject * obj0 = 0 ;
35269 PyObject * obj1 = 0 ;
35270 char * kwnames[] = {
35271 (char *) "self",(char *) "caret", NULL
35272 };
35273
35274 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) SWIG_fail;
35275 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35276 if (!SWIG_IsOK(res1)) {
35277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCaret" "', expected argument " "1"" of type '" "wxWindow *""'");
35278 }
35279 arg1 = reinterpret_cast< wxWindow * >(argp1);
35280 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
35281 if (!SWIG_IsOK(res2)) {
35282 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCaret" "', expected argument " "2"" of type '" "wxCaret *""'");
35283 }
35284 {
35285 PyThreadState* __tstate = wxPyBeginAllowThreads();
35286 (arg1)->SetCaret(arg2);
35287 wxPyEndAllowThreads(__tstate);
35288 if (PyErr_Occurred()) SWIG_fail;
35289 }
35290 resultobj = SWIG_Py_Void();
35291 return resultobj;
35292 fail:
35293 return NULL;
35294 }
35295
35296
35297 SWIGINTERN PyObject *_wrap_Window_GetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35298 PyObject *resultobj = 0;
35299 wxWindow *arg1 = (wxWindow *) 0 ;
35300 wxCaret *result = 0 ;
35301 void *argp1 = 0 ;
35302 int res1 = 0 ;
35303 PyObject *swig_obj[1] ;
35304
35305 if (!args) SWIG_fail;
35306 swig_obj[0] = args;
35307 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35308 if (!SWIG_IsOK(res1)) {
35309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCaret" "', expected argument " "1"" of type '" "wxWindow const *""'");
35310 }
35311 arg1 = reinterpret_cast< wxWindow * >(argp1);
35312 {
35313 PyThreadState* __tstate = wxPyBeginAllowThreads();
35314 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
35315 wxPyEndAllowThreads(__tstate);
35316 if (PyErr_Occurred()) SWIG_fail;
35317 }
35318 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, 0 | 0 );
35319 return resultobj;
35320 fail:
35321 return NULL;
35322 }
35323
35324
35325 SWIGINTERN PyObject *_wrap_Window_GetCharHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35326 PyObject *resultobj = 0;
35327 wxWindow *arg1 = (wxWindow *) 0 ;
35328 int result;
35329 void *argp1 = 0 ;
35330 int res1 = 0 ;
35331 PyObject *swig_obj[1] ;
35332
35333 if (!args) SWIG_fail;
35334 swig_obj[0] = args;
35335 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35336 if (!SWIG_IsOK(res1)) {
35337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
35338 }
35339 arg1 = reinterpret_cast< wxWindow * >(argp1);
35340 {
35341 PyThreadState* __tstate = wxPyBeginAllowThreads();
35342 result = (int)((wxWindow const *)arg1)->GetCharHeight();
35343 wxPyEndAllowThreads(__tstate);
35344 if (PyErr_Occurred()) SWIG_fail;
35345 }
35346 resultobj = SWIG_From_int(static_cast< int >(result));
35347 return resultobj;
35348 fail:
35349 return NULL;
35350 }
35351
35352
35353 SWIGINTERN PyObject *_wrap_Window_GetCharWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35354 PyObject *resultobj = 0;
35355 wxWindow *arg1 = (wxWindow *) 0 ;
35356 int result;
35357 void *argp1 = 0 ;
35358 int res1 = 0 ;
35359 PyObject *swig_obj[1] ;
35360
35361 if (!args) SWIG_fail;
35362 swig_obj[0] = args;
35363 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35364 if (!SWIG_IsOK(res1)) {
35365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
35366 }
35367 arg1 = reinterpret_cast< wxWindow * >(argp1);
35368 {
35369 PyThreadState* __tstate = wxPyBeginAllowThreads();
35370 result = (int)((wxWindow const *)arg1)->GetCharWidth();
35371 wxPyEndAllowThreads(__tstate);
35372 if (PyErr_Occurred()) SWIG_fail;
35373 }
35374 resultobj = SWIG_From_int(static_cast< int >(result));
35375 return resultobj;
35376 fail:
35377 return NULL;
35378 }
35379
35380
35381 SWIGINTERN PyObject *_wrap_Window_GetTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35382 PyObject *resultobj = 0;
35383 wxWindow *arg1 = (wxWindow *) 0 ;
35384 wxString *arg2 = 0 ;
35385 int *arg3 = (int *) 0 ;
35386 int *arg4 = (int *) 0 ;
35387 void *argp1 = 0 ;
35388 int res1 = 0 ;
35389 bool temp2 = false ;
35390 int temp3 ;
35391 int res3 = SWIG_TMPOBJ ;
35392 int temp4 ;
35393 int res4 = SWIG_TMPOBJ ;
35394 PyObject * obj0 = 0 ;
35395 PyObject * obj1 = 0 ;
35396 char * kwnames[] = {
35397 (char *) "self",(char *) "string", NULL
35398 };
35399
35400 arg3 = &temp3;
35401 arg4 = &temp4;
35402 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) SWIG_fail;
35403 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35404 if (!SWIG_IsOK(res1)) {
35405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
35406 }
35407 arg1 = reinterpret_cast< wxWindow * >(argp1);
35408 {
35409 arg2 = wxString_in_helper(obj1);
35410 if (arg2 == NULL) SWIG_fail;
35411 temp2 = true;
35412 }
35413 {
35414 PyThreadState* __tstate = wxPyBeginAllowThreads();
35415 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
35416 wxPyEndAllowThreads(__tstate);
35417 if (PyErr_Occurred()) SWIG_fail;
35418 }
35419 resultobj = SWIG_Py_Void();
35420 if (SWIG_IsTmpObj(res3)) {
35421 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35422 } else {
35423 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35424 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35425 }
35426 if (SWIG_IsTmpObj(res4)) {
35427 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
35428 } else {
35429 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35430 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
35431 }
35432 {
35433 if (temp2)
35434 delete arg2;
35435 }
35436 return resultobj;
35437 fail:
35438 {
35439 if (temp2)
35440 delete arg2;
35441 }
35442 return NULL;
35443 }
35444
35445
35446 SWIGINTERN PyObject *_wrap_Window_GetFullTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35447 PyObject *resultobj = 0;
35448 wxWindow *arg1 = (wxWindow *) 0 ;
35449 wxString *arg2 = 0 ;
35450 int *arg3 = (int *) 0 ;
35451 int *arg4 = (int *) 0 ;
35452 int *arg5 = (int *) 0 ;
35453 int *arg6 = (int *) 0 ;
35454 wxFont *arg7 = (wxFont *) NULL ;
35455 void *argp1 = 0 ;
35456 int res1 = 0 ;
35457 bool temp2 = false ;
35458 int temp3 ;
35459 int res3 = SWIG_TMPOBJ ;
35460 int temp4 ;
35461 int res4 = SWIG_TMPOBJ ;
35462 int temp5 ;
35463 int res5 = SWIG_TMPOBJ ;
35464 int temp6 ;
35465 int res6 = SWIG_TMPOBJ ;
35466 void *argp7 = 0 ;
35467 int res7 = 0 ;
35468 PyObject * obj0 = 0 ;
35469 PyObject * obj1 = 0 ;
35470 PyObject * obj2 = 0 ;
35471 char * kwnames[] = {
35472 (char *) "self",(char *) "string",(char *) "font", NULL
35473 };
35474
35475 arg3 = &temp3;
35476 arg4 = &temp4;
35477 arg5 = &temp5;
35478 arg6 = &temp6;
35479 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35480 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35481 if (!SWIG_IsOK(res1)) {
35482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFullTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
35483 }
35484 arg1 = reinterpret_cast< wxWindow * >(argp1);
35485 {
35486 arg2 = wxString_in_helper(obj1);
35487 if (arg2 == NULL) SWIG_fail;
35488 temp2 = true;
35489 }
35490 if (obj2) {
35491 res7 = SWIG_ConvertPtr(obj2, &argp7,SWIGTYPE_p_wxFont, 0 | 0 );
35492 if (!SWIG_IsOK(res7)) {
35493 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Window_GetFullTextExtent" "', expected argument " "7"" of type '" "wxFont const *""'");
35494 }
35495 arg7 = reinterpret_cast< wxFont * >(argp7);
35496 }
35497 {
35498 PyThreadState* __tstate = wxPyBeginAllowThreads();
35499 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
35500 wxPyEndAllowThreads(__tstate);
35501 if (PyErr_Occurred()) SWIG_fail;
35502 }
35503 resultobj = SWIG_Py_Void();
35504 if (SWIG_IsTmpObj(res3)) {
35505 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35506 } else {
35507 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35508 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35509 }
35510 if (SWIG_IsTmpObj(res4)) {
35511 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
35512 } else {
35513 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35514 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
35515 }
35516 if (SWIG_IsTmpObj(res5)) {
35517 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
35518 } else {
35519 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35520 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
35521 }
35522 if (SWIG_IsTmpObj(res6)) {
35523 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
35524 } else {
35525 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35526 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
35527 }
35528 {
35529 if (temp2)
35530 delete arg2;
35531 }
35532 return resultobj;
35533 fail:
35534 {
35535 if (temp2)
35536 delete arg2;
35537 }
35538 return NULL;
35539 }
35540
35541
35542 SWIGINTERN PyObject *_wrap_Window_ClientToScreenXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35543 PyObject *resultobj = 0;
35544 wxWindow *arg1 = (wxWindow *) 0 ;
35545 int *arg2 = (int *) 0 ;
35546 int *arg3 = (int *) 0 ;
35547 void *argp1 = 0 ;
35548 int res1 = 0 ;
35549 int temp2 ;
35550 int res2 = 0 ;
35551 int temp3 ;
35552 int res3 = 0 ;
35553 PyObject * obj0 = 0 ;
35554 PyObject * obj1 = 0 ;
35555 PyObject * obj2 = 0 ;
35556 char * kwnames[] = {
35557 (char *) "self",(char *) "x",(char *) "y", NULL
35558 };
35559
35560 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35561 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35562 if (!SWIG_IsOK(res1)) {
35563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreenXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35564 }
35565 arg1 = reinterpret_cast< wxWindow * >(argp1);
35566 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
35567 int val;
35568 int ecode = SWIG_AsVal_int(obj1, &val);
35569 if (!SWIG_IsOK(ecode)) {
35570 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "2"" of type '" "int""'");
35571 }
35572 temp2 = static_cast< int >(val);
35573 arg2 = &temp2;
35574 res2 = SWIG_AddTmpMask(ecode);
35575 }
35576 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
35577 int val;
35578 int ecode = SWIG_AsVal_int(obj2, &val);
35579 if (!SWIG_IsOK(ecode)) {
35580 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "3"" of type '" "int""'");
35581 }
35582 temp3 = static_cast< int >(val);
35583 arg3 = &temp3;
35584 res3 = SWIG_AddTmpMask(ecode);
35585 }
35586 {
35587 PyThreadState* __tstate = wxPyBeginAllowThreads();
35588 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
35589 wxPyEndAllowThreads(__tstate);
35590 if (PyErr_Occurred()) SWIG_fail;
35591 }
35592 resultobj = SWIG_Py_Void();
35593 if (SWIG_IsTmpObj(res2)) {
35594 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35595 } else {
35596 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35597 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35598 }
35599 if (SWIG_IsTmpObj(res3)) {
35600 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35601 } else {
35602 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35603 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35604 }
35605 return resultobj;
35606 fail:
35607 return NULL;
35608 }
35609
35610
35611 SWIGINTERN PyObject *_wrap_Window_ScreenToClientXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35612 PyObject *resultobj = 0;
35613 wxWindow *arg1 = (wxWindow *) 0 ;
35614 int *arg2 = (int *) 0 ;
35615 int *arg3 = (int *) 0 ;
35616 void *argp1 = 0 ;
35617 int res1 = 0 ;
35618 int temp2 ;
35619 int res2 = 0 ;
35620 int temp3 ;
35621 int res3 = 0 ;
35622 PyObject * obj0 = 0 ;
35623 PyObject * obj1 = 0 ;
35624 PyObject * obj2 = 0 ;
35625 char * kwnames[] = {
35626 (char *) "self",(char *) "x",(char *) "y", NULL
35627 };
35628
35629 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35630 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35631 if (!SWIG_IsOK(res1)) {
35632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClientXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35633 }
35634 arg1 = reinterpret_cast< wxWindow * >(argp1);
35635 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
35636 int val;
35637 int ecode = SWIG_AsVal_int(obj1, &val);
35638 if (!SWIG_IsOK(ecode)) {
35639 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "2"" of type '" "int""'");
35640 }
35641 temp2 = static_cast< int >(val);
35642 arg2 = &temp2;
35643 res2 = SWIG_AddTmpMask(ecode);
35644 }
35645 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
35646 int val;
35647 int ecode = SWIG_AsVal_int(obj2, &val);
35648 if (!SWIG_IsOK(ecode)) {
35649 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "3"" of type '" "int""'");
35650 }
35651 temp3 = static_cast< int >(val);
35652 arg3 = &temp3;
35653 res3 = SWIG_AddTmpMask(ecode);
35654 }
35655 {
35656 PyThreadState* __tstate = wxPyBeginAllowThreads();
35657 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
35658 wxPyEndAllowThreads(__tstate);
35659 if (PyErr_Occurred()) SWIG_fail;
35660 }
35661 resultobj = SWIG_Py_Void();
35662 if (SWIG_IsTmpObj(res2)) {
35663 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35664 } else {
35665 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35666 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35667 }
35668 if (SWIG_IsTmpObj(res3)) {
35669 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35670 } else {
35671 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35672 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35673 }
35674 return resultobj;
35675 fail:
35676 return NULL;
35677 }
35678
35679
35680 SWIGINTERN PyObject *_wrap_Window_ClientToScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35681 PyObject *resultobj = 0;
35682 wxWindow *arg1 = (wxWindow *) 0 ;
35683 wxPoint *arg2 = 0 ;
35684 wxPoint result;
35685 void *argp1 = 0 ;
35686 int res1 = 0 ;
35687 wxPoint temp2 ;
35688 PyObject * obj0 = 0 ;
35689 PyObject * obj1 = 0 ;
35690 char * kwnames[] = {
35691 (char *) "self",(char *) "pt", NULL
35692 };
35693
35694 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) SWIG_fail;
35695 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35696 if (!SWIG_IsOK(res1)) {
35697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
35698 }
35699 arg1 = reinterpret_cast< wxWindow * >(argp1);
35700 {
35701 arg2 = &temp2;
35702 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35703 }
35704 {
35705 PyThreadState* __tstate = wxPyBeginAllowThreads();
35706 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
35707 wxPyEndAllowThreads(__tstate);
35708 if (PyErr_Occurred()) SWIG_fail;
35709 }
35710 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35711 return resultobj;
35712 fail:
35713 return NULL;
35714 }
35715
35716
35717 SWIGINTERN PyObject *_wrap_Window_ScreenToClient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35718 PyObject *resultobj = 0;
35719 wxWindow *arg1 = (wxWindow *) 0 ;
35720 wxPoint *arg2 = 0 ;
35721 wxPoint result;
35722 void *argp1 = 0 ;
35723 int res1 = 0 ;
35724 wxPoint temp2 ;
35725 PyObject * obj0 = 0 ;
35726 PyObject * obj1 = 0 ;
35727 char * kwnames[] = {
35728 (char *) "self",(char *) "pt", NULL
35729 };
35730
35731 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) SWIG_fail;
35732 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35733 if (!SWIG_IsOK(res1)) {
35734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClient" "', expected argument " "1"" of type '" "wxWindow const *""'");
35735 }
35736 arg1 = reinterpret_cast< wxWindow * >(argp1);
35737 {
35738 arg2 = &temp2;
35739 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35740 }
35741 {
35742 PyThreadState* __tstate = wxPyBeginAllowThreads();
35743 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
35744 wxPyEndAllowThreads(__tstate);
35745 if (PyErr_Occurred()) SWIG_fail;
35746 }
35747 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35748 return resultobj;
35749 fail:
35750 return NULL;
35751 }
35752
35753
35754 SWIGINTERN PyObject *_wrap_Window_HitTestXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35755 PyObject *resultobj = 0;
35756 wxWindow *arg1 = (wxWindow *) 0 ;
35757 int arg2 ;
35758 int arg3 ;
35759 wxHitTest result;
35760 void *argp1 = 0 ;
35761 int res1 = 0 ;
35762 int val2 ;
35763 int ecode2 = 0 ;
35764 int val3 ;
35765 int ecode3 = 0 ;
35766 PyObject * obj0 = 0 ;
35767 PyObject * obj1 = 0 ;
35768 PyObject * obj2 = 0 ;
35769 char * kwnames[] = {
35770 (char *) "self",(char *) "x",(char *) "y", NULL
35771 };
35772
35773 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) 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_HitTestXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35777 }
35778 arg1 = reinterpret_cast< wxWindow * >(argp1);
35779 ecode2 = SWIG_AsVal_int(obj1, &val2);
35780 if (!SWIG_IsOK(ecode2)) {
35781 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HitTestXY" "', expected argument " "2"" of type '" "int""'");
35782 }
35783 arg2 = static_cast< int >(val2);
35784 ecode3 = SWIG_AsVal_int(obj2, &val3);
35785 if (!SWIG_IsOK(ecode3)) {
35786 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_HitTestXY" "', expected argument " "3"" of type '" "int""'");
35787 }
35788 arg3 = static_cast< int >(val3);
35789 {
35790 PyThreadState* __tstate = wxPyBeginAllowThreads();
35791 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
35792 wxPyEndAllowThreads(__tstate);
35793 if (PyErr_Occurred()) SWIG_fail;
35794 }
35795 resultobj = SWIG_From_int(static_cast< int >(result));
35796 return resultobj;
35797 fail:
35798 return NULL;
35799 }
35800
35801
35802 SWIGINTERN PyObject *_wrap_Window_HitTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35803 PyObject *resultobj = 0;
35804 wxWindow *arg1 = (wxWindow *) 0 ;
35805 wxPoint *arg2 = 0 ;
35806 wxHitTest result;
35807 void *argp1 = 0 ;
35808 int res1 = 0 ;
35809 wxPoint temp2 ;
35810 PyObject * obj0 = 0 ;
35811 PyObject * obj1 = 0 ;
35812 char * kwnames[] = {
35813 (char *) "self",(char *) "pt", NULL
35814 };
35815
35816 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) SWIG_fail;
35817 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35818 if (!SWIG_IsOK(res1)) {
35819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTest" "', expected argument " "1"" of type '" "wxWindow const *""'");
35820 }
35821 arg1 = reinterpret_cast< wxWindow * >(argp1);
35822 {
35823 arg2 = &temp2;
35824 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35825 }
35826 {
35827 PyThreadState* __tstate = wxPyBeginAllowThreads();
35828 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
35829 wxPyEndAllowThreads(__tstate);
35830 if (PyErr_Occurred()) SWIG_fail;
35831 }
35832 resultobj = SWIG_From_int(static_cast< int >(result));
35833 return resultobj;
35834 fail:
35835 return NULL;
35836 }
35837
35838
35839 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
35840 PyObject *resultobj = 0;
35841 wxWindow *arg1 = (wxWindow *) 0 ;
35842 long arg2 ;
35843 wxBorder result;
35844 void *argp1 = 0 ;
35845 int res1 = 0 ;
35846 long val2 ;
35847 int ecode2 = 0 ;
35848
35849 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
35850 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35851 if (!SWIG_IsOK(res1)) {
35852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
35853 }
35854 arg1 = reinterpret_cast< wxWindow * >(argp1);
35855 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
35856 if (!SWIG_IsOK(ecode2)) {
35857 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetBorder" "', expected argument " "2"" of type '" "long""'");
35858 }
35859 arg2 = static_cast< long >(val2);
35860 {
35861 PyThreadState* __tstate = wxPyBeginAllowThreads();
35862 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
35863 wxPyEndAllowThreads(__tstate);
35864 if (PyErr_Occurred()) SWIG_fail;
35865 }
35866 resultobj = SWIG_From_int(static_cast< int >(result));
35867 return resultobj;
35868 fail:
35869 return NULL;
35870 }
35871
35872
35873 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
35874 PyObject *resultobj = 0;
35875 wxWindow *arg1 = (wxWindow *) 0 ;
35876 wxBorder result;
35877 void *argp1 = 0 ;
35878 int res1 = 0 ;
35879
35880 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
35881 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35882 if (!SWIG_IsOK(res1)) {
35883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
35884 }
35885 arg1 = reinterpret_cast< wxWindow * >(argp1);
35886 {
35887 PyThreadState* __tstate = wxPyBeginAllowThreads();
35888 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
35889 wxPyEndAllowThreads(__tstate);
35890 if (PyErr_Occurred()) SWIG_fail;
35891 }
35892 resultobj = SWIG_From_int(static_cast< int >(result));
35893 return resultobj;
35894 fail:
35895 return NULL;
35896 }
35897
35898
35899 SWIGINTERN PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
35900 int argc;
35901 PyObject *argv[3];
35902
35903 if (!(argc = SWIG_Python_UnpackTuple(args,"Window_GetBorder",0,2,argv))) SWIG_fail;
35904 --argc;
35905 if (argc == 1) {
35906 return _wrap_Window_GetBorder__SWIG_1(self, argc, argv);
35907 }
35908 if (argc == 2) {
35909 return _wrap_Window_GetBorder__SWIG_0(self, argc, argv);
35910 }
35911
35912 fail:
35913 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
35914 return NULL;
35915 }
35916
35917
35918 SWIGINTERN PyObject *_wrap_Window_UpdateWindowUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35919 PyObject *resultobj = 0;
35920 wxWindow *arg1 = (wxWindow *) 0 ;
35921 long arg2 = (long) wxUPDATE_UI_NONE ;
35922 void *argp1 = 0 ;
35923 int res1 = 0 ;
35924 long val2 ;
35925 int ecode2 = 0 ;
35926 PyObject * obj0 = 0 ;
35927 PyObject * obj1 = 0 ;
35928 char * kwnames[] = {
35929 (char *) "self",(char *) "flags", NULL
35930 };
35931
35932 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) SWIG_fail;
35933 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35934 if (!SWIG_IsOK(res1)) {
35935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UpdateWindowUI" "', expected argument " "1"" of type '" "wxWindow *""'");
35936 }
35937 arg1 = reinterpret_cast< wxWindow * >(argp1);
35938 if (obj1) {
35939 ecode2 = SWIG_AsVal_long(obj1, &val2);
35940 if (!SWIG_IsOK(ecode2)) {
35941 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UpdateWindowUI" "', expected argument " "2"" of type '" "long""'");
35942 }
35943 arg2 = static_cast< long >(val2);
35944 }
35945 {
35946 PyThreadState* __tstate = wxPyBeginAllowThreads();
35947 (arg1)->UpdateWindowUI(arg2);
35948 wxPyEndAllowThreads(__tstate);
35949 if (PyErr_Occurred()) SWIG_fail;
35950 }
35951 resultobj = SWIG_Py_Void();
35952 return resultobj;
35953 fail:
35954 return NULL;
35955 }
35956
35957
35958 SWIGINTERN PyObject *_wrap_Window_PopupMenuXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35959 PyObject *resultobj = 0;
35960 wxWindow *arg1 = (wxWindow *) 0 ;
35961 wxMenu *arg2 = (wxMenu *) 0 ;
35962 int arg3 = (int) -1 ;
35963 int arg4 = (int) -1 ;
35964 bool result;
35965 void *argp1 = 0 ;
35966 int res1 = 0 ;
35967 void *argp2 = 0 ;
35968 int res2 = 0 ;
35969 int val3 ;
35970 int ecode3 = 0 ;
35971 int val4 ;
35972 int ecode4 = 0 ;
35973 PyObject * obj0 = 0 ;
35974 PyObject * obj1 = 0 ;
35975 PyObject * obj2 = 0 ;
35976 PyObject * obj3 = 0 ;
35977 char * kwnames[] = {
35978 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
35979 };
35980
35981 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35982 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35983 if (!SWIG_IsOK(res1)) {
35984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenuXY" "', expected argument " "1"" of type '" "wxWindow *""'");
35985 }
35986 arg1 = reinterpret_cast< wxWindow * >(argp1);
35987 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
35988 if (!SWIG_IsOK(res2)) {
35989 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenuXY" "', expected argument " "2"" of type '" "wxMenu *""'");
35990 }
35991 arg2 = reinterpret_cast< wxMenu * >(argp2);
35992 if (obj2) {
35993 ecode3 = SWIG_AsVal_int(obj2, &val3);
35994 if (!SWIG_IsOK(ecode3)) {
35995 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_PopupMenuXY" "', expected argument " "3"" of type '" "int""'");
35996 }
35997 arg3 = static_cast< int >(val3);
35998 }
35999 if (obj3) {
36000 ecode4 = SWIG_AsVal_int(obj3, &val4);
36001 if (!SWIG_IsOK(ecode4)) {
36002 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_PopupMenuXY" "', expected argument " "4"" of type '" "int""'");
36003 }
36004 arg4 = static_cast< int >(val4);
36005 }
36006 {
36007 PyThreadState* __tstate = wxPyBeginAllowThreads();
36008 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
36009 wxPyEndAllowThreads(__tstate);
36010 if (PyErr_Occurred()) SWIG_fail;
36011 }
36012 {
36013 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36014 }
36015 return resultobj;
36016 fail:
36017 return NULL;
36018 }
36019
36020
36021 SWIGINTERN PyObject *_wrap_Window_PopupMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36022 PyObject *resultobj = 0;
36023 wxWindow *arg1 = (wxWindow *) 0 ;
36024 wxMenu *arg2 = (wxMenu *) 0 ;
36025 wxPoint const &arg3_defvalue = wxDefaultPosition ;
36026 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
36027 bool result;
36028 void *argp1 = 0 ;
36029 int res1 = 0 ;
36030 void *argp2 = 0 ;
36031 int res2 = 0 ;
36032 wxPoint temp3 ;
36033 PyObject * obj0 = 0 ;
36034 PyObject * obj1 = 0 ;
36035 PyObject * obj2 = 0 ;
36036 char * kwnames[] = {
36037 (char *) "self",(char *) "menu",(char *) "pos", NULL
36038 };
36039
36040 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36041 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36042 if (!SWIG_IsOK(res1)) {
36043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenu" "', expected argument " "1"" of type '" "wxWindow *""'");
36044 }
36045 arg1 = reinterpret_cast< wxWindow * >(argp1);
36046 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
36047 if (!SWIG_IsOK(res2)) {
36048 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
36049 }
36050 arg2 = reinterpret_cast< wxMenu * >(argp2);
36051 if (obj2) {
36052 {
36053 arg3 = &temp3;
36054 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
36055 }
36056 }
36057 {
36058 PyThreadState* __tstate = wxPyBeginAllowThreads();
36059 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
36060 wxPyEndAllowThreads(__tstate);
36061 if (PyErr_Occurred()) SWIG_fail;
36062 }
36063 {
36064 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36065 }
36066 return resultobj;
36067 fail:
36068 return NULL;
36069 }
36070
36071
36072 SWIGINTERN PyObject *_wrap_Window_GetHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36073 PyObject *resultobj = 0;
36074 wxWindow *arg1 = (wxWindow *) 0 ;
36075 long result;
36076 void *argp1 = 0 ;
36077 int res1 = 0 ;
36078 PyObject *swig_obj[1] ;
36079
36080 if (!args) SWIG_fail;
36081 swig_obj[0] = args;
36082 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36083 if (!SWIG_IsOK(res1)) {
36084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36085 }
36086 arg1 = reinterpret_cast< wxWindow * >(argp1);
36087 {
36088 PyThreadState* __tstate = wxPyBeginAllowThreads();
36089 result = (long)wxWindow_GetHandle(arg1);
36090 wxPyEndAllowThreads(__tstate);
36091 if (PyErr_Occurred()) SWIG_fail;
36092 }
36093 resultobj = SWIG_From_long(static_cast< long >(result));
36094 return resultobj;
36095 fail:
36096 return NULL;
36097 }
36098
36099
36100 SWIGINTERN PyObject *_wrap_Window_AssociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36101 PyObject *resultobj = 0;
36102 wxWindow *arg1 = (wxWindow *) 0 ;
36103 long arg2 ;
36104 void *argp1 = 0 ;
36105 int res1 = 0 ;
36106 long val2 ;
36107 int ecode2 = 0 ;
36108 PyObject * obj0 = 0 ;
36109 PyObject * obj1 = 0 ;
36110 char * kwnames[] = {
36111 (char *) "self",(char *) "handle", NULL
36112 };
36113
36114 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) SWIG_fail;
36115 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36116 if (!SWIG_IsOK(res1)) {
36117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AssociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36118 }
36119 arg1 = reinterpret_cast< wxWindow * >(argp1);
36120 ecode2 = SWIG_AsVal_long(obj1, &val2);
36121 if (!SWIG_IsOK(ecode2)) {
36122 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AssociateHandle" "', expected argument " "2"" of type '" "long""'");
36123 }
36124 arg2 = static_cast< long >(val2);
36125 {
36126 PyThreadState* __tstate = wxPyBeginAllowThreads();
36127 wxWindow_AssociateHandle(arg1,arg2);
36128 wxPyEndAllowThreads(__tstate);
36129 if (PyErr_Occurred()) SWIG_fail;
36130 }
36131 resultobj = SWIG_Py_Void();
36132 return resultobj;
36133 fail:
36134 return NULL;
36135 }
36136
36137
36138 SWIGINTERN PyObject *_wrap_Window_DissociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36139 PyObject *resultobj = 0;
36140 wxWindow *arg1 = (wxWindow *) 0 ;
36141 void *argp1 = 0 ;
36142 int res1 = 0 ;
36143 PyObject *swig_obj[1] ;
36144
36145 if (!args) SWIG_fail;
36146 swig_obj[0] = args;
36147 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36148 if (!SWIG_IsOK(res1)) {
36149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DissociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36150 }
36151 arg1 = reinterpret_cast< wxWindow * >(argp1);
36152 {
36153 PyThreadState* __tstate = wxPyBeginAllowThreads();
36154 (arg1)->DissociateHandle();
36155 wxPyEndAllowThreads(__tstate);
36156 if (PyErr_Occurred()) SWIG_fail;
36157 }
36158 resultobj = SWIG_Py_Void();
36159 return resultobj;
36160 fail:
36161 return NULL;
36162 }
36163
36164
36165 SWIGINTERN PyObject *_wrap_Window_OnPaint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36166 PyObject *resultobj = 0;
36167 wxWindow *arg1 = (wxWindow *) 0 ;
36168 wxPaintEvent *arg2 = 0 ;
36169 void *argp1 = 0 ;
36170 int res1 = 0 ;
36171 void *argp2 = 0 ;
36172 int res2 = 0 ;
36173 PyObject * obj0 = 0 ;
36174 PyObject * obj1 = 0 ;
36175 char * kwnames[] = {
36176 (char *) "self",(char *) "event", NULL
36177 };
36178
36179 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_OnPaint",kwnames,&obj0,&obj1)) SWIG_fail;
36180 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36181 if (!SWIG_IsOK(res1)) {
36182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_OnPaint" "', expected argument " "1"" of type '" "wxWindow *""'");
36183 }
36184 arg1 = reinterpret_cast< wxWindow * >(argp1);
36185 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPaintEvent, 0 );
36186 if (!SWIG_IsOK(res2)) {
36187 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_OnPaint" "', expected argument " "2"" of type '" "wxPaintEvent &""'");
36188 }
36189 if (!argp2) {
36190 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_OnPaint" "', expected argument " "2"" of type '" "wxPaintEvent &""'");
36191 }
36192 arg2 = reinterpret_cast< wxPaintEvent * >(argp2);
36193 {
36194 PyThreadState* __tstate = wxPyBeginAllowThreads();
36195 (arg1)->OnPaint(*arg2);
36196 wxPyEndAllowThreads(__tstate);
36197 if (PyErr_Occurred()) SWIG_fail;
36198 }
36199 resultobj = SWIG_Py_Void();
36200 return resultobj;
36201 fail:
36202 return NULL;
36203 }
36204
36205
36206 SWIGINTERN PyObject *_wrap_Window_HasScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36207 PyObject *resultobj = 0;
36208 wxWindow *arg1 = (wxWindow *) 0 ;
36209 int arg2 ;
36210 bool result;
36211 void *argp1 = 0 ;
36212 int res1 = 0 ;
36213 int val2 ;
36214 int ecode2 = 0 ;
36215 PyObject * obj0 = 0 ;
36216 PyObject * obj1 = 0 ;
36217 char * kwnames[] = {
36218 (char *) "self",(char *) "orient", NULL
36219 };
36220
36221 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) SWIG_fail;
36222 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36223 if (!SWIG_IsOK(res1)) {
36224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasScrollbar" "', expected argument " "1"" of type '" "wxWindow const *""'");
36225 }
36226 arg1 = reinterpret_cast< wxWindow * >(argp1);
36227 ecode2 = SWIG_AsVal_int(obj1, &val2);
36228 if (!SWIG_IsOK(ecode2)) {
36229 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasScrollbar" "', expected argument " "2"" of type '" "int""'");
36230 }
36231 arg2 = static_cast< int >(val2);
36232 {
36233 PyThreadState* __tstate = wxPyBeginAllowThreads();
36234 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
36235 wxPyEndAllowThreads(__tstate);
36236 if (PyErr_Occurred()) SWIG_fail;
36237 }
36238 {
36239 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36240 }
36241 return resultobj;
36242 fail:
36243 return NULL;
36244 }
36245
36246
36247 SWIGINTERN PyObject *_wrap_Window_SetScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36248 PyObject *resultobj = 0;
36249 wxWindow *arg1 = (wxWindow *) 0 ;
36250 int arg2 ;
36251 int arg3 ;
36252 int arg4 ;
36253 int arg5 ;
36254 bool arg6 = (bool) true ;
36255 void *argp1 = 0 ;
36256 int res1 = 0 ;
36257 int val2 ;
36258 int ecode2 = 0 ;
36259 int val3 ;
36260 int ecode3 = 0 ;
36261 int val4 ;
36262 int ecode4 = 0 ;
36263 int val5 ;
36264 int ecode5 = 0 ;
36265 bool val6 ;
36266 int ecode6 = 0 ;
36267 PyObject * obj0 = 0 ;
36268 PyObject * obj1 = 0 ;
36269 PyObject * obj2 = 0 ;
36270 PyObject * obj3 = 0 ;
36271 PyObject * obj4 = 0 ;
36272 PyObject * obj5 = 0 ;
36273 char * kwnames[] = {
36274 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
36275 };
36276
36277 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
36278 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36279 if (!SWIG_IsOK(res1)) {
36280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollbar" "', expected argument " "1"" of type '" "wxWindow *""'");
36281 }
36282 arg1 = reinterpret_cast< wxWindow * >(argp1);
36283 ecode2 = SWIG_AsVal_int(obj1, &val2);
36284 if (!SWIG_IsOK(ecode2)) {
36285 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollbar" "', expected argument " "2"" of type '" "int""'");
36286 }
36287 arg2 = static_cast< int >(val2);
36288 ecode3 = SWIG_AsVal_int(obj2, &val3);
36289 if (!SWIG_IsOK(ecode3)) {
36290 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollbar" "', expected argument " "3"" of type '" "int""'");
36291 }
36292 arg3 = static_cast< int >(val3);
36293 ecode4 = SWIG_AsVal_int(obj3, &val4);
36294 if (!SWIG_IsOK(ecode4)) {
36295 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollbar" "', expected argument " "4"" of type '" "int""'");
36296 }
36297 arg4 = static_cast< int >(val4);
36298 ecode5 = SWIG_AsVal_int(obj4, &val5);
36299 if (!SWIG_IsOK(ecode5)) {
36300 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetScrollbar" "', expected argument " "5"" of type '" "int""'");
36301 }
36302 arg5 = static_cast< int >(val5);
36303 if (obj5) {
36304 ecode6 = SWIG_AsVal_bool(obj5, &val6);
36305 if (!SWIG_IsOK(ecode6)) {
36306 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetScrollbar" "', expected argument " "6"" of type '" "bool""'");
36307 }
36308 arg6 = static_cast< bool >(val6);
36309 }
36310 {
36311 PyThreadState* __tstate = wxPyBeginAllowThreads();
36312 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
36313 wxPyEndAllowThreads(__tstate);
36314 if (PyErr_Occurred()) SWIG_fail;
36315 }
36316 resultobj = SWIG_Py_Void();
36317 return resultobj;
36318 fail:
36319 return NULL;
36320 }
36321
36322
36323 SWIGINTERN PyObject *_wrap_Window_SetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36324 PyObject *resultobj = 0;
36325 wxWindow *arg1 = (wxWindow *) 0 ;
36326 int arg2 ;
36327 int arg3 ;
36328 bool arg4 = (bool) true ;
36329 void *argp1 = 0 ;
36330 int res1 = 0 ;
36331 int val2 ;
36332 int ecode2 = 0 ;
36333 int val3 ;
36334 int ecode3 = 0 ;
36335 bool val4 ;
36336 int ecode4 = 0 ;
36337 PyObject * obj0 = 0 ;
36338 PyObject * obj1 = 0 ;
36339 PyObject * obj2 = 0 ;
36340 PyObject * obj3 = 0 ;
36341 char * kwnames[] = {
36342 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
36343 };
36344
36345 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36346 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36347 if (!SWIG_IsOK(res1)) {
36348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollPos" "', expected argument " "1"" of type '" "wxWindow *""'");
36349 }
36350 arg1 = reinterpret_cast< wxWindow * >(argp1);
36351 ecode2 = SWIG_AsVal_int(obj1, &val2);
36352 if (!SWIG_IsOK(ecode2)) {
36353 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollPos" "', expected argument " "2"" of type '" "int""'");
36354 }
36355 arg2 = static_cast< int >(val2);
36356 ecode3 = SWIG_AsVal_int(obj2, &val3);
36357 if (!SWIG_IsOK(ecode3)) {
36358 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollPos" "', expected argument " "3"" of type '" "int""'");
36359 }
36360 arg3 = static_cast< int >(val3);
36361 if (obj3) {
36362 ecode4 = SWIG_AsVal_bool(obj3, &val4);
36363 if (!SWIG_IsOK(ecode4)) {
36364 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollPos" "', expected argument " "4"" of type '" "bool""'");
36365 }
36366 arg4 = static_cast< bool >(val4);
36367 }
36368 {
36369 PyThreadState* __tstate = wxPyBeginAllowThreads();
36370 (arg1)->SetScrollPos(arg2,arg3,arg4);
36371 wxPyEndAllowThreads(__tstate);
36372 if (PyErr_Occurred()) SWIG_fail;
36373 }
36374 resultobj = SWIG_Py_Void();
36375 return resultobj;
36376 fail:
36377 return NULL;
36378 }
36379
36380
36381 SWIGINTERN PyObject *_wrap_Window_GetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36382 PyObject *resultobj = 0;
36383 wxWindow *arg1 = (wxWindow *) 0 ;
36384 int arg2 ;
36385 int result;
36386 void *argp1 = 0 ;
36387 int res1 = 0 ;
36388 int val2 ;
36389 int ecode2 = 0 ;
36390 PyObject * obj0 = 0 ;
36391 PyObject * obj1 = 0 ;
36392 char * kwnames[] = {
36393 (char *) "self",(char *) "orientation", NULL
36394 };
36395
36396 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) SWIG_fail;
36397 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36398 if (!SWIG_IsOK(res1)) {
36399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollPos" "', expected argument " "1"" of type '" "wxWindow const *""'");
36400 }
36401 arg1 = reinterpret_cast< wxWindow * >(argp1);
36402 ecode2 = SWIG_AsVal_int(obj1, &val2);
36403 if (!SWIG_IsOK(ecode2)) {
36404 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollPos" "', expected argument " "2"" of type '" "int""'");
36405 }
36406 arg2 = static_cast< int >(val2);
36407 {
36408 PyThreadState* __tstate = wxPyBeginAllowThreads();
36409 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
36410 wxPyEndAllowThreads(__tstate);
36411 if (PyErr_Occurred()) SWIG_fail;
36412 }
36413 resultobj = SWIG_From_int(static_cast< int >(result));
36414 return resultobj;
36415 fail:
36416 return NULL;
36417 }
36418
36419
36420 SWIGINTERN PyObject *_wrap_Window_GetScrollThumb(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36421 PyObject *resultobj = 0;
36422 wxWindow *arg1 = (wxWindow *) 0 ;
36423 int arg2 ;
36424 int result;
36425 void *argp1 = 0 ;
36426 int res1 = 0 ;
36427 int val2 ;
36428 int ecode2 = 0 ;
36429 PyObject * obj0 = 0 ;
36430 PyObject * obj1 = 0 ;
36431 char * kwnames[] = {
36432 (char *) "self",(char *) "orientation", NULL
36433 };
36434
36435 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) SWIG_fail;
36436 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36437 if (!SWIG_IsOK(res1)) {
36438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollThumb" "', expected argument " "1"" of type '" "wxWindow const *""'");
36439 }
36440 arg1 = reinterpret_cast< wxWindow * >(argp1);
36441 ecode2 = SWIG_AsVal_int(obj1, &val2);
36442 if (!SWIG_IsOK(ecode2)) {
36443 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollThumb" "', expected argument " "2"" of type '" "int""'");
36444 }
36445 arg2 = static_cast< int >(val2);
36446 {
36447 PyThreadState* __tstate = wxPyBeginAllowThreads();
36448 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
36449 wxPyEndAllowThreads(__tstate);
36450 if (PyErr_Occurred()) SWIG_fail;
36451 }
36452 resultobj = SWIG_From_int(static_cast< int >(result));
36453 return resultobj;
36454 fail:
36455 return NULL;
36456 }
36457
36458
36459 SWIGINTERN PyObject *_wrap_Window_GetScrollRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36460 PyObject *resultobj = 0;
36461 wxWindow *arg1 = (wxWindow *) 0 ;
36462 int arg2 ;
36463 int result;
36464 void *argp1 = 0 ;
36465 int res1 = 0 ;
36466 int val2 ;
36467 int ecode2 = 0 ;
36468 PyObject * obj0 = 0 ;
36469 PyObject * obj1 = 0 ;
36470 char * kwnames[] = {
36471 (char *) "self",(char *) "orientation", NULL
36472 };
36473
36474 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) SWIG_fail;
36475 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36476 if (!SWIG_IsOK(res1)) {
36477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollRange" "', expected argument " "1"" of type '" "wxWindow const *""'");
36478 }
36479 arg1 = reinterpret_cast< wxWindow * >(argp1);
36480 ecode2 = SWIG_AsVal_int(obj1, &val2);
36481 if (!SWIG_IsOK(ecode2)) {
36482 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollRange" "', expected argument " "2"" of type '" "int""'");
36483 }
36484 arg2 = static_cast< int >(val2);
36485 {
36486 PyThreadState* __tstate = wxPyBeginAllowThreads();
36487 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
36488 wxPyEndAllowThreads(__tstate);
36489 if (PyErr_Occurred()) SWIG_fail;
36490 }
36491 resultobj = SWIG_From_int(static_cast< int >(result));
36492 return resultobj;
36493 fail:
36494 return NULL;
36495 }
36496
36497
36498 SWIGINTERN PyObject *_wrap_Window_ScrollWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36499 PyObject *resultobj = 0;
36500 wxWindow *arg1 = (wxWindow *) 0 ;
36501 int arg2 ;
36502 int arg3 ;
36503 wxRect *arg4 = (wxRect *) NULL ;
36504 void *argp1 = 0 ;
36505 int res1 = 0 ;
36506 int val2 ;
36507 int ecode2 = 0 ;
36508 int val3 ;
36509 int ecode3 = 0 ;
36510 void *argp4 = 0 ;
36511 int res4 = 0 ;
36512 PyObject * obj0 = 0 ;
36513 PyObject * obj1 = 0 ;
36514 PyObject * obj2 = 0 ;
36515 PyObject * obj3 = 0 ;
36516 char * kwnames[] = {
36517 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
36518 };
36519
36520 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36521 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36522 if (!SWIG_IsOK(res1)) {
36523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
36524 }
36525 arg1 = reinterpret_cast< wxWindow * >(argp1);
36526 ecode2 = SWIG_AsVal_int(obj1, &val2);
36527 if (!SWIG_IsOK(ecode2)) {
36528 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollWindow" "', expected argument " "2"" of type '" "int""'");
36529 }
36530 arg2 = static_cast< int >(val2);
36531 ecode3 = SWIG_AsVal_int(obj2, &val3);
36532 if (!SWIG_IsOK(ecode3)) {
36533 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_ScrollWindow" "', expected argument " "3"" of type '" "int""'");
36534 }
36535 arg3 = static_cast< int >(val3);
36536 if (obj3) {
36537 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxRect, 0 | 0 );
36538 if (!SWIG_IsOK(res4)) {
36539 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Window_ScrollWindow" "', expected argument " "4"" of type '" "wxRect const *""'");
36540 }
36541 arg4 = reinterpret_cast< wxRect * >(argp4);
36542 }
36543 {
36544 PyThreadState* __tstate = wxPyBeginAllowThreads();
36545 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
36546 wxPyEndAllowThreads(__tstate);
36547 if (PyErr_Occurred()) SWIG_fail;
36548 }
36549 resultobj = SWIG_Py_Void();
36550 return resultobj;
36551 fail:
36552 return NULL;
36553 }
36554
36555
36556 SWIGINTERN PyObject *_wrap_Window_ScrollLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36557 PyObject *resultobj = 0;
36558 wxWindow *arg1 = (wxWindow *) 0 ;
36559 int arg2 ;
36560 bool result;
36561 void *argp1 = 0 ;
36562 int res1 = 0 ;
36563 int val2 ;
36564 int ecode2 = 0 ;
36565 PyObject * obj0 = 0 ;
36566 PyObject * obj1 = 0 ;
36567 char * kwnames[] = {
36568 (char *) "self",(char *) "lines", NULL
36569 };
36570
36571 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) SWIG_fail;
36572 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36573 if (!SWIG_IsOK(res1)) {
36574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollLines" "', expected argument " "1"" of type '" "wxWindow *""'");
36575 }
36576 arg1 = reinterpret_cast< wxWindow * >(argp1);
36577 ecode2 = SWIG_AsVal_int(obj1, &val2);
36578 if (!SWIG_IsOK(ecode2)) {
36579 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollLines" "', expected argument " "2"" of type '" "int""'");
36580 }
36581 arg2 = static_cast< int >(val2);
36582 {
36583 PyThreadState* __tstate = wxPyBeginAllowThreads();
36584 result = (bool)(arg1)->ScrollLines(arg2);
36585 wxPyEndAllowThreads(__tstate);
36586 if (PyErr_Occurred()) SWIG_fail;
36587 }
36588 {
36589 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36590 }
36591 return resultobj;
36592 fail:
36593 return NULL;
36594 }
36595
36596
36597 SWIGINTERN PyObject *_wrap_Window_ScrollPages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36598 PyObject *resultobj = 0;
36599 wxWindow *arg1 = (wxWindow *) 0 ;
36600 int arg2 ;
36601 bool result;
36602 void *argp1 = 0 ;
36603 int res1 = 0 ;
36604 int val2 ;
36605 int ecode2 = 0 ;
36606 PyObject * obj0 = 0 ;
36607 PyObject * obj1 = 0 ;
36608 char * kwnames[] = {
36609 (char *) "self",(char *) "pages", NULL
36610 };
36611
36612 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) SWIG_fail;
36613 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36614 if (!SWIG_IsOK(res1)) {
36615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollPages" "', expected argument " "1"" of type '" "wxWindow *""'");
36616 }
36617 arg1 = reinterpret_cast< wxWindow * >(argp1);
36618 ecode2 = SWIG_AsVal_int(obj1, &val2);
36619 if (!SWIG_IsOK(ecode2)) {
36620 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollPages" "', expected argument " "2"" of type '" "int""'");
36621 }
36622 arg2 = static_cast< int >(val2);
36623 {
36624 PyThreadState* __tstate = wxPyBeginAllowThreads();
36625 result = (bool)(arg1)->ScrollPages(arg2);
36626 wxPyEndAllowThreads(__tstate);
36627 if (PyErr_Occurred()) SWIG_fail;
36628 }
36629 {
36630 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36631 }
36632 return resultobj;
36633 fail:
36634 return NULL;
36635 }
36636
36637
36638 SWIGINTERN PyObject *_wrap_Window_LineUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36639 PyObject *resultobj = 0;
36640 wxWindow *arg1 = (wxWindow *) 0 ;
36641 bool result;
36642 void *argp1 = 0 ;
36643 int res1 = 0 ;
36644 PyObject *swig_obj[1] ;
36645
36646 if (!args) SWIG_fail;
36647 swig_obj[0] = args;
36648 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36649 if (!SWIG_IsOK(res1)) {
36650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineUp" "', expected argument " "1"" of type '" "wxWindow *""'");
36651 }
36652 arg1 = reinterpret_cast< wxWindow * >(argp1);
36653 {
36654 PyThreadState* __tstate = wxPyBeginAllowThreads();
36655 result = (bool)(arg1)->LineUp();
36656 wxPyEndAllowThreads(__tstate);
36657 if (PyErr_Occurred()) SWIG_fail;
36658 }
36659 {
36660 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36661 }
36662 return resultobj;
36663 fail:
36664 return NULL;
36665 }
36666
36667
36668 SWIGINTERN PyObject *_wrap_Window_LineDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36669 PyObject *resultobj = 0;
36670 wxWindow *arg1 = (wxWindow *) 0 ;
36671 bool result;
36672 void *argp1 = 0 ;
36673 int res1 = 0 ;
36674 PyObject *swig_obj[1] ;
36675
36676 if (!args) SWIG_fail;
36677 swig_obj[0] = args;
36678 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36679 if (!SWIG_IsOK(res1)) {
36680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineDown" "', expected argument " "1"" of type '" "wxWindow *""'");
36681 }
36682 arg1 = reinterpret_cast< wxWindow * >(argp1);
36683 {
36684 PyThreadState* __tstate = wxPyBeginAllowThreads();
36685 result = (bool)(arg1)->LineDown();
36686 wxPyEndAllowThreads(__tstate);
36687 if (PyErr_Occurred()) SWIG_fail;
36688 }
36689 {
36690 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36691 }
36692 return resultobj;
36693 fail:
36694 return NULL;
36695 }
36696
36697
36698 SWIGINTERN PyObject *_wrap_Window_PageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36699 PyObject *resultobj = 0;
36700 wxWindow *arg1 = (wxWindow *) 0 ;
36701 bool result;
36702 void *argp1 = 0 ;
36703 int res1 = 0 ;
36704 PyObject *swig_obj[1] ;
36705
36706 if (!args) SWIG_fail;
36707 swig_obj[0] = args;
36708 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36709 if (!SWIG_IsOK(res1)) {
36710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageUp" "', expected argument " "1"" of type '" "wxWindow *""'");
36711 }
36712 arg1 = reinterpret_cast< wxWindow * >(argp1);
36713 {
36714 PyThreadState* __tstate = wxPyBeginAllowThreads();
36715 result = (bool)(arg1)->PageUp();
36716 wxPyEndAllowThreads(__tstate);
36717 if (PyErr_Occurred()) SWIG_fail;
36718 }
36719 {
36720 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36721 }
36722 return resultobj;
36723 fail:
36724 return NULL;
36725 }
36726
36727
36728 SWIGINTERN PyObject *_wrap_Window_PageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36729 PyObject *resultobj = 0;
36730 wxWindow *arg1 = (wxWindow *) 0 ;
36731 bool result;
36732 void *argp1 = 0 ;
36733 int res1 = 0 ;
36734 PyObject *swig_obj[1] ;
36735
36736 if (!args) SWIG_fail;
36737 swig_obj[0] = args;
36738 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36739 if (!SWIG_IsOK(res1)) {
36740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageDown" "', expected argument " "1"" of type '" "wxWindow *""'");
36741 }
36742 arg1 = reinterpret_cast< wxWindow * >(argp1);
36743 {
36744 PyThreadState* __tstate = wxPyBeginAllowThreads();
36745 result = (bool)(arg1)->PageDown();
36746 wxPyEndAllowThreads(__tstate);
36747 if (PyErr_Occurred()) SWIG_fail;
36748 }
36749 {
36750 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36751 }
36752 return resultobj;
36753 fail:
36754 return NULL;
36755 }
36756
36757
36758 SWIGINTERN PyObject *_wrap_Window_SetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36759 PyObject *resultobj = 0;
36760 wxWindow *arg1 = (wxWindow *) 0 ;
36761 wxString *arg2 = 0 ;
36762 void *argp1 = 0 ;
36763 int res1 = 0 ;
36764 bool temp2 = false ;
36765 PyObject * obj0 = 0 ;
36766 PyObject * obj1 = 0 ;
36767 char * kwnames[] = {
36768 (char *) "self",(char *) "text", NULL
36769 };
36770
36771 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) SWIG_fail;
36772 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36773 if (!SWIG_IsOK(res1)) {
36774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpText" "', expected argument " "1"" of type '" "wxWindow *""'");
36775 }
36776 arg1 = reinterpret_cast< wxWindow * >(argp1);
36777 {
36778 arg2 = wxString_in_helper(obj1);
36779 if (arg2 == NULL) SWIG_fail;
36780 temp2 = true;
36781 }
36782 {
36783 PyThreadState* __tstate = wxPyBeginAllowThreads();
36784 (arg1)->SetHelpText((wxString const &)*arg2);
36785 wxPyEndAllowThreads(__tstate);
36786 if (PyErr_Occurred()) SWIG_fail;
36787 }
36788 resultobj = SWIG_Py_Void();
36789 {
36790 if (temp2)
36791 delete arg2;
36792 }
36793 return resultobj;
36794 fail:
36795 {
36796 if (temp2)
36797 delete arg2;
36798 }
36799 return NULL;
36800 }
36801
36802
36803 SWIGINTERN PyObject *_wrap_Window_SetHelpTextForId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36804 PyObject *resultobj = 0;
36805 wxWindow *arg1 = (wxWindow *) 0 ;
36806 wxString *arg2 = 0 ;
36807 void *argp1 = 0 ;
36808 int res1 = 0 ;
36809 bool temp2 = false ;
36810 PyObject * obj0 = 0 ;
36811 PyObject * obj1 = 0 ;
36812 char * kwnames[] = {
36813 (char *) "self",(char *) "text", NULL
36814 };
36815
36816 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) SWIG_fail;
36817 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36818 if (!SWIG_IsOK(res1)) {
36819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpTextForId" "', expected argument " "1"" of type '" "wxWindow *""'");
36820 }
36821 arg1 = reinterpret_cast< wxWindow * >(argp1);
36822 {
36823 arg2 = wxString_in_helper(obj1);
36824 if (arg2 == NULL) SWIG_fail;
36825 temp2 = true;
36826 }
36827 {
36828 PyThreadState* __tstate = wxPyBeginAllowThreads();
36829 (arg1)->SetHelpTextForId((wxString const &)*arg2);
36830 wxPyEndAllowThreads(__tstate);
36831 if (PyErr_Occurred()) SWIG_fail;
36832 }
36833 resultobj = SWIG_Py_Void();
36834 {
36835 if (temp2)
36836 delete arg2;
36837 }
36838 return resultobj;
36839 fail:
36840 {
36841 if (temp2)
36842 delete arg2;
36843 }
36844 return NULL;
36845 }
36846
36847
36848 SWIGINTERN PyObject *_wrap_Window_GetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36849 PyObject *resultobj = 0;
36850 wxWindow *arg1 = (wxWindow *) 0 ;
36851 wxString result;
36852 void *argp1 = 0 ;
36853 int res1 = 0 ;
36854 PyObject *swig_obj[1] ;
36855
36856 if (!args) SWIG_fail;
36857 swig_obj[0] = args;
36858 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36859 if (!SWIG_IsOK(res1)) {
36860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpText" "', expected argument " "1"" of type '" "wxWindow const *""'");
36861 }
36862 arg1 = reinterpret_cast< wxWindow * >(argp1);
36863 {
36864 PyThreadState* __tstate = wxPyBeginAllowThreads();
36865 result = ((wxWindow const *)arg1)->GetHelpText();
36866 wxPyEndAllowThreads(__tstate);
36867 if (PyErr_Occurred()) SWIG_fail;
36868 }
36869 {
36870 #if wxUSE_UNICODE
36871 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36872 #else
36873 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36874 #endif
36875 }
36876 return resultobj;
36877 fail:
36878 return NULL;
36879 }
36880
36881
36882 SWIGINTERN PyObject *_wrap_Window_SetToolTipString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36883 PyObject *resultobj = 0;
36884 wxWindow *arg1 = (wxWindow *) 0 ;
36885 wxString *arg2 = 0 ;
36886 void *argp1 = 0 ;
36887 int res1 = 0 ;
36888 bool temp2 = false ;
36889 PyObject * obj0 = 0 ;
36890 PyObject * obj1 = 0 ;
36891 char * kwnames[] = {
36892 (char *) "self",(char *) "tip", NULL
36893 };
36894
36895 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) SWIG_fail;
36896 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36897 if (!SWIG_IsOK(res1)) {
36898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTipString" "', expected argument " "1"" of type '" "wxWindow *""'");
36899 }
36900 arg1 = reinterpret_cast< wxWindow * >(argp1);
36901 {
36902 arg2 = wxString_in_helper(obj1);
36903 if (arg2 == NULL) SWIG_fail;
36904 temp2 = true;
36905 }
36906 {
36907 PyThreadState* __tstate = wxPyBeginAllowThreads();
36908 (arg1)->SetToolTip((wxString const &)*arg2);
36909 wxPyEndAllowThreads(__tstate);
36910 if (PyErr_Occurred()) SWIG_fail;
36911 }
36912 resultobj = SWIG_Py_Void();
36913 {
36914 if (temp2)
36915 delete arg2;
36916 }
36917 return resultobj;
36918 fail:
36919 {
36920 if (temp2)
36921 delete arg2;
36922 }
36923 return NULL;
36924 }
36925
36926
36927 SWIGINTERN PyObject *_wrap_Window_SetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36928 PyObject *resultobj = 0;
36929 wxWindow *arg1 = (wxWindow *) 0 ;
36930 wxToolTip *arg2 = (wxToolTip *) 0 ;
36931 void *argp1 = 0 ;
36932 int res1 = 0 ;
36933 int res2 = 0 ;
36934 PyObject * obj0 = 0 ;
36935 PyObject * obj1 = 0 ;
36936 char * kwnames[] = {
36937 (char *) "self",(char *) "tip", NULL
36938 };
36939
36940 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) SWIG_fail;
36941 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36942 if (!SWIG_IsOK(res1)) {
36943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTip" "', expected argument " "1"" of type '" "wxWindow *""'");
36944 }
36945 arg1 = reinterpret_cast< wxWindow * >(argp1);
36946 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
36947 if (!SWIG_IsOK(res2)) {
36948 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetToolTip" "', expected argument " "2"" of type '" "wxToolTip *""'");
36949 }
36950 {
36951 PyThreadState* __tstate = wxPyBeginAllowThreads();
36952 (arg1)->SetToolTip(arg2);
36953 wxPyEndAllowThreads(__tstate);
36954 if (PyErr_Occurred()) SWIG_fail;
36955 }
36956 resultobj = SWIG_Py_Void();
36957 return resultobj;
36958 fail:
36959 return NULL;
36960 }
36961
36962
36963 SWIGINTERN PyObject *_wrap_Window_GetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36964 PyObject *resultobj = 0;
36965 wxWindow *arg1 = (wxWindow *) 0 ;
36966 wxToolTip *result = 0 ;
36967 void *argp1 = 0 ;
36968 int res1 = 0 ;
36969 PyObject *swig_obj[1] ;
36970
36971 if (!args) SWIG_fail;
36972 swig_obj[0] = args;
36973 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36974 if (!SWIG_IsOK(res1)) {
36975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetToolTip" "', expected argument " "1"" of type '" "wxWindow const *""'");
36976 }
36977 arg1 = reinterpret_cast< wxWindow * >(argp1);
36978 {
36979 PyThreadState* __tstate = wxPyBeginAllowThreads();
36980 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
36981 wxPyEndAllowThreads(__tstate);
36982 if (PyErr_Occurred()) SWIG_fail;
36983 }
36984 {
36985 resultobj = wxPyMake_wxObject(result, (bool)0);
36986 }
36987 return resultobj;
36988 fail:
36989 return NULL;
36990 }
36991
36992
36993 SWIGINTERN PyObject *_wrap_Window_SetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36994 PyObject *resultobj = 0;
36995 wxWindow *arg1 = (wxWindow *) 0 ;
36996 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
36997 void *argp1 = 0 ;
36998 int res1 = 0 ;
36999 int res2 = 0 ;
37000 PyObject * obj0 = 0 ;
37001 PyObject * obj1 = 0 ;
37002 char * kwnames[] = {
37003 (char *) "self",(char *) "dropTarget", NULL
37004 };
37005
37006 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) SWIG_fail;
37007 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37008 if (!SWIG_IsOK(res1)) {
37009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDropTarget" "', expected argument " "1"" of type '" "wxWindow *""'");
37010 }
37011 arg1 = reinterpret_cast< wxWindow * >(argp1);
37012 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
37013 if (!SWIG_IsOK(res2)) {
37014 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDropTarget" "', expected argument " "2"" of type '" "wxPyDropTarget *""'");
37015 }
37016 {
37017 PyThreadState* __tstate = wxPyBeginAllowThreads();
37018 (arg1)->SetDropTarget(arg2);
37019 wxPyEndAllowThreads(__tstate);
37020 if (PyErr_Occurred()) SWIG_fail;
37021 }
37022 resultobj = SWIG_Py_Void();
37023 return resultobj;
37024 fail:
37025 return NULL;
37026 }
37027
37028
37029 SWIGINTERN PyObject *_wrap_Window_GetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37030 PyObject *resultobj = 0;
37031 wxWindow *arg1 = (wxWindow *) 0 ;
37032 wxPyDropTarget *result = 0 ;
37033 void *argp1 = 0 ;
37034 int res1 = 0 ;
37035 PyObject *swig_obj[1] ;
37036
37037 if (!args) SWIG_fail;
37038 swig_obj[0] = args;
37039 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37040 if (!SWIG_IsOK(res1)) {
37041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDropTarget" "', expected argument " "1"" of type '" "wxWindow const *""'");
37042 }
37043 arg1 = reinterpret_cast< wxWindow * >(argp1);
37044 {
37045 PyThreadState* __tstate = wxPyBeginAllowThreads();
37046 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
37047 wxPyEndAllowThreads(__tstate);
37048 if (PyErr_Occurred()) SWIG_fail;
37049 }
37050 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
37051 return resultobj;
37052 fail:
37053 return NULL;
37054 }
37055
37056
37057 SWIGINTERN PyObject *_wrap_Window_DragAcceptFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37058 PyObject *resultobj = 0;
37059 wxWindow *arg1 = (wxWindow *) 0 ;
37060 bool arg2 ;
37061 void *argp1 = 0 ;
37062 int res1 = 0 ;
37063 bool val2 ;
37064 int ecode2 = 0 ;
37065 PyObject * obj0 = 0 ;
37066 PyObject * obj1 = 0 ;
37067 char * kwnames[] = {
37068 (char *) "self",(char *) "accept", NULL
37069 };
37070
37071 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) SWIG_fail;
37072 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37073 if (!SWIG_IsOK(res1)) {
37074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DragAcceptFiles" "', expected argument " "1"" of type '" "wxWindow *""'");
37075 }
37076 arg1 = reinterpret_cast< wxWindow * >(argp1);
37077 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37078 if (!SWIG_IsOK(ecode2)) {
37079 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_DragAcceptFiles" "', expected argument " "2"" of type '" "bool""'");
37080 }
37081 arg2 = static_cast< bool >(val2);
37082 {
37083 PyThreadState* __tstate = wxPyBeginAllowThreads();
37084 (arg1)->DragAcceptFiles(arg2);
37085 wxPyEndAllowThreads(__tstate);
37086 if (PyErr_Occurred()) SWIG_fail;
37087 }
37088 resultobj = SWIG_Py_Void();
37089 return resultobj;
37090 fail:
37091 return NULL;
37092 }
37093
37094
37095 SWIGINTERN PyObject *_wrap_Window_SetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37096 PyObject *resultobj = 0;
37097 wxWindow *arg1 = (wxWindow *) 0 ;
37098 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
37099 void *argp1 = 0 ;
37100 int res1 = 0 ;
37101 int res2 = 0 ;
37102 PyObject * obj0 = 0 ;
37103 PyObject * obj1 = 0 ;
37104 char * kwnames[] = {
37105 (char *) "self",(char *) "constraints", NULL
37106 };
37107
37108 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
37109 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37110 if (!SWIG_IsOK(res1)) {
37111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetConstraints" "', expected argument " "1"" of type '" "wxWindow *""'");
37112 }
37113 arg1 = reinterpret_cast< wxWindow * >(argp1);
37114 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
37115 if (!SWIG_IsOK(res2)) {
37116 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetConstraints" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
37117 }
37118 {
37119 PyThreadState* __tstate = wxPyBeginAllowThreads();
37120 (arg1)->SetConstraints(arg2);
37121 wxPyEndAllowThreads(__tstate);
37122 if (PyErr_Occurred()) SWIG_fail;
37123 }
37124 resultobj = SWIG_Py_Void();
37125 return resultobj;
37126 fail:
37127 return NULL;
37128 }
37129
37130
37131 SWIGINTERN PyObject *_wrap_Window_GetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37132 PyObject *resultobj = 0;
37133 wxWindow *arg1 = (wxWindow *) 0 ;
37134 wxLayoutConstraints *result = 0 ;
37135 void *argp1 = 0 ;
37136 int res1 = 0 ;
37137 PyObject *swig_obj[1] ;
37138
37139 if (!args) SWIG_fail;
37140 swig_obj[0] = args;
37141 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37142 if (!SWIG_IsOK(res1)) {
37143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetConstraints" "', expected argument " "1"" of type '" "wxWindow const *""'");
37144 }
37145 arg1 = reinterpret_cast< wxWindow * >(argp1);
37146 {
37147 PyThreadState* __tstate = wxPyBeginAllowThreads();
37148 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
37149 wxPyEndAllowThreads(__tstate);
37150 if (PyErr_Occurred()) SWIG_fail;
37151 }
37152 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
37153 return resultobj;
37154 fail:
37155 return NULL;
37156 }
37157
37158
37159 SWIGINTERN PyObject *_wrap_Window_SetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37160 PyObject *resultobj = 0;
37161 wxWindow *arg1 = (wxWindow *) 0 ;
37162 bool arg2 ;
37163 void *argp1 = 0 ;
37164 int res1 = 0 ;
37165 bool val2 ;
37166 int ecode2 = 0 ;
37167 PyObject * obj0 = 0 ;
37168 PyObject * obj1 = 0 ;
37169 char * kwnames[] = {
37170 (char *) "self",(char *) "autoLayout", NULL
37171 };
37172
37173 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) SWIG_fail;
37174 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37175 if (!SWIG_IsOK(res1)) {
37176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAutoLayout" "', expected argument " "1"" of type '" "wxWindow *""'");
37177 }
37178 arg1 = reinterpret_cast< wxWindow * >(argp1);
37179 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37180 if (!SWIG_IsOK(ecode2)) {
37181 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetAutoLayout" "', expected argument " "2"" of type '" "bool""'");
37182 }
37183 arg2 = static_cast< bool >(val2);
37184 {
37185 PyThreadState* __tstate = wxPyBeginAllowThreads();
37186 (arg1)->SetAutoLayout(arg2);
37187 wxPyEndAllowThreads(__tstate);
37188 if (PyErr_Occurred()) SWIG_fail;
37189 }
37190 resultobj = SWIG_Py_Void();
37191 return resultobj;
37192 fail:
37193 return NULL;
37194 }
37195
37196
37197 SWIGINTERN PyObject *_wrap_Window_GetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37198 PyObject *resultobj = 0;
37199 wxWindow *arg1 = (wxWindow *) 0 ;
37200 bool result;
37201 void *argp1 = 0 ;
37202 int res1 = 0 ;
37203 PyObject *swig_obj[1] ;
37204
37205 if (!args) SWIG_fail;
37206 swig_obj[0] = args;
37207 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37208 if (!SWIG_IsOK(res1)) {
37209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAutoLayout" "', expected argument " "1"" of type '" "wxWindow const *""'");
37210 }
37211 arg1 = reinterpret_cast< wxWindow * >(argp1);
37212 {
37213 PyThreadState* __tstate = wxPyBeginAllowThreads();
37214 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
37215 wxPyEndAllowThreads(__tstate);
37216 if (PyErr_Occurred()) SWIG_fail;
37217 }
37218 {
37219 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37220 }
37221 return resultobj;
37222 fail:
37223 return NULL;
37224 }
37225
37226
37227 SWIGINTERN PyObject *_wrap_Window_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37228 PyObject *resultobj = 0;
37229 wxWindow *arg1 = (wxWindow *) 0 ;
37230 bool result;
37231 void *argp1 = 0 ;
37232 int res1 = 0 ;
37233 PyObject *swig_obj[1] ;
37234
37235 if (!args) SWIG_fail;
37236 swig_obj[0] = args;
37237 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37238 if (!SWIG_IsOK(res1)) {
37239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Layout" "', expected argument " "1"" of type '" "wxWindow *""'");
37240 }
37241 arg1 = reinterpret_cast< wxWindow * >(argp1);
37242 {
37243 PyThreadState* __tstate = wxPyBeginAllowThreads();
37244 result = (bool)(arg1)->Layout();
37245 wxPyEndAllowThreads(__tstate);
37246 if (PyErr_Occurred()) SWIG_fail;
37247 }
37248 {
37249 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37250 }
37251 return resultobj;
37252 fail:
37253 return NULL;
37254 }
37255
37256
37257 SWIGINTERN PyObject *_wrap_Window_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37258 PyObject *resultobj = 0;
37259 wxWindow *arg1 = (wxWindow *) 0 ;
37260 wxSizer *arg2 = (wxSizer *) 0 ;
37261 bool arg3 = (bool) true ;
37262 void *argp1 = 0 ;
37263 int res1 = 0 ;
37264 int res2 = 0 ;
37265 bool val3 ;
37266 int ecode3 = 0 ;
37267 PyObject * obj0 = 0 ;
37268 PyObject * obj1 = 0 ;
37269 PyObject * obj2 = 0 ;
37270 char * kwnames[] = {
37271 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
37272 };
37273
37274 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37275 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37276 if (!SWIG_IsOK(res1)) {
37277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
37278 }
37279 arg1 = reinterpret_cast< wxWindow * >(argp1);
37280 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
37281 if (!SWIG_IsOK(res2)) {
37282 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
37283 }
37284 if (obj2) {
37285 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37286 if (!SWIG_IsOK(ecode3)) {
37287 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizer" "', expected argument " "3"" of type '" "bool""'");
37288 }
37289 arg3 = static_cast< bool >(val3);
37290 }
37291 {
37292 PyThreadState* __tstate = wxPyBeginAllowThreads();
37293 (arg1)->SetSizer(arg2,arg3);
37294 wxPyEndAllowThreads(__tstate);
37295 if (PyErr_Occurred()) SWIG_fail;
37296 }
37297 resultobj = SWIG_Py_Void();
37298 return resultobj;
37299 fail:
37300 return NULL;
37301 }
37302
37303
37304 SWIGINTERN PyObject *_wrap_Window_SetSizerAndFit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37305 PyObject *resultobj = 0;
37306 wxWindow *arg1 = (wxWindow *) 0 ;
37307 wxSizer *arg2 = (wxSizer *) 0 ;
37308 bool arg3 = (bool) true ;
37309 void *argp1 = 0 ;
37310 int res1 = 0 ;
37311 int res2 = 0 ;
37312 bool val3 ;
37313 int ecode3 = 0 ;
37314 PyObject * obj0 = 0 ;
37315 PyObject * obj1 = 0 ;
37316 PyObject * obj2 = 0 ;
37317 char * kwnames[] = {
37318 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
37319 };
37320
37321 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37322 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37323 if (!SWIG_IsOK(res1)) {
37324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizerAndFit" "', expected argument " "1"" of type '" "wxWindow *""'");
37325 }
37326 arg1 = reinterpret_cast< wxWindow * >(argp1);
37327 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
37328 if (!SWIG_IsOK(res2)) {
37329 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizerAndFit" "', expected argument " "2"" of type '" "wxSizer *""'");
37330 }
37331 if (obj2) {
37332 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37333 if (!SWIG_IsOK(ecode3)) {
37334 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizerAndFit" "', expected argument " "3"" of type '" "bool""'");
37335 }
37336 arg3 = static_cast< bool >(val3);
37337 }
37338 {
37339 PyThreadState* __tstate = wxPyBeginAllowThreads();
37340 (arg1)->SetSizerAndFit(arg2,arg3);
37341 wxPyEndAllowThreads(__tstate);
37342 if (PyErr_Occurred()) SWIG_fail;
37343 }
37344 resultobj = SWIG_Py_Void();
37345 return resultobj;
37346 fail:
37347 return NULL;
37348 }
37349
37350
37351 SWIGINTERN PyObject *_wrap_Window_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37352 PyObject *resultobj = 0;
37353 wxWindow *arg1 = (wxWindow *) 0 ;
37354 wxSizer *result = 0 ;
37355 void *argp1 = 0 ;
37356 int res1 = 0 ;
37357 PyObject *swig_obj[1] ;
37358
37359 if (!args) SWIG_fail;
37360 swig_obj[0] = args;
37361 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37362 if (!SWIG_IsOK(res1)) {
37363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
37364 }
37365 arg1 = reinterpret_cast< wxWindow * >(argp1);
37366 {
37367 PyThreadState* __tstate = wxPyBeginAllowThreads();
37368 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
37369 wxPyEndAllowThreads(__tstate);
37370 if (PyErr_Occurred()) SWIG_fail;
37371 }
37372 {
37373 resultobj = wxPyMake_wxObject(result, (bool)0);
37374 }
37375 return resultobj;
37376 fail:
37377 return NULL;
37378 }
37379
37380
37381 SWIGINTERN PyObject *_wrap_Window_SetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37382 PyObject *resultobj = 0;
37383 wxWindow *arg1 = (wxWindow *) 0 ;
37384 wxSizer *arg2 = (wxSizer *) 0 ;
37385 void *argp1 = 0 ;
37386 int res1 = 0 ;
37387 void *argp2 = 0 ;
37388 int res2 = 0 ;
37389 PyObject * obj0 = 0 ;
37390 PyObject * obj1 = 0 ;
37391 char * kwnames[] = {
37392 (char *) "self",(char *) "sizer", NULL
37393 };
37394
37395 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) SWIG_fail;
37396 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37397 if (!SWIG_IsOK(res1)) {
37398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetContainingSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
37399 }
37400 arg1 = reinterpret_cast< wxWindow * >(argp1);
37401 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
37402 if (!SWIG_IsOK(res2)) {
37403 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetContainingSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
37404 }
37405 arg2 = reinterpret_cast< wxSizer * >(argp2);
37406 {
37407 PyThreadState* __tstate = wxPyBeginAllowThreads();
37408 (arg1)->SetContainingSizer(arg2);
37409 wxPyEndAllowThreads(__tstate);
37410 if (PyErr_Occurred()) SWIG_fail;
37411 }
37412 resultobj = SWIG_Py_Void();
37413 return resultobj;
37414 fail:
37415 return NULL;
37416 }
37417
37418
37419 SWIGINTERN PyObject *_wrap_Window_GetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37420 PyObject *resultobj = 0;
37421 wxWindow *arg1 = (wxWindow *) 0 ;
37422 wxSizer *result = 0 ;
37423 void *argp1 = 0 ;
37424 int res1 = 0 ;
37425 PyObject *swig_obj[1] ;
37426
37427 if (!args) SWIG_fail;
37428 swig_obj[0] = args;
37429 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37430 if (!SWIG_IsOK(res1)) {
37431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetContainingSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
37432 }
37433 arg1 = reinterpret_cast< wxWindow * >(argp1);
37434 {
37435 PyThreadState* __tstate = wxPyBeginAllowThreads();
37436 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
37437 wxPyEndAllowThreads(__tstate);
37438 if (PyErr_Occurred()) SWIG_fail;
37439 }
37440 {
37441 resultobj = wxPyMake_wxObject(result, (bool)0);
37442 }
37443 return resultobj;
37444 fail:
37445 return NULL;
37446 }
37447
37448
37449 SWIGINTERN PyObject *_wrap_Window_InheritAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37450 PyObject *resultobj = 0;
37451 wxWindow *arg1 = (wxWindow *) 0 ;
37452 void *argp1 = 0 ;
37453 int res1 = 0 ;
37454 PyObject *swig_obj[1] ;
37455
37456 if (!args) SWIG_fail;
37457 swig_obj[0] = args;
37458 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37459 if (!SWIG_IsOK(res1)) {
37460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritAttributes" "', expected argument " "1"" of type '" "wxWindow *""'");
37461 }
37462 arg1 = reinterpret_cast< wxWindow * >(argp1);
37463 {
37464 PyThreadState* __tstate = wxPyBeginAllowThreads();
37465 (arg1)->InheritAttributes();
37466 wxPyEndAllowThreads(__tstate);
37467 if (PyErr_Occurred()) SWIG_fail;
37468 }
37469 resultobj = SWIG_Py_Void();
37470 return resultobj;
37471 fail:
37472 return NULL;
37473 }
37474
37475
37476 SWIGINTERN PyObject *_wrap_Window_ShouldInheritColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37477 PyObject *resultobj = 0;
37478 wxWindow *arg1 = (wxWindow *) 0 ;
37479 bool result;
37480 void *argp1 = 0 ;
37481 int res1 = 0 ;
37482 PyObject *swig_obj[1] ;
37483
37484 if (!args) SWIG_fail;
37485 swig_obj[0] = args;
37486 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37487 if (!SWIG_IsOK(res1)) {
37488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ShouldInheritColours" "', expected argument " "1"" of type '" "wxWindow const *""'");
37489 }
37490 arg1 = reinterpret_cast< wxWindow * >(argp1);
37491 {
37492 PyThreadState* __tstate = wxPyBeginAllowThreads();
37493 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
37494 wxPyEndAllowThreads(__tstate);
37495 if (PyErr_Occurred()) SWIG_fail;
37496 }
37497 {
37498 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37499 }
37500 return resultobj;
37501 fail:
37502 return NULL;
37503 }
37504
37505
37506 SWIGINTERN PyObject *Window_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37507 PyObject *obj;
37508 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37509 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindow, SWIG_NewClientData(obj));
37510 return SWIG_Py_Void();
37511 }
37512
37513 SWIGINTERN PyObject *Window_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37514 return SWIG_Python_InitShadowInstance(args);
37515 }
37516
37517 SWIGINTERN PyObject *_wrap_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37518 PyObject *resultobj = 0;
37519 long arg1 ;
37520 wxWindow *arg2 = (wxWindow *) NULL ;
37521 wxWindow *result = 0 ;
37522 long val1 ;
37523 int ecode1 = 0 ;
37524 void *argp2 = 0 ;
37525 int res2 = 0 ;
37526 PyObject * obj0 = 0 ;
37527 PyObject * obj1 = 0 ;
37528 char * kwnames[] = {
37529 (char *) "id",(char *) "parent", NULL
37530 };
37531
37532 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
37533 ecode1 = SWIG_AsVal_long(obj0, &val1);
37534 if (!SWIG_IsOK(ecode1)) {
37535 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FindWindowById" "', expected argument " "1"" of type '" "long""'");
37536 }
37537 arg1 = static_cast< long >(val1);
37538 if (obj1) {
37539 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37540 if (!SWIG_IsOK(res2)) {
37541 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowById" "', expected argument " "2"" of type '" "wxWindow const *""'");
37542 }
37543 arg2 = reinterpret_cast< wxWindow * >(argp2);
37544 }
37545 {
37546 if (!wxPyCheckForApp()) SWIG_fail;
37547 PyThreadState* __tstate = wxPyBeginAllowThreads();
37548 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
37549 wxPyEndAllowThreads(__tstate);
37550 if (PyErr_Occurred()) SWIG_fail;
37551 }
37552 {
37553 resultobj = wxPyMake_wxObject(result, 0);
37554 }
37555 return resultobj;
37556 fail:
37557 return NULL;
37558 }
37559
37560
37561 SWIGINTERN PyObject *_wrap_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37562 PyObject *resultobj = 0;
37563 wxString *arg1 = 0 ;
37564 wxWindow *arg2 = (wxWindow *) NULL ;
37565 wxWindow *result = 0 ;
37566 bool temp1 = false ;
37567 void *argp2 = 0 ;
37568 int res2 = 0 ;
37569 PyObject * obj0 = 0 ;
37570 PyObject * obj1 = 0 ;
37571 char * kwnames[] = {
37572 (char *) "name",(char *) "parent", NULL
37573 };
37574
37575 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
37576 {
37577 arg1 = wxString_in_helper(obj0);
37578 if (arg1 == NULL) SWIG_fail;
37579 temp1 = true;
37580 }
37581 if (obj1) {
37582 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37583 if (!SWIG_IsOK(res2)) {
37584 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByName" "', expected argument " "2"" of type '" "wxWindow const *""'");
37585 }
37586 arg2 = reinterpret_cast< wxWindow * >(argp2);
37587 }
37588 {
37589 if (!wxPyCheckForApp()) SWIG_fail;
37590 PyThreadState* __tstate = wxPyBeginAllowThreads();
37591 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
37592 wxPyEndAllowThreads(__tstate);
37593 if (PyErr_Occurred()) SWIG_fail;
37594 }
37595 {
37596 resultobj = wxPyMake_wxObject(result, 0);
37597 }
37598 {
37599 if (temp1)
37600 delete arg1;
37601 }
37602 return resultobj;
37603 fail:
37604 {
37605 if (temp1)
37606 delete arg1;
37607 }
37608 return NULL;
37609 }
37610
37611
37612 SWIGINTERN PyObject *_wrap_FindWindowByLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37613 PyObject *resultobj = 0;
37614 wxString *arg1 = 0 ;
37615 wxWindow *arg2 = (wxWindow *) NULL ;
37616 wxWindow *result = 0 ;
37617 bool temp1 = false ;
37618 void *argp2 = 0 ;
37619 int res2 = 0 ;
37620 PyObject * obj0 = 0 ;
37621 PyObject * obj1 = 0 ;
37622 char * kwnames[] = {
37623 (char *) "label",(char *) "parent", NULL
37624 };
37625
37626 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) SWIG_fail;
37627 {
37628 arg1 = wxString_in_helper(obj0);
37629 if (arg1 == NULL) SWIG_fail;
37630 temp1 = true;
37631 }
37632 if (obj1) {
37633 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37634 if (!SWIG_IsOK(res2)) {
37635 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByLabel" "', expected argument " "2"" of type '" "wxWindow const *""'");
37636 }
37637 arg2 = reinterpret_cast< wxWindow * >(argp2);
37638 }
37639 {
37640 if (!wxPyCheckForApp()) SWIG_fail;
37641 PyThreadState* __tstate = wxPyBeginAllowThreads();
37642 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
37643 wxPyEndAllowThreads(__tstate);
37644 if (PyErr_Occurred()) SWIG_fail;
37645 }
37646 {
37647 resultobj = wxPyMake_wxObject(result, 0);
37648 }
37649 {
37650 if (temp1)
37651 delete arg1;
37652 }
37653 return resultobj;
37654 fail:
37655 {
37656 if (temp1)
37657 delete arg1;
37658 }
37659 return NULL;
37660 }
37661
37662
37663 SWIGINTERN PyObject *_wrap_Window_FromHWND(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37664 PyObject *resultobj = 0;
37665 wxWindow *arg1 = (wxWindow *) 0 ;
37666 unsigned long arg2 ;
37667 wxWindow *result = 0 ;
37668 void *argp1 = 0 ;
37669 int res1 = 0 ;
37670 unsigned long val2 ;
37671 int ecode2 = 0 ;
37672 PyObject * obj0 = 0 ;
37673 PyObject * obj1 = 0 ;
37674 char * kwnames[] = {
37675 (char *) "parent",(char *) "_hWnd", NULL
37676 };
37677
37678 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) SWIG_fail;
37679 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37680 if (!SWIG_IsOK(res1)) {
37681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FromHWND" "', expected argument " "1"" of type '" "wxWindow *""'");
37682 }
37683 arg1 = reinterpret_cast< wxWindow * >(argp1);
37684 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
37685 if (!SWIG_IsOK(ecode2)) {
37686 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FromHWND" "', expected argument " "2"" of type '" "unsigned long""'");
37687 }
37688 arg2 = static_cast< unsigned long >(val2);
37689 {
37690 PyThreadState* __tstate = wxPyBeginAllowThreads();
37691 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
37692 wxPyEndAllowThreads(__tstate);
37693 if (PyErr_Occurred()) SWIG_fail;
37694 }
37695 {
37696 resultobj = wxPyMake_wxObject(result, 0);
37697 }
37698 return resultobj;
37699 fail:
37700 return NULL;
37701 }
37702
37703
37704 SWIGINTERN PyObject *_wrap_GetTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37705 PyObject *resultobj = 0;
37706 PyObject *result = 0 ;
37707
37708 if (!SWIG_Python_UnpackTuple(args,"GetTopLevelWindows",0,0,0)) SWIG_fail;
37709 {
37710 PyThreadState* __tstate = wxPyBeginAllowThreads();
37711 result = (PyObject *)GetTopLevelWindows();
37712 wxPyEndAllowThreads(__tstate);
37713 if (PyErr_Occurred()) SWIG_fail;
37714 }
37715 resultobj = result;
37716 return resultobj;
37717 fail:
37718 return NULL;
37719 }
37720
37721
37722 SWIGINTERN PyObject *_wrap_new_Validator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37723 PyObject *resultobj = 0;
37724 wxValidator *result = 0 ;
37725
37726 if (!SWIG_Python_UnpackTuple(args,"new_Validator",0,0,0)) SWIG_fail;
37727 {
37728 PyThreadState* __tstate = wxPyBeginAllowThreads();
37729 result = (wxValidator *)new wxValidator();
37730 wxPyEndAllowThreads(__tstate);
37731 if (PyErr_Occurred()) SWIG_fail;
37732 }
37733 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxValidator, SWIG_POINTER_NEW | 0 );
37734 return resultobj;
37735 fail:
37736 return NULL;
37737 }
37738
37739
37740 SWIGINTERN PyObject *_wrap_Validator_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37741 PyObject *resultobj = 0;
37742 wxValidator *arg1 = (wxValidator *) 0 ;
37743 wxValidator *result = 0 ;
37744 void *argp1 = 0 ;
37745 int res1 = 0 ;
37746 PyObject *swig_obj[1] ;
37747
37748 if (!args) SWIG_fail;
37749 swig_obj[0] = args;
37750 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37751 if (!SWIG_IsOK(res1)) {
37752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Clone" "', expected argument " "1"" of type '" "wxValidator *""'");
37753 }
37754 arg1 = reinterpret_cast< wxValidator * >(argp1);
37755 {
37756 PyThreadState* __tstate = wxPyBeginAllowThreads();
37757 result = (wxValidator *)(arg1)->Clone();
37758 wxPyEndAllowThreads(__tstate);
37759 if (PyErr_Occurred()) SWIG_fail;
37760 }
37761 {
37762 resultobj = wxPyMake_wxObject(result, 0);
37763 }
37764 return resultobj;
37765 fail:
37766 return NULL;
37767 }
37768
37769
37770 SWIGINTERN PyObject *_wrap_Validator_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37771 PyObject *resultobj = 0;
37772 wxValidator *arg1 = (wxValidator *) 0 ;
37773 wxWindow *arg2 = (wxWindow *) 0 ;
37774 bool result;
37775 void *argp1 = 0 ;
37776 int res1 = 0 ;
37777 void *argp2 = 0 ;
37778 int res2 = 0 ;
37779 PyObject * obj0 = 0 ;
37780 PyObject * obj1 = 0 ;
37781 char * kwnames[] = {
37782 (char *) "self",(char *) "parent", NULL
37783 };
37784
37785 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) SWIG_fail;
37786 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37787 if (!SWIG_IsOK(res1)) {
37788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Validate" "', expected argument " "1"" of type '" "wxValidator *""'");
37789 }
37790 arg1 = reinterpret_cast< wxValidator * >(argp1);
37791 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37792 if (!SWIG_IsOK(res2)) {
37793 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_Validate" "', expected argument " "2"" of type '" "wxWindow *""'");
37794 }
37795 arg2 = reinterpret_cast< wxWindow * >(argp2);
37796 {
37797 PyThreadState* __tstate = wxPyBeginAllowThreads();
37798 result = (bool)(arg1)->Validate(arg2);
37799 wxPyEndAllowThreads(__tstate);
37800 if (PyErr_Occurred()) SWIG_fail;
37801 }
37802 {
37803 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37804 }
37805 return resultobj;
37806 fail:
37807 return NULL;
37808 }
37809
37810
37811 SWIGINTERN PyObject *_wrap_Validator_TransferToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37812 PyObject *resultobj = 0;
37813 wxValidator *arg1 = (wxValidator *) 0 ;
37814 bool result;
37815 void *argp1 = 0 ;
37816 int res1 = 0 ;
37817 PyObject *swig_obj[1] ;
37818
37819 if (!args) SWIG_fail;
37820 swig_obj[0] = args;
37821 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37822 if (!SWIG_IsOK(res1)) {
37823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferToWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
37824 }
37825 arg1 = reinterpret_cast< wxValidator * >(argp1);
37826 {
37827 PyThreadState* __tstate = wxPyBeginAllowThreads();
37828 result = (bool)(arg1)->TransferToWindow();
37829 wxPyEndAllowThreads(__tstate);
37830 if (PyErr_Occurred()) SWIG_fail;
37831 }
37832 {
37833 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37834 }
37835 return resultobj;
37836 fail:
37837 return NULL;
37838 }
37839
37840
37841 SWIGINTERN PyObject *_wrap_Validator_TransferFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37842 PyObject *resultobj = 0;
37843 wxValidator *arg1 = (wxValidator *) 0 ;
37844 bool result;
37845 void *argp1 = 0 ;
37846 int res1 = 0 ;
37847 PyObject *swig_obj[1] ;
37848
37849 if (!args) SWIG_fail;
37850 swig_obj[0] = args;
37851 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37852 if (!SWIG_IsOK(res1)) {
37853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferFromWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
37854 }
37855 arg1 = reinterpret_cast< wxValidator * >(argp1);
37856 {
37857 PyThreadState* __tstate = wxPyBeginAllowThreads();
37858 result = (bool)(arg1)->TransferFromWindow();
37859 wxPyEndAllowThreads(__tstate);
37860 if (PyErr_Occurred()) SWIG_fail;
37861 }
37862 {
37863 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37864 }
37865 return resultobj;
37866 fail:
37867 return NULL;
37868 }
37869
37870
37871 SWIGINTERN PyObject *_wrap_Validator_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37872 PyObject *resultobj = 0;
37873 wxValidator *arg1 = (wxValidator *) 0 ;
37874 wxWindow *result = 0 ;
37875 void *argp1 = 0 ;
37876 int res1 = 0 ;
37877 PyObject *swig_obj[1] ;
37878
37879 if (!args) SWIG_fail;
37880 swig_obj[0] = args;
37881 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37882 if (!SWIG_IsOK(res1)) {
37883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_GetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
37884 }
37885 arg1 = reinterpret_cast< wxValidator * >(argp1);
37886 {
37887 PyThreadState* __tstate = wxPyBeginAllowThreads();
37888 result = (wxWindow *)(arg1)->GetWindow();
37889 wxPyEndAllowThreads(__tstate);
37890 if (PyErr_Occurred()) SWIG_fail;
37891 }
37892 {
37893 resultobj = wxPyMake_wxObject(result, 0);
37894 }
37895 return resultobj;
37896 fail:
37897 return NULL;
37898 }
37899
37900
37901 SWIGINTERN PyObject *_wrap_Validator_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37902 PyObject *resultobj = 0;
37903 wxValidator *arg1 = (wxValidator *) 0 ;
37904 wxWindow *arg2 = (wxWindow *) 0 ;
37905 void *argp1 = 0 ;
37906 int res1 = 0 ;
37907 void *argp2 = 0 ;
37908 int res2 = 0 ;
37909 PyObject * obj0 = 0 ;
37910 PyObject * obj1 = 0 ;
37911 char * kwnames[] = {
37912 (char *) "self",(char *) "window", NULL
37913 };
37914
37915 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
37916 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37917 if (!SWIG_IsOK(res1)) {
37918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_SetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
37919 }
37920 arg1 = reinterpret_cast< wxValidator * >(argp1);
37921 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37922 if (!SWIG_IsOK(res2)) {
37923 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
37924 }
37925 arg2 = reinterpret_cast< wxWindow * >(argp2);
37926 {
37927 PyThreadState* __tstate = wxPyBeginAllowThreads();
37928 (arg1)->SetWindow(arg2);
37929 wxPyEndAllowThreads(__tstate);
37930 if (PyErr_Occurred()) SWIG_fail;
37931 }
37932 resultobj = SWIG_Py_Void();
37933 return resultobj;
37934 fail:
37935 return NULL;
37936 }
37937
37938
37939 SWIGINTERN PyObject *_wrap_Validator_IsSilent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37940 PyObject *resultobj = 0;
37941 bool result;
37942
37943 if (!SWIG_Python_UnpackTuple(args,"Validator_IsSilent",0,0,0)) SWIG_fail;
37944 {
37945 PyThreadState* __tstate = wxPyBeginAllowThreads();
37946 result = (bool)wxValidator::IsSilent();
37947 wxPyEndAllowThreads(__tstate);
37948 if (PyErr_Occurred()) SWIG_fail;
37949 }
37950 {
37951 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37952 }
37953 return resultobj;
37954 fail:
37955 return NULL;
37956 }
37957
37958
37959 SWIGINTERN PyObject *_wrap_Validator_SetBellOnError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37960 PyObject *resultobj = 0;
37961 int arg1 = (int) true ;
37962 int val1 ;
37963 int ecode1 = 0 ;
37964 PyObject * obj0 = 0 ;
37965 char * kwnames[] = {
37966 (char *) "doIt", NULL
37967 };
37968
37969 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) SWIG_fail;
37970 if (obj0) {
37971 ecode1 = SWIG_AsVal_int(obj0, &val1);
37972 if (!SWIG_IsOK(ecode1)) {
37973 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Validator_SetBellOnError" "', expected argument " "1"" of type '" "int""'");
37974 }
37975 arg1 = static_cast< int >(val1);
37976 }
37977 {
37978 PyThreadState* __tstate = wxPyBeginAllowThreads();
37979 wxValidator::SetBellOnError(arg1);
37980 wxPyEndAllowThreads(__tstate);
37981 if (PyErr_Occurred()) SWIG_fail;
37982 }
37983 resultobj = SWIG_Py_Void();
37984 return resultobj;
37985 fail:
37986 return NULL;
37987 }
37988
37989
37990 SWIGINTERN PyObject *Validator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37991 PyObject *obj;
37992 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37993 SWIG_TypeNewClientData(SWIGTYPE_p_wxValidator, SWIG_NewClientData(obj));
37994 return SWIG_Py_Void();
37995 }
37996
37997 SWIGINTERN PyObject *Validator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37998 return SWIG_Python_InitShadowInstance(args);
37999 }
38000
38001 SWIGINTERN PyObject *_wrap_new_PyValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38002 PyObject *resultobj = 0;
38003 wxPyValidator *result = 0 ;
38004
38005 if (!SWIG_Python_UnpackTuple(args,"new_PyValidator",0,0,0)) SWIG_fail;
38006 {
38007 PyThreadState* __tstate = wxPyBeginAllowThreads();
38008 result = (wxPyValidator *)new wxPyValidator();
38009 wxPyEndAllowThreads(__tstate);
38010 if (PyErr_Occurred()) SWIG_fail;
38011 }
38012 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyValidator, SWIG_POINTER_NEW | 0 );
38013 return resultobj;
38014 fail:
38015 return NULL;
38016 }
38017
38018
38019 SWIGINTERN PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38020 PyObject *resultobj = 0;
38021 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
38022 PyObject *arg2 = (PyObject *) 0 ;
38023 PyObject *arg3 = (PyObject *) 0 ;
38024 int arg4 = (int) true ;
38025 void *argp1 = 0 ;
38026 int res1 = 0 ;
38027 int val4 ;
38028 int ecode4 = 0 ;
38029 PyObject * obj0 = 0 ;
38030 PyObject * obj1 = 0 ;
38031 PyObject * obj2 = 0 ;
38032 PyObject * obj3 = 0 ;
38033 char * kwnames[] = {
38034 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
38035 };
38036
38037 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38038 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyValidator, 0 | 0 );
38039 if (!SWIG_IsOK(res1)) {
38040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyValidator *""'");
38041 }
38042 arg1 = reinterpret_cast< wxPyValidator * >(argp1);
38043 arg2 = obj1;
38044 arg3 = obj2;
38045 if (obj3) {
38046 ecode4 = SWIG_AsVal_int(obj3, &val4);
38047 if (!SWIG_IsOK(ecode4)) {
38048 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
38049 }
38050 arg4 = static_cast< int >(val4);
38051 }
38052 {
38053 PyThreadState* __tstate = wxPyBeginAllowThreads();
38054 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
38055 wxPyEndAllowThreads(__tstate);
38056 if (PyErr_Occurred()) SWIG_fail;
38057 }
38058 resultobj = SWIG_Py_Void();
38059 return resultobj;
38060 fail:
38061 return NULL;
38062 }
38063
38064
38065 SWIGINTERN PyObject *PyValidator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38066 PyObject *obj;
38067 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
38068 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyValidator, SWIG_NewClientData(obj));
38069 return SWIG_Py_Void();
38070 }
38071
38072 SWIGINTERN PyObject *PyValidator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38073 return SWIG_Python_InitShadowInstance(args);
38074 }
38075
38076 SWIGINTERN int DefaultValidator_set(PyObject *) {
38077 SWIG_Error(SWIG_AttributeError,"Variable DefaultValidator is read-only.");
38078 return 1;
38079 }
38080
38081
38082 SWIGINTERN PyObject *DefaultValidator_get(void) {
38083 PyObject *pyobj = 0;
38084
38085 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0 );
38086 return pyobj;
38087 }
38088
38089
38090 SWIGINTERN PyObject *_wrap_new_Menu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38091 PyObject *resultobj = 0;
38092 wxString const &arg1_defvalue = wxPyEmptyString ;
38093 wxString *arg1 = (wxString *) &arg1_defvalue ;
38094 long arg2 = (long) 0 ;
38095 wxMenu *result = 0 ;
38096 bool temp1 = false ;
38097 long val2 ;
38098 int ecode2 = 0 ;
38099 PyObject * obj0 = 0 ;
38100 PyObject * obj1 = 0 ;
38101 char * kwnames[] = {
38102 (char *) "title",(char *) "style", NULL
38103 };
38104
38105 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) SWIG_fail;
38106 if (obj0) {
38107 {
38108 arg1 = wxString_in_helper(obj0);
38109 if (arg1 == NULL) SWIG_fail;
38110 temp1 = true;
38111 }
38112 }
38113 if (obj1) {
38114 ecode2 = SWIG_AsVal_long(obj1, &val2);
38115 if (!SWIG_IsOK(ecode2)) {
38116 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Menu" "', expected argument " "2"" of type '" "long""'");
38117 }
38118 arg2 = static_cast< long >(val2);
38119 }
38120 {
38121 if (!wxPyCheckForApp()) SWIG_fail;
38122 PyThreadState* __tstate = wxPyBeginAllowThreads();
38123 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
38124 wxPyEndAllowThreads(__tstate);
38125 if (PyErr_Occurred()) SWIG_fail;
38126 }
38127 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenu, SWIG_POINTER_NEW | 0 );
38128 {
38129 if (temp1)
38130 delete arg1;
38131 }
38132 return resultobj;
38133 fail:
38134 {
38135 if (temp1)
38136 delete arg1;
38137 }
38138 return NULL;
38139 }
38140
38141
38142 SWIGINTERN PyObject *_wrap_Menu_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38143 PyObject *resultobj = 0;
38144 wxMenu *arg1 = (wxMenu *) 0 ;
38145 int arg2 ;
38146 wxString *arg3 = 0 ;
38147 wxString const &arg4_defvalue = wxPyEmptyString ;
38148 wxString *arg4 = (wxString *) &arg4_defvalue ;
38149 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
38150 wxMenuItem *result = 0 ;
38151 void *argp1 = 0 ;
38152 int res1 = 0 ;
38153 int val2 ;
38154 int ecode2 = 0 ;
38155 bool temp3 = false ;
38156 bool temp4 = false ;
38157 int val5 ;
38158 int ecode5 = 0 ;
38159 PyObject * obj0 = 0 ;
38160 PyObject * obj1 = 0 ;
38161 PyObject * obj2 = 0 ;
38162 PyObject * obj3 = 0 ;
38163 PyObject * obj4 = 0 ;
38164 char * kwnames[] = {
38165 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
38166 };
38167
38168 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38169 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38170 if (!SWIG_IsOK(res1)) {
38171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Append" "', expected argument " "1"" of type '" "wxMenu *""'");
38172 }
38173 arg1 = reinterpret_cast< wxMenu * >(argp1);
38174 ecode2 = SWIG_AsVal_int(obj1, &val2);
38175 if (!SWIG_IsOK(ecode2)) {
38176 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Append" "', expected argument " "2"" of type '" "int""'");
38177 }
38178 arg2 = static_cast< int >(val2);
38179 {
38180 arg3 = wxString_in_helper(obj2);
38181 if (arg3 == NULL) SWIG_fail;
38182 temp3 = true;
38183 }
38184 if (obj3) {
38185 {
38186 arg4 = wxString_in_helper(obj3);
38187 if (arg4 == NULL) SWIG_fail;
38188 temp4 = true;
38189 }
38190 }
38191 if (obj4) {
38192 ecode5 = SWIG_AsVal_int(obj4, &val5);
38193 if (!SWIG_IsOK(ecode5)) {
38194 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Append" "', expected argument " "5"" of type '" "wxItemKind""'");
38195 }
38196 arg5 = static_cast< wxItemKind >(val5);
38197 }
38198 {
38199 PyThreadState* __tstate = wxPyBeginAllowThreads();
38200 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
38201 wxPyEndAllowThreads(__tstate);
38202 if (PyErr_Occurred()) SWIG_fail;
38203 }
38204 {
38205 resultobj = wxPyMake_wxObject(result, (bool)0);
38206 }
38207 {
38208 if (temp3)
38209 delete arg3;
38210 }
38211 {
38212 if (temp4)
38213 delete arg4;
38214 }
38215 return resultobj;
38216 fail:
38217 {
38218 if (temp3)
38219 delete arg3;
38220 }
38221 {
38222 if (temp4)
38223 delete arg4;
38224 }
38225 return NULL;
38226 }
38227
38228
38229 SWIGINTERN PyObject *_wrap_Menu_AppendSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38230 PyObject *resultobj = 0;
38231 wxMenu *arg1 = (wxMenu *) 0 ;
38232 wxMenuItem *result = 0 ;
38233 void *argp1 = 0 ;
38234 int res1 = 0 ;
38235 PyObject *swig_obj[1] ;
38236
38237 if (!args) SWIG_fail;
38238 swig_obj[0] = args;
38239 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38240 if (!SWIG_IsOK(res1)) {
38241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
38242 }
38243 arg1 = reinterpret_cast< wxMenu * >(argp1);
38244 {
38245 PyThreadState* __tstate = wxPyBeginAllowThreads();
38246 result = (wxMenuItem *)(arg1)->AppendSeparator();
38247 wxPyEndAllowThreads(__tstate);
38248 if (PyErr_Occurred()) SWIG_fail;
38249 }
38250 {
38251 resultobj = wxPyMake_wxObject(result, (bool)0);
38252 }
38253 return resultobj;
38254 fail:
38255 return NULL;
38256 }
38257
38258
38259 SWIGINTERN PyObject *_wrap_Menu_AppendCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38260 PyObject *resultobj = 0;
38261 wxMenu *arg1 = (wxMenu *) 0 ;
38262 int arg2 ;
38263 wxString *arg3 = 0 ;
38264 wxString const &arg4_defvalue = wxPyEmptyString ;
38265 wxString *arg4 = (wxString *) &arg4_defvalue ;
38266 wxMenuItem *result = 0 ;
38267 void *argp1 = 0 ;
38268 int res1 = 0 ;
38269 int val2 ;
38270 int ecode2 = 0 ;
38271 bool temp3 = false ;
38272 bool temp4 = false ;
38273 PyObject * obj0 = 0 ;
38274 PyObject * obj1 = 0 ;
38275 PyObject * obj2 = 0 ;
38276 PyObject * obj3 = 0 ;
38277 char * kwnames[] = {
38278 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
38279 };
38280
38281 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38282 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38283 if (!SWIG_IsOK(res1)) {
38284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38285 }
38286 arg1 = reinterpret_cast< wxMenu * >(argp1);
38287 ecode2 = SWIG_AsVal_int(obj1, &val2);
38288 if (!SWIG_IsOK(ecode2)) {
38289 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendCheckItem" "', expected argument " "2"" of type '" "int""'");
38290 }
38291 arg2 = static_cast< int >(val2);
38292 {
38293 arg3 = wxString_in_helper(obj2);
38294 if (arg3 == NULL) SWIG_fail;
38295 temp3 = true;
38296 }
38297 if (obj3) {
38298 {
38299 arg4 = wxString_in_helper(obj3);
38300 if (arg4 == NULL) SWIG_fail;
38301 temp4 = true;
38302 }
38303 }
38304 {
38305 PyThreadState* __tstate = wxPyBeginAllowThreads();
38306 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38307 wxPyEndAllowThreads(__tstate);
38308 if (PyErr_Occurred()) SWIG_fail;
38309 }
38310 {
38311 resultobj = wxPyMake_wxObject(result, (bool)0);
38312 }
38313 {
38314 if (temp3)
38315 delete arg3;
38316 }
38317 {
38318 if (temp4)
38319 delete arg4;
38320 }
38321 return resultobj;
38322 fail:
38323 {
38324 if (temp3)
38325 delete arg3;
38326 }
38327 {
38328 if (temp4)
38329 delete arg4;
38330 }
38331 return NULL;
38332 }
38333
38334
38335 SWIGINTERN PyObject *_wrap_Menu_AppendRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38336 PyObject *resultobj = 0;
38337 wxMenu *arg1 = (wxMenu *) 0 ;
38338 int arg2 ;
38339 wxString *arg3 = 0 ;
38340 wxString const &arg4_defvalue = wxPyEmptyString ;
38341 wxString *arg4 = (wxString *) &arg4_defvalue ;
38342 wxMenuItem *result = 0 ;
38343 void *argp1 = 0 ;
38344 int res1 = 0 ;
38345 int val2 ;
38346 int ecode2 = 0 ;
38347 bool temp3 = false ;
38348 bool temp4 = false ;
38349 PyObject * obj0 = 0 ;
38350 PyObject * obj1 = 0 ;
38351 PyObject * obj2 = 0 ;
38352 PyObject * obj3 = 0 ;
38353 char * kwnames[] = {
38354 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
38355 };
38356
38357 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38358 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38359 if (!SWIG_IsOK(res1)) {
38360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38361 }
38362 arg1 = reinterpret_cast< wxMenu * >(argp1);
38363 ecode2 = SWIG_AsVal_int(obj1, &val2);
38364 if (!SWIG_IsOK(ecode2)) {
38365 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendRadioItem" "', expected argument " "2"" of type '" "int""'");
38366 }
38367 arg2 = static_cast< int >(val2);
38368 {
38369 arg3 = wxString_in_helper(obj2);
38370 if (arg3 == NULL) SWIG_fail;
38371 temp3 = true;
38372 }
38373 if (obj3) {
38374 {
38375 arg4 = wxString_in_helper(obj3);
38376 if (arg4 == NULL) SWIG_fail;
38377 temp4 = true;
38378 }
38379 }
38380 {
38381 PyThreadState* __tstate = wxPyBeginAllowThreads();
38382 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38383 wxPyEndAllowThreads(__tstate);
38384 if (PyErr_Occurred()) SWIG_fail;
38385 }
38386 {
38387 resultobj = wxPyMake_wxObject(result, (bool)0);
38388 }
38389 {
38390 if (temp3)
38391 delete arg3;
38392 }
38393 {
38394 if (temp4)
38395 delete arg4;
38396 }
38397 return resultobj;
38398 fail:
38399 {
38400 if (temp3)
38401 delete arg3;
38402 }
38403 {
38404 if (temp4)
38405 delete arg4;
38406 }
38407 return NULL;
38408 }
38409
38410
38411 SWIGINTERN PyObject *_wrap_Menu_AppendMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38412 PyObject *resultobj = 0;
38413 wxMenu *arg1 = (wxMenu *) 0 ;
38414 int arg2 ;
38415 wxString *arg3 = 0 ;
38416 wxMenu *arg4 = (wxMenu *) 0 ;
38417 wxString const &arg5_defvalue = wxPyEmptyString ;
38418 wxString *arg5 = (wxString *) &arg5_defvalue ;
38419 wxMenuItem *result = 0 ;
38420 void *argp1 = 0 ;
38421 int res1 = 0 ;
38422 int val2 ;
38423 int ecode2 = 0 ;
38424 bool temp3 = false ;
38425 void *argp4 = 0 ;
38426 int res4 = 0 ;
38427 bool temp5 = false ;
38428 PyObject * obj0 = 0 ;
38429 PyObject * obj1 = 0 ;
38430 PyObject * obj2 = 0 ;
38431 PyObject * obj3 = 0 ;
38432 PyObject * obj4 = 0 ;
38433 char * kwnames[] = {
38434 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
38435 };
38436
38437 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38438 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38439 if (!SWIG_IsOK(res1)) {
38440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
38441 }
38442 arg1 = reinterpret_cast< wxMenu * >(argp1);
38443 ecode2 = SWIG_AsVal_int(obj1, &val2);
38444 if (!SWIG_IsOK(ecode2)) {
38445 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendMenu" "', expected argument " "2"" of type '" "int""'");
38446 }
38447 arg2 = static_cast< int >(val2);
38448 {
38449 arg3 = wxString_in_helper(obj2);
38450 if (arg3 == NULL) SWIG_fail;
38451 temp3 = true;
38452 }
38453 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
38454 if (!SWIG_IsOK(res4)) {
38455 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_AppendMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
38456 }
38457 arg4 = reinterpret_cast< wxMenu * >(argp4);
38458 if (obj4) {
38459 {
38460 arg5 = wxString_in_helper(obj4);
38461 if (arg5 == NULL) SWIG_fail;
38462 temp5 = true;
38463 }
38464 }
38465 {
38466 PyThreadState* __tstate = wxPyBeginAllowThreads();
38467 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
38468 wxPyEndAllowThreads(__tstate);
38469 if (PyErr_Occurred()) SWIG_fail;
38470 }
38471 {
38472 resultobj = wxPyMake_wxObject(result, (bool)0);
38473 }
38474 {
38475 if (temp3)
38476 delete arg3;
38477 }
38478 {
38479 if (temp5)
38480 delete arg5;
38481 }
38482 return resultobj;
38483 fail:
38484 {
38485 if (temp3)
38486 delete arg3;
38487 }
38488 {
38489 if (temp5)
38490 delete arg5;
38491 }
38492 return NULL;
38493 }
38494
38495
38496 SWIGINTERN PyObject *_wrap_Menu_AppendSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38497 PyObject *resultobj = 0;
38498 wxMenu *arg1 = (wxMenu *) 0 ;
38499 wxMenu *arg2 = (wxMenu *) 0 ;
38500 wxString *arg3 = 0 ;
38501 wxString const &arg4_defvalue = wxPyEmptyString ;
38502 wxString *arg4 = (wxString *) &arg4_defvalue ;
38503 wxMenuItem *result = 0 ;
38504 void *argp1 = 0 ;
38505 int res1 = 0 ;
38506 void *argp2 = 0 ;
38507 int res2 = 0 ;
38508 bool temp3 = false ;
38509 bool temp4 = false ;
38510 PyObject * obj0 = 0 ;
38511 PyObject * obj1 = 0 ;
38512 PyObject * obj2 = 0 ;
38513 PyObject * obj3 = 0 ;
38514 char * kwnames[] = {
38515 (char *) "self",(char *) "submenu",(char *) "text",(char *) "help", NULL
38516 };
38517
38518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendSubMenu",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38519 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38520 if (!SWIG_IsOK(res1)) {
38521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSubMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
38522 }
38523 arg1 = reinterpret_cast< wxMenu * >(argp1);
38524 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
38525 if (!SWIG_IsOK(res2)) {
38526 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
38527 }
38528 arg2 = reinterpret_cast< wxMenu * >(argp2);
38529 {
38530 arg3 = wxString_in_helper(obj2);
38531 if (arg3 == NULL) SWIG_fail;
38532 temp3 = true;
38533 }
38534 if (obj3) {
38535 {
38536 arg4 = wxString_in_helper(obj3);
38537 if (arg4 == NULL) SWIG_fail;
38538 temp4 = true;
38539 }
38540 }
38541 {
38542 PyThreadState* __tstate = wxPyBeginAllowThreads();
38543 result = (wxMenuItem *)(arg1)->AppendSubMenu(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38544 wxPyEndAllowThreads(__tstate);
38545 if (PyErr_Occurred()) SWIG_fail;
38546 }
38547 {
38548 resultobj = wxPyMake_wxObject(result, (bool)0);
38549 }
38550 {
38551 if (temp3)
38552 delete arg3;
38553 }
38554 {
38555 if (temp4)
38556 delete arg4;
38557 }
38558 return resultobj;
38559 fail:
38560 {
38561 if (temp3)
38562 delete arg3;
38563 }
38564 {
38565 if (temp4)
38566 delete arg4;
38567 }
38568 return NULL;
38569 }
38570
38571
38572 SWIGINTERN PyObject *_wrap_Menu_AppendItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38573 PyObject *resultobj = 0;
38574 wxMenu *arg1 = (wxMenu *) 0 ;
38575 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
38576 wxMenuItem *result = 0 ;
38577 void *argp1 = 0 ;
38578 int res1 = 0 ;
38579 int res2 = 0 ;
38580 PyObject * obj0 = 0 ;
38581 PyObject * obj1 = 0 ;
38582 char * kwnames[] = {
38583 (char *) "self",(char *) "item", NULL
38584 };
38585
38586 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) SWIG_fail;
38587 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38588 if (!SWIG_IsOK(res1)) {
38589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38590 }
38591 arg1 = reinterpret_cast< wxMenu * >(argp1);
38592 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38593 if (!SWIG_IsOK(res2)) {
38594 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
38595 }
38596 {
38597 PyThreadState* __tstate = wxPyBeginAllowThreads();
38598 result = (wxMenuItem *)(arg1)->Append(arg2);
38599 wxPyEndAllowThreads(__tstate);
38600 if (PyErr_Occurred()) SWIG_fail;
38601 }
38602 {
38603 resultobj = wxPyMake_wxObject(result, (bool)0);
38604 }
38605 return resultobj;
38606 fail:
38607 return NULL;
38608 }
38609
38610
38611 SWIGINTERN PyObject *_wrap_Menu_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38612 PyObject *resultobj = 0;
38613 wxMenu *arg1 = (wxMenu *) 0 ;
38614 size_t arg2 ;
38615 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
38616 wxMenuItem *result = 0 ;
38617 void *argp1 = 0 ;
38618 int res1 = 0 ;
38619 size_t val2 ;
38620 int ecode2 = 0 ;
38621 int res3 = 0 ;
38622 PyObject * obj0 = 0 ;
38623 PyObject * obj1 = 0 ;
38624 PyObject * obj2 = 0 ;
38625 char * kwnames[] = {
38626 (char *) "self",(char *) "pos",(char *) "item", NULL
38627 };
38628
38629 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38630 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38631 if (!SWIG_IsOK(res1)) {
38632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38633 }
38634 arg1 = reinterpret_cast< wxMenu * >(argp1);
38635 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38636 if (!SWIG_IsOK(ecode2)) {
38637 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
38638 }
38639 arg2 = static_cast< size_t >(val2);
38640 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38641 if (!SWIG_IsOK(res3)) {
38642 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Menu_InsertItem" "', expected argument " "3"" of type '" "wxMenuItem *""'");
38643 }
38644 {
38645 PyThreadState* __tstate = wxPyBeginAllowThreads();
38646 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
38647 wxPyEndAllowThreads(__tstate);
38648 if (PyErr_Occurred()) SWIG_fail;
38649 }
38650 {
38651 resultobj = wxPyMake_wxObject(result, (bool)0);
38652 }
38653 return resultobj;
38654 fail:
38655 return NULL;
38656 }
38657
38658
38659 SWIGINTERN PyObject *_wrap_Menu_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38660 PyObject *resultobj = 0;
38661 wxMenu *arg1 = (wxMenu *) 0 ;
38662 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
38663 wxMenuItem *result = 0 ;
38664 void *argp1 = 0 ;
38665 int res1 = 0 ;
38666 int res2 = 0 ;
38667 PyObject * obj0 = 0 ;
38668 PyObject * obj1 = 0 ;
38669 char * kwnames[] = {
38670 (char *) "self",(char *) "item", NULL
38671 };
38672
38673 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
38674 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38675 if (!SWIG_IsOK(res1)) {
38676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38677 }
38678 arg1 = reinterpret_cast< wxMenu * >(argp1);
38679 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38680 if (!SWIG_IsOK(res2)) {
38681 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_PrependItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
38682 }
38683 {
38684 PyThreadState* __tstate = wxPyBeginAllowThreads();
38685 result = (wxMenuItem *)(arg1)->Prepend(arg2);
38686 wxPyEndAllowThreads(__tstate);
38687 if (PyErr_Occurred()) SWIG_fail;
38688 }
38689 {
38690 resultobj = wxPyMake_wxObject(result, (bool)0);
38691 }
38692 return resultobj;
38693 fail:
38694 return NULL;
38695 }
38696
38697
38698 SWIGINTERN PyObject *_wrap_Menu_Break(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38699 PyObject *resultobj = 0;
38700 wxMenu *arg1 = (wxMenu *) 0 ;
38701 void *argp1 = 0 ;
38702 int res1 = 0 ;
38703 PyObject *swig_obj[1] ;
38704
38705 if (!args) SWIG_fail;
38706 swig_obj[0] = args;
38707 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38708 if (!SWIG_IsOK(res1)) {
38709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Break" "', expected argument " "1"" of type '" "wxMenu *""'");
38710 }
38711 arg1 = reinterpret_cast< wxMenu * >(argp1);
38712 {
38713 PyThreadState* __tstate = wxPyBeginAllowThreads();
38714 (arg1)->Break();
38715 wxPyEndAllowThreads(__tstate);
38716 if (PyErr_Occurred()) SWIG_fail;
38717 }
38718 resultobj = SWIG_Py_Void();
38719 return resultobj;
38720 fail:
38721 return NULL;
38722 }
38723
38724
38725 SWIGINTERN PyObject *_wrap_Menu_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38726 PyObject *resultobj = 0;
38727 wxMenu *arg1 = (wxMenu *) 0 ;
38728 size_t arg2 ;
38729 int arg3 ;
38730 wxString *arg4 = 0 ;
38731 wxString const &arg5_defvalue = wxPyEmptyString ;
38732 wxString *arg5 = (wxString *) &arg5_defvalue ;
38733 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
38734 wxMenuItem *result = 0 ;
38735 void *argp1 = 0 ;
38736 int res1 = 0 ;
38737 size_t val2 ;
38738 int ecode2 = 0 ;
38739 int val3 ;
38740 int ecode3 = 0 ;
38741 bool temp4 = false ;
38742 bool temp5 = false ;
38743 int val6 ;
38744 int ecode6 = 0 ;
38745 PyObject * obj0 = 0 ;
38746 PyObject * obj1 = 0 ;
38747 PyObject * obj2 = 0 ;
38748 PyObject * obj3 = 0 ;
38749 PyObject * obj4 = 0 ;
38750 PyObject * obj5 = 0 ;
38751 char * kwnames[] = {
38752 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
38753 };
38754
38755 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) 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_Insert" "', expected argument " "1"" of type '" "wxMenu *""'");
38759 }
38760 arg1 = reinterpret_cast< wxMenu * >(argp1);
38761 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38762 if (!SWIG_IsOK(ecode2)) {
38763 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Insert" "', expected argument " "2"" of type '" "size_t""'");
38764 }
38765 arg2 = static_cast< size_t >(val2);
38766 ecode3 = SWIG_AsVal_int(obj2, &val3);
38767 if (!SWIG_IsOK(ecode3)) {
38768 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Insert" "', expected argument " "3"" of type '" "int""'");
38769 }
38770 arg3 = static_cast< int >(val3);
38771 {
38772 arg4 = wxString_in_helper(obj3);
38773 if (arg4 == NULL) SWIG_fail;
38774 temp4 = true;
38775 }
38776 if (obj4) {
38777 {
38778 arg5 = wxString_in_helper(obj4);
38779 if (arg5 == NULL) SWIG_fail;
38780 temp5 = true;
38781 }
38782 }
38783 if (obj5) {
38784 ecode6 = SWIG_AsVal_int(obj5, &val6);
38785 if (!SWIG_IsOK(ecode6)) {
38786 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Menu_Insert" "', expected argument " "6"" of type '" "wxItemKind""'");
38787 }
38788 arg6 = static_cast< wxItemKind >(val6);
38789 }
38790 {
38791 PyThreadState* __tstate = wxPyBeginAllowThreads();
38792 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6);
38793 wxPyEndAllowThreads(__tstate);
38794 if (PyErr_Occurred()) SWIG_fail;
38795 }
38796 {
38797 resultobj = wxPyMake_wxObject(result, (bool)0);
38798 }
38799 {
38800 if (temp4)
38801 delete arg4;
38802 }
38803 {
38804 if (temp5)
38805 delete arg5;
38806 }
38807 return resultobj;
38808 fail:
38809 {
38810 if (temp4)
38811 delete arg4;
38812 }
38813 {
38814 if (temp5)
38815 delete arg5;
38816 }
38817 return NULL;
38818 }
38819
38820
38821 SWIGINTERN PyObject *_wrap_Menu_InsertSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38822 PyObject *resultobj = 0;
38823 wxMenu *arg1 = (wxMenu *) 0 ;
38824 size_t arg2 ;
38825 wxMenuItem *result = 0 ;
38826 void *argp1 = 0 ;
38827 int res1 = 0 ;
38828 size_t val2 ;
38829 int ecode2 = 0 ;
38830 PyObject * obj0 = 0 ;
38831 PyObject * obj1 = 0 ;
38832 char * kwnames[] = {
38833 (char *) "self",(char *) "pos", NULL
38834 };
38835
38836 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) SWIG_fail;
38837 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38838 if (!SWIG_IsOK(res1)) {
38839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
38840 }
38841 arg1 = reinterpret_cast< wxMenu * >(argp1);
38842 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38843 if (!SWIG_IsOK(ecode2)) {
38844 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertSeparator" "', expected argument " "2"" of type '" "size_t""'");
38845 }
38846 arg2 = static_cast< size_t >(val2);
38847 {
38848 PyThreadState* __tstate = wxPyBeginAllowThreads();
38849 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
38850 wxPyEndAllowThreads(__tstate);
38851 if (PyErr_Occurred()) SWIG_fail;
38852 }
38853 {
38854 resultobj = wxPyMake_wxObject(result, (bool)0);
38855 }
38856 return resultobj;
38857 fail:
38858 return NULL;
38859 }
38860
38861
38862 SWIGINTERN PyObject *_wrap_Menu_InsertCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38863 PyObject *resultobj = 0;
38864 wxMenu *arg1 = (wxMenu *) 0 ;
38865 size_t arg2 ;
38866 int arg3 ;
38867 wxString *arg4 = 0 ;
38868 wxString const &arg5_defvalue = wxPyEmptyString ;
38869 wxString *arg5 = (wxString *) &arg5_defvalue ;
38870 wxMenuItem *result = 0 ;
38871 void *argp1 = 0 ;
38872 int res1 = 0 ;
38873 size_t val2 ;
38874 int ecode2 = 0 ;
38875 int val3 ;
38876 int ecode3 = 0 ;
38877 bool temp4 = false ;
38878 bool temp5 = false ;
38879 PyObject * obj0 = 0 ;
38880 PyObject * obj1 = 0 ;
38881 PyObject * obj2 = 0 ;
38882 PyObject * obj3 = 0 ;
38883 PyObject * obj4 = 0 ;
38884 char * kwnames[] = {
38885 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
38886 };
38887
38888 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38889 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38890 if (!SWIG_IsOK(res1)) {
38891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38892 }
38893 arg1 = reinterpret_cast< wxMenu * >(argp1);
38894 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38895 if (!SWIG_IsOK(ecode2)) {
38896 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertCheckItem" "', expected argument " "2"" of type '" "size_t""'");
38897 }
38898 arg2 = static_cast< size_t >(val2);
38899 ecode3 = SWIG_AsVal_int(obj2, &val3);
38900 if (!SWIG_IsOK(ecode3)) {
38901 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertCheckItem" "', expected argument " "3"" of type '" "int""'");
38902 }
38903 arg3 = static_cast< int >(val3);
38904 {
38905 arg4 = wxString_in_helper(obj3);
38906 if (arg4 == NULL) SWIG_fail;
38907 temp4 = true;
38908 }
38909 if (obj4) {
38910 {
38911 arg5 = wxString_in_helper(obj4);
38912 if (arg5 == NULL) SWIG_fail;
38913 temp5 = true;
38914 }
38915 }
38916 {
38917 PyThreadState* __tstate = wxPyBeginAllowThreads();
38918 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
38919 wxPyEndAllowThreads(__tstate);
38920 if (PyErr_Occurred()) SWIG_fail;
38921 }
38922 {
38923 resultobj = wxPyMake_wxObject(result, (bool)0);
38924 }
38925 {
38926 if (temp4)
38927 delete arg4;
38928 }
38929 {
38930 if (temp5)
38931 delete arg5;
38932 }
38933 return resultobj;
38934 fail:
38935 {
38936 if (temp4)
38937 delete arg4;
38938 }
38939 {
38940 if (temp5)
38941 delete arg5;
38942 }
38943 return NULL;
38944 }
38945
38946
38947 SWIGINTERN PyObject *_wrap_Menu_InsertRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38948 PyObject *resultobj = 0;
38949 wxMenu *arg1 = (wxMenu *) 0 ;
38950 size_t arg2 ;
38951 int arg3 ;
38952 wxString *arg4 = 0 ;
38953 wxString const &arg5_defvalue = wxPyEmptyString ;
38954 wxString *arg5 = (wxString *) &arg5_defvalue ;
38955 wxMenuItem *result = 0 ;
38956 void *argp1 = 0 ;
38957 int res1 = 0 ;
38958 size_t val2 ;
38959 int ecode2 = 0 ;
38960 int val3 ;
38961 int ecode3 = 0 ;
38962 bool temp4 = false ;
38963 bool temp5 = false ;
38964 PyObject * obj0 = 0 ;
38965 PyObject * obj1 = 0 ;
38966 PyObject * obj2 = 0 ;
38967 PyObject * obj3 = 0 ;
38968 PyObject * obj4 = 0 ;
38969 char * kwnames[] = {
38970 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
38971 };
38972
38973 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38974 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38975 if (!SWIG_IsOK(res1)) {
38976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38977 }
38978 arg1 = reinterpret_cast< wxMenu * >(argp1);
38979 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38980 if (!SWIG_IsOK(ecode2)) {
38981 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertRadioItem" "', expected argument " "2"" of type '" "size_t""'");
38982 }
38983 arg2 = static_cast< size_t >(val2);
38984 ecode3 = SWIG_AsVal_int(obj2, &val3);
38985 if (!SWIG_IsOK(ecode3)) {
38986 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertRadioItem" "', expected argument " "3"" of type '" "int""'");
38987 }
38988 arg3 = static_cast< int >(val3);
38989 {
38990 arg4 = wxString_in_helper(obj3);
38991 if (arg4 == NULL) SWIG_fail;
38992 temp4 = true;
38993 }
38994 if (obj4) {
38995 {
38996 arg5 = wxString_in_helper(obj4);
38997 if (arg5 == NULL) SWIG_fail;
38998 temp5 = true;
38999 }
39000 }
39001 {
39002 PyThreadState* __tstate = wxPyBeginAllowThreads();
39003 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
39004 wxPyEndAllowThreads(__tstate);
39005 if (PyErr_Occurred()) SWIG_fail;
39006 }
39007 {
39008 resultobj = wxPyMake_wxObject(result, (bool)0);
39009 }
39010 {
39011 if (temp4)
39012 delete arg4;
39013 }
39014 {
39015 if (temp5)
39016 delete arg5;
39017 }
39018 return resultobj;
39019 fail:
39020 {
39021 if (temp4)
39022 delete arg4;
39023 }
39024 {
39025 if (temp5)
39026 delete arg5;
39027 }
39028 return NULL;
39029 }
39030
39031
39032 SWIGINTERN PyObject *_wrap_Menu_InsertMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39033 PyObject *resultobj = 0;
39034 wxMenu *arg1 = (wxMenu *) 0 ;
39035 size_t arg2 ;
39036 int arg3 ;
39037 wxString *arg4 = 0 ;
39038 wxMenu *arg5 = (wxMenu *) 0 ;
39039 wxString const &arg6_defvalue = wxPyEmptyString ;
39040 wxString *arg6 = (wxString *) &arg6_defvalue ;
39041 wxMenuItem *result = 0 ;
39042 void *argp1 = 0 ;
39043 int res1 = 0 ;
39044 size_t val2 ;
39045 int ecode2 = 0 ;
39046 int val3 ;
39047 int ecode3 = 0 ;
39048 bool temp4 = false ;
39049 void *argp5 = 0 ;
39050 int res5 = 0 ;
39051 bool temp6 = false ;
39052 PyObject * obj0 = 0 ;
39053 PyObject * obj1 = 0 ;
39054 PyObject * obj2 = 0 ;
39055 PyObject * obj3 = 0 ;
39056 PyObject * obj4 = 0 ;
39057 PyObject * obj5 = 0 ;
39058 char * kwnames[] = {
39059 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39060 };
39061
39062 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
39063 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39064 if (!SWIG_IsOK(res1)) {
39065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39066 }
39067 arg1 = reinterpret_cast< wxMenu * >(argp1);
39068 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39069 if (!SWIG_IsOK(ecode2)) {
39070 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertMenu" "', expected argument " "2"" of type '" "size_t""'");
39071 }
39072 arg2 = static_cast< size_t >(val2);
39073 ecode3 = SWIG_AsVal_int(obj2, &val3);
39074 if (!SWIG_IsOK(ecode3)) {
39075 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertMenu" "', expected argument " "3"" of type '" "int""'");
39076 }
39077 arg3 = static_cast< int >(val3);
39078 {
39079 arg4 = wxString_in_helper(obj3);
39080 if (arg4 == NULL) SWIG_fail;
39081 temp4 = true;
39082 }
39083 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxMenu, 0 | 0 );
39084 if (!SWIG_IsOK(res5)) {
39085 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Menu_InsertMenu" "', expected argument " "5"" of type '" "wxMenu *""'");
39086 }
39087 arg5 = reinterpret_cast< wxMenu * >(argp5);
39088 if (obj5) {
39089 {
39090 arg6 = wxString_in_helper(obj5);
39091 if (arg6 == NULL) SWIG_fail;
39092 temp6 = true;
39093 }
39094 }
39095 {
39096 PyThreadState* __tstate = wxPyBeginAllowThreads();
39097 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
39098 wxPyEndAllowThreads(__tstate);
39099 if (PyErr_Occurred()) SWIG_fail;
39100 }
39101 {
39102 resultobj = wxPyMake_wxObject(result, (bool)0);
39103 }
39104 {
39105 if (temp4)
39106 delete arg4;
39107 }
39108 {
39109 if (temp6)
39110 delete arg6;
39111 }
39112 return resultobj;
39113 fail:
39114 {
39115 if (temp4)
39116 delete arg4;
39117 }
39118 {
39119 if (temp6)
39120 delete arg6;
39121 }
39122 return NULL;
39123 }
39124
39125
39126 SWIGINTERN PyObject *_wrap_Menu_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39127 PyObject *resultobj = 0;
39128 wxMenu *arg1 = (wxMenu *) 0 ;
39129 int arg2 ;
39130 wxString *arg3 = 0 ;
39131 wxString const &arg4_defvalue = wxPyEmptyString ;
39132 wxString *arg4 = (wxString *) &arg4_defvalue ;
39133 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
39134 wxMenuItem *result = 0 ;
39135 void *argp1 = 0 ;
39136 int res1 = 0 ;
39137 int val2 ;
39138 int ecode2 = 0 ;
39139 bool temp3 = false ;
39140 bool temp4 = false ;
39141 int val5 ;
39142 int ecode5 = 0 ;
39143 PyObject * obj0 = 0 ;
39144 PyObject * obj1 = 0 ;
39145 PyObject * obj2 = 0 ;
39146 PyObject * obj3 = 0 ;
39147 PyObject * obj4 = 0 ;
39148 char * kwnames[] = {
39149 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
39150 };
39151
39152 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39153 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39154 if (!SWIG_IsOK(res1)) {
39155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Prepend" "', expected argument " "1"" of type '" "wxMenu *""'");
39156 }
39157 arg1 = reinterpret_cast< wxMenu * >(argp1);
39158 ecode2 = SWIG_AsVal_int(obj1, &val2);
39159 if (!SWIG_IsOK(ecode2)) {
39160 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Prepend" "', expected argument " "2"" of type '" "int""'");
39161 }
39162 arg2 = static_cast< int >(val2);
39163 {
39164 arg3 = wxString_in_helper(obj2);
39165 if (arg3 == NULL) SWIG_fail;
39166 temp3 = true;
39167 }
39168 if (obj3) {
39169 {
39170 arg4 = wxString_in_helper(obj3);
39171 if (arg4 == NULL) SWIG_fail;
39172 temp4 = true;
39173 }
39174 }
39175 if (obj4) {
39176 ecode5 = SWIG_AsVal_int(obj4, &val5);
39177 if (!SWIG_IsOK(ecode5)) {
39178 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Prepend" "', expected argument " "5"" of type '" "wxItemKind""'");
39179 }
39180 arg5 = static_cast< wxItemKind >(val5);
39181 }
39182 {
39183 PyThreadState* __tstate = wxPyBeginAllowThreads();
39184 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
39185 wxPyEndAllowThreads(__tstate);
39186 if (PyErr_Occurred()) SWIG_fail;
39187 }
39188 {
39189 resultobj = wxPyMake_wxObject(result, (bool)0);
39190 }
39191 {
39192 if (temp3)
39193 delete arg3;
39194 }
39195 {
39196 if (temp4)
39197 delete arg4;
39198 }
39199 return resultobj;
39200 fail:
39201 {
39202 if (temp3)
39203 delete arg3;
39204 }
39205 {
39206 if (temp4)
39207 delete arg4;
39208 }
39209 return NULL;
39210 }
39211
39212
39213 SWIGINTERN PyObject *_wrap_Menu_PrependSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39214 PyObject *resultobj = 0;
39215 wxMenu *arg1 = (wxMenu *) 0 ;
39216 wxMenuItem *result = 0 ;
39217 void *argp1 = 0 ;
39218 int res1 = 0 ;
39219 PyObject *swig_obj[1] ;
39220
39221 if (!args) SWIG_fail;
39222 swig_obj[0] = args;
39223 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39224 if (!SWIG_IsOK(res1)) {
39225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
39226 }
39227 arg1 = reinterpret_cast< wxMenu * >(argp1);
39228 {
39229 PyThreadState* __tstate = wxPyBeginAllowThreads();
39230 result = (wxMenuItem *)(arg1)->PrependSeparator();
39231 wxPyEndAllowThreads(__tstate);
39232 if (PyErr_Occurred()) SWIG_fail;
39233 }
39234 {
39235 resultobj = wxPyMake_wxObject(result, (bool)0);
39236 }
39237 return resultobj;
39238 fail:
39239 return NULL;
39240 }
39241
39242
39243 SWIGINTERN PyObject *_wrap_Menu_PrependCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39244 PyObject *resultobj = 0;
39245 wxMenu *arg1 = (wxMenu *) 0 ;
39246 int arg2 ;
39247 wxString *arg3 = 0 ;
39248 wxString const &arg4_defvalue = wxPyEmptyString ;
39249 wxString *arg4 = (wxString *) &arg4_defvalue ;
39250 wxMenuItem *result = 0 ;
39251 void *argp1 = 0 ;
39252 int res1 = 0 ;
39253 int val2 ;
39254 int ecode2 = 0 ;
39255 bool temp3 = false ;
39256 bool temp4 = false ;
39257 PyObject * obj0 = 0 ;
39258 PyObject * obj1 = 0 ;
39259 PyObject * obj2 = 0 ;
39260 PyObject * obj3 = 0 ;
39261 char * kwnames[] = {
39262 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39263 };
39264
39265 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39266 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39267 if (!SWIG_IsOK(res1)) {
39268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39269 }
39270 arg1 = reinterpret_cast< wxMenu * >(argp1);
39271 ecode2 = SWIG_AsVal_int(obj1, &val2);
39272 if (!SWIG_IsOK(ecode2)) {
39273 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependCheckItem" "', expected argument " "2"" of type '" "int""'");
39274 }
39275 arg2 = static_cast< int >(val2);
39276 {
39277 arg3 = wxString_in_helper(obj2);
39278 if (arg3 == NULL) SWIG_fail;
39279 temp3 = true;
39280 }
39281 if (obj3) {
39282 {
39283 arg4 = wxString_in_helper(obj3);
39284 if (arg4 == NULL) SWIG_fail;
39285 temp4 = true;
39286 }
39287 }
39288 {
39289 PyThreadState* __tstate = wxPyBeginAllowThreads();
39290 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39291 wxPyEndAllowThreads(__tstate);
39292 if (PyErr_Occurred()) SWIG_fail;
39293 }
39294 {
39295 resultobj = wxPyMake_wxObject(result, (bool)0);
39296 }
39297 {
39298 if (temp3)
39299 delete arg3;
39300 }
39301 {
39302 if (temp4)
39303 delete arg4;
39304 }
39305 return resultobj;
39306 fail:
39307 {
39308 if (temp3)
39309 delete arg3;
39310 }
39311 {
39312 if (temp4)
39313 delete arg4;
39314 }
39315 return NULL;
39316 }
39317
39318
39319 SWIGINTERN PyObject *_wrap_Menu_PrependRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39320 PyObject *resultobj = 0;
39321 wxMenu *arg1 = (wxMenu *) 0 ;
39322 int arg2 ;
39323 wxString *arg3 = 0 ;
39324 wxString const &arg4_defvalue = wxPyEmptyString ;
39325 wxString *arg4 = (wxString *) &arg4_defvalue ;
39326 wxMenuItem *result = 0 ;
39327 void *argp1 = 0 ;
39328 int res1 = 0 ;
39329 int val2 ;
39330 int ecode2 = 0 ;
39331 bool temp3 = false ;
39332 bool temp4 = false ;
39333 PyObject * obj0 = 0 ;
39334 PyObject * obj1 = 0 ;
39335 PyObject * obj2 = 0 ;
39336 PyObject * obj3 = 0 ;
39337 char * kwnames[] = {
39338 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39339 };
39340
39341 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39342 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39343 if (!SWIG_IsOK(res1)) {
39344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39345 }
39346 arg1 = reinterpret_cast< wxMenu * >(argp1);
39347 ecode2 = SWIG_AsVal_int(obj1, &val2);
39348 if (!SWIG_IsOK(ecode2)) {
39349 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependRadioItem" "', expected argument " "2"" of type '" "int""'");
39350 }
39351 arg2 = static_cast< int >(val2);
39352 {
39353 arg3 = wxString_in_helper(obj2);
39354 if (arg3 == NULL) SWIG_fail;
39355 temp3 = true;
39356 }
39357 if (obj3) {
39358 {
39359 arg4 = wxString_in_helper(obj3);
39360 if (arg4 == NULL) SWIG_fail;
39361 temp4 = true;
39362 }
39363 }
39364 {
39365 PyThreadState* __tstate = wxPyBeginAllowThreads();
39366 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39367 wxPyEndAllowThreads(__tstate);
39368 if (PyErr_Occurred()) SWIG_fail;
39369 }
39370 {
39371 resultobj = wxPyMake_wxObject(result, (bool)0);
39372 }
39373 {
39374 if (temp3)
39375 delete arg3;
39376 }
39377 {
39378 if (temp4)
39379 delete arg4;
39380 }
39381 return resultobj;
39382 fail:
39383 {
39384 if (temp3)
39385 delete arg3;
39386 }
39387 {
39388 if (temp4)
39389 delete arg4;
39390 }
39391 return NULL;
39392 }
39393
39394
39395 SWIGINTERN PyObject *_wrap_Menu_PrependMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39396 PyObject *resultobj = 0;
39397 wxMenu *arg1 = (wxMenu *) 0 ;
39398 int arg2 ;
39399 wxString *arg3 = 0 ;
39400 wxMenu *arg4 = (wxMenu *) 0 ;
39401 wxString const &arg5_defvalue = wxPyEmptyString ;
39402 wxString *arg5 = (wxString *) &arg5_defvalue ;
39403 wxMenuItem *result = 0 ;
39404 void *argp1 = 0 ;
39405 int res1 = 0 ;
39406 int val2 ;
39407 int ecode2 = 0 ;
39408 bool temp3 = false ;
39409 void *argp4 = 0 ;
39410 int res4 = 0 ;
39411 bool temp5 = false ;
39412 PyObject * obj0 = 0 ;
39413 PyObject * obj1 = 0 ;
39414 PyObject * obj2 = 0 ;
39415 PyObject * obj3 = 0 ;
39416 PyObject * obj4 = 0 ;
39417 char * kwnames[] = {
39418 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39419 };
39420
39421 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39422 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39423 if (!SWIG_IsOK(res1)) {
39424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39425 }
39426 arg1 = reinterpret_cast< wxMenu * >(argp1);
39427 ecode2 = SWIG_AsVal_int(obj1, &val2);
39428 if (!SWIG_IsOK(ecode2)) {
39429 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependMenu" "', expected argument " "2"" of type '" "int""'");
39430 }
39431 arg2 = static_cast< int >(val2);
39432 {
39433 arg3 = wxString_in_helper(obj2);
39434 if (arg3 == NULL) SWIG_fail;
39435 temp3 = true;
39436 }
39437 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
39438 if (!SWIG_IsOK(res4)) {
39439 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_PrependMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
39440 }
39441 arg4 = reinterpret_cast< wxMenu * >(argp4);
39442 if (obj4) {
39443 {
39444 arg5 = wxString_in_helper(obj4);
39445 if (arg5 == NULL) SWIG_fail;
39446 temp5 = true;
39447 }
39448 }
39449 {
39450 PyThreadState* __tstate = wxPyBeginAllowThreads();
39451 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
39452 wxPyEndAllowThreads(__tstate);
39453 if (PyErr_Occurred()) SWIG_fail;
39454 }
39455 {
39456 resultobj = wxPyMake_wxObject(result, (bool)0);
39457 }
39458 {
39459 if (temp3)
39460 delete arg3;
39461 }
39462 {
39463 if (temp5)
39464 delete arg5;
39465 }
39466 return resultobj;
39467 fail:
39468 {
39469 if (temp3)
39470 delete arg3;
39471 }
39472 {
39473 if (temp5)
39474 delete arg5;
39475 }
39476 return NULL;
39477 }
39478
39479
39480 SWIGINTERN PyObject *_wrap_Menu_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39481 PyObject *resultobj = 0;
39482 wxMenu *arg1 = (wxMenu *) 0 ;
39483 int arg2 ;
39484 wxMenuItem *result = 0 ;
39485 void *argp1 = 0 ;
39486 int res1 = 0 ;
39487 int val2 ;
39488 int ecode2 = 0 ;
39489 PyObject * obj0 = 0 ;
39490 PyObject * obj1 = 0 ;
39491 char * kwnames[] = {
39492 (char *) "self",(char *) "id", NULL
39493 };
39494
39495 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
39496 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39497 if (!SWIG_IsOK(res1)) {
39498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Remove" "', expected argument " "1"" of type '" "wxMenu *""'");
39499 }
39500 arg1 = reinterpret_cast< wxMenu * >(argp1);
39501 ecode2 = SWIG_AsVal_int(obj1, &val2);
39502 if (!SWIG_IsOK(ecode2)) {
39503 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Remove" "', expected argument " "2"" of type '" "int""'");
39504 }
39505 arg2 = static_cast< int >(val2);
39506 {
39507 PyThreadState* __tstate = wxPyBeginAllowThreads();
39508 result = (wxMenuItem *)(arg1)->Remove(arg2);
39509 wxPyEndAllowThreads(__tstate);
39510 if (PyErr_Occurred()) SWIG_fail;
39511 }
39512 {
39513 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
39514 }
39515 return resultobj;
39516 fail:
39517 return NULL;
39518 }
39519
39520
39521 SWIGINTERN PyObject *_wrap_Menu_RemoveItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39522 PyObject *resultobj = 0;
39523 wxMenu *arg1 = (wxMenu *) 0 ;
39524 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39525 wxMenuItem *result = 0 ;
39526 void *argp1 = 0 ;
39527 int res1 = 0 ;
39528 void *argp2 = 0 ;
39529 int res2 = 0 ;
39530 PyObject * obj0 = 0 ;
39531 PyObject * obj1 = 0 ;
39532 char * kwnames[] = {
39533 (char *) "self",(char *) "item", NULL
39534 };
39535
39536 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) SWIG_fail;
39537 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39538 if (!SWIG_IsOK(res1)) {
39539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_RemoveItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39540 }
39541 arg1 = reinterpret_cast< wxMenu * >(argp1);
39542 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39543 if (!SWIG_IsOK(res2)) {
39544 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_RemoveItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39545 }
39546 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39547 {
39548 PyThreadState* __tstate = wxPyBeginAllowThreads();
39549 result = (wxMenuItem *)(arg1)->Remove(arg2);
39550 wxPyEndAllowThreads(__tstate);
39551 if (PyErr_Occurred()) SWIG_fail;
39552 }
39553 {
39554 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
39555 }
39556 return resultobj;
39557 fail:
39558 return NULL;
39559 }
39560
39561
39562 SWIGINTERN PyObject *_wrap_Menu_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39563 PyObject *resultobj = 0;
39564 wxMenu *arg1 = (wxMenu *) 0 ;
39565 int arg2 ;
39566 bool result;
39567 void *argp1 = 0 ;
39568 int res1 = 0 ;
39569 int val2 ;
39570 int ecode2 = 0 ;
39571 PyObject * obj0 = 0 ;
39572 PyObject * obj1 = 0 ;
39573 char * kwnames[] = {
39574 (char *) "self",(char *) "id", NULL
39575 };
39576
39577 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
39578 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39579 if (!SWIG_IsOK(res1)) {
39580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Delete" "', expected argument " "1"" of type '" "wxMenu *""'");
39581 }
39582 arg1 = reinterpret_cast< wxMenu * >(argp1);
39583 ecode2 = SWIG_AsVal_int(obj1, &val2);
39584 if (!SWIG_IsOK(ecode2)) {
39585 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Delete" "', expected argument " "2"" of type '" "int""'");
39586 }
39587 arg2 = static_cast< int >(val2);
39588 {
39589 PyThreadState* __tstate = wxPyBeginAllowThreads();
39590 result = (bool)(arg1)->Delete(arg2);
39591 wxPyEndAllowThreads(__tstate);
39592 if (PyErr_Occurred()) SWIG_fail;
39593 }
39594 {
39595 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39596 }
39597 return resultobj;
39598 fail:
39599 return NULL;
39600 }
39601
39602
39603 SWIGINTERN PyObject *_wrap_Menu_DeleteItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39604 PyObject *resultobj = 0;
39605 wxMenu *arg1 = (wxMenu *) 0 ;
39606 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39607 bool result;
39608 void *argp1 = 0 ;
39609 int res1 = 0 ;
39610 void *argp2 = 0 ;
39611 int res2 = 0 ;
39612 PyObject * obj0 = 0 ;
39613 PyObject * obj1 = 0 ;
39614 char * kwnames[] = {
39615 (char *) "self",(char *) "item", NULL
39616 };
39617
39618 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) SWIG_fail;
39619 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39620 if (!SWIG_IsOK(res1)) {
39621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DeleteItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39622 }
39623 arg1 = reinterpret_cast< wxMenu * >(argp1);
39624 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39625 if (!SWIG_IsOK(res2)) {
39626 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DeleteItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39627 }
39628 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39629 {
39630 PyThreadState* __tstate = wxPyBeginAllowThreads();
39631 result = (bool)(arg1)->Delete(arg2);
39632 wxPyEndAllowThreads(__tstate);
39633 if (PyErr_Occurred()) SWIG_fail;
39634 }
39635 {
39636 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39637 }
39638 return resultobj;
39639 fail:
39640 return NULL;
39641 }
39642
39643
39644 SWIGINTERN PyObject *_wrap_Menu_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39645 PyObject *resultobj = 0;
39646 wxMenu *arg1 = (wxMenu *) 0 ;
39647 void *argp1 = 0 ;
39648 int res1 = 0 ;
39649 PyObject *swig_obj[1] ;
39650
39651 if (!args) SWIG_fail;
39652 swig_obj[0] = args;
39653 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39654 if (!SWIG_IsOK(res1)) {
39655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Destroy" "', expected argument " "1"" of type '" "wxMenu *""'");
39656 }
39657 arg1 = reinterpret_cast< wxMenu * >(argp1);
39658 {
39659 PyThreadState* __tstate = wxPyBeginAllowThreads();
39660 wxMenu_Destroy(arg1);
39661 wxPyEndAllowThreads(__tstate);
39662 if (PyErr_Occurred()) SWIG_fail;
39663 }
39664 resultobj = SWIG_Py_Void();
39665 return resultobj;
39666 fail:
39667 return NULL;
39668 }
39669
39670
39671 SWIGINTERN PyObject *_wrap_Menu_DestroyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39672 PyObject *resultobj = 0;
39673 wxMenu *arg1 = (wxMenu *) 0 ;
39674 int arg2 ;
39675 bool result;
39676 void *argp1 = 0 ;
39677 int res1 = 0 ;
39678 int val2 ;
39679 int ecode2 = 0 ;
39680 PyObject * obj0 = 0 ;
39681 PyObject * obj1 = 0 ;
39682 char * kwnames[] = {
39683 (char *) "self",(char *) "id", NULL
39684 };
39685
39686 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) SWIG_fail;
39687 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39688 if (!SWIG_IsOK(res1)) {
39689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyId" "', expected argument " "1"" of type '" "wxMenu *""'");
39690 }
39691 arg1 = reinterpret_cast< wxMenu * >(argp1);
39692 ecode2 = SWIG_AsVal_int(obj1, &val2);
39693 if (!SWIG_IsOK(ecode2)) {
39694 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_DestroyId" "', expected argument " "2"" of type '" "int""'");
39695 }
39696 arg2 = static_cast< int >(val2);
39697 {
39698 PyThreadState* __tstate = wxPyBeginAllowThreads();
39699 result = (bool)(arg1)->Destroy(arg2);
39700 wxPyEndAllowThreads(__tstate);
39701 if (PyErr_Occurred()) SWIG_fail;
39702 }
39703 {
39704 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39705 }
39706 return resultobj;
39707 fail:
39708 return NULL;
39709 }
39710
39711
39712 SWIGINTERN PyObject *_wrap_Menu_DestroyItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39713 PyObject *resultobj = 0;
39714 wxMenu *arg1 = (wxMenu *) 0 ;
39715 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39716 bool result;
39717 void *argp1 = 0 ;
39718 int res1 = 0 ;
39719 void *argp2 = 0 ;
39720 int res2 = 0 ;
39721 PyObject * obj0 = 0 ;
39722 PyObject * obj1 = 0 ;
39723 char * kwnames[] = {
39724 (char *) "self",(char *) "item", NULL
39725 };
39726
39727 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) SWIG_fail;
39728 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39729 if (!SWIG_IsOK(res1)) {
39730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39731 }
39732 arg1 = reinterpret_cast< wxMenu * >(argp1);
39733 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39734 if (!SWIG_IsOK(res2)) {
39735 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DestroyItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39736 }
39737 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39738 {
39739 PyThreadState* __tstate = wxPyBeginAllowThreads();
39740 result = (bool)(arg1)->Destroy(arg2);
39741 wxPyEndAllowThreads(__tstate);
39742 if (PyErr_Occurred()) SWIG_fail;
39743 }
39744 {
39745 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39746 }
39747 return resultobj;
39748 fail:
39749 return NULL;
39750 }
39751
39752
39753 SWIGINTERN PyObject *_wrap_Menu_GetMenuItemCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39754 PyObject *resultobj = 0;
39755 wxMenu *arg1 = (wxMenu *) 0 ;
39756 size_t result;
39757 void *argp1 = 0 ;
39758 int res1 = 0 ;
39759 PyObject *swig_obj[1] ;
39760
39761 if (!args) SWIG_fail;
39762 swig_obj[0] = args;
39763 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39764 if (!SWIG_IsOK(res1)) {
39765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItemCount" "', expected argument " "1"" of type '" "wxMenu const *""'");
39766 }
39767 arg1 = reinterpret_cast< wxMenu * >(argp1);
39768 {
39769 PyThreadState* __tstate = wxPyBeginAllowThreads();
39770 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
39771 wxPyEndAllowThreads(__tstate);
39772 if (PyErr_Occurred()) SWIG_fail;
39773 }
39774 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
39775 return resultobj;
39776 fail:
39777 return NULL;
39778 }
39779
39780
39781 SWIGINTERN PyObject *_wrap_Menu_GetMenuItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39782 PyObject *resultobj = 0;
39783 wxMenu *arg1 = (wxMenu *) 0 ;
39784 PyObject *result = 0 ;
39785 void *argp1 = 0 ;
39786 int res1 = 0 ;
39787 PyObject *swig_obj[1] ;
39788
39789 if (!args) SWIG_fail;
39790 swig_obj[0] = args;
39791 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39792 if (!SWIG_IsOK(res1)) {
39793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItems" "', expected argument " "1"" of type '" "wxMenu *""'");
39794 }
39795 arg1 = reinterpret_cast< wxMenu * >(argp1);
39796 {
39797 PyThreadState* __tstate = wxPyBeginAllowThreads();
39798 result = (PyObject *)wxMenu_GetMenuItems(arg1);
39799 wxPyEndAllowThreads(__tstate);
39800 if (PyErr_Occurred()) SWIG_fail;
39801 }
39802 resultobj = result;
39803 return resultobj;
39804 fail:
39805 return NULL;
39806 }
39807
39808
39809 SWIGINTERN PyObject *_wrap_Menu_FindItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39810 PyObject *resultobj = 0;
39811 wxMenu *arg1 = (wxMenu *) 0 ;
39812 wxString *arg2 = 0 ;
39813 int result;
39814 void *argp1 = 0 ;
39815 int res1 = 0 ;
39816 bool temp2 = false ;
39817 PyObject * obj0 = 0 ;
39818 PyObject * obj1 = 0 ;
39819 char * kwnames[] = {
39820 (char *) "self",(char *) "item", NULL
39821 };
39822
39823 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) SWIG_fail;
39824 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39825 if (!SWIG_IsOK(res1)) {
39826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItem" "', expected argument " "1"" of type '" "wxMenu const *""'");
39827 }
39828 arg1 = reinterpret_cast< wxMenu * >(argp1);
39829 {
39830 arg2 = wxString_in_helper(obj1);
39831 if (arg2 == NULL) SWIG_fail;
39832 temp2 = true;
39833 }
39834 {
39835 PyThreadState* __tstate = wxPyBeginAllowThreads();
39836 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
39837 wxPyEndAllowThreads(__tstate);
39838 if (PyErr_Occurred()) SWIG_fail;
39839 }
39840 resultobj = SWIG_From_int(static_cast< int >(result));
39841 {
39842 if (temp2)
39843 delete arg2;
39844 }
39845 return resultobj;
39846 fail:
39847 {
39848 if (temp2)
39849 delete arg2;
39850 }
39851 return NULL;
39852 }
39853
39854
39855 SWIGINTERN PyObject *_wrap_Menu_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39856 PyObject *resultobj = 0;
39857 wxMenu *arg1 = (wxMenu *) 0 ;
39858 int arg2 ;
39859 wxMenuItem *result = 0 ;
39860 void *argp1 = 0 ;
39861 int res1 = 0 ;
39862 int val2 ;
39863 int ecode2 = 0 ;
39864 PyObject * obj0 = 0 ;
39865 PyObject * obj1 = 0 ;
39866 char * kwnames[] = {
39867 (char *) "self",(char *) "id", NULL
39868 };
39869
39870 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
39871 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39872 if (!SWIG_IsOK(res1)) {
39873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemById" "', expected argument " "1"" of type '" "wxMenu const *""'");
39874 }
39875 arg1 = reinterpret_cast< wxMenu * >(argp1);
39876 ecode2 = SWIG_AsVal_int(obj1, &val2);
39877 if (!SWIG_IsOK(ecode2)) {
39878 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemById" "', expected argument " "2"" of type '" "int""'");
39879 }
39880 arg2 = static_cast< int >(val2);
39881 {
39882 PyThreadState* __tstate = wxPyBeginAllowThreads();
39883 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
39884 wxPyEndAllowThreads(__tstate);
39885 if (PyErr_Occurred()) SWIG_fail;
39886 }
39887 {
39888 resultobj = wxPyMake_wxObject(result, (bool)0);
39889 }
39890 return resultobj;
39891 fail:
39892 return NULL;
39893 }
39894
39895
39896 SWIGINTERN PyObject *_wrap_Menu_FindItemByPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39897 PyObject *resultobj = 0;
39898 wxMenu *arg1 = (wxMenu *) 0 ;
39899 size_t arg2 ;
39900 wxMenuItem *result = 0 ;
39901 void *argp1 = 0 ;
39902 int res1 = 0 ;
39903 size_t val2 ;
39904 int ecode2 = 0 ;
39905 PyObject * obj0 = 0 ;
39906 PyObject * obj1 = 0 ;
39907 char * kwnames[] = {
39908 (char *) "self",(char *) "position", NULL
39909 };
39910
39911 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) SWIG_fail;
39912 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39913 if (!SWIG_IsOK(res1)) {
39914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemByPosition" "', expected argument " "1"" of type '" "wxMenu const *""'");
39915 }
39916 arg1 = reinterpret_cast< wxMenu * >(argp1);
39917 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39918 if (!SWIG_IsOK(ecode2)) {
39919 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemByPosition" "', expected argument " "2"" of type '" "size_t""'");
39920 }
39921 arg2 = static_cast< size_t >(val2);
39922 {
39923 PyThreadState* __tstate = wxPyBeginAllowThreads();
39924 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
39925 wxPyEndAllowThreads(__tstate);
39926 if (PyErr_Occurred()) SWIG_fail;
39927 }
39928 {
39929 resultobj = wxPyMake_wxObject(result, (bool)0);
39930 }
39931 return resultobj;
39932 fail:
39933 return NULL;
39934 }
39935
39936
39937 SWIGINTERN PyObject *_wrap_Menu_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39938 PyObject *resultobj = 0;
39939 wxMenu *arg1 = (wxMenu *) 0 ;
39940 int arg2 ;
39941 bool arg3 ;
39942 void *argp1 = 0 ;
39943 int res1 = 0 ;
39944 int val2 ;
39945 int ecode2 = 0 ;
39946 bool val3 ;
39947 int ecode3 = 0 ;
39948 PyObject * obj0 = 0 ;
39949 PyObject * obj1 = 0 ;
39950 PyObject * obj2 = 0 ;
39951 char * kwnames[] = {
39952 (char *) "self",(char *) "id",(char *) "enable", NULL
39953 };
39954
39955 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39956 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39957 if (!SWIG_IsOK(res1)) {
39958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Enable" "', expected argument " "1"" of type '" "wxMenu *""'");
39959 }
39960 arg1 = reinterpret_cast< wxMenu * >(argp1);
39961 ecode2 = SWIG_AsVal_int(obj1, &val2);
39962 if (!SWIG_IsOK(ecode2)) {
39963 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Enable" "', expected argument " "2"" of type '" "int""'");
39964 }
39965 arg2 = static_cast< int >(val2);
39966 ecode3 = SWIG_AsVal_bool(obj2, &val3);
39967 if (!SWIG_IsOK(ecode3)) {
39968 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Enable" "', expected argument " "3"" of type '" "bool""'");
39969 }
39970 arg3 = static_cast< bool >(val3);
39971 {
39972 PyThreadState* __tstate = wxPyBeginAllowThreads();
39973 (arg1)->Enable(arg2,arg3);
39974 wxPyEndAllowThreads(__tstate);
39975 if (PyErr_Occurred()) SWIG_fail;
39976 }
39977 resultobj = SWIG_Py_Void();
39978 return resultobj;
39979 fail:
39980 return NULL;
39981 }
39982
39983
39984 SWIGINTERN PyObject *_wrap_Menu_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39985 PyObject *resultobj = 0;
39986 wxMenu *arg1 = (wxMenu *) 0 ;
39987 int arg2 ;
39988 bool result;
39989 void *argp1 = 0 ;
39990 int res1 = 0 ;
39991 int val2 ;
39992 int ecode2 = 0 ;
39993 PyObject * obj0 = 0 ;
39994 PyObject * obj1 = 0 ;
39995 char * kwnames[] = {
39996 (char *) "self",(char *) "id", NULL
39997 };
39998
39999 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
40000 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40001 if (!SWIG_IsOK(res1)) {
40002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsEnabled" "', expected argument " "1"" of type '" "wxMenu const *""'");
40003 }
40004 arg1 = reinterpret_cast< wxMenu * >(argp1);
40005 ecode2 = SWIG_AsVal_int(obj1, &val2);
40006 if (!SWIG_IsOK(ecode2)) {
40007 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsEnabled" "', expected argument " "2"" of type '" "int""'");
40008 }
40009 arg2 = static_cast< int >(val2);
40010 {
40011 PyThreadState* __tstate = wxPyBeginAllowThreads();
40012 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
40013 wxPyEndAllowThreads(__tstate);
40014 if (PyErr_Occurred()) SWIG_fail;
40015 }
40016 {
40017 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40018 }
40019 return resultobj;
40020 fail:
40021 return NULL;
40022 }
40023
40024
40025 SWIGINTERN PyObject *_wrap_Menu_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40026 PyObject *resultobj = 0;
40027 wxMenu *arg1 = (wxMenu *) 0 ;
40028 int arg2 ;
40029 bool arg3 ;
40030 void *argp1 = 0 ;
40031 int res1 = 0 ;
40032 int val2 ;
40033 int ecode2 = 0 ;
40034 bool val3 ;
40035 int ecode3 = 0 ;
40036 PyObject * obj0 = 0 ;
40037 PyObject * obj1 = 0 ;
40038 PyObject * obj2 = 0 ;
40039 char * kwnames[] = {
40040 (char *) "self",(char *) "id",(char *) "check", NULL
40041 };
40042
40043 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40044 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40045 if (!SWIG_IsOK(res1)) {
40046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Check" "', expected argument " "1"" of type '" "wxMenu *""'");
40047 }
40048 arg1 = reinterpret_cast< wxMenu * >(argp1);
40049 ecode2 = SWIG_AsVal_int(obj1, &val2);
40050 if (!SWIG_IsOK(ecode2)) {
40051 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Check" "', expected argument " "2"" of type '" "int""'");
40052 }
40053 arg2 = static_cast< int >(val2);
40054 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40055 if (!SWIG_IsOK(ecode3)) {
40056 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Check" "', expected argument " "3"" of type '" "bool""'");
40057 }
40058 arg3 = static_cast< bool >(val3);
40059 {
40060 PyThreadState* __tstate = wxPyBeginAllowThreads();
40061 (arg1)->Check(arg2,arg3);
40062 wxPyEndAllowThreads(__tstate);
40063 if (PyErr_Occurred()) SWIG_fail;
40064 }
40065 resultobj = SWIG_Py_Void();
40066 return resultobj;
40067 fail:
40068 return NULL;
40069 }
40070
40071
40072 SWIGINTERN PyObject *_wrap_Menu_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40073 PyObject *resultobj = 0;
40074 wxMenu *arg1 = (wxMenu *) 0 ;
40075 int arg2 ;
40076 bool result;
40077 void *argp1 = 0 ;
40078 int res1 = 0 ;
40079 int val2 ;
40080 int ecode2 = 0 ;
40081 PyObject * obj0 = 0 ;
40082 PyObject * obj1 = 0 ;
40083 char * kwnames[] = {
40084 (char *) "self",(char *) "id", NULL
40085 };
40086
40087 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
40088 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40089 if (!SWIG_IsOK(res1)) {
40090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsChecked" "', expected argument " "1"" of type '" "wxMenu const *""'");
40091 }
40092 arg1 = reinterpret_cast< wxMenu * >(argp1);
40093 ecode2 = SWIG_AsVal_int(obj1, &val2);
40094 if (!SWIG_IsOK(ecode2)) {
40095 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsChecked" "', expected argument " "2"" of type '" "int""'");
40096 }
40097 arg2 = static_cast< int >(val2);
40098 {
40099 PyThreadState* __tstate = wxPyBeginAllowThreads();
40100 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
40101 wxPyEndAllowThreads(__tstate);
40102 if (PyErr_Occurred()) SWIG_fail;
40103 }
40104 {
40105 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40106 }
40107 return resultobj;
40108 fail:
40109 return NULL;
40110 }
40111
40112
40113 SWIGINTERN PyObject *_wrap_Menu_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40114 PyObject *resultobj = 0;
40115 wxMenu *arg1 = (wxMenu *) 0 ;
40116 int arg2 ;
40117 wxString *arg3 = 0 ;
40118 void *argp1 = 0 ;
40119 int res1 = 0 ;
40120 int val2 ;
40121 int ecode2 = 0 ;
40122 bool temp3 = false ;
40123 PyObject * obj0 = 0 ;
40124 PyObject * obj1 = 0 ;
40125 PyObject * obj2 = 0 ;
40126 char * kwnames[] = {
40127 (char *) "self",(char *) "id",(char *) "label", NULL
40128 };
40129
40130 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40131 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40132 if (!SWIG_IsOK(res1)) {
40133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetLabel" "', expected argument " "1"" of type '" "wxMenu *""'");
40134 }
40135 arg1 = reinterpret_cast< wxMenu * >(argp1);
40136 ecode2 = SWIG_AsVal_int(obj1, &val2);
40137 if (!SWIG_IsOK(ecode2)) {
40138 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetLabel" "', expected argument " "2"" of type '" "int""'");
40139 }
40140 arg2 = static_cast< int >(val2);
40141 {
40142 arg3 = wxString_in_helper(obj2);
40143 if (arg3 == NULL) SWIG_fail;
40144 temp3 = true;
40145 }
40146 {
40147 PyThreadState* __tstate = wxPyBeginAllowThreads();
40148 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
40149 wxPyEndAllowThreads(__tstate);
40150 if (PyErr_Occurred()) SWIG_fail;
40151 }
40152 resultobj = SWIG_Py_Void();
40153 {
40154 if (temp3)
40155 delete arg3;
40156 }
40157 return resultobj;
40158 fail:
40159 {
40160 if (temp3)
40161 delete arg3;
40162 }
40163 return NULL;
40164 }
40165
40166
40167 SWIGINTERN PyObject *_wrap_Menu_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40168 PyObject *resultobj = 0;
40169 wxMenu *arg1 = (wxMenu *) 0 ;
40170 int arg2 ;
40171 wxString result;
40172 void *argp1 = 0 ;
40173 int res1 = 0 ;
40174 int val2 ;
40175 int ecode2 = 0 ;
40176 PyObject * obj0 = 0 ;
40177 PyObject * obj1 = 0 ;
40178 char * kwnames[] = {
40179 (char *) "self",(char *) "id", NULL
40180 };
40181
40182 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
40183 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40184 if (!SWIG_IsOK(res1)) {
40185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetLabel" "', expected argument " "1"" of type '" "wxMenu const *""'");
40186 }
40187 arg1 = reinterpret_cast< wxMenu * >(argp1);
40188 ecode2 = SWIG_AsVal_int(obj1, &val2);
40189 if (!SWIG_IsOK(ecode2)) {
40190 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetLabel" "', expected argument " "2"" of type '" "int""'");
40191 }
40192 arg2 = static_cast< int >(val2);
40193 {
40194 PyThreadState* __tstate = wxPyBeginAllowThreads();
40195 result = ((wxMenu const *)arg1)->GetLabel(arg2);
40196 wxPyEndAllowThreads(__tstate);
40197 if (PyErr_Occurred()) SWIG_fail;
40198 }
40199 {
40200 #if wxUSE_UNICODE
40201 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40202 #else
40203 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40204 #endif
40205 }
40206 return resultobj;
40207 fail:
40208 return NULL;
40209 }
40210
40211
40212 SWIGINTERN PyObject *_wrap_Menu_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40213 PyObject *resultobj = 0;
40214 wxMenu *arg1 = (wxMenu *) 0 ;
40215 int arg2 ;
40216 wxString *arg3 = 0 ;
40217 void *argp1 = 0 ;
40218 int res1 = 0 ;
40219 int val2 ;
40220 int ecode2 = 0 ;
40221 bool temp3 = false ;
40222 PyObject * obj0 = 0 ;
40223 PyObject * obj1 = 0 ;
40224 PyObject * obj2 = 0 ;
40225 char * kwnames[] = {
40226 (char *) "self",(char *) "id",(char *) "helpString", NULL
40227 };
40228
40229 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40230 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40231 if (!SWIG_IsOK(res1)) {
40232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetHelpString" "', expected argument " "1"" of type '" "wxMenu *""'");
40233 }
40234 arg1 = reinterpret_cast< wxMenu * >(argp1);
40235 ecode2 = SWIG_AsVal_int(obj1, &val2);
40236 if (!SWIG_IsOK(ecode2)) {
40237 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetHelpString" "', expected argument " "2"" of type '" "int""'");
40238 }
40239 arg2 = static_cast< int >(val2);
40240 {
40241 arg3 = wxString_in_helper(obj2);
40242 if (arg3 == NULL) SWIG_fail;
40243 temp3 = true;
40244 }
40245 {
40246 PyThreadState* __tstate = wxPyBeginAllowThreads();
40247 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
40248 wxPyEndAllowThreads(__tstate);
40249 if (PyErr_Occurred()) SWIG_fail;
40250 }
40251 resultobj = SWIG_Py_Void();
40252 {
40253 if (temp3)
40254 delete arg3;
40255 }
40256 return resultobj;
40257 fail:
40258 {
40259 if (temp3)
40260 delete arg3;
40261 }
40262 return NULL;
40263 }
40264
40265
40266 SWIGINTERN PyObject *_wrap_Menu_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40267 PyObject *resultobj = 0;
40268 wxMenu *arg1 = (wxMenu *) 0 ;
40269 int arg2 ;
40270 wxString result;
40271 void *argp1 = 0 ;
40272 int res1 = 0 ;
40273 int val2 ;
40274 int ecode2 = 0 ;
40275 PyObject * obj0 = 0 ;
40276 PyObject * obj1 = 0 ;
40277 char * kwnames[] = {
40278 (char *) "self",(char *) "id", NULL
40279 };
40280
40281 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
40282 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40283 if (!SWIG_IsOK(res1)) {
40284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetHelpString" "', expected argument " "1"" of type '" "wxMenu const *""'");
40285 }
40286 arg1 = reinterpret_cast< wxMenu * >(argp1);
40287 ecode2 = SWIG_AsVal_int(obj1, &val2);
40288 if (!SWIG_IsOK(ecode2)) {
40289 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetHelpString" "', expected argument " "2"" of type '" "int""'");
40290 }
40291 arg2 = static_cast< int >(val2);
40292 {
40293 PyThreadState* __tstate = wxPyBeginAllowThreads();
40294 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
40295 wxPyEndAllowThreads(__tstate);
40296 if (PyErr_Occurred()) SWIG_fail;
40297 }
40298 {
40299 #if wxUSE_UNICODE
40300 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40301 #else
40302 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40303 #endif
40304 }
40305 return resultobj;
40306 fail:
40307 return NULL;
40308 }
40309
40310
40311 SWIGINTERN PyObject *_wrap_Menu_SetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40312 PyObject *resultobj = 0;
40313 wxMenu *arg1 = (wxMenu *) 0 ;
40314 wxString *arg2 = 0 ;
40315 void *argp1 = 0 ;
40316 int res1 = 0 ;
40317 bool temp2 = false ;
40318 PyObject * obj0 = 0 ;
40319 PyObject * obj1 = 0 ;
40320 char * kwnames[] = {
40321 (char *) "self",(char *) "title", NULL
40322 };
40323
40324 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) SWIG_fail;
40325 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40326 if (!SWIG_IsOK(res1)) {
40327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetTitle" "', expected argument " "1"" of type '" "wxMenu *""'");
40328 }
40329 arg1 = reinterpret_cast< wxMenu * >(argp1);
40330 {
40331 arg2 = wxString_in_helper(obj1);
40332 if (arg2 == NULL) SWIG_fail;
40333 temp2 = true;
40334 }
40335 {
40336 PyThreadState* __tstate = wxPyBeginAllowThreads();
40337 (arg1)->SetTitle((wxString const &)*arg2);
40338 wxPyEndAllowThreads(__tstate);
40339 if (PyErr_Occurred()) SWIG_fail;
40340 }
40341 resultobj = SWIG_Py_Void();
40342 {
40343 if (temp2)
40344 delete arg2;
40345 }
40346 return resultobj;
40347 fail:
40348 {
40349 if (temp2)
40350 delete arg2;
40351 }
40352 return NULL;
40353 }
40354
40355
40356 SWIGINTERN PyObject *_wrap_Menu_GetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40357 PyObject *resultobj = 0;
40358 wxMenu *arg1 = (wxMenu *) 0 ;
40359 wxString result;
40360 void *argp1 = 0 ;
40361 int res1 = 0 ;
40362 PyObject *swig_obj[1] ;
40363
40364 if (!args) SWIG_fail;
40365 swig_obj[0] = args;
40366 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40367 if (!SWIG_IsOK(res1)) {
40368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetTitle" "', expected argument " "1"" of type '" "wxMenu const *""'");
40369 }
40370 arg1 = reinterpret_cast< wxMenu * >(argp1);
40371 {
40372 PyThreadState* __tstate = wxPyBeginAllowThreads();
40373 result = ((wxMenu const *)arg1)->GetTitle();
40374 wxPyEndAllowThreads(__tstate);
40375 if (PyErr_Occurred()) SWIG_fail;
40376 }
40377 {
40378 #if wxUSE_UNICODE
40379 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40380 #else
40381 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40382 #endif
40383 }
40384 return resultobj;
40385 fail:
40386 return NULL;
40387 }
40388
40389
40390 SWIGINTERN PyObject *_wrap_Menu_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40391 PyObject *resultobj = 0;
40392 wxMenu *arg1 = (wxMenu *) 0 ;
40393 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
40394 void *argp1 = 0 ;
40395 int res1 = 0 ;
40396 void *argp2 = 0 ;
40397 int res2 = 0 ;
40398 PyObject * obj0 = 0 ;
40399 PyObject * obj1 = 0 ;
40400 char * kwnames[] = {
40401 (char *) "self",(char *) "handler", NULL
40402 };
40403
40404 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
40405 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40406 if (!SWIG_IsOK(res1)) {
40407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetEventHandler" "', expected argument " "1"" of type '" "wxMenu *""'");
40408 }
40409 arg1 = reinterpret_cast< wxMenu * >(argp1);
40410 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
40411 if (!SWIG_IsOK(res2)) {
40412 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
40413 }
40414 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
40415 {
40416 PyThreadState* __tstate = wxPyBeginAllowThreads();
40417 (arg1)->SetEventHandler(arg2);
40418 wxPyEndAllowThreads(__tstate);
40419 if (PyErr_Occurred()) SWIG_fail;
40420 }
40421 resultobj = SWIG_Py_Void();
40422 return resultobj;
40423 fail:
40424 return NULL;
40425 }
40426
40427
40428 SWIGINTERN PyObject *_wrap_Menu_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40429 PyObject *resultobj = 0;
40430 wxMenu *arg1 = (wxMenu *) 0 ;
40431 wxEvtHandler *result = 0 ;
40432 void *argp1 = 0 ;
40433 int res1 = 0 ;
40434 PyObject *swig_obj[1] ;
40435
40436 if (!args) SWIG_fail;
40437 swig_obj[0] = args;
40438 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40439 if (!SWIG_IsOK(res1)) {
40440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetEventHandler" "', expected argument " "1"" of type '" "wxMenu const *""'");
40441 }
40442 arg1 = reinterpret_cast< wxMenu * >(argp1);
40443 {
40444 PyThreadState* __tstate = wxPyBeginAllowThreads();
40445 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
40446 wxPyEndAllowThreads(__tstate);
40447 if (PyErr_Occurred()) SWIG_fail;
40448 }
40449 {
40450 resultobj = wxPyMake_wxObject(result, 0);
40451 }
40452 return resultobj;
40453 fail:
40454 return NULL;
40455 }
40456
40457
40458 SWIGINTERN PyObject *_wrap_Menu_SetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40459 PyObject *resultobj = 0;
40460 wxMenu *arg1 = (wxMenu *) 0 ;
40461 wxWindow *arg2 = (wxWindow *) 0 ;
40462 void *argp1 = 0 ;
40463 int res1 = 0 ;
40464 void *argp2 = 0 ;
40465 int res2 = 0 ;
40466 PyObject * obj0 = 0 ;
40467 PyObject * obj1 = 0 ;
40468 char * kwnames[] = {
40469 (char *) "self",(char *) "win", NULL
40470 };
40471
40472 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
40473 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40474 if (!SWIG_IsOK(res1)) {
40475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu *""'");
40476 }
40477 arg1 = reinterpret_cast< wxMenu * >(argp1);
40478 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
40479 if (!SWIG_IsOK(res2)) {
40480 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetInvokingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
40481 }
40482 arg2 = reinterpret_cast< wxWindow * >(argp2);
40483 {
40484 PyThreadState* __tstate = wxPyBeginAllowThreads();
40485 (arg1)->SetInvokingWindow(arg2);
40486 wxPyEndAllowThreads(__tstate);
40487 if (PyErr_Occurred()) SWIG_fail;
40488 }
40489 resultobj = SWIG_Py_Void();
40490 return resultobj;
40491 fail:
40492 return NULL;
40493 }
40494
40495
40496 SWIGINTERN PyObject *_wrap_Menu_GetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40497 PyObject *resultobj = 0;
40498 wxMenu *arg1 = (wxMenu *) 0 ;
40499 wxWindow *result = 0 ;
40500 void *argp1 = 0 ;
40501 int res1 = 0 ;
40502 PyObject *swig_obj[1] ;
40503
40504 if (!args) SWIG_fail;
40505 swig_obj[0] = args;
40506 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40507 if (!SWIG_IsOK(res1)) {
40508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu const *""'");
40509 }
40510 arg1 = reinterpret_cast< wxMenu * >(argp1);
40511 {
40512 PyThreadState* __tstate = wxPyBeginAllowThreads();
40513 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
40514 wxPyEndAllowThreads(__tstate);
40515 if (PyErr_Occurred()) SWIG_fail;
40516 }
40517 {
40518 resultobj = wxPyMake_wxObject(result, 0);
40519 }
40520 return resultobj;
40521 fail:
40522 return NULL;
40523 }
40524
40525
40526 SWIGINTERN PyObject *_wrap_Menu_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40527 PyObject *resultobj = 0;
40528 wxMenu *arg1 = (wxMenu *) 0 ;
40529 long result;
40530 void *argp1 = 0 ;
40531 int res1 = 0 ;
40532 PyObject *swig_obj[1] ;
40533
40534 if (!args) SWIG_fail;
40535 swig_obj[0] = args;
40536 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40537 if (!SWIG_IsOK(res1)) {
40538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetStyle" "', expected argument " "1"" of type '" "wxMenu const *""'");
40539 }
40540 arg1 = reinterpret_cast< wxMenu * >(argp1);
40541 {
40542 PyThreadState* __tstate = wxPyBeginAllowThreads();
40543 result = (long)((wxMenu const *)arg1)->GetStyle();
40544 wxPyEndAllowThreads(__tstate);
40545 if (PyErr_Occurred()) SWIG_fail;
40546 }
40547 resultobj = SWIG_From_long(static_cast< long >(result));
40548 return resultobj;
40549 fail:
40550 return NULL;
40551 }
40552
40553
40554 SWIGINTERN PyObject *_wrap_Menu_UpdateUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40555 PyObject *resultobj = 0;
40556 wxMenu *arg1 = (wxMenu *) 0 ;
40557 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
40558 void *argp1 = 0 ;
40559 int res1 = 0 ;
40560 void *argp2 = 0 ;
40561 int res2 = 0 ;
40562 PyObject * obj0 = 0 ;
40563 PyObject * obj1 = 0 ;
40564 char * kwnames[] = {
40565 (char *) "self",(char *) "source", NULL
40566 };
40567
40568 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) SWIG_fail;
40569 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40570 if (!SWIG_IsOK(res1)) {
40571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_UpdateUI" "', expected argument " "1"" of type '" "wxMenu *""'");
40572 }
40573 arg1 = reinterpret_cast< wxMenu * >(argp1);
40574 if (obj1) {
40575 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
40576 if (!SWIG_IsOK(res2)) {
40577 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_UpdateUI" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
40578 }
40579 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
40580 }
40581 {
40582 PyThreadState* __tstate = wxPyBeginAllowThreads();
40583 (arg1)->UpdateUI(arg2);
40584 wxPyEndAllowThreads(__tstate);
40585 if (PyErr_Occurred()) SWIG_fail;
40586 }
40587 resultobj = SWIG_Py_Void();
40588 return resultobj;
40589 fail:
40590 return NULL;
40591 }
40592
40593
40594 SWIGINTERN PyObject *_wrap_Menu_GetMenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40595 PyObject *resultobj = 0;
40596 wxMenu *arg1 = (wxMenu *) 0 ;
40597 wxMenuBar *result = 0 ;
40598 void *argp1 = 0 ;
40599 int res1 = 0 ;
40600 PyObject *swig_obj[1] ;
40601
40602 if (!args) SWIG_fail;
40603 swig_obj[0] = args;
40604 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40605 if (!SWIG_IsOK(res1)) {
40606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuBar" "', expected argument " "1"" of type '" "wxMenu const *""'");
40607 }
40608 arg1 = reinterpret_cast< wxMenu * >(argp1);
40609 {
40610 PyThreadState* __tstate = wxPyBeginAllowThreads();
40611 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
40612 wxPyEndAllowThreads(__tstate);
40613 if (PyErr_Occurred()) SWIG_fail;
40614 }
40615 {
40616 resultobj = wxPyMake_wxObject(result, (bool)0);
40617 }
40618 return resultobj;
40619 fail:
40620 return NULL;
40621 }
40622
40623
40624 SWIGINTERN PyObject *_wrap_Menu_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40625 PyObject *resultobj = 0;
40626 wxMenu *arg1 = (wxMenu *) 0 ;
40627 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
40628 void *argp1 = 0 ;
40629 int res1 = 0 ;
40630 void *argp2 = 0 ;
40631 int res2 = 0 ;
40632 PyObject * obj0 = 0 ;
40633 PyObject * obj1 = 0 ;
40634 char * kwnames[] = {
40635 (char *) "self",(char *) "menubar", NULL
40636 };
40637
40638 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
40639 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40640 if (!SWIG_IsOK(res1)) {
40641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Attach" "', expected argument " "1"" of type '" "wxMenu *""'");
40642 }
40643 arg1 = reinterpret_cast< wxMenu * >(argp1);
40644 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuBarBase, 0 | 0 );
40645 if (!SWIG_IsOK(res2)) {
40646 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_Attach" "', expected argument " "2"" of type '" "wxMenuBarBase *""'");
40647 }
40648 arg2 = reinterpret_cast< wxMenuBarBase * >(argp2);
40649 {
40650 PyThreadState* __tstate = wxPyBeginAllowThreads();
40651 (arg1)->Attach(arg2);
40652 wxPyEndAllowThreads(__tstate);
40653 if (PyErr_Occurred()) SWIG_fail;
40654 }
40655 resultobj = SWIG_Py_Void();
40656 return resultobj;
40657 fail:
40658 return NULL;
40659 }
40660
40661
40662 SWIGINTERN PyObject *_wrap_Menu_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40663 PyObject *resultobj = 0;
40664 wxMenu *arg1 = (wxMenu *) 0 ;
40665 void *argp1 = 0 ;
40666 int res1 = 0 ;
40667 PyObject *swig_obj[1] ;
40668
40669 if (!args) SWIG_fail;
40670 swig_obj[0] = args;
40671 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40672 if (!SWIG_IsOK(res1)) {
40673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Detach" "', expected argument " "1"" of type '" "wxMenu *""'");
40674 }
40675 arg1 = reinterpret_cast< wxMenu * >(argp1);
40676 {
40677 PyThreadState* __tstate = wxPyBeginAllowThreads();
40678 (arg1)->Detach();
40679 wxPyEndAllowThreads(__tstate);
40680 if (PyErr_Occurred()) SWIG_fail;
40681 }
40682 resultobj = SWIG_Py_Void();
40683 return resultobj;
40684 fail:
40685 return NULL;
40686 }
40687
40688
40689 SWIGINTERN PyObject *_wrap_Menu_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40690 PyObject *resultobj = 0;
40691 wxMenu *arg1 = (wxMenu *) 0 ;
40692 bool result;
40693 void *argp1 = 0 ;
40694 int res1 = 0 ;
40695 PyObject *swig_obj[1] ;
40696
40697 if (!args) SWIG_fail;
40698 swig_obj[0] = args;
40699 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40700 if (!SWIG_IsOK(res1)) {
40701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsAttached" "', expected argument " "1"" of type '" "wxMenu const *""'");
40702 }
40703 arg1 = reinterpret_cast< wxMenu * >(argp1);
40704 {
40705 PyThreadState* __tstate = wxPyBeginAllowThreads();
40706 result = (bool)((wxMenu const *)arg1)->IsAttached();
40707 wxPyEndAllowThreads(__tstate);
40708 if (PyErr_Occurred()) SWIG_fail;
40709 }
40710 {
40711 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40712 }
40713 return resultobj;
40714 fail:
40715 return NULL;
40716 }
40717
40718
40719 SWIGINTERN PyObject *_wrap_Menu_SetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40720 PyObject *resultobj = 0;
40721 wxMenu *arg1 = (wxMenu *) 0 ;
40722 wxMenu *arg2 = (wxMenu *) 0 ;
40723 void *argp1 = 0 ;
40724 int res1 = 0 ;
40725 void *argp2 = 0 ;
40726 int res2 = 0 ;
40727 PyObject * obj0 = 0 ;
40728 PyObject * obj1 = 0 ;
40729 char * kwnames[] = {
40730 (char *) "self",(char *) "parent", NULL
40731 };
40732
40733 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) SWIG_fail;
40734 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40735 if (!SWIG_IsOK(res1)) {
40736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetParent" "', expected argument " "1"" of type '" "wxMenu *""'");
40737 }
40738 arg1 = reinterpret_cast< wxMenu * >(argp1);
40739 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
40740 if (!SWIG_IsOK(res2)) {
40741 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetParent" "', expected argument " "2"" of type '" "wxMenu *""'");
40742 }
40743 arg2 = reinterpret_cast< wxMenu * >(argp2);
40744 {
40745 PyThreadState* __tstate = wxPyBeginAllowThreads();
40746 (arg1)->SetParent(arg2);
40747 wxPyEndAllowThreads(__tstate);
40748 if (PyErr_Occurred()) SWIG_fail;
40749 }
40750 resultobj = SWIG_Py_Void();
40751 return resultobj;
40752 fail:
40753 return NULL;
40754 }
40755
40756
40757 SWIGINTERN PyObject *_wrap_Menu_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40758 PyObject *resultobj = 0;
40759 wxMenu *arg1 = (wxMenu *) 0 ;
40760 wxMenu *result = 0 ;
40761 void *argp1 = 0 ;
40762 int res1 = 0 ;
40763 PyObject *swig_obj[1] ;
40764
40765 if (!args) SWIG_fail;
40766 swig_obj[0] = args;
40767 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40768 if (!SWIG_IsOK(res1)) {
40769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetParent" "', expected argument " "1"" of type '" "wxMenu const *""'");
40770 }
40771 arg1 = reinterpret_cast< wxMenu * >(argp1);
40772 {
40773 PyThreadState* __tstate = wxPyBeginAllowThreads();
40774 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
40775 wxPyEndAllowThreads(__tstate);
40776 if (PyErr_Occurred()) SWIG_fail;
40777 }
40778 {
40779 resultobj = wxPyMake_wxObject(result, 0);
40780 }
40781 return resultobj;
40782 fail:
40783 return NULL;
40784 }
40785
40786
40787 SWIGINTERN PyObject *Menu_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40788 PyObject *obj;
40789 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
40790 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenu, SWIG_NewClientData(obj));
40791 return SWIG_Py_Void();
40792 }
40793
40794 SWIGINTERN PyObject *Menu_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40795 return SWIG_Python_InitShadowInstance(args);
40796 }
40797
40798 SWIGINTERN PyObject *_wrap_new_MenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40799 PyObject *resultobj = 0;
40800 long arg1 = (long) 0 ;
40801 wxMenuBar *result = 0 ;
40802 long val1 ;
40803 int ecode1 = 0 ;
40804 PyObject * obj0 = 0 ;
40805 char * kwnames[] = {
40806 (char *) "style", NULL
40807 };
40808
40809 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) SWIG_fail;
40810 if (obj0) {
40811 ecode1 = SWIG_AsVal_long(obj0, &val1);
40812 if (!SWIG_IsOK(ecode1)) {
40813 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuBar" "', expected argument " "1"" of type '" "long""'");
40814 }
40815 arg1 = static_cast< long >(val1);
40816 }
40817 {
40818 if (!wxPyCheckForApp()) SWIG_fail;
40819 PyThreadState* __tstate = wxPyBeginAllowThreads();
40820 result = (wxMenuBar *)new wxMenuBar(arg1);
40821 wxPyEndAllowThreads(__tstate);
40822 if (PyErr_Occurred()) SWIG_fail;
40823 }
40824 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuBar, SWIG_POINTER_NEW | 0 );
40825 return resultobj;
40826 fail:
40827 return NULL;
40828 }
40829
40830
40831 SWIGINTERN PyObject *_wrap_MenuBar_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40832 PyObject *resultobj = 0;
40833 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40834 wxMenu *arg2 = (wxMenu *) 0 ;
40835 wxString *arg3 = 0 ;
40836 bool result;
40837 void *argp1 = 0 ;
40838 int res1 = 0 ;
40839 void *argp2 = 0 ;
40840 int res2 = 0 ;
40841 bool temp3 = false ;
40842 PyObject * obj0 = 0 ;
40843 PyObject * obj1 = 0 ;
40844 PyObject * obj2 = 0 ;
40845 char * kwnames[] = {
40846 (char *) "self",(char *) "menu",(char *) "title", NULL
40847 };
40848
40849 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40850 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40851 if (!SWIG_IsOK(res1)) {
40852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Append" "', expected argument " "1"" of type '" "wxMenuBar *""'");
40853 }
40854 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40855 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
40856 if (!SWIG_IsOK(res2)) {
40857 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Append" "', expected argument " "2"" of type '" "wxMenu *""'");
40858 }
40859 arg2 = reinterpret_cast< wxMenu * >(argp2);
40860 {
40861 arg3 = wxString_in_helper(obj2);
40862 if (arg3 == NULL) SWIG_fail;
40863 temp3 = true;
40864 }
40865 {
40866 PyThreadState* __tstate = wxPyBeginAllowThreads();
40867 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
40868 wxPyEndAllowThreads(__tstate);
40869 if (PyErr_Occurred()) SWIG_fail;
40870 }
40871 {
40872 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40873 }
40874 {
40875 if (temp3)
40876 delete arg3;
40877 }
40878 return resultobj;
40879 fail:
40880 {
40881 if (temp3)
40882 delete arg3;
40883 }
40884 return NULL;
40885 }
40886
40887
40888 SWIGINTERN PyObject *_wrap_MenuBar_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40889 PyObject *resultobj = 0;
40890 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40891 size_t arg2 ;
40892 wxMenu *arg3 = (wxMenu *) 0 ;
40893 wxString *arg4 = 0 ;
40894 bool result;
40895 void *argp1 = 0 ;
40896 int res1 = 0 ;
40897 size_t val2 ;
40898 int ecode2 = 0 ;
40899 void *argp3 = 0 ;
40900 int res3 = 0 ;
40901 bool temp4 = false ;
40902 PyObject * obj0 = 0 ;
40903 PyObject * obj1 = 0 ;
40904 PyObject * obj2 = 0 ;
40905 PyObject * obj3 = 0 ;
40906 char * kwnames[] = {
40907 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
40908 };
40909
40910 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40911 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40912 if (!SWIG_IsOK(res1)) {
40913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Insert" "', expected argument " "1"" of type '" "wxMenuBar *""'");
40914 }
40915 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40916 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40917 if (!SWIG_IsOK(ecode2)) {
40918 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Insert" "', expected argument " "2"" of type '" "size_t""'");
40919 }
40920 arg2 = static_cast< size_t >(val2);
40921 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
40922 if (!SWIG_IsOK(res3)) {
40923 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Insert" "', expected argument " "3"" of type '" "wxMenu *""'");
40924 }
40925 arg3 = reinterpret_cast< wxMenu * >(argp3);
40926 {
40927 arg4 = wxString_in_helper(obj3);
40928 if (arg4 == NULL) SWIG_fail;
40929 temp4 = true;
40930 }
40931 {
40932 PyThreadState* __tstate = wxPyBeginAllowThreads();
40933 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
40934 wxPyEndAllowThreads(__tstate);
40935 if (PyErr_Occurred()) SWIG_fail;
40936 }
40937 {
40938 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40939 }
40940 {
40941 if (temp4)
40942 delete arg4;
40943 }
40944 return resultobj;
40945 fail:
40946 {
40947 if (temp4)
40948 delete arg4;
40949 }
40950 return NULL;
40951 }
40952
40953
40954 SWIGINTERN PyObject *_wrap_MenuBar_GetMenuCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40955 PyObject *resultobj = 0;
40956 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40957 size_t result;
40958 void *argp1 = 0 ;
40959 int res1 = 0 ;
40960 PyObject *swig_obj[1] ;
40961
40962 if (!args) SWIG_fail;
40963 swig_obj[0] = args;
40964 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40965 if (!SWIG_IsOK(res1)) {
40966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenuCount" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
40967 }
40968 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40969 {
40970 PyThreadState* __tstate = wxPyBeginAllowThreads();
40971 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
40972 wxPyEndAllowThreads(__tstate);
40973 if (PyErr_Occurred()) SWIG_fail;
40974 }
40975 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
40976 return resultobj;
40977 fail:
40978 return NULL;
40979 }
40980
40981
40982 SWIGINTERN PyObject *_wrap_MenuBar_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40983 PyObject *resultobj = 0;
40984 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40985 size_t arg2 ;
40986 wxMenu *result = 0 ;
40987 void *argp1 = 0 ;
40988 int res1 = 0 ;
40989 size_t val2 ;
40990 int ecode2 = 0 ;
40991 PyObject * obj0 = 0 ;
40992 PyObject * obj1 = 0 ;
40993 char * kwnames[] = {
40994 (char *) "self",(char *) "pos", NULL
40995 };
40996
40997 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
40998 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40999 if (!SWIG_IsOK(res1)) {
41000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenu" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41001 }
41002 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41003 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41004 if (!SWIG_IsOK(ecode2)) {
41005 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetMenu" "', expected argument " "2"" of type '" "size_t""'");
41006 }
41007 arg2 = static_cast< size_t >(val2);
41008 {
41009 PyThreadState* __tstate = wxPyBeginAllowThreads();
41010 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
41011 wxPyEndAllowThreads(__tstate);
41012 if (PyErr_Occurred()) SWIG_fail;
41013 }
41014 {
41015 resultobj = wxPyMake_wxObject(result, 0);
41016 }
41017 return resultobj;
41018 fail:
41019 return NULL;
41020 }
41021
41022
41023 SWIGINTERN PyObject *_wrap_MenuBar_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41024 PyObject *resultobj = 0;
41025 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41026 size_t arg2 ;
41027 wxMenu *arg3 = (wxMenu *) 0 ;
41028 wxString *arg4 = 0 ;
41029 wxMenu *result = 0 ;
41030 void *argp1 = 0 ;
41031 int res1 = 0 ;
41032 size_t val2 ;
41033 int ecode2 = 0 ;
41034 void *argp3 = 0 ;
41035 int res3 = 0 ;
41036 bool temp4 = false ;
41037 PyObject * obj0 = 0 ;
41038 PyObject * obj1 = 0 ;
41039 PyObject * obj2 = 0 ;
41040 PyObject * obj3 = 0 ;
41041 char * kwnames[] = {
41042 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
41043 };
41044
41045 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41046 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41047 if (!SWIG_IsOK(res1)) {
41048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Replace" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41049 }
41050 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41051 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41052 if (!SWIG_IsOK(ecode2)) {
41053 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Replace" "', expected argument " "2"" of type '" "size_t""'");
41054 }
41055 arg2 = static_cast< size_t >(val2);
41056 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
41057 if (!SWIG_IsOK(res3)) {
41058 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Replace" "', expected argument " "3"" of type '" "wxMenu *""'");
41059 }
41060 arg3 = reinterpret_cast< wxMenu * >(argp3);
41061 {
41062 arg4 = wxString_in_helper(obj3);
41063 if (arg4 == NULL) SWIG_fail;
41064 temp4 = true;
41065 }
41066 {
41067 PyThreadState* __tstate = wxPyBeginAllowThreads();
41068 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
41069 wxPyEndAllowThreads(__tstate);
41070 if (PyErr_Occurred()) SWIG_fail;
41071 }
41072 {
41073 resultobj = wxPyMake_wxObject(result, 0);
41074 }
41075 {
41076 if (temp4)
41077 delete arg4;
41078 }
41079 return resultobj;
41080 fail:
41081 {
41082 if (temp4)
41083 delete arg4;
41084 }
41085 return NULL;
41086 }
41087
41088
41089 SWIGINTERN PyObject *_wrap_MenuBar_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41090 PyObject *resultobj = 0;
41091 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41092 size_t arg2 ;
41093 wxMenu *result = 0 ;
41094 void *argp1 = 0 ;
41095 int res1 = 0 ;
41096 size_t val2 ;
41097 int ecode2 = 0 ;
41098 PyObject * obj0 = 0 ;
41099 PyObject * obj1 = 0 ;
41100 char * kwnames[] = {
41101 (char *) "self",(char *) "pos", NULL
41102 };
41103
41104 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
41105 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41106 if (!SWIG_IsOK(res1)) {
41107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Remove" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41108 }
41109 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41110 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41111 if (!SWIG_IsOK(ecode2)) {
41112 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Remove" "', expected argument " "2"" of type '" "size_t""'");
41113 }
41114 arg2 = static_cast< size_t >(val2);
41115 {
41116 PyThreadState* __tstate = wxPyBeginAllowThreads();
41117 result = (wxMenu *)(arg1)->Remove(arg2);
41118 wxPyEndAllowThreads(__tstate);
41119 if (PyErr_Occurred()) SWIG_fail;
41120 }
41121 {
41122 resultobj = wxPyMake_wxObject(result, 0);
41123 }
41124 return resultobj;
41125 fail:
41126 return NULL;
41127 }
41128
41129
41130 SWIGINTERN PyObject *_wrap_MenuBar_EnableTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41131 PyObject *resultobj = 0;
41132 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41133 size_t arg2 ;
41134 bool arg3 ;
41135 void *argp1 = 0 ;
41136 int res1 = 0 ;
41137 size_t val2 ;
41138 int ecode2 = 0 ;
41139 bool val3 ;
41140 int ecode3 = 0 ;
41141 PyObject * obj0 = 0 ;
41142 PyObject * obj1 = 0 ;
41143 PyObject * obj2 = 0 ;
41144 char * kwnames[] = {
41145 (char *) "self",(char *) "pos",(char *) "enable", NULL
41146 };
41147
41148 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41149 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41150 if (!SWIG_IsOK(res1)) {
41151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_EnableTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41152 }
41153 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41154 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41155 if (!SWIG_IsOK(ecode2)) {
41156 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_EnableTop" "', expected argument " "2"" of type '" "size_t""'");
41157 }
41158 arg2 = static_cast< size_t >(val2);
41159 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41160 if (!SWIG_IsOK(ecode3)) {
41161 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_EnableTop" "', expected argument " "3"" of type '" "bool""'");
41162 }
41163 arg3 = static_cast< bool >(val3);
41164 {
41165 PyThreadState* __tstate = wxPyBeginAllowThreads();
41166 (arg1)->EnableTop(arg2,arg3);
41167 wxPyEndAllowThreads(__tstate);
41168 if (PyErr_Occurred()) SWIG_fail;
41169 }
41170 resultobj = SWIG_Py_Void();
41171 return resultobj;
41172 fail:
41173 return NULL;
41174 }
41175
41176
41177 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41178 PyObject *resultobj = 0;
41179 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41180 size_t arg2 ;
41181 bool result;
41182 void *argp1 = 0 ;
41183 int res1 = 0 ;
41184 size_t val2 ;
41185 int ecode2 = 0 ;
41186 PyObject * obj0 = 0 ;
41187 PyObject * obj1 = 0 ;
41188 char * kwnames[] = {
41189 (char *) "self",(char *) "pos", NULL
41190 };
41191
41192 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) SWIG_fail;
41193 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41194 if (!SWIG_IsOK(res1)) {
41195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41196 }
41197 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41198 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41199 if (!SWIG_IsOK(ecode2)) {
41200 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "2"" of type '" "size_t""'");
41201 }
41202 arg2 = static_cast< size_t >(val2);
41203 {
41204 PyThreadState* __tstate = wxPyBeginAllowThreads();
41205 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
41206 wxPyEndAllowThreads(__tstate);
41207 if (PyErr_Occurred()) SWIG_fail;
41208 }
41209 {
41210 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41211 }
41212 return resultobj;
41213 fail:
41214 return NULL;
41215 }
41216
41217
41218 SWIGINTERN PyObject *_wrap_MenuBar_SetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41219 PyObject *resultobj = 0;
41220 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41221 size_t arg2 ;
41222 wxString *arg3 = 0 ;
41223 void *argp1 = 0 ;
41224 int res1 = 0 ;
41225 size_t val2 ;
41226 int ecode2 = 0 ;
41227 bool temp3 = false ;
41228 PyObject * obj0 = 0 ;
41229 PyObject * obj1 = 0 ;
41230 PyObject * obj2 = 0 ;
41231 char * kwnames[] = {
41232 (char *) "self",(char *) "pos",(char *) "label", NULL
41233 };
41234
41235 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41236 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41237 if (!SWIG_IsOK(res1)) {
41238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41239 }
41240 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41241 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41242 if (!SWIG_IsOK(ecode2)) {
41243 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
41244 }
41245 arg2 = static_cast< size_t >(val2);
41246 {
41247 arg3 = wxString_in_helper(obj2);
41248 if (arg3 == NULL) SWIG_fail;
41249 temp3 = true;
41250 }
41251 {
41252 PyThreadState* __tstate = wxPyBeginAllowThreads();
41253 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
41254 wxPyEndAllowThreads(__tstate);
41255 if (PyErr_Occurred()) SWIG_fail;
41256 }
41257 resultobj = SWIG_Py_Void();
41258 {
41259 if (temp3)
41260 delete arg3;
41261 }
41262 return resultobj;
41263 fail:
41264 {
41265 if (temp3)
41266 delete arg3;
41267 }
41268 return NULL;
41269 }
41270
41271
41272 SWIGINTERN PyObject *_wrap_MenuBar_GetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41273 PyObject *resultobj = 0;
41274 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41275 size_t arg2 ;
41276 wxString result;
41277 void *argp1 = 0 ;
41278 int res1 = 0 ;
41279 size_t val2 ;
41280 int ecode2 = 0 ;
41281 PyObject * obj0 = 0 ;
41282 PyObject * obj1 = 0 ;
41283 char * kwnames[] = {
41284 (char *) "self",(char *) "pos", NULL
41285 };
41286
41287 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) SWIG_fail;
41288 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41289 if (!SWIG_IsOK(res1)) {
41290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41291 }
41292 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41293 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41294 if (!SWIG_IsOK(ecode2)) {
41295 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
41296 }
41297 arg2 = static_cast< size_t >(val2);
41298 {
41299 PyThreadState* __tstate = wxPyBeginAllowThreads();
41300 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
41301 wxPyEndAllowThreads(__tstate);
41302 if (PyErr_Occurred()) SWIG_fail;
41303 }
41304 {
41305 #if wxUSE_UNICODE
41306 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41307 #else
41308 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41309 #endif
41310 }
41311 return resultobj;
41312 fail:
41313 return NULL;
41314 }
41315
41316
41317 SWIGINTERN PyObject *_wrap_MenuBar_FindMenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41318 PyObject *resultobj = 0;
41319 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41320 wxString *arg2 = 0 ;
41321 wxString *arg3 = 0 ;
41322 int result;
41323 void *argp1 = 0 ;
41324 int res1 = 0 ;
41325 bool temp2 = false ;
41326 bool temp3 = false ;
41327 PyObject * obj0 = 0 ;
41328 PyObject * obj1 = 0 ;
41329 PyObject * obj2 = 0 ;
41330 char * kwnames[] = {
41331 (char *) "self",(char *) "menu",(char *) "item", NULL
41332 };
41333
41334 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41335 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41336 if (!SWIG_IsOK(res1)) {
41337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenuItem" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41338 }
41339 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41340 {
41341 arg2 = wxString_in_helper(obj1);
41342 if (arg2 == NULL) SWIG_fail;
41343 temp2 = true;
41344 }
41345 {
41346 arg3 = wxString_in_helper(obj2);
41347 if (arg3 == NULL) SWIG_fail;
41348 temp3 = true;
41349 }
41350 {
41351 PyThreadState* __tstate = wxPyBeginAllowThreads();
41352 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
41353 wxPyEndAllowThreads(__tstate);
41354 if (PyErr_Occurred()) SWIG_fail;
41355 }
41356 resultobj = SWIG_From_int(static_cast< int >(result));
41357 {
41358 if (temp2)
41359 delete arg2;
41360 }
41361 {
41362 if (temp3)
41363 delete arg3;
41364 }
41365 return resultobj;
41366 fail:
41367 {
41368 if (temp2)
41369 delete arg2;
41370 }
41371 {
41372 if (temp3)
41373 delete arg3;
41374 }
41375 return NULL;
41376 }
41377
41378
41379 SWIGINTERN PyObject *_wrap_MenuBar_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41380 PyObject *resultobj = 0;
41381 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41382 int arg2 ;
41383 wxMenuItem *result = 0 ;
41384 void *argp1 = 0 ;
41385 int res1 = 0 ;
41386 int val2 ;
41387 int ecode2 = 0 ;
41388 PyObject * obj0 = 0 ;
41389 PyObject * obj1 = 0 ;
41390 char * kwnames[] = {
41391 (char *) "self",(char *) "id", NULL
41392 };
41393
41394 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
41395 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41396 if (!SWIG_IsOK(res1)) {
41397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindItemById" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41398 }
41399 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41400 ecode2 = SWIG_AsVal_int(obj1, &val2);
41401 if (!SWIG_IsOK(ecode2)) {
41402 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_FindItemById" "', expected argument " "2"" of type '" "int""'");
41403 }
41404 arg2 = static_cast< int >(val2);
41405 {
41406 PyThreadState* __tstate = wxPyBeginAllowThreads();
41407 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
41408 wxPyEndAllowThreads(__tstate);
41409 if (PyErr_Occurred()) SWIG_fail;
41410 }
41411 {
41412 resultobj = wxPyMake_wxObject(result, (bool)0);
41413 }
41414 return resultobj;
41415 fail:
41416 return NULL;
41417 }
41418
41419
41420 SWIGINTERN PyObject *_wrap_MenuBar_FindMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41421 PyObject *resultobj = 0;
41422 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41423 wxString *arg2 = 0 ;
41424 int result;
41425 void *argp1 = 0 ;
41426 int res1 = 0 ;
41427 bool temp2 = false ;
41428 PyObject * obj0 = 0 ;
41429 PyObject * obj1 = 0 ;
41430 char * kwnames[] = {
41431 (char *) "self",(char *) "title", NULL
41432 };
41433
41434 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) SWIG_fail;
41435 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41436 if (!SWIG_IsOK(res1)) {
41437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenu" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41438 }
41439 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41440 {
41441 arg2 = wxString_in_helper(obj1);
41442 if (arg2 == NULL) SWIG_fail;
41443 temp2 = true;
41444 }
41445 {
41446 PyThreadState* __tstate = wxPyBeginAllowThreads();
41447 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
41448 wxPyEndAllowThreads(__tstate);
41449 if (PyErr_Occurred()) SWIG_fail;
41450 }
41451 resultobj = SWIG_From_int(static_cast< int >(result));
41452 {
41453 if (temp2)
41454 delete arg2;
41455 }
41456 return resultobj;
41457 fail:
41458 {
41459 if (temp2)
41460 delete arg2;
41461 }
41462 return NULL;
41463 }
41464
41465
41466 SWIGINTERN PyObject *_wrap_MenuBar_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41467 PyObject *resultobj = 0;
41468 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41469 int arg2 ;
41470 bool arg3 ;
41471 void *argp1 = 0 ;
41472 int res1 = 0 ;
41473 int val2 ;
41474 int ecode2 = 0 ;
41475 bool val3 ;
41476 int ecode3 = 0 ;
41477 PyObject * obj0 = 0 ;
41478 PyObject * obj1 = 0 ;
41479 PyObject * obj2 = 0 ;
41480 char * kwnames[] = {
41481 (char *) "self",(char *) "id",(char *) "enable", NULL
41482 };
41483
41484 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41485 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41486 if (!SWIG_IsOK(res1)) {
41487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Enable" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41488 }
41489 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41490 ecode2 = SWIG_AsVal_int(obj1, &val2);
41491 if (!SWIG_IsOK(ecode2)) {
41492 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Enable" "', expected argument " "2"" of type '" "int""'");
41493 }
41494 arg2 = static_cast< int >(val2);
41495 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41496 if (!SWIG_IsOK(ecode3)) {
41497 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Enable" "', expected argument " "3"" of type '" "bool""'");
41498 }
41499 arg3 = static_cast< bool >(val3);
41500 {
41501 PyThreadState* __tstate = wxPyBeginAllowThreads();
41502 (arg1)->Enable(arg2,arg3);
41503 wxPyEndAllowThreads(__tstate);
41504 if (PyErr_Occurred()) SWIG_fail;
41505 }
41506 resultobj = SWIG_Py_Void();
41507 return resultobj;
41508 fail:
41509 return NULL;
41510 }
41511
41512
41513 SWIGINTERN PyObject *_wrap_MenuBar_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41514 PyObject *resultobj = 0;
41515 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41516 int arg2 ;
41517 bool arg3 ;
41518 void *argp1 = 0 ;
41519 int res1 = 0 ;
41520 int val2 ;
41521 int ecode2 = 0 ;
41522 bool val3 ;
41523 int ecode3 = 0 ;
41524 PyObject * obj0 = 0 ;
41525 PyObject * obj1 = 0 ;
41526 PyObject * obj2 = 0 ;
41527 char * kwnames[] = {
41528 (char *) "self",(char *) "id",(char *) "check", NULL
41529 };
41530
41531 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41532 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41533 if (!SWIG_IsOK(res1)) {
41534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Check" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41535 }
41536 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41537 ecode2 = SWIG_AsVal_int(obj1, &val2);
41538 if (!SWIG_IsOK(ecode2)) {
41539 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Check" "', expected argument " "2"" of type '" "int""'");
41540 }
41541 arg2 = static_cast< int >(val2);
41542 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41543 if (!SWIG_IsOK(ecode3)) {
41544 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Check" "', expected argument " "3"" of type '" "bool""'");
41545 }
41546 arg3 = static_cast< bool >(val3);
41547 {
41548 PyThreadState* __tstate = wxPyBeginAllowThreads();
41549 (arg1)->Check(arg2,arg3);
41550 wxPyEndAllowThreads(__tstate);
41551 if (PyErr_Occurred()) SWIG_fail;
41552 }
41553 resultobj = SWIG_Py_Void();
41554 return resultobj;
41555 fail:
41556 return NULL;
41557 }
41558
41559
41560 SWIGINTERN PyObject *_wrap_MenuBar_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41561 PyObject *resultobj = 0;
41562 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41563 int arg2 ;
41564 bool result;
41565 void *argp1 = 0 ;
41566 int res1 = 0 ;
41567 int val2 ;
41568 int ecode2 = 0 ;
41569 PyObject * obj0 = 0 ;
41570 PyObject * obj1 = 0 ;
41571 char * kwnames[] = {
41572 (char *) "self",(char *) "id", NULL
41573 };
41574
41575 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
41576 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41577 if (!SWIG_IsOK(res1)) {
41578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsChecked" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41579 }
41580 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41581 ecode2 = SWIG_AsVal_int(obj1, &val2);
41582 if (!SWIG_IsOK(ecode2)) {
41583 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsChecked" "', expected argument " "2"" of type '" "int""'");
41584 }
41585 arg2 = static_cast< int >(val2);
41586 {
41587 PyThreadState* __tstate = wxPyBeginAllowThreads();
41588 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
41589 wxPyEndAllowThreads(__tstate);
41590 if (PyErr_Occurred()) SWIG_fail;
41591 }
41592 {
41593 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41594 }
41595 return resultobj;
41596 fail:
41597 return NULL;
41598 }
41599
41600
41601 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41602 PyObject *resultobj = 0;
41603 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41604 int arg2 ;
41605 bool result;
41606 void *argp1 = 0 ;
41607 int res1 = 0 ;
41608 int val2 ;
41609 int ecode2 = 0 ;
41610 PyObject * obj0 = 0 ;
41611 PyObject * obj1 = 0 ;
41612 char * kwnames[] = {
41613 (char *) "self",(char *) "id", NULL
41614 };
41615
41616 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
41617 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41618 if (!SWIG_IsOK(res1)) {
41619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabled" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41620 }
41621 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41622 ecode2 = SWIG_AsVal_int(obj1, &val2);
41623 if (!SWIG_IsOK(ecode2)) {
41624 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabled" "', expected argument " "2"" of type '" "int""'");
41625 }
41626 arg2 = static_cast< int >(val2);
41627 {
41628 PyThreadState* __tstate = wxPyBeginAllowThreads();
41629 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
41630 wxPyEndAllowThreads(__tstate);
41631 if (PyErr_Occurred()) SWIG_fail;
41632 }
41633 {
41634 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41635 }
41636 return resultobj;
41637 fail:
41638 return NULL;
41639 }
41640
41641
41642 SWIGINTERN PyObject *_wrap_MenuBar_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41643 PyObject *resultobj = 0;
41644 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41645 int arg2 ;
41646 wxString *arg3 = 0 ;
41647 void *argp1 = 0 ;
41648 int res1 = 0 ;
41649 int val2 ;
41650 int ecode2 = 0 ;
41651 bool temp3 = false ;
41652 PyObject * obj0 = 0 ;
41653 PyObject * obj1 = 0 ;
41654 PyObject * obj2 = 0 ;
41655 char * kwnames[] = {
41656 (char *) "self",(char *) "id",(char *) "label", NULL
41657 };
41658
41659 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41660 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41661 if (!SWIG_IsOK(res1)) {
41662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabel" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41663 }
41664 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41665 ecode2 = SWIG_AsVal_int(obj1, &val2);
41666 if (!SWIG_IsOK(ecode2)) {
41667 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabel" "', expected argument " "2"" of type '" "int""'");
41668 }
41669 arg2 = static_cast< int >(val2);
41670 {
41671 arg3 = wxString_in_helper(obj2);
41672 if (arg3 == NULL) SWIG_fail;
41673 temp3 = true;
41674 }
41675 {
41676 PyThreadState* __tstate = wxPyBeginAllowThreads();
41677 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
41678 wxPyEndAllowThreads(__tstate);
41679 if (PyErr_Occurred()) SWIG_fail;
41680 }
41681 resultobj = SWIG_Py_Void();
41682 {
41683 if (temp3)
41684 delete arg3;
41685 }
41686 return resultobj;
41687 fail:
41688 {
41689 if (temp3)
41690 delete arg3;
41691 }
41692 return NULL;
41693 }
41694
41695
41696 SWIGINTERN PyObject *_wrap_MenuBar_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41697 PyObject *resultobj = 0;
41698 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41699 int arg2 ;
41700 wxString result;
41701 void *argp1 = 0 ;
41702 int res1 = 0 ;
41703 int val2 ;
41704 int ecode2 = 0 ;
41705 PyObject * obj0 = 0 ;
41706 PyObject * obj1 = 0 ;
41707 char * kwnames[] = {
41708 (char *) "self",(char *) "id", NULL
41709 };
41710
41711 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
41712 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41713 if (!SWIG_IsOK(res1)) {
41714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabel" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41715 }
41716 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41717 ecode2 = SWIG_AsVal_int(obj1, &val2);
41718 if (!SWIG_IsOK(ecode2)) {
41719 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabel" "', expected argument " "2"" of type '" "int""'");
41720 }
41721 arg2 = static_cast< int >(val2);
41722 {
41723 PyThreadState* __tstate = wxPyBeginAllowThreads();
41724 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
41725 wxPyEndAllowThreads(__tstate);
41726 if (PyErr_Occurred()) SWIG_fail;
41727 }
41728 {
41729 #if wxUSE_UNICODE
41730 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41731 #else
41732 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41733 #endif
41734 }
41735 return resultobj;
41736 fail:
41737 return NULL;
41738 }
41739
41740
41741 SWIGINTERN PyObject *_wrap_MenuBar_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41742 PyObject *resultobj = 0;
41743 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41744 int arg2 ;
41745 wxString *arg3 = 0 ;
41746 void *argp1 = 0 ;
41747 int res1 = 0 ;
41748 int val2 ;
41749 int ecode2 = 0 ;
41750 bool temp3 = false ;
41751 PyObject * obj0 = 0 ;
41752 PyObject * obj1 = 0 ;
41753 PyObject * obj2 = 0 ;
41754 char * kwnames[] = {
41755 (char *) "self",(char *) "id",(char *) "helpString", NULL
41756 };
41757
41758 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41759 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41760 if (!SWIG_IsOK(res1)) {
41761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetHelpString" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41762 }
41763 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41764 ecode2 = SWIG_AsVal_int(obj1, &val2);
41765 if (!SWIG_IsOK(ecode2)) {
41766 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetHelpString" "', expected argument " "2"" of type '" "int""'");
41767 }
41768 arg2 = static_cast< int >(val2);
41769 {
41770 arg3 = wxString_in_helper(obj2);
41771 if (arg3 == NULL) SWIG_fail;
41772 temp3 = true;
41773 }
41774 {
41775 PyThreadState* __tstate = wxPyBeginAllowThreads();
41776 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
41777 wxPyEndAllowThreads(__tstate);
41778 if (PyErr_Occurred()) SWIG_fail;
41779 }
41780 resultobj = SWIG_Py_Void();
41781 {
41782 if (temp3)
41783 delete arg3;
41784 }
41785 return resultobj;
41786 fail:
41787 {
41788 if (temp3)
41789 delete arg3;
41790 }
41791 return NULL;
41792 }
41793
41794
41795 SWIGINTERN PyObject *_wrap_MenuBar_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41796 PyObject *resultobj = 0;
41797 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41798 int arg2 ;
41799 wxString result;
41800 void *argp1 = 0 ;
41801 int res1 = 0 ;
41802 int val2 ;
41803 int ecode2 = 0 ;
41804 PyObject * obj0 = 0 ;
41805 PyObject * obj1 = 0 ;
41806 char * kwnames[] = {
41807 (char *) "self",(char *) "id", NULL
41808 };
41809
41810 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
41811 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41812 if (!SWIG_IsOK(res1)) {
41813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetHelpString" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41814 }
41815 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41816 ecode2 = SWIG_AsVal_int(obj1, &val2);
41817 if (!SWIG_IsOK(ecode2)) {
41818 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetHelpString" "', expected argument " "2"" of type '" "int""'");
41819 }
41820 arg2 = static_cast< int >(val2);
41821 {
41822 PyThreadState* __tstate = wxPyBeginAllowThreads();
41823 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
41824 wxPyEndAllowThreads(__tstate);
41825 if (PyErr_Occurred()) SWIG_fail;
41826 }
41827 {
41828 #if wxUSE_UNICODE
41829 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41830 #else
41831 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41832 #endif
41833 }
41834 return resultobj;
41835 fail:
41836 return NULL;
41837 }
41838
41839
41840 SWIGINTERN PyObject *_wrap_MenuBar_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41841 PyObject *resultobj = 0;
41842 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41843 wxFrame *result = 0 ;
41844 void *argp1 = 0 ;
41845 int res1 = 0 ;
41846 PyObject *swig_obj[1] ;
41847
41848 if (!args) SWIG_fail;
41849 swig_obj[0] = args;
41850 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41851 if (!SWIG_IsOK(res1)) {
41852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetFrame" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41853 }
41854 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41855 {
41856 PyThreadState* __tstate = wxPyBeginAllowThreads();
41857 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
41858 wxPyEndAllowThreads(__tstate);
41859 if (PyErr_Occurred()) SWIG_fail;
41860 }
41861 {
41862 resultobj = wxPyMake_wxObject(result, (bool)0);
41863 }
41864 return resultobj;
41865 fail:
41866 return NULL;
41867 }
41868
41869
41870 SWIGINTERN PyObject *_wrap_MenuBar_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41871 PyObject *resultobj = 0;
41872 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41873 bool result;
41874 void *argp1 = 0 ;
41875 int res1 = 0 ;
41876 PyObject *swig_obj[1] ;
41877
41878 if (!args) SWIG_fail;
41879 swig_obj[0] = args;
41880 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41881 if (!SWIG_IsOK(res1)) {
41882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsAttached" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41883 }
41884 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41885 {
41886 PyThreadState* __tstate = wxPyBeginAllowThreads();
41887 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
41888 wxPyEndAllowThreads(__tstate);
41889 if (PyErr_Occurred()) SWIG_fail;
41890 }
41891 {
41892 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41893 }
41894 return resultobj;
41895 fail:
41896 return NULL;
41897 }
41898
41899
41900 SWIGINTERN PyObject *_wrap_MenuBar_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41901 PyObject *resultobj = 0;
41902 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41903 wxFrame *arg2 = (wxFrame *) 0 ;
41904 void *argp1 = 0 ;
41905 int res1 = 0 ;
41906 void *argp2 = 0 ;
41907 int res2 = 0 ;
41908 PyObject * obj0 = 0 ;
41909 PyObject * obj1 = 0 ;
41910 char * kwnames[] = {
41911 (char *) "self",(char *) "frame", NULL
41912 };
41913
41914 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
41915 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41916 if (!SWIG_IsOK(res1)) {
41917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Attach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41918 }
41919 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41920 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFrame, 0 | 0 );
41921 if (!SWIG_IsOK(res2)) {
41922 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Attach" "', expected argument " "2"" of type '" "wxFrame *""'");
41923 }
41924 arg2 = reinterpret_cast< wxFrame * >(argp2);
41925 {
41926 PyThreadState* __tstate = wxPyBeginAllowThreads();
41927 (arg1)->Attach(arg2);
41928 wxPyEndAllowThreads(__tstate);
41929 if (PyErr_Occurred()) SWIG_fail;
41930 }
41931 resultobj = SWIG_Py_Void();
41932 return resultobj;
41933 fail:
41934 return NULL;
41935 }
41936
41937
41938 SWIGINTERN PyObject *_wrap_MenuBar_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41939 PyObject *resultobj = 0;
41940 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41941 void *argp1 = 0 ;
41942 int res1 = 0 ;
41943 PyObject *swig_obj[1] ;
41944
41945 if (!args) SWIG_fail;
41946 swig_obj[0] = args;
41947 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41948 if (!SWIG_IsOK(res1)) {
41949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Detach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41950 }
41951 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41952 {
41953 PyThreadState* __tstate = wxPyBeginAllowThreads();
41954 (arg1)->Detach();
41955 wxPyEndAllowThreads(__tstate);
41956 if (PyErr_Occurred()) SWIG_fail;
41957 }
41958 resultobj = SWIG_Py_Void();
41959 return resultobj;
41960 fail:
41961 return NULL;
41962 }
41963
41964
41965 SWIGINTERN PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41966 PyObject *resultobj = 0;
41967 bool arg1 ;
41968 bool val1 ;
41969 int ecode1 = 0 ;
41970 PyObject * obj0 = 0 ;
41971 char * kwnames[] = {
41972 (char *) "enable", NULL
41973 };
41974
41975 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) SWIG_fail;
41976 ecode1 = SWIG_AsVal_bool(obj0, &val1);
41977 if (!SWIG_IsOK(ecode1)) {
41978 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MenuBar_SetAutoWindowMenu" "', expected argument " "1"" of type '" "bool""'");
41979 }
41980 arg1 = static_cast< bool >(val1);
41981 {
41982 PyThreadState* __tstate = wxPyBeginAllowThreads();
41983 wxMenuBar_SetAutoWindowMenu(arg1);
41984 wxPyEndAllowThreads(__tstate);
41985 if (PyErr_Occurred()) SWIG_fail;
41986 }
41987 resultobj = SWIG_Py_Void();
41988 return resultobj;
41989 fail:
41990 return NULL;
41991 }
41992
41993
41994 SWIGINTERN PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41995 PyObject *resultobj = 0;
41996 bool result;
41997
41998 if (!SWIG_Python_UnpackTuple(args,"MenuBar_GetAutoWindowMenu",0,0,0)) SWIG_fail;
41999 {
42000 PyThreadState* __tstate = wxPyBeginAllowThreads();
42001 result = (bool)wxMenuBar_GetAutoWindowMenu();
42002 wxPyEndAllowThreads(__tstate);
42003 if (PyErr_Occurred()) SWIG_fail;
42004 }
42005 {
42006 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42007 }
42008 return resultobj;
42009 fail:
42010 return NULL;
42011 }
42012
42013
42014 SWIGINTERN PyObject *MenuBar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42015 PyObject *obj;
42016 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
42017 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuBar, SWIG_NewClientData(obj));
42018 return SWIG_Py_Void();
42019 }
42020
42021 SWIGINTERN PyObject *MenuBar_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42022 return SWIG_Python_InitShadowInstance(args);
42023 }
42024
42025 SWIGINTERN PyObject *_wrap_new_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42026 PyObject *resultobj = 0;
42027 wxMenu *arg1 = (wxMenu *) NULL ;
42028 int arg2 = (int) wxID_ANY ;
42029 wxString const &arg3_defvalue = wxPyEmptyString ;
42030 wxString *arg3 = (wxString *) &arg3_defvalue ;
42031 wxString const &arg4_defvalue = wxPyEmptyString ;
42032 wxString *arg4 = (wxString *) &arg4_defvalue ;
42033 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
42034 wxMenu *arg6 = (wxMenu *) NULL ;
42035 wxMenuItem *result = 0 ;
42036 void *argp1 = 0 ;
42037 int res1 = 0 ;
42038 int val2 ;
42039 int ecode2 = 0 ;
42040 bool temp3 = false ;
42041 bool temp4 = false ;
42042 int val5 ;
42043 int ecode5 = 0 ;
42044 void *argp6 = 0 ;
42045 int res6 = 0 ;
42046 PyObject * obj0 = 0 ;
42047 PyObject * obj1 = 0 ;
42048 PyObject * obj2 = 0 ;
42049 PyObject * obj3 = 0 ;
42050 PyObject * obj4 = 0 ;
42051 PyObject * obj5 = 0 ;
42052 char * kwnames[] = {
42053 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
42054 };
42055
42056 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
42057 if (obj0) {
42058 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42059 if (!SWIG_IsOK(res1)) {
42060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MenuItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42061 }
42062 arg1 = reinterpret_cast< wxMenu * >(argp1);
42063 }
42064 if (obj1) {
42065 ecode2 = SWIG_AsVal_int(obj1, &val2);
42066 if (!SWIG_IsOK(ecode2)) {
42067 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuItem" "', expected argument " "2"" of type '" "int""'");
42068 }
42069 arg2 = static_cast< int >(val2);
42070 }
42071 if (obj2) {
42072 {
42073 arg3 = wxString_in_helper(obj2);
42074 if (arg3 == NULL) SWIG_fail;
42075 temp3 = true;
42076 }
42077 }
42078 if (obj3) {
42079 {
42080 arg4 = wxString_in_helper(obj3);
42081 if (arg4 == NULL) SWIG_fail;
42082 temp4 = true;
42083 }
42084 }
42085 if (obj4) {
42086 ecode5 = SWIG_AsVal_int(obj4, &val5);
42087 if (!SWIG_IsOK(ecode5)) {
42088 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MenuItem" "', expected argument " "5"" of type '" "wxItemKind""'");
42089 }
42090 arg5 = static_cast< wxItemKind >(val5);
42091 }
42092 if (obj5) {
42093 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxMenu, 0 | 0 );
42094 if (!SWIG_IsOK(res6)) {
42095 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MenuItem" "', expected argument " "6"" of type '" "wxMenu *""'");
42096 }
42097 arg6 = reinterpret_cast< wxMenu * >(argp6);
42098 }
42099 {
42100 PyThreadState* __tstate = wxPyBeginAllowThreads();
42101 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
42102 wxPyEndAllowThreads(__tstate);
42103 if (PyErr_Occurred()) SWIG_fail;
42104 }
42105 {
42106 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
42107 }
42108 {
42109 if (temp3)
42110 delete arg3;
42111 }
42112 {
42113 if (temp4)
42114 delete arg4;
42115 }
42116 return resultobj;
42117 fail:
42118 {
42119 if (temp3)
42120 delete arg3;
42121 }
42122 {
42123 if (temp4)
42124 delete arg4;
42125 }
42126 return NULL;
42127 }
42128
42129
42130 SWIGINTERN PyObject *_wrap_delete_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42131 PyObject *resultobj = 0;
42132 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42133 void *argp1 = 0 ;
42134 int res1 = 0 ;
42135 PyObject *swig_obj[1] ;
42136
42137 if (!args) SWIG_fail;
42138 swig_obj[0] = args;
42139 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42140 if (!SWIG_IsOK(res1)) {
42141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MenuItem" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42142 }
42143 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42144 {
42145 PyThreadState* __tstate = wxPyBeginAllowThreads();
42146 delete arg1;
42147
42148 wxPyEndAllowThreads(__tstate);
42149 if (PyErr_Occurred()) SWIG_fail;
42150 }
42151 resultobj = SWIG_Py_Void();
42152 return resultobj;
42153 fail:
42154 return NULL;
42155 }
42156
42157
42158 SWIGINTERN PyObject *_wrap_MenuItem_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42159 PyObject *resultobj = 0;
42160 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42161 wxMenu *result = 0 ;
42162 void *argp1 = 0 ;
42163 int res1 = 0 ;
42164 PyObject *swig_obj[1] ;
42165
42166 if (!args) SWIG_fail;
42167 swig_obj[0] = args;
42168 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42169 if (!SWIG_IsOK(res1)) {
42170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42171 }
42172 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42173 {
42174 PyThreadState* __tstate = wxPyBeginAllowThreads();
42175 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
42176 wxPyEndAllowThreads(__tstate);
42177 if (PyErr_Occurred()) SWIG_fail;
42178 }
42179 {
42180 resultobj = wxPyMake_wxObject(result, 0);
42181 }
42182 return resultobj;
42183 fail:
42184 return NULL;
42185 }
42186
42187
42188 SWIGINTERN PyObject *_wrap_MenuItem_SetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42189 PyObject *resultobj = 0;
42190 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42191 wxMenu *arg2 = (wxMenu *) 0 ;
42192 void *argp1 = 0 ;
42193 int res1 = 0 ;
42194 void *argp2 = 0 ;
42195 int res2 = 0 ;
42196 PyObject * obj0 = 0 ;
42197 PyObject * obj1 = 0 ;
42198 char * kwnames[] = {
42199 (char *) "self",(char *) "menu", NULL
42200 };
42201
42202 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42203 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42204 if (!SWIG_IsOK(res1)) {
42205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42206 }
42207 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42208 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42209 if (!SWIG_IsOK(res2)) {
42210 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
42211 }
42212 arg2 = reinterpret_cast< wxMenu * >(argp2);
42213 {
42214 PyThreadState* __tstate = wxPyBeginAllowThreads();
42215 (arg1)->SetMenu(arg2);
42216 wxPyEndAllowThreads(__tstate);
42217 if (PyErr_Occurred()) SWIG_fail;
42218 }
42219 resultobj = SWIG_Py_Void();
42220 return resultobj;
42221 fail:
42222 return NULL;
42223 }
42224
42225
42226 SWIGINTERN PyObject *_wrap_MenuItem_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42227 PyObject *resultobj = 0;
42228 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42229 int arg2 ;
42230 void *argp1 = 0 ;
42231 int res1 = 0 ;
42232 int val2 ;
42233 int ecode2 = 0 ;
42234 PyObject * obj0 = 0 ;
42235 PyObject * obj1 = 0 ;
42236 char * kwnames[] = {
42237 (char *) "self",(char *) "id", NULL
42238 };
42239
42240 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
42241 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42242 if (!SWIG_IsOK(res1)) {
42243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetId" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42244 }
42245 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42246 ecode2 = SWIG_AsVal_int(obj1, &val2);
42247 if (!SWIG_IsOK(ecode2)) {
42248 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetId" "', expected argument " "2"" of type '" "int""'");
42249 }
42250 arg2 = static_cast< int >(val2);
42251 {
42252 PyThreadState* __tstate = wxPyBeginAllowThreads();
42253 (arg1)->SetId(arg2);
42254 wxPyEndAllowThreads(__tstate);
42255 if (PyErr_Occurred()) SWIG_fail;
42256 }
42257 resultobj = SWIG_Py_Void();
42258 return resultobj;
42259 fail:
42260 return NULL;
42261 }
42262
42263
42264 SWIGINTERN PyObject *_wrap_MenuItem_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42265 PyObject *resultobj = 0;
42266 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42267 int result;
42268 void *argp1 = 0 ;
42269 int res1 = 0 ;
42270 PyObject *swig_obj[1] ;
42271
42272 if (!args) SWIG_fail;
42273 swig_obj[0] = args;
42274 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42275 if (!SWIG_IsOK(res1)) {
42276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetId" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42277 }
42278 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42279 {
42280 PyThreadState* __tstate = wxPyBeginAllowThreads();
42281 result = (int)((wxMenuItem const *)arg1)->GetId();
42282 wxPyEndAllowThreads(__tstate);
42283 if (PyErr_Occurred()) SWIG_fail;
42284 }
42285 resultobj = SWIG_From_int(static_cast< int >(result));
42286 return resultobj;
42287 fail:
42288 return NULL;
42289 }
42290
42291
42292 SWIGINTERN PyObject *_wrap_MenuItem_IsSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42293 PyObject *resultobj = 0;
42294 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42295 bool result;
42296 void *argp1 = 0 ;
42297 int res1 = 0 ;
42298 PyObject *swig_obj[1] ;
42299
42300 if (!args) SWIG_fail;
42301 swig_obj[0] = args;
42302 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42303 if (!SWIG_IsOK(res1)) {
42304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSeparator" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42305 }
42306 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42307 {
42308 PyThreadState* __tstate = wxPyBeginAllowThreads();
42309 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
42310 wxPyEndAllowThreads(__tstate);
42311 if (PyErr_Occurred()) SWIG_fail;
42312 }
42313 {
42314 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42315 }
42316 return resultobj;
42317 fail:
42318 return NULL;
42319 }
42320
42321
42322 SWIGINTERN PyObject *_wrap_MenuItem_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42323 PyObject *resultobj = 0;
42324 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42325 wxString *arg2 = 0 ;
42326 void *argp1 = 0 ;
42327 int res1 = 0 ;
42328 bool temp2 = false ;
42329 PyObject * obj0 = 0 ;
42330 PyObject * obj1 = 0 ;
42331 char * kwnames[] = {
42332 (char *) "self",(char *) "str", NULL
42333 };
42334
42335 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
42336 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42337 if (!SWIG_IsOK(res1)) {
42338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetText" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42339 }
42340 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42341 {
42342 arg2 = wxString_in_helper(obj1);
42343 if (arg2 == NULL) SWIG_fail;
42344 temp2 = true;
42345 }
42346 {
42347 PyThreadState* __tstate = wxPyBeginAllowThreads();
42348 (arg1)->SetText((wxString const &)*arg2);
42349 wxPyEndAllowThreads(__tstate);
42350 if (PyErr_Occurred()) SWIG_fail;
42351 }
42352 resultobj = SWIG_Py_Void();
42353 {
42354 if (temp2)
42355 delete arg2;
42356 }
42357 return resultobj;
42358 fail:
42359 {
42360 if (temp2)
42361 delete arg2;
42362 }
42363 return NULL;
42364 }
42365
42366
42367 SWIGINTERN PyObject *_wrap_MenuItem_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42368 PyObject *resultobj = 0;
42369 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42370 wxString result;
42371 void *argp1 = 0 ;
42372 int res1 = 0 ;
42373 PyObject *swig_obj[1] ;
42374
42375 if (!args) SWIG_fail;
42376 swig_obj[0] = args;
42377 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42378 if (!SWIG_IsOK(res1)) {
42379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetLabel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42380 }
42381 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42382 {
42383 PyThreadState* __tstate = wxPyBeginAllowThreads();
42384 result = ((wxMenuItem const *)arg1)->GetLabel();
42385 wxPyEndAllowThreads(__tstate);
42386 if (PyErr_Occurred()) SWIG_fail;
42387 }
42388 {
42389 #if wxUSE_UNICODE
42390 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42391 #else
42392 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42393 #endif
42394 }
42395 return resultobj;
42396 fail:
42397 return NULL;
42398 }
42399
42400
42401 SWIGINTERN PyObject *_wrap_MenuItem_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42402 PyObject *resultobj = 0;
42403 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42404 wxString *result = 0 ;
42405 void *argp1 = 0 ;
42406 int res1 = 0 ;
42407 PyObject *swig_obj[1] ;
42408
42409 if (!args) SWIG_fail;
42410 swig_obj[0] = args;
42411 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42412 if (!SWIG_IsOK(res1)) {
42413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetText" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42414 }
42415 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42416 {
42417 PyThreadState* __tstate = wxPyBeginAllowThreads();
42418 {
42419 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
42420 result = (wxString *) &_result_ref;
42421 }
42422 wxPyEndAllowThreads(__tstate);
42423 if (PyErr_Occurred()) SWIG_fail;
42424 }
42425 {
42426 #if wxUSE_UNICODE
42427 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
42428 #else
42429 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
42430 #endif
42431 }
42432 return resultobj;
42433 fail:
42434 return NULL;
42435 }
42436
42437
42438 SWIGINTERN PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42439 PyObject *resultobj = 0;
42440 wxString *arg1 = 0 ;
42441 wxString result;
42442 bool temp1 = false ;
42443 PyObject * obj0 = 0 ;
42444 char * kwnames[] = {
42445 (char *) "text", NULL
42446 };
42447
42448 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) SWIG_fail;
42449 {
42450 arg1 = wxString_in_helper(obj0);
42451 if (arg1 == NULL) SWIG_fail;
42452 temp1 = true;
42453 }
42454 {
42455 PyThreadState* __tstate = wxPyBeginAllowThreads();
42456 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
42457 wxPyEndAllowThreads(__tstate);
42458 if (PyErr_Occurred()) SWIG_fail;
42459 }
42460 {
42461 #if wxUSE_UNICODE
42462 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42463 #else
42464 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42465 #endif
42466 }
42467 {
42468 if (temp1)
42469 delete arg1;
42470 }
42471 return resultobj;
42472 fail:
42473 {
42474 if (temp1)
42475 delete arg1;
42476 }
42477 return NULL;
42478 }
42479
42480
42481 SWIGINTERN PyObject *_wrap_MenuItem_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42482 PyObject *resultobj = 0;
42483 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42484 wxItemKind result;
42485 void *argp1 = 0 ;
42486 int res1 = 0 ;
42487 PyObject *swig_obj[1] ;
42488
42489 if (!args) SWIG_fail;
42490 swig_obj[0] = args;
42491 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42492 if (!SWIG_IsOK(res1)) {
42493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetKind" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42494 }
42495 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42496 {
42497 PyThreadState* __tstate = wxPyBeginAllowThreads();
42498 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
42499 wxPyEndAllowThreads(__tstate);
42500 if (PyErr_Occurred()) SWIG_fail;
42501 }
42502 resultobj = SWIG_From_int(static_cast< int >(result));
42503 return resultobj;
42504 fail:
42505 return NULL;
42506 }
42507
42508
42509 SWIGINTERN PyObject *_wrap_MenuItem_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42510 PyObject *resultobj = 0;
42511 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42512 wxItemKind arg2 ;
42513 void *argp1 = 0 ;
42514 int res1 = 0 ;
42515 int val2 ;
42516 int ecode2 = 0 ;
42517 PyObject * obj0 = 0 ;
42518 PyObject * obj1 = 0 ;
42519 char * kwnames[] = {
42520 (char *) "self",(char *) "kind", NULL
42521 };
42522
42523 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
42524 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42525 if (!SWIG_IsOK(res1)) {
42526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetKind" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42527 }
42528 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42529 ecode2 = SWIG_AsVal_int(obj1, &val2);
42530 if (!SWIG_IsOK(ecode2)) {
42531 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetKind" "', expected argument " "2"" of type '" "wxItemKind""'");
42532 }
42533 arg2 = static_cast< wxItemKind >(val2);
42534 {
42535 PyThreadState* __tstate = wxPyBeginAllowThreads();
42536 (arg1)->SetKind(arg2);
42537 wxPyEndAllowThreads(__tstate);
42538 if (PyErr_Occurred()) SWIG_fail;
42539 }
42540 resultobj = SWIG_Py_Void();
42541 return resultobj;
42542 fail:
42543 return NULL;
42544 }
42545
42546
42547 SWIGINTERN PyObject *_wrap_MenuItem_SetCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42548 PyObject *resultobj = 0;
42549 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42550 bool arg2 ;
42551 void *argp1 = 0 ;
42552 int res1 = 0 ;
42553 bool val2 ;
42554 int ecode2 = 0 ;
42555 PyObject * obj0 = 0 ;
42556 PyObject * obj1 = 0 ;
42557 char * kwnames[] = {
42558 (char *) "self",(char *) "checkable", NULL
42559 };
42560
42561 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) SWIG_fail;
42562 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42563 if (!SWIG_IsOK(res1)) {
42564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetCheckable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42565 }
42566 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42567 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42568 if (!SWIG_IsOK(ecode2)) {
42569 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetCheckable" "', expected argument " "2"" of type '" "bool""'");
42570 }
42571 arg2 = static_cast< bool >(val2);
42572 {
42573 PyThreadState* __tstate = wxPyBeginAllowThreads();
42574 (arg1)->SetCheckable(arg2);
42575 wxPyEndAllowThreads(__tstate);
42576 if (PyErr_Occurred()) SWIG_fail;
42577 }
42578 resultobj = SWIG_Py_Void();
42579 return resultobj;
42580 fail:
42581 return NULL;
42582 }
42583
42584
42585 SWIGINTERN PyObject *_wrap_MenuItem_IsCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42586 PyObject *resultobj = 0;
42587 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42588 bool result;
42589 void *argp1 = 0 ;
42590 int res1 = 0 ;
42591 PyObject *swig_obj[1] ;
42592
42593 if (!args) SWIG_fail;
42594 swig_obj[0] = args;
42595 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42596 if (!SWIG_IsOK(res1)) {
42597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsCheckable" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42598 }
42599 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42600 {
42601 PyThreadState* __tstate = wxPyBeginAllowThreads();
42602 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
42603 wxPyEndAllowThreads(__tstate);
42604 if (PyErr_Occurred()) SWIG_fail;
42605 }
42606 {
42607 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42608 }
42609 return resultobj;
42610 fail:
42611 return NULL;
42612 }
42613
42614
42615 SWIGINTERN PyObject *_wrap_MenuItem_IsSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42616 PyObject *resultobj = 0;
42617 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42618 bool result;
42619 void *argp1 = 0 ;
42620 int res1 = 0 ;
42621 PyObject *swig_obj[1] ;
42622
42623 if (!args) SWIG_fail;
42624 swig_obj[0] = args;
42625 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42626 if (!SWIG_IsOK(res1)) {
42627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42628 }
42629 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42630 {
42631 PyThreadState* __tstate = wxPyBeginAllowThreads();
42632 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
42633 wxPyEndAllowThreads(__tstate);
42634 if (PyErr_Occurred()) SWIG_fail;
42635 }
42636 {
42637 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42638 }
42639 return resultobj;
42640 fail:
42641 return NULL;
42642 }
42643
42644
42645 SWIGINTERN PyObject *_wrap_MenuItem_SetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42646 PyObject *resultobj = 0;
42647 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42648 wxMenu *arg2 = (wxMenu *) 0 ;
42649 void *argp1 = 0 ;
42650 int res1 = 0 ;
42651 void *argp2 = 0 ;
42652 int res2 = 0 ;
42653 PyObject * obj0 = 0 ;
42654 PyObject * obj1 = 0 ;
42655 char * kwnames[] = {
42656 (char *) "self",(char *) "menu", NULL
42657 };
42658
42659 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42660 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42661 if (!SWIG_IsOK(res1)) {
42662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42663 }
42664 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42665 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42666 if (!SWIG_IsOK(res2)) {
42667 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
42668 }
42669 arg2 = reinterpret_cast< wxMenu * >(argp2);
42670 {
42671 PyThreadState* __tstate = wxPyBeginAllowThreads();
42672 (arg1)->SetSubMenu(arg2);
42673 wxPyEndAllowThreads(__tstate);
42674 if (PyErr_Occurred()) SWIG_fail;
42675 }
42676 resultobj = SWIG_Py_Void();
42677 return resultobj;
42678 fail:
42679 return NULL;
42680 }
42681
42682
42683 SWIGINTERN PyObject *_wrap_MenuItem_GetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42684 PyObject *resultobj = 0;
42685 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42686 wxMenu *result = 0 ;
42687 void *argp1 = 0 ;
42688 int res1 = 0 ;
42689 PyObject *swig_obj[1] ;
42690
42691 if (!args) SWIG_fail;
42692 swig_obj[0] = args;
42693 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42694 if (!SWIG_IsOK(res1)) {
42695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42696 }
42697 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42698 {
42699 PyThreadState* __tstate = wxPyBeginAllowThreads();
42700 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
42701 wxPyEndAllowThreads(__tstate);
42702 if (PyErr_Occurred()) SWIG_fail;
42703 }
42704 {
42705 resultobj = wxPyMake_wxObject(result, 0);
42706 }
42707 return resultobj;
42708 fail:
42709 return NULL;
42710 }
42711
42712
42713 SWIGINTERN PyObject *_wrap_MenuItem_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42714 PyObject *resultobj = 0;
42715 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42716 bool arg2 = (bool) true ;
42717 void *argp1 = 0 ;
42718 int res1 = 0 ;
42719 bool val2 ;
42720 int ecode2 = 0 ;
42721 PyObject * obj0 = 0 ;
42722 PyObject * obj1 = 0 ;
42723 char * kwnames[] = {
42724 (char *) "self",(char *) "enable", NULL
42725 };
42726
42727 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
42728 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42729 if (!SWIG_IsOK(res1)) {
42730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Enable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42731 }
42732 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42733 if (obj1) {
42734 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42735 if (!SWIG_IsOK(ecode2)) {
42736 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Enable" "', expected argument " "2"" of type '" "bool""'");
42737 }
42738 arg2 = static_cast< bool >(val2);
42739 }
42740 {
42741 PyThreadState* __tstate = wxPyBeginAllowThreads();
42742 (arg1)->Enable(arg2);
42743 wxPyEndAllowThreads(__tstate);
42744 if (PyErr_Occurred()) SWIG_fail;
42745 }
42746 resultobj = SWIG_Py_Void();
42747 return resultobj;
42748 fail:
42749 return NULL;
42750 }
42751
42752
42753 SWIGINTERN PyObject *_wrap_MenuItem_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42754 PyObject *resultobj = 0;
42755 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42756 bool result;
42757 void *argp1 = 0 ;
42758 int res1 = 0 ;
42759 PyObject *swig_obj[1] ;
42760
42761 if (!args) SWIG_fail;
42762 swig_obj[0] = args;
42763 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42764 if (!SWIG_IsOK(res1)) {
42765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsEnabled" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42766 }
42767 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42768 {
42769 PyThreadState* __tstate = wxPyBeginAllowThreads();
42770 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
42771 wxPyEndAllowThreads(__tstate);
42772 if (PyErr_Occurred()) SWIG_fail;
42773 }
42774 {
42775 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42776 }
42777 return resultobj;
42778 fail:
42779 return NULL;
42780 }
42781
42782
42783 SWIGINTERN PyObject *_wrap_MenuItem_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42784 PyObject *resultobj = 0;
42785 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42786 bool arg2 = (bool) true ;
42787 void *argp1 = 0 ;
42788 int res1 = 0 ;
42789 bool val2 ;
42790 int ecode2 = 0 ;
42791 PyObject * obj0 = 0 ;
42792 PyObject * obj1 = 0 ;
42793 char * kwnames[] = {
42794 (char *) "self",(char *) "check", NULL
42795 };
42796
42797 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) SWIG_fail;
42798 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42799 if (!SWIG_IsOK(res1)) {
42800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Check" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42801 }
42802 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42803 if (obj1) {
42804 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42805 if (!SWIG_IsOK(ecode2)) {
42806 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Check" "', expected argument " "2"" of type '" "bool""'");
42807 }
42808 arg2 = static_cast< bool >(val2);
42809 }
42810 {
42811 PyThreadState* __tstate = wxPyBeginAllowThreads();
42812 (arg1)->Check(arg2);
42813 wxPyEndAllowThreads(__tstate);
42814 if (PyErr_Occurred()) SWIG_fail;
42815 }
42816 resultobj = SWIG_Py_Void();
42817 return resultobj;
42818 fail:
42819 return NULL;
42820 }
42821
42822
42823 SWIGINTERN PyObject *_wrap_MenuItem_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42824 PyObject *resultobj = 0;
42825 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42826 bool result;
42827 void *argp1 = 0 ;
42828 int res1 = 0 ;
42829 PyObject *swig_obj[1] ;
42830
42831 if (!args) SWIG_fail;
42832 swig_obj[0] = args;
42833 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42834 if (!SWIG_IsOK(res1)) {
42835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsChecked" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42836 }
42837 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42838 {
42839 PyThreadState* __tstate = wxPyBeginAllowThreads();
42840 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
42841 wxPyEndAllowThreads(__tstate);
42842 if (PyErr_Occurred()) SWIG_fail;
42843 }
42844 {
42845 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42846 }
42847 return resultobj;
42848 fail:
42849 return NULL;
42850 }
42851
42852
42853 SWIGINTERN PyObject *_wrap_MenuItem_Toggle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42854 PyObject *resultobj = 0;
42855 wxMenuItem *arg1 = (wxMenuItem *) 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_Toggle" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42865 }
42866 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42867 {
42868 PyThreadState* __tstate = wxPyBeginAllowThreads();
42869 (arg1)->Toggle();
42870 wxPyEndAllowThreads(__tstate);
42871 if (PyErr_Occurred()) SWIG_fail;
42872 }
42873 resultobj = SWIG_Py_Void();
42874 return resultobj;
42875 fail:
42876 return NULL;
42877 }
42878
42879
42880 SWIGINTERN PyObject *_wrap_MenuItem_SetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42881 PyObject *resultobj = 0;
42882 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42883 wxString *arg2 = 0 ;
42884 void *argp1 = 0 ;
42885 int res1 = 0 ;
42886 bool temp2 = false ;
42887 PyObject * obj0 = 0 ;
42888 PyObject * obj1 = 0 ;
42889 char * kwnames[] = {
42890 (char *) "self",(char *) "str", NULL
42891 };
42892
42893 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) SWIG_fail;
42894 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42895 if (!SWIG_IsOK(res1)) {
42896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetHelp" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42897 }
42898 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42899 {
42900 arg2 = wxString_in_helper(obj1);
42901 if (arg2 == NULL) SWIG_fail;
42902 temp2 = true;
42903 }
42904 {
42905 PyThreadState* __tstate = wxPyBeginAllowThreads();
42906 (arg1)->SetHelp((wxString const &)*arg2);
42907 wxPyEndAllowThreads(__tstate);
42908 if (PyErr_Occurred()) SWIG_fail;
42909 }
42910 resultobj = SWIG_Py_Void();
42911 {
42912 if (temp2)
42913 delete arg2;
42914 }
42915 return resultobj;
42916 fail:
42917 {
42918 if (temp2)
42919 delete arg2;
42920 }
42921 return NULL;
42922 }
42923
42924
42925 SWIGINTERN PyObject *_wrap_MenuItem_GetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42926 PyObject *resultobj = 0;
42927 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42928 wxString *result = 0 ;
42929 void *argp1 = 0 ;
42930 int res1 = 0 ;
42931 PyObject *swig_obj[1] ;
42932
42933 if (!args) SWIG_fail;
42934 swig_obj[0] = args;
42935 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42936 if (!SWIG_IsOK(res1)) {
42937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetHelp" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42938 }
42939 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42940 {
42941 PyThreadState* __tstate = wxPyBeginAllowThreads();
42942 {
42943 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
42944 result = (wxString *) &_result_ref;
42945 }
42946 wxPyEndAllowThreads(__tstate);
42947 if (PyErr_Occurred()) SWIG_fail;
42948 }
42949 {
42950 #if wxUSE_UNICODE
42951 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
42952 #else
42953 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
42954 #endif
42955 }
42956 return resultobj;
42957 fail:
42958 return NULL;
42959 }
42960
42961
42962 SWIGINTERN PyObject *_wrap_MenuItem_GetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42963 PyObject *resultobj = 0;
42964 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42965 wxAcceleratorEntry *result = 0 ;
42966 void *argp1 = 0 ;
42967 int res1 = 0 ;
42968 PyObject *swig_obj[1] ;
42969
42970 if (!args) SWIG_fail;
42971 swig_obj[0] = args;
42972 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42973 if (!SWIG_IsOK(res1)) {
42974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetAccel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42975 }
42976 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42977 {
42978 PyThreadState* __tstate = wxPyBeginAllowThreads();
42979 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
42980 wxPyEndAllowThreads(__tstate);
42981 if (PyErr_Occurred()) SWIG_fail;
42982 }
42983 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
42984 return resultobj;
42985 fail:
42986 return NULL;
42987 }
42988
42989
42990 SWIGINTERN PyObject *_wrap_MenuItem_SetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42991 PyObject *resultobj = 0;
42992 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42993 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
42994 void *argp1 = 0 ;
42995 int res1 = 0 ;
42996 void *argp2 = 0 ;
42997 int res2 = 0 ;
42998 PyObject * obj0 = 0 ;
42999 PyObject * obj1 = 0 ;
43000 char * kwnames[] = {
43001 (char *) "self",(char *) "accel", NULL
43002 };
43003
43004 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) SWIG_fail;
43005 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43006 if (!SWIG_IsOK(res1)) {
43007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetAccel" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43008 }
43009 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43010 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
43011 if (!SWIG_IsOK(res2)) {
43012 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetAccel" "', expected argument " "2"" of type '" "wxAcceleratorEntry *""'");
43013 }
43014 arg2 = reinterpret_cast< wxAcceleratorEntry * >(argp2);
43015 {
43016 PyThreadState* __tstate = wxPyBeginAllowThreads();
43017 (arg1)->SetAccel(arg2);
43018 wxPyEndAllowThreads(__tstate);
43019 if (PyErr_Occurred()) SWIG_fail;
43020 }
43021 resultobj = SWIG_Py_Void();
43022 return resultobj;
43023 fail:
43024 return NULL;
43025 }
43026
43027
43028 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43029 PyObject *resultobj = 0;
43030 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43031 wxBitmap *arg2 = 0 ;
43032 void *argp1 = 0 ;
43033 int res1 = 0 ;
43034 void *argp2 = 0 ;
43035 int res2 = 0 ;
43036 PyObject * obj0 = 0 ;
43037 PyObject * obj1 = 0 ;
43038 char * kwnames[] = {
43039 (char *) "self",(char *) "bitmap", NULL
43040 };
43041
43042 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
43043 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43044 if (!SWIG_IsOK(res1)) {
43045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43046 }
43047 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43048 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43049 if (!SWIG_IsOK(res2)) {
43050 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43051 }
43052 if (!argp2) {
43053 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43054 }
43055 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43056 {
43057 PyThreadState* __tstate = wxPyBeginAllowThreads();
43058 (arg1)->SetBitmap((wxBitmap const &)*arg2);
43059 wxPyEndAllowThreads(__tstate);
43060 if (PyErr_Occurred()) SWIG_fail;
43061 }
43062 resultobj = SWIG_Py_Void();
43063 return resultobj;
43064 fail:
43065 return NULL;
43066 }
43067
43068
43069 SWIGINTERN PyObject *_wrap_MenuItem_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43070 PyObject *resultobj = 0;
43071 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43072 wxBitmap *result = 0 ;
43073 void *argp1 = 0 ;
43074 int res1 = 0 ;
43075 PyObject *swig_obj[1] ;
43076
43077 if (!args) SWIG_fail;
43078 swig_obj[0] = args;
43079 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43080 if (!SWIG_IsOK(res1)) {
43081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43082 }
43083 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43084 {
43085 PyThreadState* __tstate = wxPyBeginAllowThreads();
43086 {
43087 wxBitmap const &_result_ref = (arg1)->GetBitmap();
43088 result = (wxBitmap *) &_result_ref;
43089 }
43090 wxPyEndAllowThreads(__tstate);
43091 if (PyErr_Occurred()) SWIG_fail;
43092 }
43093 {
43094 wxBitmap* resultptr = new wxBitmap(*result);
43095 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
43096 }
43097 return resultobj;
43098 fail:
43099 return NULL;
43100 }
43101
43102
43103 SWIGINTERN PyObject *_wrap_MenuItem_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43104 PyObject *resultobj = 0;
43105 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43106 wxFont *arg2 = 0 ;
43107 void *argp1 = 0 ;
43108 int res1 = 0 ;
43109 void *argp2 = 0 ;
43110 int res2 = 0 ;
43111 PyObject * obj0 = 0 ;
43112 PyObject * obj1 = 0 ;
43113 char * kwnames[] = {
43114 (char *) "self",(char *) "font", NULL
43115 };
43116
43117 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
43118 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43119 if (!SWIG_IsOK(res1)) {
43120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43121 }
43122 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43123 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
43124 if (!SWIG_IsOK(res2)) {
43125 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
43126 }
43127 if (!argp2) {
43128 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
43129 }
43130 arg2 = reinterpret_cast< wxFont * >(argp2);
43131 {
43132 PyThreadState* __tstate = wxPyBeginAllowThreads();
43133 (arg1)->SetFont((wxFont const &)*arg2);
43134 wxPyEndAllowThreads(__tstate);
43135 if (PyErr_Occurred()) SWIG_fail;
43136 }
43137 resultobj = SWIG_Py_Void();
43138 return resultobj;
43139 fail:
43140 return NULL;
43141 }
43142
43143
43144 SWIGINTERN PyObject *_wrap_MenuItem_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43145 PyObject *resultobj = 0;
43146 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43147 wxFont result;
43148 void *argp1 = 0 ;
43149 int res1 = 0 ;
43150 PyObject *swig_obj[1] ;
43151
43152 if (!args) SWIG_fail;
43153 swig_obj[0] = args;
43154 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43155 if (!SWIG_IsOK(res1)) {
43156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43157 }
43158 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43159 {
43160 PyThreadState* __tstate = wxPyBeginAllowThreads();
43161 result = (arg1)->GetFont();
43162 wxPyEndAllowThreads(__tstate);
43163 if (PyErr_Occurred()) SWIG_fail;
43164 }
43165 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
43166 return resultobj;
43167 fail:
43168 return NULL;
43169 }
43170
43171
43172 SWIGINTERN PyObject *_wrap_MenuItem_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43173 PyObject *resultobj = 0;
43174 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43175 wxColour *arg2 = 0 ;
43176 void *argp1 = 0 ;
43177 int res1 = 0 ;
43178 wxColour temp2 ;
43179 PyObject * obj0 = 0 ;
43180 PyObject * obj1 = 0 ;
43181 char * kwnames[] = {
43182 (char *) "self",(char *) "colText", NULL
43183 };
43184
43185 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
43186 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43187 if (!SWIG_IsOK(res1)) {
43188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43189 }
43190 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43191 {
43192 arg2 = &temp2;
43193 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
43194 }
43195 {
43196 PyThreadState* __tstate = wxPyBeginAllowThreads();
43197 (arg1)->SetTextColour((wxColour const &)*arg2);
43198 wxPyEndAllowThreads(__tstate);
43199 if (PyErr_Occurred()) SWIG_fail;
43200 }
43201 resultobj = SWIG_Py_Void();
43202 return resultobj;
43203 fail:
43204 return NULL;
43205 }
43206
43207
43208 SWIGINTERN PyObject *_wrap_MenuItem_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43209 PyObject *resultobj = 0;
43210 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43211 wxColour result;
43212 void *argp1 = 0 ;
43213 int res1 = 0 ;
43214 PyObject *swig_obj[1] ;
43215
43216 if (!args) SWIG_fail;
43217 swig_obj[0] = args;
43218 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43219 if (!SWIG_IsOK(res1)) {
43220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43221 }
43222 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43223 {
43224 PyThreadState* __tstate = wxPyBeginAllowThreads();
43225 result = (arg1)->GetTextColour();
43226 wxPyEndAllowThreads(__tstate);
43227 if (PyErr_Occurred()) SWIG_fail;
43228 }
43229 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
43230 return resultobj;
43231 fail:
43232 return NULL;
43233 }
43234
43235
43236 SWIGINTERN PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43237 PyObject *resultobj = 0;
43238 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43239 wxColour *arg2 = 0 ;
43240 void *argp1 = 0 ;
43241 int res1 = 0 ;
43242 wxColour temp2 ;
43243 PyObject * obj0 = 0 ;
43244 PyObject * obj1 = 0 ;
43245 char * kwnames[] = {
43246 (char *) "self",(char *) "colBack", NULL
43247 };
43248
43249 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
43250 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43251 if (!SWIG_IsOK(res1)) {
43252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43253 }
43254 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43255 {
43256 arg2 = &temp2;
43257 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
43258 }
43259 {
43260 PyThreadState* __tstate = wxPyBeginAllowThreads();
43261 (arg1)->SetBackgroundColour((wxColour const &)*arg2);
43262 wxPyEndAllowThreads(__tstate);
43263 if (PyErr_Occurred()) SWIG_fail;
43264 }
43265 resultobj = SWIG_Py_Void();
43266 return resultobj;
43267 fail:
43268 return NULL;
43269 }
43270
43271
43272 SWIGINTERN PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43273 PyObject *resultobj = 0;
43274 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43275 wxColour result;
43276 void *argp1 = 0 ;
43277 int res1 = 0 ;
43278 PyObject *swig_obj[1] ;
43279
43280 if (!args) SWIG_fail;
43281 swig_obj[0] = args;
43282 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43283 if (!SWIG_IsOK(res1)) {
43284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43285 }
43286 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43287 {
43288 PyThreadState* __tstate = wxPyBeginAllowThreads();
43289 result = (arg1)->GetBackgroundColour();
43290 wxPyEndAllowThreads(__tstate);
43291 if (PyErr_Occurred()) SWIG_fail;
43292 }
43293 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
43294 return resultobj;
43295 fail:
43296 return NULL;
43297 }
43298
43299
43300 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43301 PyObject *resultobj = 0;
43302 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43303 wxBitmap *arg2 = 0 ;
43304 wxBitmap const &arg3_defvalue = wxNullBitmap ;
43305 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
43306 void *argp1 = 0 ;
43307 int res1 = 0 ;
43308 void *argp2 = 0 ;
43309 int res2 = 0 ;
43310 void *argp3 = 0 ;
43311 int res3 = 0 ;
43312 PyObject * obj0 = 0 ;
43313 PyObject * obj1 = 0 ;
43314 PyObject * obj2 = 0 ;
43315 char * kwnames[] = {
43316 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
43317 };
43318
43319 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43320 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43321 if (!SWIG_IsOK(res1)) {
43322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmaps" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43323 }
43324 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43325 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43326 if (!SWIG_IsOK(res2)) {
43327 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43328 }
43329 if (!argp2) {
43330 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43331 }
43332 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43333 if (obj2) {
43334 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
43335 if (!SWIG_IsOK(res3)) {
43336 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
43337 }
43338 if (!argp3) {
43339 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
43340 }
43341 arg3 = reinterpret_cast< wxBitmap * >(argp3);
43342 }
43343 {
43344 PyThreadState* __tstate = wxPyBeginAllowThreads();
43345 (arg1)->SetBitmaps((wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
43346 wxPyEndAllowThreads(__tstate);
43347 if (PyErr_Occurred()) SWIG_fail;
43348 }
43349 resultobj = SWIG_Py_Void();
43350 return resultobj;
43351 fail:
43352 return NULL;
43353 }
43354
43355
43356 SWIGINTERN PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43357 PyObject *resultobj = 0;
43358 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43359 wxBitmap *arg2 = 0 ;
43360 void *argp1 = 0 ;
43361 int res1 = 0 ;
43362 void *argp2 = 0 ;
43363 int res2 = 0 ;
43364 PyObject * obj0 = 0 ;
43365 PyObject * obj1 = 0 ;
43366 char * kwnames[] = {
43367 (char *) "self",(char *) "bmpDisabled", NULL
43368 };
43369
43370 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
43371 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43372 if (!SWIG_IsOK(res1)) {
43373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43374 }
43375 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43376 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43377 if (!SWIG_IsOK(res2)) {
43378 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43379 }
43380 if (!argp2) {
43381 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43382 }
43383 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43384 {
43385 PyThreadState* __tstate = wxPyBeginAllowThreads();
43386 (arg1)->SetDisabledBitmap((wxBitmap const &)*arg2);
43387 wxPyEndAllowThreads(__tstate);
43388 if (PyErr_Occurred()) SWIG_fail;
43389 }
43390 resultobj = SWIG_Py_Void();
43391 return resultobj;
43392 fail:
43393 return NULL;
43394 }
43395
43396
43397 SWIGINTERN PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43398 PyObject *resultobj = 0;
43399 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43400 wxBitmap *result = 0 ;
43401 void *argp1 = 0 ;
43402 int res1 = 0 ;
43403 PyObject *swig_obj[1] ;
43404
43405 if (!args) SWIG_fail;
43406 swig_obj[0] = args;
43407 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43408 if (!SWIG_IsOK(res1)) {
43409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43410 }
43411 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43412 {
43413 PyThreadState* __tstate = wxPyBeginAllowThreads();
43414 {
43415 wxBitmap const &_result_ref = ((wxMenuItem const *)arg1)->GetDisabledBitmap();
43416 result = (wxBitmap *) &_result_ref;
43417 }
43418 wxPyEndAllowThreads(__tstate);
43419 if (PyErr_Occurred()) SWIG_fail;
43420 }
43421 {
43422 wxBitmap* resultptr = new wxBitmap(*result);
43423 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
43424 }
43425 return resultobj;
43426 fail:
43427 return NULL;
43428 }
43429
43430
43431 SWIGINTERN PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43432 PyObject *resultobj = 0;
43433 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43434 int arg2 ;
43435 void *argp1 = 0 ;
43436 int res1 = 0 ;
43437 int val2 ;
43438 int ecode2 = 0 ;
43439 PyObject * obj0 = 0 ;
43440 PyObject * obj1 = 0 ;
43441 char * kwnames[] = {
43442 (char *) "self",(char *) "nWidth", NULL
43443 };
43444
43445 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) SWIG_fail;
43446 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43447 if (!SWIG_IsOK(res1)) {
43448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43449 }
43450 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43451 ecode2 = SWIG_AsVal_int(obj1, &val2);
43452 if (!SWIG_IsOK(ecode2)) {
43453 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "2"" of type '" "int""'");
43454 }
43455 arg2 = static_cast< int >(val2);
43456 {
43457 PyThreadState* __tstate = wxPyBeginAllowThreads();
43458 (arg1)->SetMarginWidth(arg2);
43459 wxPyEndAllowThreads(__tstate);
43460 if (PyErr_Occurred()) SWIG_fail;
43461 }
43462 resultobj = SWIG_Py_Void();
43463 return resultobj;
43464 fail:
43465 return NULL;
43466 }
43467
43468
43469 SWIGINTERN PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43470 PyObject *resultobj = 0;
43471 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43472 int result;
43473 void *argp1 = 0 ;
43474 int res1 = 0 ;
43475 PyObject *swig_obj[1] ;
43476
43477 if (!args) SWIG_fail;
43478 swig_obj[0] = args;
43479 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43480 if (!SWIG_IsOK(res1)) {
43481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43482 }
43483 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43484 {
43485 PyThreadState* __tstate = wxPyBeginAllowThreads();
43486 result = (int)(arg1)->GetMarginWidth();
43487 wxPyEndAllowThreads(__tstate);
43488 if (PyErr_Occurred()) SWIG_fail;
43489 }
43490 resultobj = SWIG_From_int(static_cast< int >(result));
43491 return resultobj;
43492 fail:
43493 return NULL;
43494 }
43495
43496
43497 SWIGINTERN PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43498 PyObject *resultobj = 0;
43499 int result;
43500
43501 if (!SWIG_Python_UnpackTuple(args,"MenuItem_GetDefaultMarginWidth",0,0,0)) SWIG_fail;
43502 {
43503 PyThreadState* __tstate = wxPyBeginAllowThreads();
43504 result = (int)wxMenuItem::GetDefaultMarginWidth();
43505 wxPyEndAllowThreads(__tstate);
43506 if (PyErr_Occurred()) SWIG_fail;
43507 }
43508 resultobj = SWIG_From_int(static_cast< int >(result));
43509 return resultobj;
43510 fail:
43511 return NULL;
43512 }
43513
43514
43515 SWIGINTERN PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43516 PyObject *resultobj = 0;
43517 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43518 bool result;
43519 void *argp1 = 0 ;
43520 int res1 = 0 ;
43521 PyObject *swig_obj[1] ;
43522
43523 if (!args) SWIG_fail;
43524 swig_obj[0] = args;
43525 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43526 if (!SWIG_IsOK(res1)) {
43527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43528 }
43529 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43530 {
43531 PyThreadState* __tstate = wxPyBeginAllowThreads();
43532 result = (bool)(arg1)->IsOwnerDrawn();
43533 wxPyEndAllowThreads(__tstate);
43534 if (PyErr_Occurred()) SWIG_fail;
43535 }
43536 {
43537 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43538 }
43539 return resultobj;
43540 fail:
43541 return NULL;
43542 }
43543
43544
43545 SWIGINTERN PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43546 PyObject *resultobj = 0;
43547 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43548 bool arg2 = (bool) true ;
43549 void *argp1 = 0 ;
43550 int res1 = 0 ;
43551 bool val2 ;
43552 int ecode2 = 0 ;
43553 PyObject * obj0 = 0 ;
43554 PyObject * obj1 = 0 ;
43555 char * kwnames[] = {
43556 (char *) "self",(char *) "ownerDrawn", NULL
43557 };
43558
43559 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) SWIG_fail;
43560 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43561 if (!SWIG_IsOK(res1)) {
43562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43563 }
43564 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43565 if (obj1) {
43566 ecode2 = SWIG_AsVal_bool(obj1, &val2);
43567 if (!SWIG_IsOK(ecode2)) {
43568 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "2"" of type '" "bool""'");
43569 }
43570 arg2 = static_cast< bool >(val2);
43571 }
43572 {
43573 PyThreadState* __tstate = wxPyBeginAllowThreads();
43574 (arg1)->SetOwnerDrawn(arg2);
43575 wxPyEndAllowThreads(__tstate);
43576 if (PyErr_Occurred()) SWIG_fail;
43577 }
43578 resultobj = SWIG_Py_Void();
43579 return resultobj;
43580 fail:
43581 return NULL;
43582 }
43583
43584
43585 SWIGINTERN PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43586 PyObject *resultobj = 0;
43587 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43588 void *argp1 = 0 ;
43589 int res1 = 0 ;
43590 PyObject *swig_obj[1] ;
43591
43592 if (!args) SWIG_fail;
43593 swig_obj[0] = args;
43594 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43595 if (!SWIG_IsOK(res1)) {
43596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_ResetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43597 }
43598 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43599 {
43600 PyThreadState* __tstate = wxPyBeginAllowThreads();
43601 (arg1)->ResetOwnerDrawn();
43602 wxPyEndAllowThreads(__tstate);
43603 if (PyErr_Occurred()) SWIG_fail;
43604 }
43605 resultobj = SWIG_Py_Void();
43606 return resultobj;
43607 fail:
43608 return NULL;
43609 }
43610
43611
43612 SWIGINTERN PyObject *MenuItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43613 PyObject *obj;
43614 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
43615 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuItem, SWIG_NewClientData(obj));
43616 return SWIG_Py_Void();
43617 }
43618
43619 SWIGINTERN PyObject *MenuItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43620 return SWIG_Python_InitShadowInstance(args);
43621 }
43622
43623 SWIGINTERN int ControlNameStr_set(PyObject *) {
43624 SWIG_Error(SWIG_AttributeError,"Variable ControlNameStr is read-only.");
43625 return 1;
43626 }
43627
43628
43629 SWIGINTERN PyObject *ControlNameStr_get(void) {
43630 PyObject *pyobj = 0;
43631
43632 {
43633 #if wxUSE_UNICODE
43634 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
43635 #else
43636 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
43637 #endif
43638 }
43639 return pyobj;
43640 }
43641
43642
43643 SWIGINTERN PyObject *_wrap_new_Control(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43644 PyObject *resultobj = 0;
43645 wxWindow *arg1 = (wxWindow *) 0 ;
43646 int arg2 = (int) -1 ;
43647 wxPoint const &arg3_defvalue = wxDefaultPosition ;
43648 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
43649 wxSize const &arg4_defvalue = wxDefaultSize ;
43650 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
43651 long arg5 = (long) 0 ;
43652 wxValidator const &arg6_defvalue = wxDefaultValidator ;
43653 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
43654 wxString const &arg7_defvalue = wxPyControlNameStr ;
43655 wxString *arg7 = (wxString *) &arg7_defvalue ;
43656 wxControl *result = 0 ;
43657 void *argp1 = 0 ;
43658 int res1 = 0 ;
43659 int val2 ;
43660 int ecode2 = 0 ;
43661 wxPoint temp3 ;
43662 wxSize temp4 ;
43663 long val5 ;
43664 int ecode5 = 0 ;
43665 void *argp6 = 0 ;
43666 int res6 = 0 ;
43667 bool temp7 = false ;
43668 PyObject * obj0 = 0 ;
43669 PyObject * obj1 = 0 ;
43670 PyObject * obj2 = 0 ;
43671 PyObject * obj3 = 0 ;
43672 PyObject * obj4 = 0 ;
43673 PyObject * obj5 = 0 ;
43674 PyObject * obj6 = 0 ;
43675 char * kwnames[] = {
43676 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
43677 };
43678
43679 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
43680 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
43681 if (!SWIG_IsOK(res1)) {
43682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Control" "', expected argument " "1"" of type '" "wxWindow *""'");
43683 }
43684 arg1 = reinterpret_cast< wxWindow * >(argp1);
43685 if (obj1) {
43686 ecode2 = SWIG_AsVal_int(obj1, &val2);
43687 if (!SWIG_IsOK(ecode2)) {
43688 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Control" "', expected argument " "2"" of type '" "int""'");
43689 }
43690 arg2 = static_cast< int >(val2);
43691 }
43692 if (obj2) {
43693 {
43694 arg3 = &temp3;
43695 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
43696 }
43697 }
43698 if (obj3) {
43699 {
43700 arg4 = &temp4;
43701 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
43702 }
43703 }
43704 if (obj4) {
43705 ecode5 = SWIG_AsVal_long(obj4, &val5);
43706 if (!SWIG_IsOK(ecode5)) {
43707 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Control" "', expected argument " "5"" of type '" "long""'");
43708 }
43709 arg5 = static_cast< long >(val5);
43710 }
43711 if (obj5) {
43712 res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_wxValidator, 0 | 0);
43713 if (!SWIG_IsOK(res6)) {
43714 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
43715 }
43716 if (!argp6) {
43717 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
43718 }
43719 arg6 = reinterpret_cast< wxValidator * >(argp6);
43720 }
43721 if (obj6) {
43722 {
43723 arg7 = wxString_in_helper(obj6);
43724 if (arg7 == NULL) SWIG_fail;
43725 temp7 = true;
43726 }
43727 }
43728 {
43729 if (!wxPyCheckForApp()) SWIG_fail;
43730 PyThreadState* __tstate = wxPyBeginAllowThreads();
43731 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
43732 wxPyEndAllowThreads(__tstate);
43733 if (PyErr_Occurred()) SWIG_fail;
43734 }
43735 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_NEW | 0 );
43736 {
43737 if (temp7)
43738 delete arg7;
43739 }
43740 return resultobj;
43741 fail:
43742 {
43743 if (temp7)
43744 delete arg7;
43745 }
43746 return NULL;
43747 }
43748
43749
43750 SWIGINTERN PyObject *_wrap_new_PreControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43751 PyObject *resultobj = 0;
43752 wxControl *result = 0 ;
43753
43754 if (!SWIG_Python_UnpackTuple(args,"new_PreControl",0,0,0)) SWIG_fail;
43755 {
43756 if (!wxPyCheckForApp()) SWIG_fail;
43757 PyThreadState* __tstate = wxPyBeginAllowThreads();
43758 result = (wxControl *)new wxControl();
43759 wxPyEndAllowThreads(__tstate);
43760 if (PyErr_Occurred()) SWIG_fail;
43761 }
43762 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_OWN | 0 );
43763 return resultobj;
43764 fail:
43765 return NULL;
43766 }
43767
43768
43769 SWIGINTERN PyObject *_wrap_Control_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43770 PyObject *resultobj = 0;
43771 wxControl *arg1 = (wxControl *) 0 ;
43772 wxWindow *arg2 = (wxWindow *) 0 ;
43773 int arg3 = (int) -1 ;
43774 wxPoint const &arg4_defvalue = wxDefaultPosition ;
43775 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
43776 wxSize const &arg5_defvalue = wxDefaultSize ;
43777 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
43778 long arg6 = (long) 0 ;
43779 wxValidator const &arg7_defvalue = wxDefaultValidator ;
43780 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
43781 wxString const &arg8_defvalue = wxPyControlNameStr ;
43782 wxString *arg8 = (wxString *) &arg8_defvalue ;
43783 bool result;
43784 void *argp1 = 0 ;
43785 int res1 = 0 ;
43786 void *argp2 = 0 ;
43787 int res2 = 0 ;
43788 int val3 ;
43789 int ecode3 = 0 ;
43790 wxPoint temp4 ;
43791 wxSize temp5 ;
43792 long val6 ;
43793 int ecode6 = 0 ;
43794 void *argp7 = 0 ;
43795 int res7 = 0 ;
43796 bool temp8 = false ;
43797 PyObject * obj0 = 0 ;
43798 PyObject * obj1 = 0 ;
43799 PyObject * obj2 = 0 ;
43800 PyObject * obj3 = 0 ;
43801 PyObject * obj4 = 0 ;
43802 PyObject * obj5 = 0 ;
43803 PyObject * obj6 = 0 ;
43804 PyObject * obj7 = 0 ;
43805 char * kwnames[] = {
43806 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
43807 };
43808
43809 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
43810 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
43811 if (!SWIG_IsOK(res1)) {
43812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Create" "', expected argument " "1"" of type '" "wxControl *""'");
43813 }
43814 arg1 = reinterpret_cast< wxControl * >(argp1);
43815 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
43816 if (!SWIG_IsOK(res2)) {
43817 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
43818 }
43819 arg2 = reinterpret_cast< wxWindow * >(argp2);
43820 if (obj2) {
43821 ecode3 = SWIG_AsVal_int(obj2, &val3);
43822 if (!SWIG_IsOK(ecode3)) {
43823 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Control_Create" "', expected argument " "3"" of type '" "int""'");
43824 }
43825 arg3 = static_cast< int >(val3);
43826 }
43827 if (obj3) {
43828 {
43829 arg4 = &temp4;
43830 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
43831 }
43832 }
43833 if (obj4) {
43834 {
43835 arg5 = &temp5;
43836 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
43837 }
43838 }
43839 if (obj5) {
43840 ecode6 = SWIG_AsVal_long(obj5, &val6);
43841 if (!SWIG_IsOK(ecode6)) {
43842 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Control_Create" "', expected argument " "6"" of type '" "long""'");
43843 }
43844 arg6 = static_cast< long >(val6);
43845 }
43846 if (obj6) {
43847 res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator, 0 | 0);
43848 if (!SWIG_IsOK(res7)) {
43849 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
43850 }
43851 if (!argp7) {
43852 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
43853 }
43854 arg7 = reinterpret_cast< wxValidator * >(argp7);
43855 }
43856 if (obj7) {
43857 {
43858 arg8 = wxString_in_helper(obj7);
43859 if (arg8 == NULL) SWIG_fail;
43860 temp8 = true;
43861 }
43862 }
43863 {
43864 PyThreadState* __tstate = wxPyBeginAllowThreads();
43865 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
43866 wxPyEndAllowThreads(__tstate);
43867 if (PyErr_Occurred()) SWIG_fail;
43868 }
43869 {
43870 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43871 }
43872 {
43873 if (temp8)
43874 delete arg8;
43875 }
43876 return resultobj;
43877 fail:
43878 {
43879 if (temp8)
43880 delete arg8;
43881 }
43882 return NULL;
43883 }
43884
43885
43886 SWIGINTERN PyObject *_wrap_Control_Command(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43887 PyObject *resultobj = 0;
43888 wxControl *arg1 = (wxControl *) 0 ;
43889 wxCommandEvent *arg2 = 0 ;
43890 void *argp1 = 0 ;
43891 int res1 = 0 ;
43892 void *argp2 = 0 ;
43893 int res2 = 0 ;
43894 PyObject * obj0 = 0 ;
43895 PyObject * obj1 = 0 ;
43896 char * kwnames[] = {
43897 (char *) "self",(char *) "event", NULL
43898 };
43899
43900 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) SWIG_fail;
43901 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
43902 if (!SWIG_IsOK(res1)) {
43903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Command" "', expected argument " "1"" of type '" "wxControl *""'");
43904 }
43905 arg1 = reinterpret_cast< wxControl * >(argp1);
43906 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCommandEvent, 0 );
43907 if (!SWIG_IsOK(res2)) {
43908 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
43909 }
43910 if (!argp2) {
43911 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
43912 }
43913 arg2 = reinterpret_cast< wxCommandEvent * >(argp2);
43914 {
43915 PyThreadState* __tstate = wxPyBeginAllowThreads();
43916 (arg1)->Command(*arg2);
43917 wxPyEndAllowThreads(__tstate);
43918 if (PyErr_Occurred()) SWIG_fail;
43919 }
43920 resultobj = SWIG_Py_Void();
43921 return resultobj;
43922 fail:
43923 return NULL;
43924 }
43925
43926
43927 SWIGINTERN PyObject *_wrap_Control_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43928 PyObject *resultobj = 0;
43929 wxControl *arg1 = (wxControl *) 0 ;
43930 wxString result;
43931 void *argp1 = 0 ;
43932 int res1 = 0 ;
43933 PyObject *swig_obj[1] ;
43934
43935 if (!args) SWIG_fail;
43936 swig_obj[0] = args;
43937 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
43938 if (!SWIG_IsOK(res1)) {
43939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabel" "', expected argument " "1"" of type '" "wxControl *""'");
43940 }
43941 arg1 = reinterpret_cast< wxControl * >(argp1);
43942 {
43943 PyThreadState* __tstate = wxPyBeginAllowThreads();
43944 result = (arg1)->GetLabel();
43945 wxPyEndAllowThreads(__tstate);
43946 if (PyErr_Occurred()) SWIG_fail;
43947 }
43948 {
43949 #if wxUSE_UNICODE
43950 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43951 #else
43952 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43953 #endif
43954 }
43955 return resultobj;
43956 fail:
43957 return NULL;
43958 }
43959
43960
43961 SWIGINTERN PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43962 PyObject *resultobj = 0;
43963 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
43964 SwigValueWrapper<wxVisualAttributes > result;
43965 int val1 ;
43966 int ecode1 = 0 ;
43967 PyObject * obj0 = 0 ;
43968 char * kwnames[] = {
43969 (char *) "variant", NULL
43970 };
43971
43972 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
43973 if (obj0) {
43974 ecode1 = SWIG_AsVal_int(obj0, &val1);
43975 if (!SWIG_IsOK(ecode1)) {
43976 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Control_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
43977 }
43978 arg1 = static_cast< wxWindowVariant >(val1);
43979 }
43980 {
43981 if (!wxPyCheckForApp()) SWIG_fail;
43982 PyThreadState* __tstate = wxPyBeginAllowThreads();
43983 result = wxControl::GetClassDefaultAttributes(arg1);
43984 wxPyEndAllowThreads(__tstate);
43985 if (PyErr_Occurred()) SWIG_fail;
43986 }
43987 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
43988 return resultobj;
43989 fail:
43990 return NULL;
43991 }
43992
43993
43994 SWIGINTERN PyObject *Control_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43995 PyObject *obj;
43996 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
43997 SWIG_TypeNewClientData(SWIGTYPE_p_wxControl, SWIG_NewClientData(obj));
43998 return SWIG_Py_Void();
43999 }
44000
44001 SWIGINTERN PyObject *Control_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44002 return SWIG_Python_InitShadowInstance(args);
44003 }
44004
44005 SWIGINTERN PyObject *_wrap_ItemContainer_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44006 PyObject *resultobj = 0;
44007 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44008 wxString *arg2 = 0 ;
44009 PyObject *arg3 = (PyObject *) NULL ;
44010 int result;
44011 void *argp1 = 0 ;
44012 int res1 = 0 ;
44013 bool temp2 = false ;
44014 PyObject * obj0 = 0 ;
44015 PyObject * obj1 = 0 ;
44016 PyObject * obj2 = 0 ;
44017 char * kwnames[] = {
44018 (char *) "self",(char *) "item",(char *) "clientData", NULL
44019 };
44020
44021 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44022 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44023 if (!SWIG_IsOK(res1)) {
44024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Append" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44025 }
44026 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44027 {
44028 arg2 = wxString_in_helper(obj1);
44029 if (arg2 == NULL) SWIG_fail;
44030 temp2 = true;
44031 }
44032 if (obj2) {
44033 arg3 = obj2;
44034 }
44035 {
44036 PyThreadState* __tstate = wxPyBeginAllowThreads();
44037 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
44038 wxPyEndAllowThreads(__tstate);
44039 if (PyErr_Occurred()) SWIG_fail;
44040 }
44041 resultobj = SWIG_From_int(static_cast< int >(result));
44042 {
44043 if (temp2)
44044 delete arg2;
44045 }
44046 return resultobj;
44047 fail:
44048 {
44049 if (temp2)
44050 delete arg2;
44051 }
44052 return NULL;
44053 }
44054
44055
44056 SWIGINTERN PyObject *_wrap_ItemContainer_AppendItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44057 PyObject *resultobj = 0;
44058 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44059 wxArrayString *arg2 = 0 ;
44060 void *argp1 = 0 ;
44061 int res1 = 0 ;
44062 bool temp2 = false ;
44063 PyObject * obj0 = 0 ;
44064 PyObject * obj1 = 0 ;
44065 char * kwnames[] = {
44066 (char *) "self",(char *) "strings", NULL
44067 };
44068
44069 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) SWIG_fail;
44070 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44071 if (!SWIG_IsOK(res1)) {
44072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_AppendItems" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44073 }
44074 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44075 {
44076 if (! PySequence_Check(obj1)) {
44077 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
44078 SWIG_fail;
44079 }
44080 arg2 = new wxArrayString;
44081 temp2 = true;
44082 int i, len=PySequence_Length(obj1);
44083 for (i=0; i<len; i++) {
44084 PyObject* item = PySequence_GetItem(obj1, i);
44085 wxString* s = wxString_in_helper(item);
44086 if (PyErr_Occurred()) SWIG_fail;
44087 arg2->Add(*s);
44088 delete s;
44089 Py_DECREF(item);
44090 }
44091 }
44092 {
44093 PyThreadState* __tstate = wxPyBeginAllowThreads();
44094 (arg1)->Append((wxArrayString const &)*arg2);
44095 wxPyEndAllowThreads(__tstate);
44096 if (PyErr_Occurred()) SWIG_fail;
44097 }
44098 resultobj = SWIG_Py_Void();
44099 {
44100 if (temp2) delete arg2;
44101 }
44102 return resultobj;
44103 fail:
44104 {
44105 if (temp2) delete arg2;
44106 }
44107 return NULL;
44108 }
44109
44110
44111 SWIGINTERN PyObject *_wrap_ItemContainer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44112 PyObject *resultobj = 0;
44113 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44114 wxString *arg2 = 0 ;
44115 unsigned int arg3 ;
44116 PyObject *arg4 = (PyObject *) NULL ;
44117 int result;
44118 void *argp1 = 0 ;
44119 int res1 = 0 ;
44120 bool temp2 = false ;
44121 unsigned int val3 ;
44122 int ecode3 = 0 ;
44123 PyObject * obj0 = 0 ;
44124 PyObject * obj1 = 0 ;
44125 PyObject * obj2 = 0 ;
44126 PyObject * obj3 = 0 ;
44127 char * kwnames[] = {
44128 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
44129 };
44130
44131 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
44132 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44133 if (!SWIG_IsOK(res1)) {
44134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Insert" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44135 }
44136 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44137 {
44138 arg2 = wxString_in_helper(obj1);
44139 if (arg2 == NULL) SWIG_fail;
44140 temp2 = true;
44141 }
44142 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
44143 if (!SWIG_IsOK(ecode3)) {
44144 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ItemContainer_Insert" "', expected argument " "3"" of type '" "unsigned int""'");
44145 }
44146 arg3 = static_cast< unsigned int >(val3);
44147 if (obj3) {
44148 arg4 = obj3;
44149 }
44150 {
44151 PyThreadState* __tstate = wxPyBeginAllowThreads();
44152 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
44153 wxPyEndAllowThreads(__tstate);
44154 if (PyErr_Occurred()) SWIG_fail;
44155 }
44156 resultobj = SWIG_From_int(static_cast< int >(result));
44157 {
44158 if (temp2)
44159 delete arg2;
44160 }
44161 return resultobj;
44162 fail:
44163 {
44164 if (temp2)
44165 delete arg2;
44166 }
44167 return NULL;
44168 }
44169
44170
44171 SWIGINTERN PyObject *_wrap_ItemContainer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44172 PyObject *resultobj = 0;
44173 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44174 void *argp1 = 0 ;
44175 int res1 = 0 ;
44176 PyObject *swig_obj[1] ;
44177
44178 if (!args) SWIG_fail;
44179 swig_obj[0] = args;
44180 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44181 if (!SWIG_IsOK(res1)) {
44182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Clear" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44183 }
44184 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44185 {
44186 PyThreadState* __tstate = wxPyBeginAllowThreads();
44187 (arg1)->Clear();
44188 wxPyEndAllowThreads(__tstate);
44189 if (PyErr_Occurred()) SWIG_fail;
44190 }
44191 resultobj = SWIG_Py_Void();
44192 return resultobj;
44193 fail:
44194 return NULL;
44195 }
44196
44197
44198 SWIGINTERN PyObject *_wrap_ItemContainer_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44199 PyObject *resultobj = 0;
44200 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44201 unsigned int arg2 ;
44202 void *argp1 = 0 ;
44203 int res1 = 0 ;
44204 unsigned int val2 ;
44205 int ecode2 = 0 ;
44206 PyObject * obj0 = 0 ;
44207 PyObject * obj1 = 0 ;
44208 char * kwnames[] = {
44209 (char *) "self",(char *) "n", NULL
44210 };
44211
44212 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
44213 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44214 if (!SWIG_IsOK(res1)) {
44215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Delete" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44216 }
44217 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44218 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44219 if (!SWIG_IsOK(ecode2)) {
44220 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Delete" "', expected argument " "2"" of type '" "unsigned int""'");
44221 }
44222 arg2 = static_cast< unsigned int >(val2);
44223 {
44224 PyThreadState* __tstate = wxPyBeginAllowThreads();
44225 (arg1)->Delete(arg2);
44226 wxPyEndAllowThreads(__tstate);
44227 if (PyErr_Occurred()) SWIG_fail;
44228 }
44229 resultobj = SWIG_Py_Void();
44230 return resultobj;
44231 fail:
44232 return NULL;
44233 }
44234
44235
44236 SWIGINTERN PyObject *_wrap_ItemContainer_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44237 PyObject *resultobj = 0;
44238 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44239 unsigned int arg2 ;
44240 PyObject *result = 0 ;
44241 void *argp1 = 0 ;
44242 int res1 = 0 ;
44243 unsigned int val2 ;
44244 int ecode2 = 0 ;
44245 PyObject * obj0 = 0 ;
44246 PyObject * obj1 = 0 ;
44247 char * kwnames[] = {
44248 (char *) "self",(char *) "n", NULL
44249 };
44250
44251 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
44252 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44253 if (!SWIG_IsOK(res1)) {
44254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44255 }
44256 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44257 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44258 if (!SWIG_IsOK(ecode2)) {
44259 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
44260 }
44261 arg2 = static_cast< unsigned int >(val2);
44262 {
44263 PyThreadState* __tstate = wxPyBeginAllowThreads();
44264 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
44265 wxPyEndAllowThreads(__tstate);
44266 if (PyErr_Occurred()) SWIG_fail;
44267 }
44268 resultobj = result;
44269 return resultobj;
44270 fail:
44271 return NULL;
44272 }
44273
44274
44275 SWIGINTERN PyObject *_wrap_ItemContainer_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44276 PyObject *resultobj = 0;
44277 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44278 unsigned int arg2 ;
44279 PyObject *arg3 = (PyObject *) 0 ;
44280 void *argp1 = 0 ;
44281 int res1 = 0 ;
44282 unsigned int val2 ;
44283 int ecode2 = 0 ;
44284 PyObject * obj0 = 0 ;
44285 PyObject * obj1 = 0 ;
44286 PyObject * obj2 = 0 ;
44287 char * kwnames[] = {
44288 (char *) "self",(char *) "n",(char *) "clientData", NULL
44289 };
44290
44291 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44292 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44293 if (!SWIG_IsOK(res1)) {
44294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44295 }
44296 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44297 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44298 if (!SWIG_IsOK(ecode2)) {
44299 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
44300 }
44301 arg2 = static_cast< unsigned int >(val2);
44302 arg3 = obj2;
44303 {
44304 PyThreadState* __tstate = wxPyBeginAllowThreads();
44305 wxItemContainer_SetClientData(arg1,arg2,arg3);
44306 wxPyEndAllowThreads(__tstate);
44307 if (PyErr_Occurred()) SWIG_fail;
44308 }
44309 resultobj = SWIG_Py_Void();
44310 return resultobj;
44311 fail:
44312 return NULL;
44313 }
44314
44315
44316 SWIGINTERN PyObject *_wrap_ItemContainer_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44317 PyObject *resultobj = 0;
44318 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44319 unsigned int result;
44320 void *argp1 = 0 ;
44321 int res1 = 0 ;
44322 PyObject *swig_obj[1] ;
44323
44324 if (!args) SWIG_fail;
44325 swig_obj[0] = args;
44326 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44327 if (!SWIG_IsOK(res1)) {
44328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetCount" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44329 }
44330 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44331 {
44332 PyThreadState* __tstate = wxPyBeginAllowThreads();
44333 result = (unsigned int)((wxItemContainer const *)arg1)->GetCount();
44334 wxPyEndAllowThreads(__tstate);
44335 if (PyErr_Occurred()) SWIG_fail;
44336 }
44337 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
44338 return resultobj;
44339 fail:
44340 return NULL;
44341 }
44342
44343
44344 SWIGINTERN PyObject *_wrap_ItemContainer_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44345 PyObject *resultobj = 0;
44346 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44347 bool result;
44348 void *argp1 = 0 ;
44349 int res1 = 0 ;
44350 PyObject *swig_obj[1] ;
44351
44352 if (!args) SWIG_fail;
44353 swig_obj[0] = args;
44354 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44355 if (!SWIG_IsOK(res1)) {
44356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_IsEmpty" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44357 }
44358 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44359 {
44360 PyThreadState* __tstate = wxPyBeginAllowThreads();
44361 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
44362 wxPyEndAllowThreads(__tstate);
44363 if (PyErr_Occurred()) SWIG_fail;
44364 }
44365 {
44366 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44367 }
44368 return resultobj;
44369 fail:
44370 return NULL;
44371 }
44372
44373
44374 SWIGINTERN PyObject *_wrap_ItemContainer_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44375 PyObject *resultobj = 0;
44376 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44377 unsigned int arg2 ;
44378 wxString result;
44379 void *argp1 = 0 ;
44380 int res1 = 0 ;
44381 unsigned int val2 ;
44382 int ecode2 = 0 ;
44383 PyObject * obj0 = 0 ;
44384 PyObject * obj1 = 0 ;
44385 char * kwnames[] = {
44386 (char *) "self",(char *) "n", NULL
44387 };
44388
44389 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) SWIG_fail;
44390 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44391 if (!SWIG_IsOK(res1)) {
44392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44393 }
44394 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44395 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44396 if (!SWIG_IsOK(ecode2)) {
44397 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetString" "', expected argument " "2"" of type '" "unsigned int""'");
44398 }
44399 arg2 = static_cast< unsigned int >(val2);
44400 {
44401 PyThreadState* __tstate = wxPyBeginAllowThreads();
44402 result = ((wxItemContainer const *)arg1)->GetString(arg2);
44403 wxPyEndAllowThreads(__tstate);
44404 if (PyErr_Occurred()) SWIG_fail;
44405 }
44406 {
44407 #if wxUSE_UNICODE
44408 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44409 #else
44410 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44411 #endif
44412 }
44413 return resultobj;
44414 fail:
44415 return NULL;
44416 }
44417
44418
44419 SWIGINTERN PyObject *_wrap_ItemContainer_GetStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44420 PyObject *resultobj = 0;
44421 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44422 wxArrayString result;
44423 void *argp1 = 0 ;
44424 int res1 = 0 ;
44425 PyObject *swig_obj[1] ;
44426
44427 if (!args) SWIG_fail;
44428 swig_obj[0] = args;
44429 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44430 if (!SWIG_IsOK(res1)) {
44431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStrings" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44432 }
44433 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44434 {
44435 PyThreadState* __tstate = wxPyBeginAllowThreads();
44436 result = ((wxItemContainer const *)arg1)->GetStrings();
44437 wxPyEndAllowThreads(__tstate);
44438 if (PyErr_Occurred()) SWIG_fail;
44439 }
44440 {
44441 resultobj = wxArrayString2PyList_helper(result);
44442 }
44443 return resultobj;
44444 fail:
44445 return NULL;
44446 }
44447
44448
44449 SWIGINTERN PyObject *_wrap_ItemContainer_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44450 PyObject *resultobj = 0;
44451 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44452 unsigned int arg2 ;
44453 wxString *arg3 = 0 ;
44454 void *argp1 = 0 ;
44455 int res1 = 0 ;
44456 unsigned int val2 ;
44457 int ecode2 = 0 ;
44458 bool temp3 = false ;
44459 PyObject * obj0 = 0 ;
44460 PyObject * obj1 = 0 ;
44461 PyObject * obj2 = 0 ;
44462 char * kwnames[] = {
44463 (char *) "self",(char *) "n",(char *) "s", NULL
44464 };
44465
44466 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44467 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44468 if (!SWIG_IsOK(res1)) {
44469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetString" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44470 }
44471 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44472 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44473 if (!SWIG_IsOK(ecode2)) {
44474 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetString" "', expected argument " "2"" of type '" "unsigned int""'");
44475 }
44476 arg2 = static_cast< unsigned int >(val2);
44477 {
44478 arg3 = wxString_in_helper(obj2);
44479 if (arg3 == NULL) SWIG_fail;
44480 temp3 = true;
44481 }
44482 {
44483 PyThreadState* __tstate = wxPyBeginAllowThreads();
44484 (arg1)->SetString(arg2,(wxString const &)*arg3);
44485 wxPyEndAllowThreads(__tstate);
44486 if (PyErr_Occurred()) SWIG_fail;
44487 }
44488 resultobj = SWIG_Py_Void();
44489 {
44490 if (temp3)
44491 delete arg3;
44492 }
44493 return resultobj;
44494 fail:
44495 {
44496 if (temp3)
44497 delete arg3;
44498 }
44499 return NULL;
44500 }
44501
44502
44503 SWIGINTERN PyObject *_wrap_ItemContainer_FindString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44504 PyObject *resultobj = 0;
44505 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44506 wxString *arg2 = 0 ;
44507 int result;
44508 void *argp1 = 0 ;
44509 int res1 = 0 ;
44510 bool temp2 = false ;
44511 PyObject * obj0 = 0 ;
44512 PyObject * obj1 = 0 ;
44513 char * kwnames[] = {
44514 (char *) "self",(char *) "s", NULL
44515 };
44516
44517 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) SWIG_fail;
44518 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44519 if (!SWIG_IsOK(res1)) {
44520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_FindString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44521 }
44522 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44523 {
44524 arg2 = wxString_in_helper(obj1);
44525 if (arg2 == NULL) SWIG_fail;
44526 temp2 = true;
44527 }
44528 {
44529 PyThreadState* __tstate = wxPyBeginAllowThreads();
44530 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
44531 wxPyEndAllowThreads(__tstate);
44532 if (PyErr_Occurred()) SWIG_fail;
44533 }
44534 resultobj = SWIG_From_int(static_cast< int >(result));
44535 {
44536 if (temp2)
44537 delete arg2;
44538 }
44539 return resultobj;
44540 fail:
44541 {
44542 if (temp2)
44543 delete arg2;
44544 }
44545 return NULL;
44546 }
44547
44548
44549 SWIGINTERN PyObject *_wrap_ItemContainer_SetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44550 PyObject *resultobj = 0;
44551 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44552 int arg2 ;
44553 void *argp1 = 0 ;
44554 int res1 = 0 ;
44555 int val2 ;
44556 int ecode2 = 0 ;
44557 PyObject * obj0 = 0 ;
44558 PyObject * obj1 = 0 ;
44559 char * kwnames[] = {
44560 (char *) "self",(char *) "n", NULL
44561 };
44562
44563 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) SWIG_fail;
44564 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44565 if (!SWIG_IsOK(res1)) {
44566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44567 }
44568 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44569 ecode2 = SWIG_AsVal_int(obj1, &val2);
44570 if (!SWIG_IsOK(ecode2)) {
44571 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetSelection" "', expected argument " "2"" of type '" "int""'");
44572 }
44573 arg2 = static_cast< int >(val2);
44574 {
44575 PyThreadState* __tstate = wxPyBeginAllowThreads();
44576 (arg1)->SetSelection(arg2);
44577 wxPyEndAllowThreads(__tstate);
44578 if (PyErr_Occurred()) SWIG_fail;
44579 }
44580 resultobj = SWIG_Py_Void();
44581 return resultobj;
44582 fail:
44583 return NULL;
44584 }
44585
44586
44587 SWIGINTERN PyObject *_wrap_ItemContainer_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44588 PyObject *resultobj = 0;
44589 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44590 int result;
44591 void *argp1 = 0 ;
44592 int res1 = 0 ;
44593 PyObject *swig_obj[1] ;
44594
44595 if (!args) SWIG_fail;
44596 swig_obj[0] = args;
44597 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44598 if (!SWIG_IsOK(res1)) {
44599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44600 }
44601 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44602 {
44603 PyThreadState* __tstate = wxPyBeginAllowThreads();
44604 result = (int)((wxItemContainer const *)arg1)->GetSelection();
44605 wxPyEndAllowThreads(__tstate);
44606 if (PyErr_Occurred()) SWIG_fail;
44607 }
44608 resultobj = SWIG_From_int(static_cast< int >(result));
44609 return resultobj;
44610 fail:
44611 return NULL;
44612 }
44613
44614
44615 SWIGINTERN PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44616 PyObject *resultobj = 0;
44617 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44618 wxString *arg2 = 0 ;
44619 bool result;
44620 void *argp1 = 0 ;
44621 int res1 = 0 ;
44622 bool temp2 = false ;
44623 PyObject * obj0 = 0 ;
44624 PyObject * obj1 = 0 ;
44625 char * kwnames[] = {
44626 (char *) "self",(char *) "s", NULL
44627 };
44628
44629 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) SWIG_fail;
44630 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44631 if (!SWIG_IsOK(res1)) {
44632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44633 }
44634 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44635 {
44636 arg2 = wxString_in_helper(obj1);
44637 if (arg2 == NULL) SWIG_fail;
44638 temp2 = true;
44639 }
44640 {
44641 PyThreadState* __tstate = wxPyBeginAllowThreads();
44642 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
44643 wxPyEndAllowThreads(__tstate);
44644 if (PyErr_Occurred()) SWIG_fail;
44645 }
44646 {
44647 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44648 }
44649 {
44650 if (temp2)
44651 delete arg2;
44652 }
44653 return resultobj;
44654 fail:
44655 {
44656 if (temp2)
44657 delete arg2;
44658 }
44659 return NULL;
44660 }
44661
44662
44663 SWIGINTERN PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44664 PyObject *resultobj = 0;
44665 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44666 wxString result;
44667 void *argp1 = 0 ;
44668 int res1 = 0 ;
44669 PyObject *swig_obj[1] ;
44670
44671 if (!args) SWIG_fail;
44672 swig_obj[0] = args;
44673 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44674 if (!SWIG_IsOK(res1)) {
44675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44676 }
44677 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44678 {
44679 PyThreadState* __tstate = wxPyBeginAllowThreads();
44680 result = ((wxItemContainer const *)arg1)->GetStringSelection();
44681 wxPyEndAllowThreads(__tstate);
44682 if (PyErr_Occurred()) SWIG_fail;
44683 }
44684 {
44685 #if wxUSE_UNICODE
44686 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44687 #else
44688 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44689 #endif
44690 }
44691 return resultobj;
44692 fail:
44693 return NULL;
44694 }
44695
44696
44697 SWIGINTERN PyObject *_wrap_ItemContainer_Select(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44698 PyObject *resultobj = 0;
44699 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44700 int arg2 ;
44701 void *argp1 = 0 ;
44702 int res1 = 0 ;
44703 int val2 ;
44704 int ecode2 = 0 ;
44705 PyObject * obj0 = 0 ;
44706 PyObject * obj1 = 0 ;
44707 char * kwnames[] = {
44708 (char *) "self",(char *) "n", NULL
44709 };
44710
44711 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) SWIG_fail;
44712 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44713 if (!SWIG_IsOK(res1)) {
44714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Select" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44715 }
44716 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44717 ecode2 = SWIG_AsVal_int(obj1, &val2);
44718 if (!SWIG_IsOK(ecode2)) {
44719 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Select" "', expected argument " "2"" of type '" "int""'");
44720 }
44721 arg2 = static_cast< int >(val2);
44722 {
44723 PyThreadState* __tstate = wxPyBeginAllowThreads();
44724 (arg1)->Select(arg2);
44725 wxPyEndAllowThreads(__tstate);
44726 if (PyErr_Occurred()) SWIG_fail;
44727 }
44728 resultobj = SWIG_Py_Void();
44729 return resultobj;
44730 fail:
44731 return NULL;
44732 }
44733
44734
44735 SWIGINTERN PyObject *ItemContainer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44736 PyObject *obj;
44737 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44738 SWIG_TypeNewClientData(SWIGTYPE_p_wxItemContainer, SWIG_NewClientData(obj));
44739 return SWIG_Py_Void();
44740 }
44741
44742 SWIGINTERN PyObject *ControlWithItems_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44743 PyObject *obj;
44744 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44745 SWIG_TypeNewClientData(SWIGTYPE_p_wxControlWithItems, SWIG_NewClientData(obj));
44746 return SWIG_Py_Void();
44747 }
44748
44749 SWIGINTERN PyObject *_wrap_new_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44750 PyObject *resultobj = 0;
44751 wxSizerItem *result = 0 ;
44752
44753 if (!SWIG_Python_UnpackTuple(args,"new_SizerItem",0,0,0)) SWIG_fail;
44754 {
44755 PyThreadState* __tstate = wxPyBeginAllowThreads();
44756 result = (wxSizerItem *)new wxSizerItem();
44757 wxPyEndAllowThreads(__tstate);
44758 if (PyErr_Occurred()) SWIG_fail;
44759 }
44760 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_NEW | 0 );
44761 return resultobj;
44762 fail:
44763 return NULL;
44764 }
44765
44766
44767 SWIGINTERN PyObject *_wrap_delete_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44768 PyObject *resultobj = 0;
44769 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44770 void *argp1 = 0 ;
44771 int res1 = 0 ;
44772 PyObject *swig_obj[1] ;
44773
44774 if (!args) SWIG_fail;
44775 swig_obj[0] = args;
44776 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
44777 if (!SWIG_IsOK(res1)) {
44778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerItem" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44779 }
44780 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44781 {
44782 PyThreadState* __tstate = wxPyBeginAllowThreads();
44783 delete arg1;
44784
44785 wxPyEndAllowThreads(__tstate);
44786 if (PyErr_Occurred()) SWIG_fail;
44787 }
44788 resultobj = SWIG_Py_Void();
44789 return resultobj;
44790 fail:
44791 return NULL;
44792 }
44793
44794
44795 SWIGINTERN PyObject *_wrap_new_SizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44796 PyObject *resultobj = 0;
44797 wxWindow *arg1 = (wxWindow *) 0 ;
44798 int arg2 ;
44799 int arg3 ;
44800 int arg4 ;
44801 PyObject *arg5 = (PyObject *) NULL ;
44802 wxSizerItem *result = 0 ;
44803 void *argp1 = 0 ;
44804 int res1 = 0 ;
44805 int val2 ;
44806 int ecode2 = 0 ;
44807 int val3 ;
44808 int ecode3 = 0 ;
44809 int val4 ;
44810 int ecode4 = 0 ;
44811 PyObject * obj0 = 0 ;
44812 PyObject * obj1 = 0 ;
44813 PyObject * obj2 = 0 ;
44814 PyObject * obj3 = 0 ;
44815 PyObject * obj4 = 0 ;
44816 char * kwnames[] = {
44817 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
44818 };
44819
44820 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
44821 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
44822 if (!SWIG_IsOK(res1)) {
44823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
44824 }
44825 arg1 = reinterpret_cast< wxWindow * >(argp1);
44826 ecode2 = SWIG_AsVal_int(obj1, &val2);
44827 if (!SWIG_IsOK(ecode2)) {
44828 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemWindow" "', expected argument " "2"" of type '" "int""'");
44829 }
44830 arg2 = static_cast< int >(val2);
44831 ecode3 = SWIG_AsVal_int(obj2, &val3);
44832 if (!SWIG_IsOK(ecode3)) {
44833 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemWindow" "', expected argument " "3"" of type '" "int""'");
44834 }
44835 arg3 = static_cast< int >(val3);
44836 ecode4 = SWIG_AsVal_int(obj3, &val4);
44837 if (!SWIG_IsOK(ecode4)) {
44838 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemWindow" "', expected argument " "4"" of type '" "int""'");
44839 }
44840 arg4 = static_cast< int >(val4);
44841 if (obj4) {
44842 arg5 = obj4;
44843 }
44844 {
44845 PyThreadState* __tstate = wxPyBeginAllowThreads();
44846 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
44847 wxPyEndAllowThreads(__tstate);
44848 if (PyErr_Occurred()) SWIG_fail;
44849 }
44850 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
44851 return resultobj;
44852 fail:
44853 return NULL;
44854 }
44855
44856
44857 SWIGINTERN PyObject *_wrap_new_SizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44858 PyObject *resultobj = 0;
44859 int arg1 ;
44860 int arg2 ;
44861 int arg3 ;
44862 int arg4 ;
44863 int arg5 ;
44864 PyObject *arg6 = (PyObject *) NULL ;
44865 wxSizerItem *result = 0 ;
44866 int val1 ;
44867 int ecode1 = 0 ;
44868 int val2 ;
44869 int ecode2 = 0 ;
44870 int val3 ;
44871 int ecode3 = 0 ;
44872 int val4 ;
44873 int ecode4 = 0 ;
44874 int val5 ;
44875 int ecode5 = 0 ;
44876 PyObject * obj0 = 0 ;
44877 PyObject * obj1 = 0 ;
44878 PyObject * obj2 = 0 ;
44879 PyObject * obj3 = 0 ;
44880 PyObject * obj4 = 0 ;
44881 PyObject * obj5 = 0 ;
44882 char * kwnames[] = {
44883 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
44884 };
44885
44886 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
44887 ecode1 = SWIG_AsVal_int(obj0, &val1);
44888 if (!SWIG_IsOK(ecode1)) {
44889 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
44890 }
44891 arg1 = static_cast< int >(val1);
44892 ecode2 = SWIG_AsVal_int(obj1, &val2);
44893 if (!SWIG_IsOK(ecode2)) {
44894 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
44895 }
44896 arg2 = static_cast< int >(val2);
44897 ecode3 = SWIG_AsVal_int(obj2, &val3);
44898 if (!SWIG_IsOK(ecode3)) {
44899 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSpacer" "', expected argument " "3"" of type '" "int""'");
44900 }
44901 arg3 = static_cast< int >(val3);
44902 ecode4 = SWIG_AsVal_int(obj3, &val4);
44903 if (!SWIG_IsOK(ecode4)) {
44904 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSpacer" "', expected argument " "4"" of type '" "int""'");
44905 }
44906 arg4 = static_cast< int >(val4);
44907 ecode5 = SWIG_AsVal_int(obj4, &val5);
44908 if (!SWIG_IsOK(ecode5)) {
44909 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
44910 }
44911 arg5 = static_cast< int >(val5);
44912 if (obj5) {
44913 arg6 = obj5;
44914 }
44915 {
44916 PyThreadState* __tstate = wxPyBeginAllowThreads();
44917 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
44918 wxPyEndAllowThreads(__tstate);
44919 if (PyErr_Occurred()) SWIG_fail;
44920 }
44921 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
44922 return resultobj;
44923 fail:
44924 return NULL;
44925 }
44926
44927
44928 SWIGINTERN PyObject *_wrap_new_SizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44929 PyObject *resultobj = 0;
44930 wxSizer *arg1 = (wxSizer *) 0 ;
44931 int arg2 ;
44932 int arg3 ;
44933 int arg4 ;
44934 PyObject *arg5 = (PyObject *) NULL ;
44935 wxSizerItem *result = 0 ;
44936 int res1 = 0 ;
44937 int val2 ;
44938 int ecode2 = 0 ;
44939 int val3 ;
44940 int ecode3 = 0 ;
44941 int val4 ;
44942 int ecode4 = 0 ;
44943 PyObject * obj0 = 0 ;
44944 PyObject * obj1 = 0 ;
44945 PyObject * obj2 = 0 ;
44946 PyObject * obj3 = 0 ;
44947 PyObject * obj4 = 0 ;
44948 char * kwnames[] = {
44949 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
44950 };
44951
44952 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
44953 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
44954 if (!SWIG_IsOK(res1)) {
44955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
44956 }
44957 ecode2 = SWIG_AsVal_int(obj1, &val2);
44958 if (!SWIG_IsOK(ecode2)) {
44959 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSizer" "', expected argument " "2"" of type '" "int""'");
44960 }
44961 arg2 = static_cast< int >(val2);
44962 ecode3 = SWIG_AsVal_int(obj2, &val3);
44963 if (!SWIG_IsOK(ecode3)) {
44964 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSizer" "', expected argument " "3"" of type '" "int""'");
44965 }
44966 arg3 = static_cast< int >(val3);
44967 ecode4 = SWIG_AsVal_int(obj3, &val4);
44968 if (!SWIG_IsOK(ecode4)) {
44969 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSizer" "', expected argument " "4"" of type '" "int""'");
44970 }
44971 arg4 = static_cast< int >(val4);
44972 if (obj4) {
44973 arg5 = obj4;
44974 }
44975 {
44976 PyThreadState* __tstate = wxPyBeginAllowThreads();
44977 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
44978 wxPyEndAllowThreads(__tstate);
44979 if (PyErr_Occurred()) SWIG_fail;
44980 }
44981 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
44982 return resultobj;
44983 fail:
44984 return NULL;
44985 }
44986
44987
44988 SWIGINTERN PyObject *_wrap_SizerItem_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44989 PyObject *resultobj = 0;
44990 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44991 void *argp1 = 0 ;
44992 int res1 = 0 ;
44993 PyObject *swig_obj[1] ;
44994
44995 if (!args) SWIG_fail;
44996 swig_obj[0] = args;
44997 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
44998 if (!SWIG_IsOK(res1)) {
44999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DeleteWindows" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45000 }
45001 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45002 {
45003 PyThreadState* __tstate = wxPyBeginAllowThreads();
45004 (arg1)->DeleteWindows();
45005 wxPyEndAllowThreads(__tstate);
45006 if (PyErr_Occurred()) SWIG_fail;
45007 }
45008 resultobj = SWIG_Py_Void();
45009 return resultobj;
45010 fail:
45011 return NULL;
45012 }
45013
45014
45015 SWIGINTERN PyObject *_wrap_SizerItem_DetachSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45016 PyObject *resultobj = 0;
45017 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45018 void *argp1 = 0 ;
45019 int res1 = 0 ;
45020 PyObject *swig_obj[1] ;
45021
45022 if (!args) SWIG_fail;
45023 swig_obj[0] = args;
45024 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45025 if (!SWIG_IsOK(res1)) {
45026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DetachSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45027 }
45028 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45029 {
45030 PyThreadState* __tstate = wxPyBeginAllowThreads();
45031 (arg1)->DetachSizer();
45032 wxPyEndAllowThreads(__tstate);
45033 if (PyErr_Occurred()) SWIG_fail;
45034 }
45035 resultobj = SWIG_Py_Void();
45036 return resultobj;
45037 fail:
45038 return NULL;
45039 }
45040
45041
45042 SWIGINTERN PyObject *_wrap_SizerItem_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45043 PyObject *resultobj = 0;
45044 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45045 wxSize result;
45046 void *argp1 = 0 ;
45047 int res1 = 0 ;
45048 PyObject *swig_obj[1] ;
45049
45050 if (!args) SWIG_fail;
45051 swig_obj[0] = args;
45052 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45053 if (!SWIG_IsOK(res1)) {
45054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45055 }
45056 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45057 {
45058 PyThreadState* __tstate = wxPyBeginAllowThreads();
45059 result = (arg1)->GetSize();
45060 wxPyEndAllowThreads(__tstate);
45061 if (PyErr_Occurred()) SWIG_fail;
45062 }
45063 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45064 return resultobj;
45065 fail:
45066 return NULL;
45067 }
45068
45069
45070 SWIGINTERN PyObject *_wrap_SizerItem_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45071 PyObject *resultobj = 0;
45072 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45073 wxSize result;
45074 void *argp1 = 0 ;
45075 int res1 = 0 ;
45076 PyObject *swig_obj[1] ;
45077
45078 if (!args) SWIG_fail;
45079 swig_obj[0] = args;
45080 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45081 if (!SWIG_IsOK(res1)) {
45082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_CalcMin" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45083 }
45084 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45085 {
45086 PyThreadState* __tstate = wxPyBeginAllowThreads();
45087 result = (arg1)->CalcMin();
45088 wxPyEndAllowThreads(__tstate);
45089 if (PyErr_Occurred()) SWIG_fail;
45090 }
45091 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45092 return resultobj;
45093 fail:
45094 return NULL;
45095 }
45096
45097
45098 SWIGINTERN PyObject *_wrap_SizerItem_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45099 PyObject *resultobj = 0;
45100 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45101 wxPoint *arg2 = 0 ;
45102 wxSize *arg3 = 0 ;
45103 void *argp1 = 0 ;
45104 int res1 = 0 ;
45105 wxPoint temp2 ;
45106 wxSize temp3 ;
45107 PyObject * obj0 = 0 ;
45108 PyObject * obj1 = 0 ;
45109 PyObject * obj2 = 0 ;
45110 char * kwnames[] = {
45111 (char *) "self",(char *) "pos",(char *) "size", NULL
45112 };
45113
45114 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45115 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45116 if (!SWIG_IsOK(res1)) {
45117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetDimension" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45118 }
45119 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45120 {
45121 arg2 = &temp2;
45122 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
45123 }
45124 {
45125 arg3 = &temp3;
45126 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
45127 }
45128 {
45129 PyThreadState* __tstate = wxPyBeginAllowThreads();
45130 (arg1)->SetDimension((wxPoint const &)*arg2,(wxSize const &)*arg3);
45131 wxPyEndAllowThreads(__tstate);
45132 if (PyErr_Occurred()) SWIG_fail;
45133 }
45134 resultobj = SWIG_Py_Void();
45135 return resultobj;
45136 fail:
45137 return NULL;
45138 }
45139
45140
45141 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45142 PyObject *resultobj = 0;
45143 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45144 wxSize result;
45145 void *argp1 = 0 ;
45146 int res1 = 0 ;
45147 PyObject *swig_obj[1] ;
45148
45149 if (!args) SWIG_fail;
45150 swig_obj[0] = args;
45151 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45152 if (!SWIG_IsOK(res1)) {
45153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45154 }
45155 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45156 {
45157 PyThreadState* __tstate = wxPyBeginAllowThreads();
45158 result = (arg1)->GetMinSize();
45159 wxPyEndAllowThreads(__tstate);
45160 if (PyErr_Occurred()) SWIG_fail;
45161 }
45162 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45163 return resultobj;
45164 fail:
45165 return NULL;
45166 }
45167
45168
45169 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45170 PyObject *resultobj = 0;
45171 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45172 wxSize result;
45173 void *argp1 = 0 ;
45174 int res1 = 0 ;
45175 PyObject *swig_obj[1] ;
45176
45177 if (!args) SWIG_fail;
45178 swig_obj[0] = args;
45179 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45180 if (!SWIG_IsOK(res1)) {
45181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSizeWithBorder" "', expected argument " "1"" of type '" "wxSizerItem const *""'");
45182 }
45183 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45184 {
45185 PyThreadState* __tstate = wxPyBeginAllowThreads();
45186 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
45187 wxPyEndAllowThreads(__tstate);
45188 if (PyErr_Occurred()) SWIG_fail;
45189 }
45190 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45191 return resultobj;
45192 fail:
45193 return NULL;
45194 }
45195
45196
45197 SWIGINTERN PyObject *_wrap_SizerItem_SetInitSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45198 PyObject *resultobj = 0;
45199 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45200 int arg2 ;
45201 int arg3 ;
45202 void *argp1 = 0 ;
45203 int res1 = 0 ;
45204 int val2 ;
45205 int ecode2 = 0 ;
45206 int val3 ;
45207 int ecode3 = 0 ;
45208 PyObject * obj0 = 0 ;
45209 PyObject * obj1 = 0 ;
45210 PyObject * obj2 = 0 ;
45211 char * kwnames[] = {
45212 (char *) "self",(char *) "x",(char *) "y", NULL
45213 };
45214
45215 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45216 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45217 if (!SWIG_IsOK(res1)) {
45218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetInitSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45219 }
45220 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45221 ecode2 = SWIG_AsVal_int(obj1, &val2);
45222 if (!SWIG_IsOK(ecode2)) {
45223 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetInitSize" "', expected argument " "2"" of type '" "int""'");
45224 }
45225 arg2 = static_cast< int >(val2);
45226 ecode3 = SWIG_AsVal_int(obj2, &val3);
45227 if (!SWIG_IsOK(ecode3)) {
45228 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetInitSize" "', expected argument " "3"" of type '" "int""'");
45229 }
45230 arg3 = static_cast< int >(val3);
45231 {
45232 PyThreadState* __tstate = wxPyBeginAllowThreads();
45233 (arg1)->SetInitSize(arg2,arg3);
45234 wxPyEndAllowThreads(__tstate);
45235 if (PyErr_Occurred()) SWIG_fail;
45236 }
45237 resultobj = SWIG_Py_Void();
45238 return resultobj;
45239 fail:
45240 return NULL;
45241 }
45242
45243
45244 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45245 PyObject *resultobj = 0;
45246 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45247 int arg2 ;
45248 int arg3 ;
45249 void *argp1 = 0 ;
45250 int res1 = 0 ;
45251 int val2 ;
45252 int ecode2 = 0 ;
45253 int val3 ;
45254 int ecode3 = 0 ;
45255 PyObject * obj0 = 0 ;
45256 PyObject * obj1 = 0 ;
45257 PyObject * obj2 = 0 ;
45258 char * kwnames[] = {
45259 (char *) "self",(char *) "width",(char *) "height", NULL
45260 };
45261
45262 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45263 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45264 if (!SWIG_IsOK(res1)) {
45265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioWH" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45266 }
45267 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45268 ecode2 = SWIG_AsVal_int(obj1, &val2);
45269 if (!SWIG_IsOK(ecode2)) {
45270 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatioWH" "', expected argument " "2"" of type '" "int""'");
45271 }
45272 arg2 = static_cast< int >(val2);
45273 ecode3 = SWIG_AsVal_int(obj2, &val3);
45274 if (!SWIG_IsOK(ecode3)) {
45275 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetRatioWH" "', expected argument " "3"" of type '" "int""'");
45276 }
45277 arg3 = static_cast< int >(val3);
45278 {
45279 PyThreadState* __tstate = wxPyBeginAllowThreads();
45280 (arg1)->SetRatio(arg2,arg3);
45281 wxPyEndAllowThreads(__tstate);
45282 if (PyErr_Occurred()) SWIG_fail;
45283 }
45284 resultobj = SWIG_Py_Void();
45285 return resultobj;
45286 fail:
45287 return NULL;
45288 }
45289
45290
45291 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45292 PyObject *resultobj = 0;
45293 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45294 wxSize *arg2 = 0 ;
45295 void *argp1 = 0 ;
45296 int res1 = 0 ;
45297 wxSize temp2 ;
45298 PyObject * obj0 = 0 ;
45299 PyObject * obj1 = 0 ;
45300 char * kwnames[] = {
45301 (char *) "self",(char *) "size", NULL
45302 };
45303
45304 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) SWIG_fail;
45305 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45306 if (!SWIG_IsOK(res1)) {
45307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45308 }
45309 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45310 {
45311 arg2 = &temp2;
45312 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
45313 }
45314 {
45315 PyThreadState* __tstate = wxPyBeginAllowThreads();
45316 (arg1)->SetRatio((wxSize const &)*arg2);
45317 wxPyEndAllowThreads(__tstate);
45318 if (PyErr_Occurred()) SWIG_fail;
45319 }
45320 resultobj = SWIG_Py_Void();
45321 return resultobj;
45322 fail:
45323 return NULL;
45324 }
45325
45326
45327 SWIGINTERN PyObject *_wrap_SizerItem_SetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45328 PyObject *resultobj = 0;
45329 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45330 float arg2 ;
45331 void *argp1 = 0 ;
45332 int res1 = 0 ;
45333 float val2 ;
45334 int ecode2 = 0 ;
45335 PyObject * obj0 = 0 ;
45336 PyObject * obj1 = 0 ;
45337 char * kwnames[] = {
45338 (char *) "self",(char *) "ratio", NULL
45339 };
45340
45341 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) SWIG_fail;
45342 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45343 if (!SWIG_IsOK(res1)) {
45344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45345 }
45346 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45347 ecode2 = SWIG_AsVal_float(obj1, &val2);
45348 if (!SWIG_IsOK(ecode2)) {
45349 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatio" "', expected argument " "2"" of type '" "float""'");
45350 }
45351 arg2 = static_cast< float >(val2);
45352 {
45353 PyThreadState* __tstate = wxPyBeginAllowThreads();
45354 (arg1)->SetRatio(arg2);
45355 wxPyEndAllowThreads(__tstate);
45356 if (PyErr_Occurred()) SWIG_fail;
45357 }
45358 resultobj = SWIG_Py_Void();
45359 return resultobj;
45360 fail:
45361 return NULL;
45362 }
45363
45364
45365 SWIGINTERN PyObject *_wrap_SizerItem_GetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45366 PyObject *resultobj = 0;
45367 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45368 float result;
45369 void *argp1 = 0 ;
45370 int res1 = 0 ;
45371 PyObject *swig_obj[1] ;
45372
45373 if (!args) SWIG_fail;
45374 swig_obj[0] = args;
45375 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45376 if (!SWIG_IsOK(res1)) {
45377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45378 }
45379 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45380 {
45381 PyThreadState* __tstate = wxPyBeginAllowThreads();
45382 result = (float)(arg1)->GetRatio();
45383 wxPyEndAllowThreads(__tstate);
45384 if (PyErr_Occurred()) SWIG_fail;
45385 }
45386 resultobj = SWIG_From_float(static_cast< float >(result));
45387 return resultobj;
45388 fail:
45389 return NULL;
45390 }
45391
45392
45393 SWIGINTERN PyObject *_wrap_SizerItem_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45394 PyObject *resultobj = 0;
45395 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45396 wxRect result;
45397 void *argp1 = 0 ;
45398 int res1 = 0 ;
45399 PyObject *swig_obj[1] ;
45400
45401 if (!args) SWIG_fail;
45402 swig_obj[0] = args;
45403 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45404 if (!SWIG_IsOK(res1)) {
45405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRect" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45406 }
45407 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45408 {
45409 PyThreadState* __tstate = wxPyBeginAllowThreads();
45410 result = (arg1)->GetRect();
45411 wxPyEndAllowThreads(__tstate);
45412 if (PyErr_Occurred()) SWIG_fail;
45413 }
45414 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
45415 return resultobj;
45416 fail:
45417 return NULL;
45418 }
45419
45420
45421 SWIGINTERN PyObject *_wrap_SizerItem_IsWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45422 PyObject *resultobj = 0;
45423 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45424 bool result;
45425 void *argp1 = 0 ;
45426 int res1 = 0 ;
45427 PyObject *swig_obj[1] ;
45428
45429 if (!args) SWIG_fail;
45430 swig_obj[0] = args;
45431 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45432 if (!SWIG_IsOK(res1)) {
45433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45434 }
45435 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45436 {
45437 PyThreadState* __tstate = wxPyBeginAllowThreads();
45438 result = (bool)(arg1)->IsWindow();
45439 wxPyEndAllowThreads(__tstate);
45440 if (PyErr_Occurred()) SWIG_fail;
45441 }
45442 {
45443 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45444 }
45445 return resultobj;
45446 fail:
45447 return NULL;
45448 }
45449
45450
45451 SWIGINTERN PyObject *_wrap_SizerItem_IsSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45452 PyObject *resultobj = 0;
45453 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45454 bool result;
45455 void *argp1 = 0 ;
45456 int res1 = 0 ;
45457 PyObject *swig_obj[1] ;
45458
45459 if (!args) SWIG_fail;
45460 swig_obj[0] = args;
45461 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45462 if (!SWIG_IsOK(res1)) {
45463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45464 }
45465 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45466 {
45467 PyThreadState* __tstate = wxPyBeginAllowThreads();
45468 result = (bool)(arg1)->IsSizer();
45469 wxPyEndAllowThreads(__tstate);
45470 if (PyErr_Occurred()) SWIG_fail;
45471 }
45472 {
45473 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45474 }
45475 return resultobj;
45476 fail:
45477 return NULL;
45478 }
45479
45480
45481 SWIGINTERN PyObject *_wrap_SizerItem_IsSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45482 PyObject *resultobj = 0;
45483 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45484 bool result;
45485 void *argp1 = 0 ;
45486 int res1 = 0 ;
45487 PyObject *swig_obj[1] ;
45488
45489 if (!args) SWIG_fail;
45490 swig_obj[0] = args;
45491 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45492 if (!SWIG_IsOK(res1)) {
45493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45494 }
45495 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45496 {
45497 PyThreadState* __tstate = wxPyBeginAllowThreads();
45498 result = (bool)(arg1)->IsSpacer();
45499 wxPyEndAllowThreads(__tstate);
45500 if (PyErr_Occurred()) SWIG_fail;
45501 }
45502 {
45503 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45504 }
45505 return resultobj;
45506 fail:
45507 return NULL;
45508 }
45509
45510
45511 SWIGINTERN PyObject *_wrap_SizerItem_SetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45512 PyObject *resultobj = 0;
45513 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45514 int arg2 ;
45515 void *argp1 = 0 ;
45516 int res1 = 0 ;
45517 int val2 ;
45518 int ecode2 = 0 ;
45519 PyObject * obj0 = 0 ;
45520 PyObject * obj1 = 0 ;
45521 char * kwnames[] = {
45522 (char *) "self",(char *) "proportion", NULL
45523 };
45524
45525 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) SWIG_fail;
45526 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45527 if (!SWIG_IsOK(res1)) {
45528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45529 }
45530 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45531 ecode2 = SWIG_AsVal_int(obj1, &val2);
45532 if (!SWIG_IsOK(ecode2)) {
45533 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetProportion" "', expected argument " "2"" of type '" "int""'");
45534 }
45535 arg2 = static_cast< int >(val2);
45536 {
45537 PyThreadState* __tstate = wxPyBeginAllowThreads();
45538 (arg1)->SetProportion(arg2);
45539 wxPyEndAllowThreads(__tstate);
45540 if (PyErr_Occurred()) SWIG_fail;
45541 }
45542 resultobj = SWIG_Py_Void();
45543 return resultobj;
45544 fail:
45545 return NULL;
45546 }
45547
45548
45549 SWIGINTERN PyObject *_wrap_SizerItem_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45550 PyObject *resultobj = 0;
45551 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45552 int result;
45553 void *argp1 = 0 ;
45554 int res1 = 0 ;
45555 PyObject *swig_obj[1] ;
45556
45557 if (!args) SWIG_fail;
45558 swig_obj[0] = args;
45559 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45560 if (!SWIG_IsOK(res1)) {
45561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45562 }
45563 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45564 {
45565 PyThreadState* __tstate = wxPyBeginAllowThreads();
45566 result = (int)(arg1)->GetProportion();
45567 wxPyEndAllowThreads(__tstate);
45568 if (PyErr_Occurred()) SWIG_fail;
45569 }
45570 resultobj = SWIG_From_int(static_cast< int >(result));
45571 return resultobj;
45572 fail:
45573 return NULL;
45574 }
45575
45576
45577 SWIGINTERN PyObject *_wrap_SizerItem_SetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45578 PyObject *resultobj = 0;
45579 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45580 int arg2 ;
45581 void *argp1 = 0 ;
45582 int res1 = 0 ;
45583 int val2 ;
45584 int ecode2 = 0 ;
45585 PyObject * obj0 = 0 ;
45586 PyObject * obj1 = 0 ;
45587 char * kwnames[] = {
45588 (char *) "self",(char *) "flag", NULL
45589 };
45590
45591 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) SWIG_fail;
45592 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45593 if (!SWIG_IsOK(res1)) {
45594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45595 }
45596 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45597 ecode2 = SWIG_AsVal_int(obj1, &val2);
45598 if (!SWIG_IsOK(ecode2)) {
45599 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetFlag" "', expected argument " "2"" of type '" "int""'");
45600 }
45601 arg2 = static_cast< int >(val2);
45602 {
45603 PyThreadState* __tstate = wxPyBeginAllowThreads();
45604 (arg1)->SetFlag(arg2);
45605 wxPyEndAllowThreads(__tstate);
45606 if (PyErr_Occurred()) SWIG_fail;
45607 }
45608 resultobj = SWIG_Py_Void();
45609 return resultobj;
45610 fail:
45611 return NULL;
45612 }
45613
45614
45615 SWIGINTERN PyObject *_wrap_SizerItem_GetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45616 PyObject *resultobj = 0;
45617 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45618 int result;
45619 void *argp1 = 0 ;
45620 int res1 = 0 ;
45621 PyObject *swig_obj[1] ;
45622
45623 if (!args) SWIG_fail;
45624 swig_obj[0] = args;
45625 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45626 if (!SWIG_IsOK(res1)) {
45627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45628 }
45629 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45630 {
45631 PyThreadState* __tstate = wxPyBeginAllowThreads();
45632 result = (int)(arg1)->GetFlag();
45633 wxPyEndAllowThreads(__tstate);
45634 if (PyErr_Occurred()) SWIG_fail;
45635 }
45636 resultobj = SWIG_From_int(static_cast< int >(result));
45637 return resultobj;
45638 fail:
45639 return NULL;
45640 }
45641
45642
45643 SWIGINTERN PyObject *_wrap_SizerItem_SetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45644 PyObject *resultobj = 0;
45645 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45646 int arg2 ;
45647 void *argp1 = 0 ;
45648 int res1 = 0 ;
45649 int val2 ;
45650 int ecode2 = 0 ;
45651 PyObject * obj0 = 0 ;
45652 PyObject * obj1 = 0 ;
45653 char * kwnames[] = {
45654 (char *) "self",(char *) "border", NULL
45655 };
45656
45657 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) SWIG_fail;
45658 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45659 if (!SWIG_IsOK(res1)) {
45660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45661 }
45662 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45663 ecode2 = SWIG_AsVal_int(obj1, &val2);
45664 if (!SWIG_IsOK(ecode2)) {
45665 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetBorder" "', expected argument " "2"" of type '" "int""'");
45666 }
45667 arg2 = static_cast< int >(val2);
45668 {
45669 PyThreadState* __tstate = wxPyBeginAllowThreads();
45670 (arg1)->SetBorder(arg2);
45671 wxPyEndAllowThreads(__tstate);
45672 if (PyErr_Occurred()) SWIG_fail;
45673 }
45674 resultobj = SWIG_Py_Void();
45675 return resultobj;
45676 fail:
45677 return NULL;
45678 }
45679
45680
45681 SWIGINTERN PyObject *_wrap_SizerItem_GetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45682 PyObject *resultobj = 0;
45683 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45684 int result;
45685 void *argp1 = 0 ;
45686 int res1 = 0 ;
45687 PyObject *swig_obj[1] ;
45688
45689 if (!args) SWIG_fail;
45690 swig_obj[0] = args;
45691 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45692 if (!SWIG_IsOK(res1)) {
45693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45694 }
45695 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45696 {
45697 PyThreadState* __tstate = wxPyBeginAllowThreads();
45698 result = (int)(arg1)->GetBorder();
45699 wxPyEndAllowThreads(__tstate);
45700 if (PyErr_Occurred()) SWIG_fail;
45701 }
45702 resultobj = SWIG_From_int(static_cast< int >(result));
45703 return resultobj;
45704 fail:
45705 return NULL;
45706 }
45707
45708
45709 SWIGINTERN PyObject *_wrap_SizerItem_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45710 PyObject *resultobj = 0;
45711 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45712 wxWindow *result = 0 ;
45713 void *argp1 = 0 ;
45714 int res1 = 0 ;
45715 PyObject *swig_obj[1] ;
45716
45717 if (!args) SWIG_fail;
45718 swig_obj[0] = args;
45719 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45720 if (!SWIG_IsOK(res1)) {
45721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45722 }
45723 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45724 {
45725 PyThreadState* __tstate = wxPyBeginAllowThreads();
45726 result = (wxWindow *)(arg1)->GetWindow();
45727 wxPyEndAllowThreads(__tstate);
45728 if (PyErr_Occurred()) SWIG_fail;
45729 }
45730 {
45731 resultobj = wxPyMake_wxObject(result, 0);
45732 }
45733 return resultobj;
45734 fail:
45735 return NULL;
45736 }
45737
45738
45739 SWIGINTERN PyObject *_wrap_SizerItem_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45740 PyObject *resultobj = 0;
45741 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45742 wxWindow *arg2 = (wxWindow *) 0 ;
45743 void *argp1 = 0 ;
45744 int res1 = 0 ;
45745 void *argp2 = 0 ;
45746 int res2 = 0 ;
45747 PyObject * obj0 = 0 ;
45748 PyObject * obj1 = 0 ;
45749 char * kwnames[] = {
45750 (char *) "self",(char *) "window", NULL
45751 };
45752
45753 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
45754 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45755 if (!SWIG_IsOK(res1)) {
45756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45757 }
45758 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45759 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
45760 if (!SWIG_IsOK(res2)) {
45761 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
45762 }
45763 arg2 = reinterpret_cast< wxWindow * >(argp2);
45764 {
45765 PyThreadState* __tstate = wxPyBeginAllowThreads();
45766 (arg1)->SetWindow(arg2);
45767 wxPyEndAllowThreads(__tstate);
45768 if (PyErr_Occurred()) SWIG_fail;
45769 }
45770 resultobj = SWIG_Py_Void();
45771 return resultobj;
45772 fail:
45773 return NULL;
45774 }
45775
45776
45777 SWIGINTERN PyObject *_wrap_SizerItem_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45778 PyObject *resultobj = 0;
45779 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45780 wxSizer *result = 0 ;
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_GetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45790 }
45791 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45792 {
45793 PyThreadState* __tstate = wxPyBeginAllowThreads();
45794 result = (wxSizer *)(arg1)->GetSizer();
45795 wxPyEndAllowThreads(__tstate);
45796 if (PyErr_Occurred()) SWIG_fail;
45797 }
45798 {
45799 resultobj = wxPyMake_wxObject(result, (bool)0);
45800 }
45801 return resultobj;
45802 fail:
45803 return NULL;
45804 }
45805
45806
45807 SWIGINTERN PyObject *_wrap_SizerItem_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45808 PyObject *resultobj = 0;
45809 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45810 wxSizer *arg2 = (wxSizer *) 0 ;
45811 void *argp1 = 0 ;
45812 int res1 = 0 ;
45813 int res2 = 0 ;
45814 PyObject * obj0 = 0 ;
45815 PyObject * obj1 = 0 ;
45816 char * kwnames[] = {
45817 (char *) "self",(char *) "sizer", NULL
45818 };
45819
45820 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) SWIG_fail;
45821 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45822 if (!SWIG_IsOK(res1)) {
45823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45824 }
45825 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45826 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
45827 if (!SWIG_IsOK(res2)) {
45828 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
45829 }
45830 {
45831 PyThreadState* __tstate = wxPyBeginAllowThreads();
45832 (arg1)->SetSizer(arg2);
45833 wxPyEndAllowThreads(__tstate);
45834 if (PyErr_Occurred()) SWIG_fail;
45835 }
45836 resultobj = SWIG_Py_Void();
45837 return resultobj;
45838 fail:
45839 return NULL;
45840 }
45841
45842
45843 SWIGINTERN PyObject *_wrap_SizerItem_GetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45844 PyObject *resultobj = 0;
45845 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45846 wxSize *result = 0 ;
45847 void *argp1 = 0 ;
45848 int res1 = 0 ;
45849 PyObject *swig_obj[1] ;
45850
45851 if (!args) SWIG_fail;
45852 swig_obj[0] = args;
45853 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45854 if (!SWIG_IsOK(res1)) {
45855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45856 }
45857 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45858 {
45859 PyThreadState* __tstate = wxPyBeginAllowThreads();
45860 {
45861 wxSize const &_result_ref = (arg1)->GetSpacer();
45862 result = (wxSize *) &_result_ref;
45863 }
45864 wxPyEndAllowThreads(__tstate);
45865 if (PyErr_Occurred()) SWIG_fail;
45866 }
45867 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
45868 return resultobj;
45869 fail:
45870 return NULL;
45871 }
45872
45873
45874 SWIGINTERN PyObject *_wrap_SizerItem_SetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45875 PyObject *resultobj = 0;
45876 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45877 wxSize *arg2 = 0 ;
45878 void *argp1 = 0 ;
45879 int res1 = 0 ;
45880 wxSize temp2 ;
45881 PyObject * obj0 = 0 ;
45882 PyObject * obj1 = 0 ;
45883 char * kwnames[] = {
45884 (char *) "self",(char *) "size", NULL
45885 };
45886
45887 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",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_SetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45891 }
45892 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45893 {
45894 arg2 = &temp2;
45895 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
45896 }
45897 {
45898 PyThreadState* __tstate = wxPyBeginAllowThreads();
45899 (arg1)->SetSpacer((wxSize const &)*arg2);
45900 wxPyEndAllowThreads(__tstate);
45901 if (PyErr_Occurred()) SWIG_fail;
45902 }
45903 resultobj = SWIG_Py_Void();
45904 return resultobj;
45905 fail:
45906 return NULL;
45907 }
45908
45909
45910 SWIGINTERN PyObject *_wrap_SizerItem_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45911 PyObject *resultobj = 0;
45912 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45913 bool arg2 ;
45914 void *argp1 = 0 ;
45915 int res1 = 0 ;
45916 bool val2 ;
45917 int ecode2 = 0 ;
45918 PyObject * obj0 = 0 ;
45919 PyObject * obj1 = 0 ;
45920 char * kwnames[] = {
45921 (char *) "self",(char *) "show", NULL
45922 };
45923
45924 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) SWIG_fail;
45925 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45926 if (!SWIG_IsOK(res1)) {
45927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_Show" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45928 }
45929 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45930 ecode2 = SWIG_AsVal_bool(obj1, &val2);
45931 if (!SWIG_IsOK(ecode2)) {
45932 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_Show" "', expected argument " "2"" of type '" "bool""'");
45933 }
45934 arg2 = static_cast< bool >(val2);
45935 {
45936 PyThreadState* __tstate = wxPyBeginAllowThreads();
45937 (arg1)->Show(arg2);
45938 wxPyEndAllowThreads(__tstate);
45939 if (PyErr_Occurred()) SWIG_fail;
45940 }
45941 resultobj = SWIG_Py_Void();
45942 return resultobj;
45943 fail:
45944 return NULL;
45945 }
45946
45947
45948 SWIGINTERN PyObject *_wrap_SizerItem_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45949 PyObject *resultobj = 0;
45950 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45951 bool result;
45952 void *argp1 = 0 ;
45953 int res1 = 0 ;
45954 PyObject *swig_obj[1] ;
45955
45956 if (!args) SWIG_fail;
45957 swig_obj[0] = args;
45958 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45959 if (!SWIG_IsOK(res1)) {
45960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsShown" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45961 }
45962 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45963 {
45964 PyThreadState* __tstate = wxPyBeginAllowThreads();
45965 result = (bool)(arg1)->IsShown();
45966 wxPyEndAllowThreads(__tstate);
45967 if (PyErr_Occurred()) SWIG_fail;
45968 }
45969 {
45970 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45971 }
45972 return resultobj;
45973 fail:
45974 return NULL;
45975 }
45976
45977
45978 SWIGINTERN PyObject *_wrap_SizerItem_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45979 PyObject *resultobj = 0;
45980 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45981 wxPoint result;
45982 void *argp1 = 0 ;
45983 int res1 = 0 ;
45984 PyObject *swig_obj[1] ;
45985
45986 if (!args) SWIG_fail;
45987 swig_obj[0] = args;
45988 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45989 if (!SWIG_IsOK(res1)) {
45990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetPosition" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45991 }
45992 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45993 {
45994 PyThreadState* __tstate = wxPyBeginAllowThreads();
45995 result = (arg1)->GetPosition();
45996 wxPyEndAllowThreads(__tstate);
45997 if (PyErr_Occurred()) SWIG_fail;
45998 }
45999 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
46000 return resultobj;
46001 fail:
46002 return NULL;
46003 }
46004
46005
46006 SWIGINTERN PyObject *_wrap_SizerItem_GetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46007 PyObject *resultobj = 0;
46008 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46009 PyObject *result = 0 ;
46010 void *argp1 = 0 ;
46011 int res1 = 0 ;
46012 PyObject *swig_obj[1] ;
46013
46014 if (!args) SWIG_fail;
46015 swig_obj[0] = args;
46016 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46017 if (!SWIG_IsOK(res1)) {
46018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46019 }
46020 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46021 {
46022 PyThreadState* __tstate = wxPyBeginAllowThreads();
46023 result = (PyObject *)wxSizerItem_GetUserData(arg1);
46024 wxPyEndAllowThreads(__tstate);
46025 if (PyErr_Occurred()) SWIG_fail;
46026 }
46027 resultobj = result;
46028 return resultobj;
46029 fail:
46030 return NULL;
46031 }
46032
46033
46034 SWIGINTERN PyObject *_wrap_SizerItem_SetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46035 PyObject *resultobj = 0;
46036 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46037 PyObject *arg2 = (PyObject *) 0 ;
46038 void *argp1 = 0 ;
46039 int res1 = 0 ;
46040 PyObject * obj0 = 0 ;
46041 PyObject * obj1 = 0 ;
46042 char * kwnames[] = {
46043 (char *) "self",(char *) "userData", NULL
46044 };
46045
46046 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetUserData",kwnames,&obj0,&obj1)) SWIG_fail;
46047 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46048 if (!SWIG_IsOK(res1)) {
46049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46050 }
46051 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46052 arg2 = obj1;
46053 {
46054 PyThreadState* __tstate = wxPyBeginAllowThreads();
46055 wxSizerItem_SetUserData(arg1,arg2);
46056 wxPyEndAllowThreads(__tstate);
46057 if (PyErr_Occurred()) SWIG_fail;
46058 }
46059 resultobj = SWIG_Py_Void();
46060 return resultobj;
46061 fail:
46062 return NULL;
46063 }
46064
46065
46066 SWIGINTERN PyObject *SizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46067 PyObject *obj;
46068 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
46069 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerItem, SWIG_NewClientData(obj));
46070 return SWIG_Py_Void();
46071 }
46072
46073 SWIGINTERN PyObject *SizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46074 return SWIG_Python_InitShadowInstance(args);
46075 }
46076
46077 SWIGINTERN PyObject *_wrap_delete_Sizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46078 PyObject *resultobj = 0;
46079 wxSizer *arg1 = (wxSizer *) 0 ;
46080 void *argp1 = 0 ;
46081 int res1 = 0 ;
46082 PyObject *swig_obj[1] ;
46083
46084 if (!args) SWIG_fail;
46085 swig_obj[0] = args;
46086 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
46087 if (!SWIG_IsOK(res1)) {
46088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sizer" "', expected argument " "1"" of type '" "wxSizer *""'");
46089 }
46090 arg1 = reinterpret_cast< wxSizer * >(argp1);
46091 {
46092 PyThreadState* __tstate = wxPyBeginAllowThreads();
46093 delete arg1;
46094
46095 wxPyEndAllowThreads(__tstate);
46096 if (PyErr_Occurred()) SWIG_fail;
46097 }
46098 resultobj = SWIG_Py_Void();
46099 return resultobj;
46100 fail:
46101 return NULL;
46102 }
46103
46104
46105 SWIGINTERN PyObject *_wrap_Sizer__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46106 PyObject *resultobj = 0;
46107 wxSizer *arg1 = (wxSizer *) 0 ;
46108 PyObject *arg2 = (PyObject *) 0 ;
46109 void *argp1 = 0 ;
46110 int res1 = 0 ;
46111 PyObject * obj0 = 0 ;
46112 PyObject * obj1 = 0 ;
46113 char * kwnames[] = {
46114 (char *) "self",(char *) "_self", NULL
46115 };
46116
46117 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
46118 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46119 if (!SWIG_IsOK(res1)) {
46120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__setOORInfo" "', expected argument " "1"" of type '" "wxSizer *""'");
46121 }
46122 arg1 = reinterpret_cast< wxSizer * >(argp1);
46123 arg2 = obj1;
46124 {
46125 PyThreadState* __tstate = wxPyBeginAllowThreads();
46126 wxSizer__setOORInfo(arg1,arg2);
46127 wxPyEndAllowThreads(__tstate);
46128 if (PyErr_Occurred()) SWIG_fail;
46129 }
46130 resultobj = SWIG_Py_Void();
46131 return resultobj;
46132 fail:
46133 return NULL;
46134 }
46135
46136
46137 SWIGINTERN PyObject *_wrap_Sizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46138 PyObject *resultobj = 0;
46139 wxSizer *arg1 = (wxSizer *) 0 ;
46140 PyObject *arg2 = (PyObject *) 0 ;
46141 int arg3 = (int) 0 ;
46142 int arg4 = (int) 0 ;
46143 int arg5 = (int) 0 ;
46144 PyObject *arg6 = (PyObject *) NULL ;
46145 wxSizerItem *result = 0 ;
46146 void *argp1 = 0 ;
46147 int res1 = 0 ;
46148 int val3 ;
46149 int ecode3 = 0 ;
46150 int val4 ;
46151 int ecode4 = 0 ;
46152 int val5 ;
46153 int ecode5 = 0 ;
46154 PyObject * obj0 = 0 ;
46155 PyObject * obj1 = 0 ;
46156 PyObject * obj2 = 0 ;
46157 PyObject * obj3 = 0 ;
46158 PyObject * obj4 = 0 ;
46159 PyObject * obj5 = 0 ;
46160 char * kwnames[] = {
46161 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46162 };
46163
46164 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
46165 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46166 if (!SWIG_IsOK(res1)) {
46167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Add" "', expected argument " "1"" of type '" "wxSizer *""'");
46168 }
46169 arg1 = reinterpret_cast< wxSizer * >(argp1);
46170 arg2 = obj1;
46171 if (obj2) {
46172 ecode3 = SWIG_AsVal_int(obj2, &val3);
46173 if (!SWIG_IsOK(ecode3)) {
46174 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Add" "', expected argument " "3"" of type '" "int""'");
46175 }
46176 arg3 = static_cast< int >(val3);
46177 }
46178 if (obj3) {
46179 ecode4 = SWIG_AsVal_int(obj3, &val4);
46180 if (!SWIG_IsOK(ecode4)) {
46181 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Add" "', expected argument " "4"" of type '" "int""'");
46182 }
46183 arg4 = static_cast< int >(val4);
46184 }
46185 if (obj4) {
46186 ecode5 = SWIG_AsVal_int(obj4, &val5);
46187 if (!SWIG_IsOK(ecode5)) {
46188 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Add" "', expected argument " "5"" of type '" "int""'");
46189 }
46190 arg5 = static_cast< int >(val5);
46191 }
46192 if (obj5) {
46193 arg6 = obj5;
46194 }
46195 {
46196 PyThreadState* __tstate = wxPyBeginAllowThreads();
46197 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
46198 wxPyEndAllowThreads(__tstate);
46199 if (PyErr_Occurred()) SWIG_fail;
46200 }
46201 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46202 return resultobj;
46203 fail:
46204 return NULL;
46205 }
46206
46207
46208 SWIGINTERN PyObject *_wrap_Sizer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46209 PyObject *resultobj = 0;
46210 wxSizer *arg1 = (wxSizer *) 0 ;
46211 int arg2 ;
46212 PyObject *arg3 = (PyObject *) 0 ;
46213 int arg4 = (int) 0 ;
46214 int arg5 = (int) 0 ;
46215 int arg6 = (int) 0 ;
46216 PyObject *arg7 = (PyObject *) NULL ;
46217 wxSizerItem *result = 0 ;
46218 void *argp1 = 0 ;
46219 int res1 = 0 ;
46220 int val2 ;
46221 int ecode2 = 0 ;
46222 int val4 ;
46223 int ecode4 = 0 ;
46224 int val5 ;
46225 int ecode5 = 0 ;
46226 int val6 ;
46227 int ecode6 = 0 ;
46228 PyObject * obj0 = 0 ;
46229 PyObject * obj1 = 0 ;
46230 PyObject * obj2 = 0 ;
46231 PyObject * obj3 = 0 ;
46232 PyObject * obj4 = 0 ;
46233 PyObject * obj5 = 0 ;
46234 PyObject * obj6 = 0 ;
46235 char * kwnames[] = {
46236 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46237 };
46238
46239 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
46240 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46241 if (!SWIG_IsOK(res1)) {
46242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Insert" "', expected argument " "1"" of type '" "wxSizer *""'");
46243 }
46244 arg1 = reinterpret_cast< wxSizer * >(argp1);
46245 ecode2 = SWIG_AsVal_int(obj1, &val2);
46246 if (!SWIG_IsOK(ecode2)) {
46247 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Insert" "', expected argument " "2"" of type '" "int""'");
46248 }
46249 arg2 = static_cast< int >(val2);
46250 arg3 = obj2;
46251 if (obj3) {
46252 ecode4 = SWIG_AsVal_int(obj3, &val4);
46253 if (!SWIG_IsOK(ecode4)) {
46254 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Insert" "', expected argument " "4"" of type '" "int""'");
46255 }
46256 arg4 = static_cast< int >(val4);
46257 }
46258 if (obj4) {
46259 ecode5 = SWIG_AsVal_int(obj4, &val5);
46260 if (!SWIG_IsOK(ecode5)) {
46261 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Insert" "', expected argument " "5"" of type '" "int""'");
46262 }
46263 arg5 = static_cast< int >(val5);
46264 }
46265 if (obj5) {
46266 ecode6 = SWIG_AsVal_int(obj5, &val6);
46267 if (!SWIG_IsOK(ecode6)) {
46268 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Sizer_Insert" "', expected argument " "6"" of type '" "int""'");
46269 }
46270 arg6 = static_cast< int >(val6);
46271 }
46272 if (obj6) {
46273 arg7 = obj6;
46274 }
46275 {
46276 PyThreadState* __tstate = wxPyBeginAllowThreads();
46277 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
46278 wxPyEndAllowThreads(__tstate);
46279 if (PyErr_Occurred()) SWIG_fail;
46280 }
46281 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46282 return resultobj;
46283 fail:
46284 return NULL;
46285 }
46286
46287
46288 SWIGINTERN PyObject *_wrap_Sizer_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46289 PyObject *resultobj = 0;
46290 wxSizer *arg1 = (wxSizer *) 0 ;
46291 PyObject *arg2 = (PyObject *) 0 ;
46292 int arg3 = (int) 0 ;
46293 int arg4 = (int) 0 ;
46294 int arg5 = (int) 0 ;
46295 PyObject *arg6 = (PyObject *) NULL ;
46296 wxSizerItem *result = 0 ;
46297 void *argp1 = 0 ;
46298 int res1 = 0 ;
46299 int val3 ;
46300 int ecode3 = 0 ;
46301 int val4 ;
46302 int ecode4 = 0 ;
46303 int val5 ;
46304 int ecode5 = 0 ;
46305 PyObject * obj0 = 0 ;
46306 PyObject * obj1 = 0 ;
46307 PyObject * obj2 = 0 ;
46308 PyObject * obj3 = 0 ;
46309 PyObject * obj4 = 0 ;
46310 PyObject * obj5 = 0 ;
46311 char * kwnames[] = {
46312 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46313 };
46314
46315 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
46316 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46317 if (!SWIG_IsOK(res1)) {
46318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Prepend" "', expected argument " "1"" of type '" "wxSizer *""'");
46319 }
46320 arg1 = reinterpret_cast< wxSizer * >(argp1);
46321 arg2 = obj1;
46322 if (obj2) {
46323 ecode3 = SWIG_AsVal_int(obj2, &val3);
46324 if (!SWIG_IsOK(ecode3)) {
46325 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Prepend" "', expected argument " "3"" of type '" "int""'");
46326 }
46327 arg3 = static_cast< int >(val3);
46328 }
46329 if (obj3) {
46330 ecode4 = SWIG_AsVal_int(obj3, &val4);
46331 if (!SWIG_IsOK(ecode4)) {
46332 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Prepend" "', expected argument " "4"" of type '" "int""'");
46333 }
46334 arg4 = static_cast< int >(val4);
46335 }
46336 if (obj4) {
46337 ecode5 = SWIG_AsVal_int(obj4, &val5);
46338 if (!SWIG_IsOK(ecode5)) {
46339 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Prepend" "', expected argument " "5"" of type '" "int""'");
46340 }
46341 arg5 = static_cast< int >(val5);
46342 }
46343 if (obj5) {
46344 arg6 = obj5;
46345 }
46346 {
46347 PyThreadState* __tstate = wxPyBeginAllowThreads();
46348 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
46349 wxPyEndAllowThreads(__tstate);
46350 if (PyErr_Occurred()) SWIG_fail;
46351 }
46352 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46353 return resultobj;
46354 fail:
46355 return NULL;
46356 }
46357
46358
46359 SWIGINTERN PyObject *_wrap_Sizer_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46360 PyObject *resultobj = 0;
46361 wxSizer *arg1 = (wxSizer *) 0 ;
46362 PyObject *arg2 = (PyObject *) 0 ;
46363 bool result;
46364 void *argp1 = 0 ;
46365 int res1 = 0 ;
46366 PyObject * obj0 = 0 ;
46367 PyObject * obj1 = 0 ;
46368 char * kwnames[] = {
46369 (char *) "self",(char *) "item", NULL
46370 };
46371
46372 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
46373 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46374 if (!SWIG_IsOK(res1)) {
46375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Remove" "', expected argument " "1"" of type '" "wxSizer *""'");
46376 }
46377 arg1 = reinterpret_cast< wxSizer * >(argp1);
46378 arg2 = obj1;
46379 {
46380 PyThreadState* __tstate = wxPyBeginAllowThreads();
46381 result = (bool)wxSizer_Remove(arg1,arg2);
46382 wxPyEndAllowThreads(__tstate);
46383 if (PyErr_Occurred()) SWIG_fail;
46384 }
46385 {
46386 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46387 }
46388 return resultobj;
46389 fail:
46390 return NULL;
46391 }
46392
46393
46394 SWIGINTERN PyObject *_wrap_Sizer_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46395 PyObject *resultobj = 0;
46396 wxSizer *arg1 = (wxSizer *) 0 ;
46397 PyObject *arg2 = (PyObject *) 0 ;
46398 bool result;
46399 void *argp1 = 0 ;
46400 int res1 = 0 ;
46401 PyObject * obj0 = 0 ;
46402 PyObject * obj1 = 0 ;
46403 char * kwnames[] = {
46404 (char *) "self",(char *) "item", NULL
46405 };
46406
46407 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) SWIG_fail;
46408 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46409 if (!SWIG_IsOK(res1)) {
46410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Detach" "', expected argument " "1"" of type '" "wxSizer *""'");
46411 }
46412 arg1 = reinterpret_cast< wxSizer * >(argp1);
46413 arg2 = obj1;
46414 {
46415 PyThreadState* __tstate = wxPyBeginAllowThreads();
46416 result = (bool)wxSizer_Detach(arg1,arg2);
46417 wxPyEndAllowThreads(__tstate);
46418 if (PyErr_Occurred()) SWIG_fail;
46419 }
46420 {
46421 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46422 }
46423 return resultobj;
46424 fail:
46425 return NULL;
46426 }
46427
46428
46429 SWIGINTERN PyObject *_wrap_Sizer_GetItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46430 PyObject *resultobj = 0;
46431 wxSizer *arg1 = (wxSizer *) 0 ;
46432 PyObject *arg2 = (PyObject *) 0 ;
46433 wxSizerItem *result = 0 ;
46434 void *argp1 = 0 ;
46435 int res1 = 0 ;
46436 PyObject * obj0 = 0 ;
46437 PyObject * obj1 = 0 ;
46438 char * kwnames[] = {
46439 (char *) "self",(char *) "item", NULL
46440 };
46441
46442 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) SWIG_fail;
46443 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46444 if (!SWIG_IsOK(res1)) {
46445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46446 }
46447 arg1 = reinterpret_cast< wxSizer * >(argp1);
46448 arg2 = obj1;
46449 {
46450 PyThreadState* __tstate = wxPyBeginAllowThreads();
46451 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
46452 wxPyEndAllowThreads(__tstate);
46453 if (PyErr_Occurred()) SWIG_fail;
46454 }
46455 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46456 return resultobj;
46457 fail:
46458 return NULL;
46459 }
46460
46461
46462 SWIGINTERN PyObject *_wrap_Sizer__SetItemMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46463 PyObject *resultobj = 0;
46464 wxSizer *arg1 = (wxSizer *) 0 ;
46465 PyObject *arg2 = (PyObject *) 0 ;
46466 wxSize *arg3 = 0 ;
46467 void *argp1 = 0 ;
46468 int res1 = 0 ;
46469 wxSize temp3 ;
46470 PyObject * obj0 = 0 ;
46471 PyObject * obj1 = 0 ;
46472 PyObject * obj2 = 0 ;
46473 char * kwnames[] = {
46474 (char *) "self",(char *) "item",(char *) "size", NULL
46475 };
46476
46477 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46478 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46479 if (!SWIG_IsOK(res1)) {
46480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__SetItemMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46481 }
46482 arg1 = reinterpret_cast< wxSizer * >(argp1);
46483 arg2 = obj1;
46484 {
46485 arg3 = &temp3;
46486 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
46487 }
46488 {
46489 PyThreadState* __tstate = wxPyBeginAllowThreads();
46490 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
46491 wxPyEndAllowThreads(__tstate);
46492 if (PyErr_Occurred()) SWIG_fail;
46493 }
46494 resultobj = SWIG_Py_Void();
46495 return resultobj;
46496 fail:
46497 return NULL;
46498 }
46499
46500
46501 SWIGINTERN PyObject *_wrap_Sizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46502 PyObject *resultobj = 0;
46503 wxSizer *arg1 = (wxSizer *) 0 ;
46504 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
46505 wxSizerItem *result = 0 ;
46506 void *argp1 = 0 ;
46507 int res1 = 0 ;
46508 int res2 = 0 ;
46509 PyObject * obj0 = 0 ;
46510 PyObject * obj1 = 0 ;
46511 char * kwnames[] = {
46512 (char *) "self",(char *) "item", NULL
46513 };
46514
46515 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
46516 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46517 if (!SWIG_IsOK(res1)) {
46518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46519 }
46520 arg1 = reinterpret_cast< wxSizer * >(argp1);
46521 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46522 if (!SWIG_IsOK(res2)) {
46523 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_AddItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
46524 }
46525 {
46526 PyThreadState* __tstate = wxPyBeginAllowThreads();
46527 result = (wxSizerItem *)(arg1)->Add(arg2);
46528 wxPyEndAllowThreads(__tstate);
46529 if (PyErr_Occurred()) SWIG_fail;
46530 }
46531 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46532 return resultobj;
46533 fail:
46534 return NULL;
46535 }
46536
46537
46538 SWIGINTERN PyObject *_wrap_Sizer_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46539 PyObject *resultobj = 0;
46540 wxSizer *arg1 = (wxSizer *) 0 ;
46541 size_t arg2 ;
46542 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
46543 wxSizerItem *result = 0 ;
46544 void *argp1 = 0 ;
46545 int res1 = 0 ;
46546 size_t val2 ;
46547 int ecode2 = 0 ;
46548 int res3 = 0 ;
46549 PyObject * obj0 = 0 ;
46550 PyObject * obj1 = 0 ;
46551 PyObject * obj2 = 0 ;
46552 char * kwnames[] = {
46553 (char *) "self",(char *) "index",(char *) "item", NULL
46554 };
46555
46556 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46557 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46558 if (!SWIG_IsOK(res1)) {
46559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_InsertItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46560 }
46561 arg1 = reinterpret_cast< wxSizer * >(argp1);
46562 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
46563 if (!SWIG_IsOK(ecode2)) {
46564 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
46565 }
46566 arg2 = static_cast< size_t >(val2);
46567 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46568 if (!SWIG_IsOK(res3)) {
46569 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_InsertItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
46570 }
46571 {
46572 PyThreadState* __tstate = wxPyBeginAllowThreads();
46573 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
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_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46585 PyObject *resultobj = 0;
46586 wxSizer *arg1 = (wxSizer *) 0 ;
46587 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
46588 wxSizerItem *result = 0 ;
46589 void *argp1 = 0 ;
46590 int res1 = 0 ;
46591 int res2 = 0 ;
46592 PyObject * obj0 = 0 ;
46593 PyObject * obj1 = 0 ;
46594 char * kwnames[] = {
46595 (char *) "self",(char *) "item", NULL
46596 };
46597
46598 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
46599 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46600 if (!SWIG_IsOK(res1)) {
46601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_PrependItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46602 }
46603 arg1 = reinterpret_cast< wxSizer * >(argp1);
46604 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46605 if (!SWIG_IsOK(res2)) {
46606 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_PrependItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
46607 }
46608 {
46609 PyThreadState* __tstate = wxPyBeginAllowThreads();
46610 result = (wxSizerItem *)(arg1)->Prepend(arg2);
46611 wxPyEndAllowThreads(__tstate);
46612 if (PyErr_Occurred()) SWIG_fail;
46613 }
46614 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46615 return resultobj;
46616 fail:
46617 return NULL;
46618 }
46619
46620
46621 SWIGINTERN PyObject *_wrap_Sizer_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46622 PyObject *resultobj = 0;
46623 wxSizer *arg1 = (wxSizer *) 0 ;
46624 int arg2 ;
46625 int arg3 ;
46626 int arg4 ;
46627 int arg5 ;
46628 void *argp1 = 0 ;
46629 int res1 = 0 ;
46630 int val2 ;
46631 int ecode2 = 0 ;
46632 int val3 ;
46633 int ecode3 = 0 ;
46634 int val4 ;
46635 int ecode4 = 0 ;
46636 int val5 ;
46637 int ecode5 = 0 ;
46638 PyObject * obj0 = 0 ;
46639 PyObject * obj1 = 0 ;
46640 PyObject * obj2 = 0 ;
46641 PyObject * obj3 = 0 ;
46642 PyObject * obj4 = 0 ;
46643 char * kwnames[] = {
46644 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
46645 };
46646
46647 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
46648 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46649 if (!SWIG_IsOK(res1)) {
46650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetDimension" "', expected argument " "1"" of type '" "wxSizer *""'");
46651 }
46652 arg1 = reinterpret_cast< wxSizer * >(argp1);
46653 ecode2 = SWIG_AsVal_int(obj1, &val2);
46654 if (!SWIG_IsOK(ecode2)) {
46655 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_SetDimension" "', expected argument " "2"" of type '" "int""'");
46656 }
46657 arg2 = static_cast< int >(val2);
46658 ecode3 = SWIG_AsVal_int(obj2, &val3);
46659 if (!SWIG_IsOK(ecode3)) {
46660 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_SetDimension" "', expected argument " "3"" of type '" "int""'");
46661 }
46662 arg3 = static_cast< int >(val3);
46663 ecode4 = SWIG_AsVal_int(obj3, &val4);
46664 if (!SWIG_IsOK(ecode4)) {
46665 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_SetDimension" "', expected argument " "4"" of type '" "int""'");
46666 }
46667 arg4 = static_cast< int >(val4);
46668 ecode5 = SWIG_AsVal_int(obj4, &val5);
46669 if (!SWIG_IsOK(ecode5)) {
46670 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_SetDimension" "', expected argument " "5"" of type '" "int""'");
46671 }
46672 arg5 = static_cast< int >(val5);
46673 {
46674 PyThreadState* __tstate = wxPyBeginAllowThreads();
46675 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
46676 wxPyEndAllowThreads(__tstate);
46677 if (PyErr_Occurred()) SWIG_fail;
46678 }
46679 resultobj = SWIG_Py_Void();
46680 return resultobj;
46681 fail:
46682 return NULL;
46683 }
46684
46685
46686 SWIGINTERN PyObject *_wrap_Sizer_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46687 PyObject *resultobj = 0;
46688 wxSizer *arg1 = (wxSizer *) 0 ;
46689 wxSize *arg2 = 0 ;
46690 void *argp1 = 0 ;
46691 int res1 = 0 ;
46692 wxSize temp2 ;
46693 PyObject * obj0 = 0 ;
46694 PyObject * obj1 = 0 ;
46695 char * kwnames[] = {
46696 (char *) "self",(char *) "size", NULL
46697 };
46698
46699 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
46700 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46701 if (!SWIG_IsOK(res1)) {
46702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46703 }
46704 arg1 = reinterpret_cast< wxSizer * >(argp1);
46705 {
46706 arg2 = &temp2;
46707 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
46708 }
46709 {
46710 PyThreadState* __tstate = wxPyBeginAllowThreads();
46711 (arg1)->SetMinSize((wxSize const &)*arg2);
46712 wxPyEndAllowThreads(__tstate);
46713 if (PyErr_Occurred()) SWIG_fail;
46714 }
46715 resultobj = SWIG_Py_Void();
46716 return resultobj;
46717 fail:
46718 return NULL;
46719 }
46720
46721
46722 SWIGINTERN PyObject *_wrap_Sizer_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46723 PyObject *resultobj = 0;
46724 wxSizer *arg1 = (wxSizer *) 0 ;
46725 wxSize result;
46726 void *argp1 = 0 ;
46727 int res1 = 0 ;
46728 PyObject *swig_obj[1] ;
46729
46730 if (!args) SWIG_fail;
46731 swig_obj[0] = args;
46732 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46733 if (!SWIG_IsOK(res1)) {
46734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46735 }
46736 arg1 = reinterpret_cast< wxSizer * >(argp1);
46737 {
46738 PyThreadState* __tstate = wxPyBeginAllowThreads();
46739 result = (arg1)->GetSize();
46740 wxPyEndAllowThreads(__tstate);
46741 if (PyErr_Occurred()) SWIG_fail;
46742 }
46743 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46744 return resultobj;
46745 fail:
46746 return NULL;
46747 }
46748
46749
46750 SWIGINTERN PyObject *_wrap_Sizer_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46751 PyObject *resultobj = 0;
46752 wxSizer *arg1 = (wxSizer *) 0 ;
46753 wxPoint result;
46754 void *argp1 = 0 ;
46755 int res1 = 0 ;
46756 PyObject *swig_obj[1] ;
46757
46758 if (!args) SWIG_fail;
46759 swig_obj[0] = args;
46760 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46761 if (!SWIG_IsOK(res1)) {
46762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetPosition" "', expected argument " "1"" of type '" "wxSizer *""'");
46763 }
46764 arg1 = reinterpret_cast< wxSizer * >(argp1);
46765 {
46766 PyThreadState* __tstate = wxPyBeginAllowThreads();
46767 result = (arg1)->GetPosition();
46768 wxPyEndAllowThreads(__tstate);
46769 if (PyErr_Occurred()) SWIG_fail;
46770 }
46771 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
46772 return resultobj;
46773 fail:
46774 return NULL;
46775 }
46776
46777
46778 SWIGINTERN PyObject *_wrap_Sizer_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46779 PyObject *resultobj = 0;
46780 wxSizer *arg1 = (wxSizer *) 0 ;
46781 wxSize result;
46782 void *argp1 = 0 ;
46783 int res1 = 0 ;
46784 PyObject *swig_obj[1] ;
46785
46786 if (!args) SWIG_fail;
46787 swig_obj[0] = args;
46788 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46789 if (!SWIG_IsOK(res1)) {
46790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46791 }
46792 arg1 = reinterpret_cast< wxSizer * >(argp1);
46793 {
46794 PyThreadState* __tstate = wxPyBeginAllowThreads();
46795 result = (arg1)->GetMinSize();
46796 wxPyEndAllowThreads(__tstate);
46797 if (PyErr_Occurred()) SWIG_fail;
46798 }
46799 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46800 return resultobj;
46801 fail:
46802 return NULL;
46803 }
46804
46805
46806 SWIGINTERN PyObject *_wrap_Sizer_RecalcSizes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46807 PyObject *resultobj = 0;
46808 wxSizer *arg1 = (wxSizer *) 0 ;
46809 void *argp1 = 0 ;
46810 int res1 = 0 ;
46811 PyObject *swig_obj[1] ;
46812
46813 if (!args) SWIG_fail;
46814 swig_obj[0] = args;
46815 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46816 if (!SWIG_IsOK(res1)) {
46817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_RecalcSizes" "', expected argument " "1"" of type '" "wxSizer *""'");
46818 }
46819 arg1 = reinterpret_cast< wxSizer * >(argp1);
46820 {
46821 PyThreadState* __tstate = wxPyBeginAllowThreads();
46822 (arg1)->RecalcSizes();
46823 wxPyEndAllowThreads(__tstate);
46824 if (PyErr_Occurred()) SWIG_fail;
46825 }
46826 resultobj = SWIG_Py_Void();
46827 return resultobj;
46828 fail:
46829 return NULL;
46830 }
46831
46832
46833 SWIGINTERN PyObject *_wrap_Sizer_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46834 PyObject *resultobj = 0;
46835 wxSizer *arg1 = (wxSizer *) 0 ;
46836 wxSize result;
46837 void *argp1 = 0 ;
46838 int res1 = 0 ;
46839 PyObject *swig_obj[1] ;
46840
46841 if (!args) SWIG_fail;
46842 swig_obj[0] = args;
46843 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46844 if (!SWIG_IsOK(res1)) {
46845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_CalcMin" "', expected argument " "1"" of type '" "wxSizer *""'");
46846 }
46847 arg1 = reinterpret_cast< wxSizer * >(argp1);
46848 {
46849 PyThreadState* __tstate = wxPyBeginAllowThreads();
46850 result = (arg1)->CalcMin();
46851 wxPyEndAllowThreads(__tstate);
46852 if (PyErr_Occurred()) SWIG_fail;
46853 }
46854 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46855 return resultobj;
46856 fail:
46857 return NULL;
46858 }
46859
46860
46861 SWIGINTERN PyObject *_wrap_Sizer_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46862 PyObject *resultobj = 0;
46863 wxSizer *arg1 = (wxSizer *) 0 ;
46864 void *argp1 = 0 ;
46865 int res1 = 0 ;
46866 PyObject *swig_obj[1] ;
46867
46868 if (!args) SWIG_fail;
46869 swig_obj[0] = args;
46870 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46871 if (!SWIG_IsOK(res1)) {
46872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Layout" "', expected argument " "1"" of type '" "wxSizer *""'");
46873 }
46874 arg1 = reinterpret_cast< wxSizer * >(argp1);
46875 {
46876 PyThreadState* __tstate = wxPyBeginAllowThreads();
46877 (arg1)->Layout();
46878 wxPyEndAllowThreads(__tstate);
46879 if (PyErr_Occurred()) SWIG_fail;
46880 }
46881 resultobj = SWIG_Py_Void();
46882 return resultobj;
46883 fail:
46884 return NULL;
46885 }
46886
46887
46888 SWIGINTERN PyObject *_wrap_Sizer_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46889 PyObject *resultobj = 0;
46890 wxSizer *arg1 = (wxSizer *) 0 ;
46891 wxWindow *arg2 = (wxWindow *) 0 ;
46892 wxSize result;
46893 void *argp1 = 0 ;
46894 int res1 = 0 ;
46895 void *argp2 = 0 ;
46896 int res2 = 0 ;
46897 PyObject * obj0 = 0 ;
46898 PyObject * obj1 = 0 ;
46899 char * kwnames[] = {
46900 (char *) "self",(char *) "window", NULL
46901 };
46902
46903 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) SWIG_fail;
46904 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46905 if (!SWIG_IsOK(res1)) {
46906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Fit" "', expected argument " "1"" of type '" "wxSizer *""'");
46907 }
46908 arg1 = reinterpret_cast< wxSizer * >(argp1);
46909 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
46910 if (!SWIG_IsOK(res2)) {
46911 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_Fit" "', expected argument " "2"" of type '" "wxWindow *""'");
46912 }
46913 arg2 = reinterpret_cast< wxWindow * >(argp2);
46914 {
46915 PyThreadState* __tstate = wxPyBeginAllowThreads();
46916 result = (arg1)->Fit(arg2);
46917 wxPyEndAllowThreads(__tstate);
46918 if (PyErr_Occurred()) SWIG_fail;
46919 }
46920 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46921 return resultobj;
46922 fail:
46923 return NULL;
46924 }
46925
46926
46927 SWIGINTERN PyObject *_wrap_Sizer_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46928 PyObject *resultobj = 0;
46929 wxSizer *arg1 = (wxSizer *) 0 ;
46930 wxWindow *arg2 = (wxWindow *) 0 ;
46931 void *argp1 = 0 ;
46932 int res1 = 0 ;
46933 void *argp2 = 0 ;
46934 int res2 = 0 ;
46935 PyObject * obj0 = 0 ;
46936 PyObject * obj1 = 0 ;
46937 char * kwnames[] = {
46938 (char *) "self",(char *) "window", NULL
46939 };
46940
46941 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) SWIG_fail;
46942 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46943 if (!SWIG_IsOK(res1)) {
46944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_FitInside" "', expected argument " "1"" of type '" "wxSizer *""'");
46945 }
46946 arg1 = reinterpret_cast< wxSizer * >(argp1);
46947 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
46948 if (!SWIG_IsOK(res2)) {
46949 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_FitInside" "', expected argument " "2"" of type '" "wxWindow *""'");
46950 }
46951 arg2 = reinterpret_cast< wxWindow * >(argp2);
46952 {
46953 PyThreadState* __tstate = wxPyBeginAllowThreads();
46954 (arg1)->FitInside(arg2);
46955 wxPyEndAllowThreads(__tstate);
46956 if (PyErr_Occurred()) SWIG_fail;
46957 }
46958 resultobj = SWIG_Py_Void();
46959 return resultobj;
46960 fail:
46961 return NULL;
46962 }
46963
46964
46965 SWIGINTERN PyObject *_wrap_Sizer_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46966 PyObject *resultobj = 0;
46967 wxSizer *arg1 = (wxSizer *) 0 ;
46968 wxWindow *arg2 = (wxWindow *) 0 ;
46969 void *argp1 = 0 ;
46970 int res1 = 0 ;
46971 void *argp2 = 0 ;
46972 int res2 = 0 ;
46973 PyObject * obj0 = 0 ;
46974 PyObject * obj1 = 0 ;
46975 char * kwnames[] = {
46976 (char *) "self",(char *) "window", NULL
46977 };
46978
46979 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
46980 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46981 if (!SWIG_IsOK(res1)) {
46982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
46983 }
46984 arg1 = reinterpret_cast< wxSizer * >(argp1);
46985 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
46986 if (!SWIG_IsOK(res2)) {
46987 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
46988 }
46989 arg2 = reinterpret_cast< wxWindow * >(argp2);
46990 {
46991 PyThreadState* __tstate = wxPyBeginAllowThreads();
46992 (arg1)->SetSizeHints(arg2);
46993 wxPyEndAllowThreads(__tstate);
46994 if (PyErr_Occurred()) SWIG_fail;
46995 }
46996 resultobj = SWIG_Py_Void();
46997 return resultobj;
46998 fail:
46999 return NULL;
47000 }
47001
47002
47003 SWIGINTERN PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47004 PyObject *resultobj = 0;
47005 wxSizer *arg1 = (wxSizer *) 0 ;
47006 wxWindow *arg2 = (wxWindow *) 0 ;
47007 void *argp1 = 0 ;
47008 int res1 = 0 ;
47009 void *argp2 = 0 ;
47010 int res2 = 0 ;
47011 PyObject * obj0 = 0 ;
47012 PyObject * obj1 = 0 ;
47013 char * kwnames[] = {
47014 (char *) "self",(char *) "window", NULL
47015 };
47016
47017 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
47018 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47019 if (!SWIG_IsOK(res1)) {
47020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
47021 }
47022 arg1 = reinterpret_cast< wxSizer * >(argp1);
47023 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47024 if (!SWIG_IsOK(res2)) {
47025 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
47026 }
47027 arg2 = reinterpret_cast< wxWindow * >(argp2);
47028 {
47029 PyThreadState* __tstate = wxPyBeginAllowThreads();
47030 (arg1)->SetVirtualSizeHints(arg2);
47031 wxPyEndAllowThreads(__tstate);
47032 if (PyErr_Occurred()) SWIG_fail;
47033 }
47034 resultobj = SWIG_Py_Void();
47035 return resultobj;
47036 fail:
47037 return NULL;
47038 }
47039
47040
47041 SWIGINTERN PyObject *_wrap_Sizer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47042 PyObject *resultobj = 0;
47043 wxSizer *arg1 = (wxSizer *) 0 ;
47044 bool arg2 = (bool) false ;
47045 void *argp1 = 0 ;
47046 int res1 = 0 ;
47047 bool val2 ;
47048 int ecode2 = 0 ;
47049 PyObject * obj0 = 0 ;
47050 PyObject * obj1 = 0 ;
47051 char * kwnames[] = {
47052 (char *) "self",(char *) "deleteWindows", NULL
47053 };
47054
47055 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) SWIG_fail;
47056 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47057 if (!SWIG_IsOK(res1)) {
47058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Clear" "', expected argument " "1"" of type '" "wxSizer *""'");
47059 }
47060 arg1 = reinterpret_cast< wxSizer * >(argp1);
47061 if (obj1) {
47062 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47063 if (!SWIG_IsOK(ecode2)) {
47064 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Clear" "', expected argument " "2"" of type '" "bool""'");
47065 }
47066 arg2 = static_cast< bool >(val2);
47067 }
47068 {
47069 PyThreadState* __tstate = wxPyBeginAllowThreads();
47070 (arg1)->Clear(arg2);
47071 wxPyEndAllowThreads(__tstate);
47072 if (PyErr_Occurred()) SWIG_fail;
47073 }
47074 resultobj = SWIG_Py_Void();
47075 return resultobj;
47076 fail:
47077 return NULL;
47078 }
47079
47080
47081 SWIGINTERN PyObject *_wrap_Sizer_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47082 PyObject *resultobj = 0;
47083 wxSizer *arg1 = (wxSizer *) 0 ;
47084 void *argp1 = 0 ;
47085 int res1 = 0 ;
47086 PyObject *swig_obj[1] ;
47087
47088 if (!args) SWIG_fail;
47089 swig_obj[0] = args;
47090 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47091 if (!SWIG_IsOK(res1)) {
47092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_DeleteWindows" "', expected argument " "1"" of type '" "wxSizer *""'");
47093 }
47094 arg1 = reinterpret_cast< wxSizer * >(argp1);
47095 {
47096 PyThreadState* __tstate = wxPyBeginAllowThreads();
47097 (arg1)->DeleteWindows();
47098 wxPyEndAllowThreads(__tstate);
47099 if (PyErr_Occurred()) SWIG_fail;
47100 }
47101 resultobj = SWIG_Py_Void();
47102 return resultobj;
47103 fail:
47104 return NULL;
47105 }
47106
47107
47108 SWIGINTERN PyObject *_wrap_Sizer_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47109 PyObject *resultobj = 0;
47110 wxSizer *arg1 = (wxSizer *) 0 ;
47111 PyObject *result = 0 ;
47112 void *argp1 = 0 ;
47113 int res1 = 0 ;
47114 PyObject *swig_obj[1] ;
47115
47116 if (!args) SWIG_fail;
47117 swig_obj[0] = args;
47118 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47119 if (!SWIG_IsOK(res1)) {
47120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetChildren" "', expected argument " "1"" of type '" "wxSizer *""'");
47121 }
47122 arg1 = reinterpret_cast< wxSizer * >(argp1);
47123 {
47124 PyThreadState* __tstate = wxPyBeginAllowThreads();
47125 result = (PyObject *)wxSizer_GetChildren(arg1);
47126 wxPyEndAllowThreads(__tstate);
47127 if (PyErr_Occurred()) SWIG_fail;
47128 }
47129 resultobj = result;
47130 return resultobj;
47131 fail:
47132 return NULL;
47133 }
47134
47135
47136 SWIGINTERN PyObject *_wrap_Sizer_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47137 PyObject *resultobj = 0;
47138 wxSizer *arg1 = (wxSizer *) 0 ;
47139 PyObject *arg2 = (PyObject *) 0 ;
47140 bool arg3 = (bool) true ;
47141 bool arg4 = (bool) false ;
47142 bool result;
47143 void *argp1 = 0 ;
47144 int res1 = 0 ;
47145 bool val3 ;
47146 int ecode3 = 0 ;
47147 bool val4 ;
47148 int ecode4 = 0 ;
47149 PyObject * obj0 = 0 ;
47150 PyObject * obj1 = 0 ;
47151 PyObject * obj2 = 0 ;
47152 PyObject * obj3 = 0 ;
47153 char * kwnames[] = {
47154 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
47155 };
47156
47157 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47158 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47159 if (!SWIG_IsOK(res1)) {
47160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Show" "', expected argument " "1"" of type '" "wxSizer *""'");
47161 }
47162 arg1 = reinterpret_cast< wxSizer * >(argp1);
47163 arg2 = obj1;
47164 if (obj2) {
47165 ecode3 = SWIG_AsVal_bool(obj2, &val3);
47166 if (!SWIG_IsOK(ecode3)) {
47167 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Show" "', expected argument " "3"" of type '" "bool""'");
47168 }
47169 arg3 = static_cast< bool >(val3);
47170 }
47171 if (obj3) {
47172 ecode4 = SWIG_AsVal_bool(obj3, &val4);
47173 if (!SWIG_IsOK(ecode4)) {
47174 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Show" "', expected argument " "4"" of type '" "bool""'");
47175 }
47176 arg4 = static_cast< bool >(val4);
47177 }
47178 {
47179 PyThreadState* __tstate = wxPyBeginAllowThreads();
47180 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
47181 wxPyEndAllowThreads(__tstate);
47182 if (PyErr_Occurred()) SWIG_fail;
47183 }
47184 {
47185 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47186 }
47187 return resultobj;
47188 fail:
47189 return NULL;
47190 }
47191
47192
47193 SWIGINTERN PyObject *_wrap_Sizer_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47194 PyObject *resultobj = 0;
47195 wxSizer *arg1 = (wxSizer *) 0 ;
47196 PyObject *arg2 = (PyObject *) 0 ;
47197 bool result;
47198 void *argp1 = 0 ;
47199 int res1 = 0 ;
47200 PyObject * obj0 = 0 ;
47201 PyObject * obj1 = 0 ;
47202 char * kwnames[] = {
47203 (char *) "self",(char *) "item", NULL
47204 };
47205
47206 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) SWIG_fail;
47207 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47208 if (!SWIG_IsOK(res1)) {
47209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_IsShown" "', expected argument " "1"" of type '" "wxSizer *""'");
47210 }
47211 arg1 = reinterpret_cast< wxSizer * >(argp1);
47212 arg2 = obj1;
47213 {
47214 PyThreadState* __tstate = wxPyBeginAllowThreads();
47215 result = (bool)wxSizer_IsShown(arg1,arg2);
47216 wxPyEndAllowThreads(__tstate);
47217 if (PyErr_Occurred()) SWIG_fail;
47218 }
47219 {
47220 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47221 }
47222 return resultobj;
47223 fail:
47224 return NULL;
47225 }
47226
47227
47228 SWIGINTERN PyObject *_wrap_Sizer_ShowItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47229 PyObject *resultobj = 0;
47230 wxSizer *arg1 = (wxSizer *) 0 ;
47231 bool arg2 ;
47232 void *argp1 = 0 ;
47233 int res1 = 0 ;
47234 bool val2 ;
47235 int ecode2 = 0 ;
47236 PyObject * obj0 = 0 ;
47237 PyObject * obj1 = 0 ;
47238 char * kwnames[] = {
47239 (char *) "self",(char *) "show", NULL
47240 };
47241
47242 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) SWIG_fail;
47243 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47244 if (!SWIG_IsOK(res1)) {
47245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_ShowItems" "', expected argument " "1"" of type '" "wxSizer *""'");
47246 }
47247 arg1 = reinterpret_cast< wxSizer * >(argp1);
47248 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47249 if (!SWIG_IsOK(ecode2)) {
47250 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_ShowItems" "', expected argument " "2"" of type '" "bool""'");
47251 }
47252 arg2 = static_cast< bool >(val2);
47253 {
47254 PyThreadState* __tstate = wxPyBeginAllowThreads();
47255 (arg1)->ShowItems(arg2);
47256 wxPyEndAllowThreads(__tstate);
47257 if (PyErr_Occurred()) SWIG_fail;
47258 }
47259 resultobj = SWIG_Py_Void();
47260 return resultobj;
47261 fail:
47262 return NULL;
47263 }
47264
47265
47266 SWIGINTERN PyObject *Sizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47267 PyObject *obj;
47268 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47269 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizer, SWIG_NewClientData(obj));
47270 return SWIG_Py_Void();
47271 }
47272
47273 SWIGINTERN PyObject *_wrap_new_PySizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47274 PyObject *resultobj = 0;
47275 wxPySizer *result = 0 ;
47276
47277 if (!SWIG_Python_UnpackTuple(args,"new_PySizer",0,0,0)) SWIG_fail;
47278 {
47279 PyThreadState* __tstate = wxPyBeginAllowThreads();
47280 result = (wxPySizer *)new wxPySizer();
47281 wxPyEndAllowThreads(__tstate);
47282 if (PyErr_Occurred()) SWIG_fail;
47283 }
47284 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPySizer, SWIG_POINTER_NEW | 0 );
47285 return resultobj;
47286 fail:
47287 return NULL;
47288 }
47289
47290
47291 SWIGINTERN PyObject *_wrap_PySizer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47292 PyObject *resultobj = 0;
47293 wxPySizer *arg1 = (wxPySizer *) 0 ;
47294 PyObject *arg2 = (PyObject *) 0 ;
47295 PyObject *arg3 = (PyObject *) 0 ;
47296 void *argp1 = 0 ;
47297 int res1 = 0 ;
47298 PyObject * obj0 = 0 ;
47299 PyObject * obj1 = 0 ;
47300 PyObject * obj2 = 0 ;
47301 char * kwnames[] = {
47302 (char *) "self",(char *) "self",(char *) "_class", NULL
47303 };
47304
47305 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47306 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPySizer, 0 | 0 );
47307 if (!SWIG_IsOK(res1)) {
47308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySizer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPySizer *""'");
47309 }
47310 arg1 = reinterpret_cast< wxPySizer * >(argp1);
47311 arg2 = obj1;
47312 arg3 = obj2;
47313 {
47314 PyThreadState* __tstate = wxPyBeginAllowThreads();
47315 (arg1)->_setCallbackInfo(arg2,arg3);
47316 wxPyEndAllowThreads(__tstate);
47317 if (PyErr_Occurred()) SWIG_fail;
47318 }
47319 resultobj = SWIG_Py_Void();
47320 return resultobj;
47321 fail:
47322 return NULL;
47323 }
47324
47325
47326 SWIGINTERN PyObject *PySizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47327 PyObject *obj;
47328 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47329 SWIG_TypeNewClientData(SWIGTYPE_p_wxPySizer, SWIG_NewClientData(obj));
47330 return SWIG_Py_Void();
47331 }
47332
47333 SWIGINTERN PyObject *PySizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47334 return SWIG_Python_InitShadowInstance(args);
47335 }
47336
47337 SWIGINTERN PyObject *_wrap_new_BoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47338 PyObject *resultobj = 0;
47339 int arg1 = (int) wxHORIZONTAL ;
47340 wxBoxSizer *result = 0 ;
47341 int val1 ;
47342 int ecode1 = 0 ;
47343 PyObject * obj0 = 0 ;
47344 char * kwnames[] = {
47345 (char *) "orient", NULL
47346 };
47347
47348 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) SWIG_fail;
47349 if (obj0) {
47350 ecode1 = SWIG_AsVal_int(obj0, &val1);
47351 if (!SWIG_IsOK(ecode1)) {
47352 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BoxSizer" "', expected argument " "1"" of type '" "int""'");
47353 }
47354 arg1 = static_cast< int >(val1);
47355 }
47356 {
47357 PyThreadState* __tstate = wxPyBeginAllowThreads();
47358 result = (wxBoxSizer *)new wxBoxSizer(arg1);
47359 wxPyEndAllowThreads(__tstate);
47360 if (PyErr_Occurred()) SWIG_fail;
47361 }
47362 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_NEW | 0 );
47363 return resultobj;
47364 fail:
47365 return NULL;
47366 }
47367
47368
47369 SWIGINTERN PyObject *_wrap_BoxSizer_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47370 PyObject *resultobj = 0;
47371 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
47372 int result;
47373 void *argp1 = 0 ;
47374 int res1 = 0 ;
47375 PyObject *swig_obj[1] ;
47376
47377 if (!args) SWIG_fail;
47378 swig_obj[0] = args;
47379 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
47380 if (!SWIG_IsOK(res1)) {
47381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_GetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
47382 }
47383 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
47384 {
47385 PyThreadState* __tstate = wxPyBeginAllowThreads();
47386 result = (int)(arg1)->GetOrientation();
47387 wxPyEndAllowThreads(__tstate);
47388 if (PyErr_Occurred()) SWIG_fail;
47389 }
47390 resultobj = SWIG_From_int(static_cast< int >(result));
47391 return resultobj;
47392 fail:
47393 return NULL;
47394 }
47395
47396
47397 SWIGINTERN PyObject *_wrap_BoxSizer_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47398 PyObject *resultobj = 0;
47399 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
47400 int arg2 ;
47401 void *argp1 = 0 ;
47402 int res1 = 0 ;
47403 int val2 ;
47404 int ecode2 = 0 ;
47405 PyObject * obj0 = 0 ;
47406 PyObject * obj1 = 0 ;
47407 char * kwnames[] = {
47408 (char *) "self",(char *) "orient", NULL
47409 };
47410
47411 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
47412 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
47413 if (!SWIG_IsOK(res1)) {
47414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_SetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
47415 }
47416 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
47417 ecode2 = SWIG_AsVal_int(obj1, &val2);
47418 if (!SWIG_IsOK(ecode2)) {
47419 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoxSizer_SetOrientation" "', expected argument " "2"" of type '" "int""'");
47420 }
47421 arg2 = static_cast< int >(val2);
47422 {
47423 PyThreadState* __tstate = wxPyBeginAllowThreads();
47424 (arg1)->SetOrientation(arg2);
47425 wxPyEndAllowThreads(__tstate);
47426 if (PyErr_Occurred()) SWIG_fail;
47427 }
47428 resultobj = SWIG_Py_Void();
47429 return resultobj;
47430 fail:
47431 return NULL;
47432 }
47433
47434
47435 SWIGINTERN PyObject *BoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47436 PyObject *obj;
47437 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47438 SWIG_TypeNewClientData(SWIGTYPE_p_wxBoxSizer, SWIG_NewClientData(obj));
47439 return SWIG_Py_Void();
47440 }
47441
47442 SWIGINTERN PyObject *BoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47443 return SWIG_Python_InitShadowInstance(args);
47444 }
47445
47446 SWIGINTERN PyObject *_wrap_new_StaticBoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47447 PyObject *resultobj = 0;
47448 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
47449 int arg2 = (int) wxHORIZONTAL ;
47450 wxStaticBoxSizer *result = 0 ;
47451 void *argp1 = 0 ;
47452 int res1 = 0 ;
47453 int val2 ;
47454 int ecode2 = 0 ;
47455 PyObject * obj0 = 0 ;
47456 PyObject * obj1 = 0 ;
47457 char * kwnames[] = {
47458 (char *) "box",(char *) "orient", NULL
47459 };
47460
47461 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) SWIG_fail;
47462 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStaticBox, 0 | 0 );
47463 if (!SWIG_IsOK(res1)) {
47464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StaticBoxSizer" "', expected argument " "1"" of type '" "wxStaticBox *""'");
47465 }
47466 arg1 = reinterpret_cast< wxStaticBox * >(argp1);
47467 if (obj1) {
47468 ecode2 = SWIG_AsVal_int(obj1, &val2);
47469 if (!SWIG_IsOK(ecode2)) {
47470 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StaticBoxSizer" "', expected argument " "2"" of type '" "int""'");
47471 }
47472 arg2 = static_cast< int >(val2);
47473 }
47474 {
47475 PyThreadState* __tstate = wxPyBeginAllowThreads();
47476 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
47477 wxPyEndAllowThreads(__tstate);
47478 if (PyErr_Occurred()) SWIG_fail;
47479 }
47480 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_NEW | 0 );
47481 return resultobj;
47482 fail:
47483 return NULL;
47484 }
47485
47486
47487 SWIGINTERN PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47488 PyObject *resultobj = 0;
47489 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
47490 wxStaticBox *result = 0 ;
47491 void *argp1 = 0 ;
47492 int res1 = 0 ;
47493 PyObject *swig_obj[1] ;
47494
47495 if (!args) SWIG_fail;
47496 swig_obj[0] = args;
47497 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStaticBoxSizer, 0 | 0 );
47498 if (!SWIG_IsOK(res1)) {
47499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StaticBoxSizer_GetStaticBox" "', expected argument " "1"" of type '" "wxStaticBoxSizer *""'");
47500 }
47501 arg1 = reinterpret_cast< wxStaticBoxSizer * >(argp1);
47502 {
47503 PyThreadState* __tstate = wxPyBeginAllowThreads();
47504 result = (wxStaticBox *)(arg1)->GetStaticBox();
47505 wxPyEndAllowThreads(__tstate);
47506 if (PyErr_Occurred()) SWIG_fail;
47507 }
47508 {
47509 resultobj = wxPyMake_wxObject(result, (bool)0);
47510 }
47511 return resultobj;
47512 fail:
47513 return NULL;
47514 }
47515
47516
47517 SWIGINTERN PyObject *StaticBoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47518 PyObject *obj;
47519 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47520 SWIG_TypeNewClientData(SWIGTYPE_p_wxStaticBoxSizer, SWIG_NewClientData(obj));
47521 return SWIG_Py_Void();
47522 }
47523
47524 SWIGINTERN PyObject *StaticBoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47525 return SWIG_Python_InitShadowInstance(args);
47526 }
47527
47528 SWIGINTERN PyObject *_wrap_new_GridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47529 PyObject *resultobj = 0;
47530 int arg1 = (int) 1 ;
47531 int arg2 = (int) 0 ;
47532 int arg3 = (int) 0 ;
47533 int arg4 = (int) 0 ;
47534 wxGridSizer *result = 0 ;
47535 int val1 ;
47536 int ecode1 = 0 ;
47537 int val2 ;
47538 int ecode2 = 0 ;
47539 int val3 ;
47540 int ecode3 = 0 ;
47541 int val4 ;
47542 int ecode4 = 0 ;
47543 PyObject * obj0 = 0 ;
47544 PyObject * obj1 = 0 ;
47545 PyObject * obj2 = 0 ;
47546 PyObject * obj3 = 0 ;
47547 char * kwnames[] = {
47548 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
47549 };
47550
47551 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47552 if (obj0) {
47553 ecode1 = SWIG_AsVal_int(obj0, &val1);
47554 if (!SWIG_IsOK(ecode1)) {
47555 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizer" "', expected argument " "1"" of type '" "int""'");
47556 }
47557 arg1 = static_cast< int >(val1);
47558 }
47559 if (obj1) {
47560 ecode2 = SWIG_AsVal_int(obj1, &val2);
47561 if (!SWIG_IsOK(ecode2)) {
47562 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizer" "', expected argument " "2"" of type '" "int""'");
47563 }
47564 arg2 = static_cast< int >(val2);
47565 }
47566 if (obj2) {
47567 ecode3 = SWIG_AsVal_int(obj2, &val3);
47568 if (!SWIG_IsOK(ecode3)) {
47569 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridSizer" "', expected argument " "3"" of type '" "int""'");
47570 }
47571 arg3 = static_cast< int >(val3);
47572 }
47573 if (obj3) {
47574 ecode4 = SWIG_AsVal_int(obj3, &val4);
47575 if (!SWIG_IsOK(ecode4)) {
47576 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizer" "', expected argument " "4"" of type '" "int""'");
47577 }
47578 arg4 = static_cast< int >(val4);
47579 }
47580 {
47581 PyThreadState* __tstate = wxPyBeginAllowThreads();
47582 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
47583 wxPyEndAllowThreads(__tstate);
47584 if (PyErr_Occurred()) SWIG_fail;
47585 }
47586 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizer, SWIG_POINTER_NEW | 0 );
47587 return resultobj;
47588 fail:
47589 return NULL;
47590 }
47591
47592
47593 SWIGINTERN PyObject *_wrap_GridSizer_SetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47594 PyObject *resultobj = 0;
47595 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47596 int arg2 ;
47597 void *argp1 = 0 ;
47598 int res1 = 0 ;
47599 int val2 ;
47600 int ecode2 = 0 ;
47601 PyObject * obj0 = 0 ;
47602 PyObject * obj1 = 0 ;
47603 char * kwnames[] = {
47604 (char *) "self",(char *) "cols", NULL
47605 };
47606
47607 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) SWIG_fail;
47608 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47609 if (!SWIG_IsOK(res1)) {
47610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47611 }
47612 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47613 ecode2 = SWIG_AsVal_int(obj1, &val2);
47614 if (!SWIG_IsOK(ecode2)) {
47615 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetCols" "', expected argument " "2"" of type '" "int""'");
47616 }
47617 arg2 = static_cast< int >(val2);
47618 {
47619 PyThreadState* __tstate = wxPyBeginAllowThreads();
47620 (arg1)->SetCols(arg2);
47621 wxPyEndAllowThreads(__tstate);
47622 if (PyErr_Occurred()) SWIG_fail;
47623 }
47624 resultobj = SWIG_Py_Void();
47625 return resultobj;
47626 fail:
47627 return NULL;
47628 }
47629
47630
47631 SWIGINTERN PyObject *_wrap_GridSizer_SetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47632 PyObject *resultobj = 0;
47633 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47634 int arg2 ;
47635 void *argp1 = 0 ;
47636 int res1 = 0 ;
47637 int val2 ;
47638 int ecode2 = 0 ;
47639 PyObject * obj0 = 0 ;
47640 PyObject * obj1 = 0 ;
47641 char * kwnames[] = {
47642 (char *) "self",(char *) "rows", NULL
47643 };
47644
47645 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) SWIG_fail;
47646 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47647 if (!SWIG_IsOK(res1)) {
47648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47649 }
47650 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47651 ecode2 = SWIG_AsVal_int(obj1, &val2);
47652 if (!SWIG_IsOK(ecode2)) {
47653 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetRows" "', expected argument " "2"" of type '" "int""'");
47654 }
47655 arg2 = static_cast< int >(val2);
47656 {
47657 PyThreadState* __tstate = wxPyBeginAllowThreads();
47658 (arg1)->SetRows(arg2);
47659 wxPyEndAllowThreads(__tstate);
47660 if (PyErr_Occurred()) SWIG_fail;
47661 }
47662 resultobj = SWIG_Py_Void();
47663 return resultobj;
47664 fail:
47665 return NULL;
47666 }
47667
47668
47669 SWIGINTERN PyObject *_wrap_GridSizer_SetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47670 PyObject *resultobj = 0;
47671 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47672 int arg2 ;
47673 void *argp1 = 0 ;
47674 int res1 = 0 ;
47675 int val2 ;
47676 int ecode2 = 0 ;
47677 PyObject * obj0 = 0 ;
47678 PyObject * obj1 = 0 ;
47679 char * kwnames[] = {
47680 (char *) "self",(char *) "gap", NULL
47681 };
47682
47683 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) SWIG_fail;
47684 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47685 if (!SWIG_IsOK(res1)) {
47686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47687 }
47688 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47689 ecode2 = SWIG_AsVal_int(obj1, &val2);
47690 if (!SWIG_IsOK(ecode2)) {
47691 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetVGap" "', expected argument " "2"" of type '" "int""'");
47692 }
47693 arg2 = static_cast< int >(val2);
47694 {
47695 PyThreadState* __tstate = wxPyBeginAllowThreads();
47696 (arg1)->SetVGap(arg2);
47697 wxPyEndAllowThreads(__tstate);
47698 if (PyErr_Occurred()) SWIG_fail;
47699 }
47700 resultobj = SWIG_Py_Void();
47701 return resultobj;
47702 fail:
47703 return NULL;
47704 }
47705
47706
47707 SWIGINTERN PyObject *_wrap_GridSizer_SetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47708 PyObject *resultobj = 0;
47709 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47710 int arg2 ;
47711 void *argp1 = 0 ;
47712 int res1 = 0 ;
47713 int val2 ;
47714 int ecode2 = 0 ;
47715 PyObject * obj0 = 0 ;
47716 PyObject * obj1 = 0 ;
47717 char * kwnames[] = {
47718 (char *) "self",(char *) "gap", NULL
47719 };
47720
47721 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) SWIG_fail;
47722 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47723 if (!SWIG_IsOK(res1)) {
47724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47725 }
47726 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47727 ecode2 = SWIG_AsVal_int(obj1, &val2);
47728 if (!SWIG_IsOK(ecode2)) {
47729 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetHGap" "', expected argument " "2"" of type '" "int""'");
47730 }
47731 arg2 = static_cast< int >(val2);
47732 {
47733 PyThreadState* __tstate = wxPyBeginAllowThreads();
47734 (arg1)->SetHGap(arg2);
47735 wxPyEndAllowThreads(__tstate);
47736 if (PyErr_Occurred()) SWIG_fail;
47737 }
47738 resultobj = SWIG_Py_Void();
47739 return resultobj;
47740 fail:
47741 return NULL;
47742 }
47743
47744
47745 SWIGINTERN PyObject *_wrap_GridSizer_GetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47746 PyObject *resultobj = 0;
47747 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47748 int result;
47749 void *argp1 = 0 ;
47750 int res1 = 0 ;
47751 PyObject *swig_obj[1] ;
47752
47753 if (!args) SWIG_fail;
47754 swig_obj[0] = args;
47755 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47756 if (!SWIG_IsOK(res1)) {
47757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47758 }
47759 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47760 {
47761 PyThreadState* __tstate = wxPyBeginAllowThreads();
47762 result = (int)(arg1)->GetCols();
47763 wxPyEndAllowThreads(__tstate);
47764 if (PyErr_Occurred()) SWIG_fail;
47765 }
47766 resultobj = SWIG_From_int(static_cast< int >(result));
47767 return resultobj;
47768 fail:
47769 return NULL;
47770 }
47771
47772
47773 SWIGINTERN PyObject *_wrap_GridSizer_GetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47774 PyObject *resultobj = 0;
47775 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47776 int result;
47777 void *argp1 = 0 ;
47778 int res1 = 0 ;
47779 PyObject *swig_obj[1] ;
47780
47781 if (!args) SWIG_fail;
47782 swig_obj[0] = args;
47783 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47784 if (!SWIG_IsOK(res1)) {
47785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47786 }
47787 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47788 {
47789 PyThreadState* __tstate = wxPyBeginAllowThreads();
47790 result = (int)(arg1)->GetRows();
47791 wxPyEndAllowThreads(__tstate);
47792 if (PyErr_Occurred()) SWIG_fail;
47793 }
47794 resultobj = SWIG_From_int(static_cast< int >(result));
47795 return resultobj;
47796 fail:
47797 return NULL;
47798 }
47799
47800
47801 SWIGINTERN PyObject *_wrap_GridSizer_GetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47802 PyObject *resultobj = 0;
47803 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47804 int result;
47805 void *argp1 = 0 ;
47806 int res1 = 0 ;
47807 PyObject *swig_obj[1] ;
47808
47809 if (!args) SWIG_fail;
47810 swig_obj[0] = args;
47811 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47812 if (!SWIG_IsOK(res1)) {
47813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47814 }
47815 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47816 {
47817 PyThreadState* __tstate = wxPyBeginAllowThreads();
47818 result = (int)(arg1)->GetVGap();
47819 wxPyEndAllowThreads(__tstate);
47820 if (PyErr_Occurred()) SWIG_fail;
47821 }
47822 resultobj = SWIG_From_int(static_cast< int >(result));
47823 return resultobj;
47824 fail:
47825 return NULL;
47826 }
47827
47828
47829 SWIGINTERN PyObject *_wrap_GridSizer_GetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47830 PyObject *resultobj = 0;
47831 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47832 int result;
47833 void *argp1 = 0 ;
47834 int res1 = 0 ;
47835 PyObject *swig_obj[1] ;
47836
47837 if (!args) SWIG_fail;
47838 swig_obj[0] = args;
47839 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47840 if (!SWIG_IsOK(res1)) {
47841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47842 }
47843 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47844 {
47845 PyThreadState* __tstate = wxPyBeginAllowThreads();
47846 result = (int)(arg1)->GetHGap();
47847 wxPyEndAllowThreads(__tstate);
47848 if (PyErr_Occurred()) SWIG_fail;
47849 }
47850 resultobj = SWIG_From_int(static_cast< int >(result));
47851 return resultobj;
47852 fail:
47853 return NULL;
47854 }
47855
47856
47857 SWIGINTERN PyObject *GridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47858 PyObject *obj;
47859 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47860 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizer, SWIG_NewClientData(obj));
47861 return SWIG_Py_Void();
47862 }
47863
47864 SWIGINTERN PyObject *GridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47865 return SWIG_Python_InitShadowInstance(args);
47866 }
47867
47868 SWIGINTERN PyObject *_wrap_new_FlexGridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47869 PyObject *resultobj = 0;
47870 int arg1 = (int) 1 ;
47871 int arg2 = (int) 0 ;
47872 int arg3 = (int) 0 ;
47873 int arg4 = (int) 0 ;
47874 wxFlexGridSizer *result = 0 ;
47875 int val1 ;
47876 int ecode1 = 0 ;
47877 int val2 ;
47878 int ecode2 = 0 ;
47879 int val3 ;
47880 int ecode3 = 0 ;
47881 int val4 ;
47882 int ecode4 = 0 ;
47883 PyObject * obj0 = 0 ;
47884 PyObject * obj1 = 0 ;
47885 PyObject * obj2 = 0 ;
47886 PyObject * obj3 = 0 ;
47887 char * kwnames[] = {
47888 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
47889 };
47890
47891 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47892 if (obj0) {
47893 ecode1 = SWIG_AsVal_int(obj0, &val1);
47894 if (!SWIG_IsOK(ecode1)) {
47895 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlexGridSizer" "', expected argument " "1"" of type '" "int""'");
47896 }
47897 arg1 = static_cast< int >(val1);
47898 }
47899 if (obj1) {
47900 ecode2 = SWIG_AsVal_int(obj1, &val2);
47901 if (!SWIG_IsOK(ecode2)) {
47902 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlexGridSizer" "', expected argument " "2"" of type '" "int""'");
47903 }
47904 arg2 = static_cast< int >(val2);
47905 }
47906 if (obj2) {
47907 ecode3 = SWIG_AsVal_int(obj2, &val3);
47908 if (!SWIG_IsOK(ecode3)) {
47909 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FlexGridSizer" "', expected argument " "3"" of type '" "int""'");
47910 }
47911 arg3 = static_cast< int >(val3);
47912 }
47913 if (obj3) {
47914 ecode4 = SWIG_AsVal_int(obj3, &val4);
47915 if (!SWIG_IsOK(ecode4)) {
47916 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FlexGridSizer" "', expected argument " "4"" of type '" "int""'");
47917 }
47918 arg4 = static_cast< int >(val4);
47919 }
47920 {
47921 PyThreadState* __tstate = wxPyBeginAllowThreads();
47922 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
47923 wxPyEndAllowThreads(__tstate);
47924 if (PyErr_Occurred()) SWIG_fail;
47925 }
47926 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_NEW | 0 );
47927 return resultobj;
47928 fail:
47929 return NULL;
47930 }
47931
47932
47933 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47934 PyObject *resultobj = 0;
47935 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47936 size_t arg2 ;
47937 int arg3 = (int) 0 ;
47938 void *argp1 = 0 ;
47939 int res1 = 0 ;
47940 size_t val2 ;
47941 int ecode2 = 0 ;
47942 int val3 ;
47943 int ecode3 = 0 ;
47944 PyObject * obj0 = 0 ;
47945 PyObject * obj1 = 0 ;
47946 PyObject * obj2 = 0 ;
47947 char * kwnames[] = {
47948 (char *) "self",(char *) "idx",(char *) "proportion", NULL
47949 };
47950
47951 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47952 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
47953 if (!SWIG_IsOK(res1)) {
47954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
47955 }
47956 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
47957 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
47958 if (!SWIG_IsOK(ecode2)) {
47959 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
47960 }
47961 arg2 = static_cast< size_t >(val2);
47962 if (obj2) {
47963 ecode3 = SWIG_AsVal_int(obj2, &val3);
47964 if (!SWIG_IsOK(ecode3)) {
47965 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "3"" of type '" "int""'");
47966 }
47967 arg3 = static_cast< int >(val3);
47968 }
47969 {
47970 PyThreadState* __tstate = wxPyBeginAllowThreads();
47971 (arg1)->AddGrowableRow(arg2,arg3);
47972 wxPyEndAllowThreads(__tstate);
47973 if (PyErr_Occurred()) SWIG_fail;
47974 }
47975 resultobj = SWIG_Py_Void();
47976 return resultobj;
47977 fail:
47978 return NULL;
47979 }
47980
47981
47982 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47983 PyObject *resultobj = 0;
47984 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47985 size_t arg2 ;
47986 void *argp1 = 0 ;
47987 int res1 = 0 ;
47988 size_t val2 ;
47989 int ecode2 = 0 ;
47990 PyObject * obj0 = 0 ;
47991 PyObject * obj1 = 0 ;
47992 char * kwnames[] = {
47993 (char *) "self",(char *) "idx", NULL
47994 };
47995
47996 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) SWIG_fail;
47997 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
47998 if (!SWIG_IsOK(res1)) {
47999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48000 }
48001 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48002 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48003 if (!SWIG_IsOK(ecode2)) {
48004 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
48005 }
48006 arg2 = static_cast< size_t >(val2);
48007 {
48008 PyThreadState* __tstate = wxPyBeginAllowThreads();
48009 (arg1)->RemoveGrowableRow(arg2);
48010 wxPyEndAllowThreads(__tstate);
48011 if (PyErr_Occurred()) SWIG_fail;
48012 }
48013 resultobj = SWIG_Py_Void();
48014 return resultobj;
48015 fail:
48016 return NULL;
48017 }
48018
48019
48020 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48021 PyObject *resultobj = 0;
48022 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48023 size_t arg2 ;
48024 int arg3 = (int) 0 ;
48025 void *argp1 = 0 ;
48026 int res1 = 0 ;
48027 size_t val2 ;
48028 int ecode2 = 0 ;
48029 int val3 ;
48030 int ecode3 = 0 ;
48031 PyObject * obj0 = 0 ;
48032 PyObject * obj1 = 0 ;
48033 PyObject * obj2 = 0 ;
48034 char * kwnames[] = {
48035 (char *) "self",(char *) "idx",(char *) "proportion", NULL
48036 };
48037
48038 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48039 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48040 if (!SWIG_IsOK(res1)) {
48041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48042 }
48043 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48044 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48045 if (!SWIG_IsOK(ecode2)) {
48046 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
48047 }
48048 arg2 = static_cast< size_t >(val2);
48049 if (obj2) {
48050 ecode3 = SWIG_AsVal_int(obj2, &val3);
48051 if (!SWIG_IsOK(ecode3)) {
48052 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "3"" of type '" "int""'");
48053 }
48054 arg3 = static_cast< int >(val3);
48055 }
48056 {
48057 PyThreadState* __tstate = wxPyBeginAllowThreads();
48058 (arg1)->AddGrowableCol(arg2,arg3);
48059 wxPyEndAllowThreads(__tstate);
48060 if (PyErr_Occurred()) SWIG_fail;
48061 }
48062 resultobj = SWIG_Py_Void();
48063 return resultobj;
48064 fail:
48065 return NULL;
48066 }
48067
48068
48069 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48070 PyObject *resultobj = 0;
48071 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48072 size_t arg2 ;
48073 void *argp1 = 0 ;
48074 int res1 = 0 ;
48075 size_t val2 ;
48076 int ecode2 = 0 ;
48077 PyObject * obj0 = 0 ;
48078 PyObject * obj1 = 0 ;
48079 char * kwnames[] = {
48080 (char *) "self",(char *) "idx", NULL
48081 };
48082
48083 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) SWIG_fail;
48084 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48085 if (!SWIG_IsOK(res1)) {
48086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48087 }
48088 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48089 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48090 if (!SWIG_IsOK(ecode2)) {
48091 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
48092 }
48093 arg2 = static_cast< size_t >(val2);
48094 {
48095 PyThreadState* __tstate = wxPyBeginAllowThreads();
48096 (arg1)->RemoveGrowableCol(arg2);
48097 wxPyEndAllowThreads(__tstate);
48098 if (PyErr_Occurred()) SWIG_fail;
48099 }
48100 resultobj = SWIG_Py_Void();
48101 return resultobj;
48102 fail:
48103 return NULL;
48104 }
48105
48106
48107 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48108 PyObject *resultobj = 0;
48109 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48110 int arg2 ;
48111 void *argp1 = 0 ;
48112 int res1 = 0 ;
48113 int val2 ;
48114 int ecode2 = 0 ;
48115 PyObject * obj0 = 0 ;
48116 PyObject * obj1 = 0 ;
48117 char * kwnames[] = {
48118 (char *) "self",(char *) "direction", NULL
48119 };
48120
48121 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) SWIG_fail;
48122 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48123 if (!SWIG_IsOK(res1)) {
48124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48125 }
48126 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48127 ecode2 = SWIG_AsVal_int(obj1, &val2);
48128 if (!SWIG_IsOK(ecode2)) {
48129 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "2"" of type '" "int""'");
48130 }
48131 arg2 = static_cast< int >(val2);
48132 {
48133 PyThreadState* __tstate = wxPyBeginAllowThreads();
48134 (arg1)->SetFlexibleDirection(arg2);
48135 wxPyEndAllowThreads(__tstate);
48136 if (PyErr_Occurred()) SWIG_fail;
48137 }
48138 resultobj = SWIG_Py_Void();
48139 return resultobj;
48140 fail:
48141 return NULL;
48142 }
48143
48144
48145 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48146 PyObject *resultobj = 0;
48147 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48148 int result;
48149 void *argp1 = 0 ;
48150 int res1 = 0 ;
48151 PyObject *swig_obj[1] ;
48152
48153 if (!args) SWIG_fail;
48154 swig_obj[0] = args;
48155 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48156 if (!SWIG_IsOK(res1)) {
48157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48158 }
48159 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48160 {
48161 PyThreadState* __tstate = wxPyBeginAllowThreads();
48162 result = (int)(arg1)->GetFlexibleDirection();
48163 wxPyEndAllowThreads(__tstate);
48164 if (PyErr_Occurred()) SWIG_fail;
48165 }
48166 resultobj = SWIG_From_int(static_cast< int >(result));
48167 return resultobj;
48168 fail:
48169 return NULL;
48170 }
48171
48172
48173 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48174 PyObject *resultobj = 0;
48175 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48176 wxFlexSizerGrowMode arg2 ;
48177 void *argp1 = 0 ;
48178 int res1 = 0 ;
48179 int val2 ;
48180 int ecode2 = 0 ;
48181 PyObject * obj0 = 0 ;
48182 PyObject * obj1 = 0 ;
48183 char * kwnames[] = {
48184 (char *) "self",(char *) "mode", NULL
48185 };
48186
48187 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) SWIG_fail;
48188 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48189 if (!SWIG_IsOK(res1)) {
48190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48191 }
48192 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48193 ecode2 = SWIG_AsVal_int(obj1, &val2);
48194 if (!SWIG_IsOK(ecode2)) {
48195 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "2"" of type '" "wxFlexSizerGrowMode""'");
48196 }
48197 arg2 = static_cast< wxFlexSizerGrowMode >(val2);
48198 {
48199 PyThreadState* __tstate = wxPyBeginAllowThreads();
48200 (arg1)->SetNonFlexibleGrowMode(arg2);
48201 wxPyEndAllowThreads(__tstate);
48202 if (PyErr_Occurred()) SWIG_fail;
48203 }
48204 resultobj = SWIG_Py_Void();
48205 return resultobj;
48206 fail:
48207 return NULL;
48208 }
48209
48210
48211 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48212 PyObject *resultobj = 0;
48213 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48214 wxFlexSizerGrowMode result;
48215 void *argp1 = 0 ;
48216 int res1 = 0 ;
48217 PyObject *swig_obj[1] ;
48218
48219 if (!args) SWIG_fail;
48220 swig_obj[0] = args;
48221 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48222 if (!SWIG_IsOK(res1)) {
48223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48224 }
48225 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48226 {
48227 PyThreadState* __tstate = wxPyBeginAllowThreads();
48228 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
48229 wxPyEndAllowThreads(__tstate);
48230 if (PyErr_Occurred()) SWIG_fail;
48231 }
48232 resultobj = SWIG_From_int(static_cast< int >(result));
48233 return resultobj;
48234 fail:
48235 return NULL;
48236 }
48237
48238
48239 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48240 PyObject *resultobj = 0;
48241 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48242 wxArrayInt *result = 0 ;
48243 void *argp1 = 0 ;
48244 int res1 = 0 ;
48245 PyObject *swig_obj[1] ;
48246
48247 if (!args) SWIG_fail;
48248 swig_obj[0] = args;
48249 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48250 if (!SWIG_IsOK(res1)) {
48251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetRowHeights" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
48252 }
48253 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48254 {
48255 PyThreadState* __tstate = wxPyBeginAllowThreads();
48256 {
48257 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
48258 result = (wxArrayInt *) &_result_ref;
48259 }
48260 wxPyEndAllowThreads(__tstate);
48261 if (PyErr_Occurred()) SWIG_fail;
48262 }
48263 {
48264 resultobj = PyList_New(0);
48265 size_t idx;
48266 for (idx = 0; idx < result->GetCount(); idx += 1) {
48267 PyObject* val = PyInt_FromLong( result->Item(idx) );
48268 PyList_Append(resultobj, val);
48269 Py_DECREF(val);
48270 }
48271 }
48272 return resultobj;
48273 fail:
48274 return NULL;
48275 }
48276
48277
48278 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48279 PyObject *resultobj = 0;
48280 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48281 wxArrayInt *result = 0 ;
48282 void *argp1 = 0 ;
48283 int res1 = 0 ;
48284 PyObject *swig_obj[1] ;
48285
48286 if (!args) SWIG_fail;
48287 swig_obj[0] = args;
48288 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48289 if (!SWIG_IsOK(res1)) {
48290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetColWidths" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
48291 }
48292 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48293 {
48294 PyThreadState* __tstate = wxPyBeginAllowThreads();
48295 {
48296 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
48297 result = (wxArrayInt *) &_result_ref;
48298 }
48299 wxPyEndAllowThreads(__tstate);
48300 if (PyErr_Occurred()) SWIG_fail;
48301 }
48302 {
48303 resultobj = PyList_New(0);
48304 size_t idx;
48305 for (idx = 0; idx < result->GetCount(); idx += 1) {
48306 PyObject* val = PyInt_FromLong( result->Item(idx) );
48307 PyList_Append(resultobj, val);
48308 Py_DECREF(val);
48309 }
48310 }
48311 return resultobj;
48312 fail:
48313 return NULL;
48314 }
48315
48316
48317 SWIGINTERN PyObject *FlexGridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48318 PyObject *obj;
48319 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48320 SWIG_TypeNewClientData(SWIGTYPE_p_wxFlexGridSizer, SWIG_NewClientData(obj));
48321 return SWIG_Py_Void();
48322 }
48323
48324 SWIGINTERN PyObject *FlexGridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48325 return SWIG_Python_InitShadowInstance(args);
48326 }
48327
48328 SWIGINTERN PyObject *_wrap_new_StdDialogButtonSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48329 PyObject *resultobj = 0;
48330 wxStdDialogButtonSizer *result = 0 ;
48331
48332 if (!SWIG_Python_UnpackTuple(args,"new_StdDialogButtonSizer",0,0,0)) SWIG_fail;
48333 {
48334 PyThreadState* __tstate = wxPyBeginAllowThreads();
48335 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
48336 wxPyEndAllowThreads(__tstate);
48337 if (PyErr_Occurred()) SWIG_fail;
48338 }
48339 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_NEW | 0 );
48340 return resultobj;
48341 fail:
48342 return NULL;
48343 }
48344
48345
48346 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48347 PyObject *resultobj = 0;
48348 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48349 wxButton *arg2 = (wxButton *) 0 ;
48350 void *argp1 = 0 ;
48351 int res1 = 0 ;
48352 void *argp2 = 0 ;
48353 int res2 = 0 ;
48354 PyObject * obj0 = 0 ;
48355 PyObject * obj1 = 0 ;
48356 char * kwnames[] = {
48357 (char *) "self",(char *) "button", NULL
48358 };
48359
48360 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) SWIG_fail;
48361 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48362 if (!SWIG_IsOK(res1)) {
48363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48364 }
48365 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48366 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48367 if (!SWIG_IsOK(res2)) {
48368 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "2"" of type '" "wxButton *""'");
48369 }
48370 arg2 = reinterpret_cast< wxButton * >(argp2);
48371 {
48372 PyThreadState* __tstate = wxPyBeginAllowThreads();
48373 (arg1)->AddButton(arg2);
48374 wxPyEndAllowThreads(__tstate);
48375 if (PyErr_Occurred()) SWIG_fail;
48376 }
48377 resultobj = SWIG_Py_Void();
48378 return resultobj;
48379 fail:
48380 return NULL;
48381 }
48382
48383
48384 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48385 PyObject *resultobj = 0;
48386 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48387 void *argp1 = 0 ;
48388 int res1 = 0 ;
48389 PyObject *swig_obj[1] ;
48390
48391 if (!args) SWIG_fail;
48392 swig_obj[0] = args;
48393 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48394 if (!SWIG_IsOK(res1)) {
48395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_Realize" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48396 }
48397 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48398 {
48399 PyThreadState* __tstate = wxPyBeginAllowThreads();
48400 (arg1)->Realize();
48401 wxPyEndAllowThreads(__tstate);
48402 if (PyErr_Occurred()) SWIG_fail;
48403 }
48404 resultobj = SWIG_Py_Void();
48405 return resultobj;
48406 fail:
48407 return NULL;
48408 }
48409
48410
48411 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48412 PyObject *resultobj = 0;
48413 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48414 wxButton *arg2 = (wxButton *) 0 ;
48415 void *argp1 = 0 ;
48416 int res1 = 0 ;
48417 void *argp2 = 0 ;
48418 int res2 = 0 ;
48419 PyObject * obj0 = 0 ;
48420 PyObject * obj1 = 0 ;
48421 char * kwnames[] = {
48422 (char *) "self",(char *) "button", NULL
48423 };
48424
48425 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
48426 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48427 if (!SWIG_IsOK(res1)) {
48428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48429 }
48430 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48431 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48432 if (!SWIG_IsOK(res2)) {
48433 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
48434 }
48435 arg2 = reinterpret_cast< wxButton * >(argp2);
48436 {
48437 PyThreadState* __tstate = wxPyBeginAllowThreads();
48438 (arg1)->SetAffirmativeButton(arg2);
48439 wxPyEndAllowThreads(__tstate);
48440 if (PyErr_Occurred()) SWIG_fail;
48441 }
48442 resultobj = SWIG_Py_Void();
48443 return resultobj;
48444 fail:
48445 return NULL;
48446 }
48447
48448
48449 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48450 PyObject *resultobj = 0;
48451 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48452 wxButton *arg2 = (wxButton *) 0 ;
48453 void *argp1 = 0 ;
48454 int res1 = 0 ;
48455 void *argp2 = 0 ;
48456 int res2 = 0 ;
48457 PyObject * obj0 = 0 ;
48458 PyObject * obj1 = 0 ;
48459 char * kwnames[] = {
48460 (char *) "self",(char *) "button", NULL
48461 };
48462
48463 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
48464 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48465 if (!SWIG_IsOK(res1)) {
48466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48467 }
48468 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48469 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48470 if (!SWIG_IsOK(res2)) {
48471 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
48472 }
48473 arg2 = reinterpret_cast< wxButton * >(argp2);
48474 {
48475 PyThreadState* __tstate = wxPyBeginAllowThreads();
48476 (arg1)->SetNegativeButton(arg2);
48477 wxPyEndAllowThreads(__tstate);
48478 if (PyErr_Occurred()) SWIG_fail;
48479 }
48480 resultobj = SWIG_Py_Void();
48481 return resultobj;
48482 fail:
48483 return NULL;
48484 }
48485
48486
48487 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48488 PyObject *resultobj = 0;
48489 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48490 wxButton *arg2 = (wxButton *) 0 ;
48491 void *argp1 = 0 ;
48492 int res1 = 0 ;
48493 void *argp2 = 0 ;
48494 int res2 = 0 ;
48495 PyObject * obj0 = 0 ;
48496 PyObject * obj1 = 0 ;
48497 char * kwnames[] = {
48498 (char *) "self",(char *) "button", NULL
48499 };
48500
48501 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) SWIG_fail;
48502 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48503 if (!SWIG_IsOK(res1)) {
48504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48505 }
48506 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48507 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48508 if (!SWIG_IsOK(res2)) {
48509 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "2"" of type '" "wxButton *""'");
48510 }
48511 arg2 = reinterpret_cast< wxButton * >(argp2);
48512 {
48513 PyThreadState* __tstate = wxPyBeginAllowThreads();
48514 (arg1)->SetCancelButton(arg2);
48515 wxPyEndAllowThreads(__tstate);
48516 if (PyErr_Occurred()) SWIG_fail;
48517 }
48518 resultobj = SWIG_Py_Void();
48519 return resultobj;
48520 fail:
48521 return NULL;
48522 }
48523
48524
48525 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48526 PyObject *resultobj = 0;
48527 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48528 wxButton *result = 0 ;
48529 void *argp1 = 0 ;
48530 int res1 = 0 ;
48531 PyObject *swig_obj[1] ;
48532
48533 if (!args) SWIG_fail;
48534 swig_obj[0] = args;
48535 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48536 if (!SWIG_IsOK(res1)) {
48537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48538 }
48539 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48540 {
48541 PyThreadState* __tstate = wxPyBeginAllowThreads();
48542 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
48543 wxPyEndAllowThreads(__tstate);
48544 if (PyErr_Occurred()) SWIG_fail;
48545 }
48546 {
48547 resultobj = wxPyMake_wxObject(result, (bool)0);
48548 }
48549 return resultobj;
48550 fail:
48551 return NULL;
48552 }
48553
48554
48555 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48556 PyObject *resultobj = 0;
48557 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48558 wxButton *result = 0 ;
48559 void *argp1 = 0 ;
48560 int res1 = 0 ;
48561 PyObject *swig_obj[1] ;
48562
48563 if (!args) SWIG_fail;
48564 swig_obj[0] = args;
48565 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48566 if (!SWIG_IsOK(res1)) {
48567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetApplyButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48568 }
48569 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48570 {
48571 PyThreadState* __tstate = wxPyBeginAllowThreads();
48572 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
48573 wxPyEndAllowThreads(__tstate);
48574 if (PyErr_Occurred()) SWIG_fail;
48575 }
48576 {
48577 resultobj = wxPyMake_wxObject(result, (bool)0);
48578 }
48579 return resultobj;
48580 fail:
48581 return NULL;
48582 }
48583
48584
48585 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48586 PyObject *resultobj = 0;
48587 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48588 wxButton *result = 0 ;
48589 void *argp1 = 0 ;
48590 int res1 = 0 ;
48591 PyObject *swig_obj[1] ;
48592
48593 if (!args) SWIG_fail;
48594 swig_obj[0] = args;
48595 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48596 if (!SWIG_IsOK(res1)) {
48597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48598 }
48599 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48600 {
48601 PyThreadState* __tstate = wxPyBeginAllowThreads();
48602 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
48603 wxPyEndAllowThreads(__tstate);
48604 if (PyErr_Occurred()) SWIG_fail;
48605 }
48606 {
48607 resultobj = wxPyMake_wxObject(result, (bool)0);
48608 }
48609 return resultobj;
48610 fail:
48611 return NULL;
48612 }
48613
48614
48615 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48616 PyObject *resultobj = 0;
48617 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48618 wxButton *result = 0 ;
48619 void *argp1 = 0 ;
48620 int res1 = 0 ;
48621 PyObject *swig_obj[1] ;
48622
48623 if (!args) SWIG_fail;
48624 swig_obj[0] = args;
48625 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48626 if (!SWIG_IsOK(res1)) {
48627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48628 }
48629 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48630 {
48631 PyThreadState* __tstate = wxPyBeginAllowThreads();
48632 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
48633 wxPyEndAllowThreads(__tstate);
48634 if (PyErr_Occurred()) SWIG_fail;
48635 }
48636 {
48637 resultobj = wxPyMake_wxObject(result, (bool)0);
48638 }
48639 return resultobj;
48640 fail:
48641 return NULL;
48642 }
48643
48644
48645 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48646 PyObject *resultobj = 0;
48647 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48648 wxButton *result = 0 ;
48649 void *argp1 = 0 ;
48650 int res1 = 0 ;
48651 PyObject *swig_obj[1] ;
48652
48653 if (!args) SWIG_fail;
48654 swig_obj[0] = args;
48655 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48656 if (!SWIG_IsOK(res1)) {
48657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetHelpButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48658 }
48659 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48660 {
48661 PyThreadState* __tstate = wxPyBeginAllowThreads();
48662 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
48663 wxPyEndAllowThreads(__tstate);
48664 if (PyErr_Occurred()) SWIG_fail;
48665 }
48666 {
48667 resultobj = wxPyMake_wxObject(result, (bool)0);
48668 }
48669 return resultobj;
48670 fail:
48671 return NULL;
48672 }
48673
48674
48675 SWIGINTERN PyObject *StdDialogButtonSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48676 PyObject *obj;
48677 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48678 SWIG_TypeNewClientData(SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_NewClientData(obj));
48679 return SWIG_Py_Void();
48680 }
48681
48682 SWIGINTERN PyObject *StdDialogButtonSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48683 return SWIG_Python_InitShadowInstance(args);
48684 }
48685
48686 SWIGINTERN PyObject *_wrap_new_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48687 PyObject *resultobj = 0;
48688 int arg1 = (int) 0 ;
48689 int arg2 = (int) 0 ;
48690 wxGBPosition *result = 0 ;
48691 int val1 ;
48692 int ecode1 = 0 ;
48693 int val2 ;
48694 int ecode2 = 0 ;
48695 PyObject * obj0 = 0 ;
48696 PyObject * obj1 = 0 ;
48697 char * kwnames[] = {
48698 (char *) "row",(char *) "col", NULL
48699 };
48700
48701 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) SWIG_fail;
48702 if (obj0) {
48703 ecode1 = SWIG_AsVal_int(obj0, &val1);
48704 if (!SWIG_IsOK(ecode1)) {
48705 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBPosition" "', expected argument " "1"" of type '" "int""'");
48706 }
48707 arg1 = static_cast< int >(val1);
48708 }
48709 if (obj1) {
48710 ecode2 = SWIG_AsVal_int(obj1, &val2);
48711 if (!SWIG_IsOK(ecode2)) {
48712 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBPosition" "', expected argument " "2"" of type '" "int""'");
48713 }
48714 arg2 = static_cast< int >(val2);
48715 }
48716 {
48717 PyThreadState* __tstate = wxPyBeginAllowThreads();
48718 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
48719 wxPyEndAllowThreads(__tstate);
48720 if (PyErr_Occurred()) SWIG_fail;
48721 }
48722 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_NEW | 0 );
48723 return resultobj;
48724 fail:
48725 return NULL;
48726 }
48727
48728
48729 SWIGINTERN PyObject *_wrap_delete_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48730 PyObject *resultobj = 0;
48731 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48732 void *argp1 = 0 ;
48733 int res1 = 0 ;
48734 PyObject *swig_obj[1] ;
48735
48736 if (!args) SWIG_fail;
48737 swig_obj[0] = args;
48738 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, SWIG_POINTER_DISOWN | 0 );
48739 if (!SWIG_IsOK(res1)) {
48740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBPosition" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48741 }
48742 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48743 {
48744 PyThreadState* __tstate = wxPyBeginAllowThreads();
48745 delete arg1;
48746
48747 wxPyEndAllowThreads(__tstate);
48748 if (PyErr_Occurred()) SWIG_fail;
48749 }
48750 resultobj = SWIG_Py_Void();
48751 return resultobj;
48752 fail:
48753 return NULL;
48754 }
48755
48756
48757 SWIGINTERN PyObject *_wrap_GBPosition_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48758 PyObject *resultobj = 0;
48759 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48760 int result;
48761 void *argp1 = 0 ;
48762 int res1 = 0 ;
48763 PyObject *swig_obj[1] ;
48764
48765 if (!args) SWIG_fail;
48766 swig_obj[0] = args;
48767 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48768 if (!SWIG_IsOK(res1)) {
48769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetRow" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
48770 }
48771 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48772 {
48773 PyThreadState* __tstate = wxPyBeginAllowThreads();
48774 result = (int)((wxGBPosition const *)arg1)->GetRow();
48775 wxPyEndAllowThreads(__tstate);
48776 if (PyErr_Occurred()) SWIG_fail;
48777 }
48778 resultobj = SWIG_From_int(static_cast< int >(result));
48779 return resultobj;
48780 fail:
48781 return NULL;
48782 }
48783
48784
48785 SWIGINTERN PyObject *_wrap_GBPosition_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48786 PyObject *resultobj = 0;
48787 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48788 int result;
48789 void *argp1 = 0 ;
48790 int res1 = 0 ;
48791 PyObject *swig_obj[1] ;
48792
48793 if (!args) SWIG_fail;
48794 swig_obj[0] = args;
48795 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48796 if (!SWIG_IsOK(res1)) {
48797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetCol" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
48798 }
48799 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48800 {
48801 PyThreadState* __tstate = wxPyBeginAllowThreads();
48802 result = (int)((wxGBPosition const *)arg1)->GetCol();
48803 wxPyEndAllowThreads(__tstate);
48804 if (PyErr_Occurred()) SWIG_fail;
48805 }
48806 resultobj = SWIG_From_int(static_cast< int >(result));
48807 return resultobj;
48808 fail:
48809 return NULL;
48810 }
48811
48812
48813 SWIGINTERN PyObject *_wrap_GBPosition_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48814 PyObject *resultobj = 0;
48815 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48816 int arg2 ;
48817 void *argp1 = 0 ;
48818 int res1 = 0 ;
48819 int val2 ;
48820 int ecode2 = 0 ;
48821 PyObject * obj0 = 0 ;
48822 PyObject * obj1 = 0 ;
48823 char * kwnames[] = {
48824 (char *) "self",(char *) "row", NULL
48825 };
48826
48827 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
48828 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48829 if (!SWIG_IsOK(res1)) {
48830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetRow" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48831 }
48832 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48833 ecode2 = SWIG_AsVal_int(obj1, &val2);
48834 if (!SWIG_IsOK(ecode2)) {
48835 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetRow" "', expected argument " "2"" of type '" "int""'");
48836 }
48837 arg2 = static_cast< int >(val2);
48838 {
48839 PyThreadState* __tstate = wxPyBeginAllowThreads();
48840 (arg1)->SetRow(arg2);
48841 wxPyEndAllowThreads(__tstate);
48842 if (PyErr_Occurred()) SWIG_fail;
48843 }
48844 resultobj = SWIG_Py_Void();
48845 return resultobj;
48846 fail:
48847 return NULL;
48848 }
48849
48850
48851 SWIGINTERN PyObject *_wrap_GBPosition_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48852 PyObject *resultobj = 0;
48853 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48854 int arg2 ;
48855 void *argp1 = 0 ;
48856 int res1 = 0 ;
48857 int val2 ;
48858 int ecode2 = 0 ;
48859 PyObject * obj0 = 0 ;
48860 PyObject * obj1 = 0 ;
48861 char * kwnames[] = {
48862 (char *) "self",(char *) "col", NULL
48863 };
48864
48865 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
48866 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48867 if (!SWIG_IsOK(res1)) {
48868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetCol" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48869 }
48870 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48871 ecode2 = SWIG_AsVal_int(obj1, &val2);
48872 if (!SWIG_IsOK(ecode2)) {
48873 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetCol" "', expected argument " "2"" of type '" "int""'");
48874 }
48875 arg2 = static_cast< int >(val2);
48876 {
48877 PyThreadState* __tstate = wxPyBeginAllowThreads();
48878 (arg1)->SetCol(arg2);
48879 wxPyEndAllowThreads(__tstate);
48880 if (PyErr_Occurred()) SWIG_fail;
48881 }
48882 resultobj = SWIG_Py_Void();
48883 return resultobj;
48884 fail:
48885 return NULL;
48886 }
48887
48888
48889 SWIGINTERN PyObject *_wrap_GBPosition___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48890 PyObject *resultobj = 0;
48891 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48892 PyObject *arg2 = (PyObject *) 0 ;
48893 bool result;
48894 void *argp1 = 0 ;
48895 int res1 = 0 ;
48896 PyObject * obj0 = 0 ;
48897 PyObject * obj1 = 0 ;
48898 char * kwnames[] = {
48899 (char *) "self",(char *) "other", NULL
48900 };
48901
48902 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
48903 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48904 if (!SWIG_IsOK(res1)) {
48905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___eq__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48906 }
48907 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48908 arg2 = obj1;
48909 {
48910 result = (bool)wxGBPosition___eq__(arg1,arg2);
48911 if (PyErr_Occurred()) SWIG_fail;
48912 }
48913 {
48914 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48915 }
48916 return resultobj;
48917 fail:
48918 return NULL;
48919 }
48920
48921
48922 SWIGINTERN PyObject *_wrap_GBPosition___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48923 PyObject *resultobj = 0;
48924 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48925 PyObject *arg2 = (PyObject *) 0 ;
48926 bool result;
48927 void *argp1 = 0 ;
48928 int res1 = 0 ;
48929 PyObject * obj0 = 0 ;
48930 PyObject * obj1 = 0 ;
48931 char * kwnames[] = {
48932 (char *) "self",(char *) "other", NULL
48933 };
48934
48935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
48936 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48937 if (!SWIG_IsOK(res1)) {
48938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___ne__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48939 }
48940 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48941 arg2 = obj1;
48942 {
48943 result = (bool)wxGBPosition___ne__(arg1,arg2);
48944 if (PyErr_Occurred()) SWIG_fail;
48945 }
48946 {
48947 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48948 }
48949 return resultobj;
48950 fail:
48951 return NULL;
48952 }
48953
48954
48955 SWIGINTERN PyObject *_wrap_GBPosition_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48956 PyObject *resultobj = 0;
48957 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48958 int arg2 = (int) 0 ;
48959 int arg3 = (int) 0 ;
48960 void *argp1 = 0 ;
48961 int res1 = 0 ;
48962 int val2 ;
48963 int ecode2 = 0 ;
48964 int val3 ;
48965 int ecode3 = 0 ;
48966 PyObject * obj0 = 0 ;
48967 PyObject * obj1 = 0 ;
48968 PyObject * obj2 = 0 ;
48969 char * kwnames[] = {
48970 (char *) "self",(char *) "row",(char *) "col", NULL
48971 };
48972
48973 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48974 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48975 if (!SWIG_IsOK(res1)) {
48976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Set" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48977 }
48978 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48979 if (obj1) {
48980 ecode2 = SWIG_AsVal_int(obj1, &val2);
48981 if (!SWIG_IsOK(ecode2)) {
48982 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_Set" "', expected argument " "2"" of type '" "int""'");
48983 }
48984 arg2 = static_cast< int >(val2);
48985 }
48986 if (obj2) {
48987 ecode3 = SWIG_AsVal_int(obj2, &val3);
48988 if (!SWIG_IsOK(ecode3)) {
48989 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBPosition_Set" "', expected argument " "3"" of type '" "int""'");
48990 }
48991 arg3 = static_cast< int >(val3);
48992 }
48993 {
48994 PyThreadState* __tstate = wxPyBeginAllowThreads();
48995 wxGBPosition_Set(arg1,arg2,arg3);
48996 wxPyEndAllowThreads(__tstate);
48997 if (PyErr_Occurred()) SWIG_fail;
48998 }
48999 resultobj = SWIG_Py_Void();
49000 return resultobj;
49001 fail:
49002 return NULL;
49003 }
49004
49005
49006 SWIGINTERN PyObject *_wrap_GBPosition_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49007 PyObject *resultobj = 0;
49008 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49009 PyObject *result = 0 ;
49010 void *argp1 = 0 ;
49011 int res1 = 0 ;
49012 PyObject *swig_obj[1] ;
49013
49014 if (!args) SWIG_fail;
49015 swig_obj[0] = args;
49016 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49017 if (!SWIG_IsOK(res1)) {
49018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Get" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49019 }
49020 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49021 {
49022 PyThreadState* __tstate = wxPyBeginAllowThreads();
49023 result = (PyObject *)wxGBPosition_Get(arg1);
49024 wxPyEndAllowThreads(__tstate);
49025 if (PyErr_Occurred()) SWIG_fail;
49026 }
49027 resultobj = result;
49028 return resultobj;
49029 fail:
49030 return NULL;
49031 }
49032
49033
49034 SWIGINTERN PyObject *GBPosition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49035 PyObject *obj;
49036 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49037 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBPosition, SWIG_NewClientData(obj));
49038 return SWIG_Py_Void();
49039 }
49040
49041 SWIGINTERN PyObject *GBPosition_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49042 return SWIG_Python_InitShadowInstance(args);
49043 }
49044
49045 SWIGINTERN PyObject *_wrap_new_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49046 PyObject *resultobj = 0;
49047 int arg1 = (int) 1 ;
49048 int arg2 = (int) 1 ;
49049 wxGBSpan *result = 0 ;
49050 int val1 ;
49051 int ecode1 = 0 ;
49052 int val2 ;
49053 int ecode2 = 0 ;
49054 PyObject * obj0 = 0 ;
49055 PyObject * obj1 = 0 ;
49056 char * kwnames[] = {
49057 (char *) "rowspan",(char *) "colspan", NULL
49058 };
49059
49060 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) SWIG_fail;
49061 if (obj0) {
49062 ecode1 = SWIG_AsVal_int(obj0, &val1);
49063 if (!SWIG_IsOK(ecode1)) {
49064 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSpan" "', expected argument " "1"" of type '" "int""'");
49065 }
49066 arg1 = static_cast< int >(val1);
49067 }
49068 if (obj1) {
49069 ecode2 = SWIG_AsVal_int(obj1, &val2);
49070 if (!SWIG_IsOK(ecode2)) {
49071 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSpan" "', expected argument " "2"" of type '" "int""'");
49072 }
49073 arg2 = static_cast< int >(val2);
49074 }
49075 {
49076 PyThreadState* __tstate = wxPyBeginAllowThreads();
49077 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
49078 wxPyEndAllowThreads(__tstate);
49079 if (PyErr_Occurred()) SWIG_fail;
49080 }
49081 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_NEW | 0 );
49082 return resultobj;
49083 fail:
49084 return NULL;
49085 }
49086
49087
49088 SWIGINTERN PyObject *_wrap_delete_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49089 PyObject *resultobj = 0;
49090 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49091 void *argp1 = 0 ;
49092 int res1 = 0 ;
49093 PyObject *swig_obj[1] ;
49094
49095 if (!args) SWIG_fail;
49096 swig_obj[0] = args;
49097 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, SWIG_POINTER_DISOWN | 0 );
49098 if (!SWIG_IsOK(res1)) {
49099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSpan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49100 }
49101 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49102 {
49103 PyThreadState* __tstate = wxPyBeginAllowThreads();
49104 delete arg1;
49105
49106 wxPyEndAllowThreads(__tstate);
49107 if (PyErr_Occurred()) SWIG_fail;
49108 }
49109 resultobj = SWIG_Py_Void();
49110 return resultobj;
49111 fail:
49112 return NULL;
49113 }
49114
49115
49116 SWIGINTERN PyObject *_wrap_GBSpan_GetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49117 PyObject *resultobj = 0;
49118 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49119 int result;
49120 void *argp1 = 0 ;
49121 int res1 = 0 ;
49122 PyObject *swig_obj[1] ;
49123
49124 if (!args) SWIG_fail;
49125 swig_obj[0] = args;
49126 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49127 if (!SWIG_IsOK(res1)) {
49128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetRowspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
49129 }
49130 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49131 {
49132 PyThreadState* __tstate = wxPyBeginAllowThreads();
49133 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
49134 wxPyEndAllowThreads(__tstate);
49135 if (PyErr_Occurred()) SWIG_fail;
49136 }
49137 resultobj = SWIG_From_int(static_cast< int >(result));
49138 return resultobj;
49139 fail:
49140 return NULL;
49141 }
49142
49143
49144 SWIGINTERN PyObject *_wrap_GBSpan_GetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49145 PyObject *resultobj = 0;
49146 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49147 int result;
49148 void *argp1 = 0 ;
49149 int res1 = 0 ;
49150 PyObject *swig_obj[1] ;
49151
49152 if (!args) SWIG_fail;
49153 swig_obj[0] = args;
49154 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49155 if (!SWIG_IsOK(res1)) {
49156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetColspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
49157 }
49158 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49159 {
49160 PyThreadState* __tstate = wxPyBeginAllowThreads();
49161 result = (int)((wxGBSpan const *)arg1)->GetColspan();
49162 wxPyEndAllowThreads(__tstate);
49163 if (PyErr_Occurred()) SWIG_fail;
49164 }
49165 resultobj = SWIG_From_int(static_cast< int >(result));
49166 return resultobj;
49167 fail:
49168 return NULL;
49169 }
49170
49171
49172 SWIGINTERN PyObject *_wrap_GBSpan_SetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49173 PyObject *resultobj = 0;
49174 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49175 int arg2 ;
49176 void *argp1 = 0 ;
49177 int res1 = 0 ;
49178 int val2 ;
49179 int ecode2 = 0 ;
49180 PyObject * obj0 = 0 ;
49181 PyObject * obj1 = 0 ;
49182 char * kwnames[] = {
49183 (char *) "self",(char *) "rowspan", NULL
49184 };
49185
49186 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) SWIG_fail;
49187 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49188 if (!SWIG_IsOK(res1)) {
49189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetRowspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49190 }
49191 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49192 ecode2 = SWIG_AsVal_int(obj1, &val2);
49193 if (!SWIG_IsOK(ecode2)) {
49194 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetRowspan" "', expected argument " "2"" of type '" "int""'");
49195 }
49196 arg2 = static_cast< int >(val2);
49197 {
49198 PyThreadState* __tstate = wxPyBeginAllowThreads();
49199 (arg1)->SetRowspan(arg2);
49200 wxPyEndAllowThreads(__tstate);
49201 if (PyErr_Occurred()) SWIG_fail;
49202 }
49203 resultobj = SWIG_Py_Void();
49204 return resultobj;
49205 fail:
49206 return NULL;
49207 }
49208
49209
49210 SWIGINTERN PyObject *_wrap_GBSpan_SetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49211 PyObject *resultobj = 0;
49212 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49213 int arg2 ;
49214 void *argp1 = 0 ;
49215 int res1 = 0 ;
49216 int val2 ;
49217 int ecode2 = 0 ;
49218 PyObject * obj0 = 0 ;
49219 PyObject * obj1 = 0 ;
49220 char * kwnames[] = {
49221 (char *) "self",(char *) "colspan", NULL
49222 };
49223
49224 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) SWIG_fail;
49225 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49226 if (!SWIG_IsOK(res1)) {
49227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetColspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49228 }
49229 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49230 ecode2 = SWIG_AsVal_int(obj1, &val2);
49231 if (!SWIG_IsOK(ecode2)) {
49232 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetColspan" "', expected argument " "2"" of type '" "int""'");
49233 }
49234 arg2 = static_cast< int >(val2);
49235 {
49236 PyThreadState* __tstate = wxPyBeginAllowThreads();
49237 (arg1)->SetColspan(arg2);
49238 wxPyEndAllowThreads(__tstate);
49239 if (PyErr_Occurred()) SWIG_fail;
49240 }
49241 resultobj = SWIG_Py_Void();
49242 return resultobj;
49243 fail:
49244 return NULL;
49245 }
49246
49247
49248 SWIGINTERN PyObject *_wrap_GBSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49249 PyObject *resultobj = 0;
49250 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49251 PyObject *arg2 = (PyObject *) 0 ;
49252 bool result;
49253 void *argp1 = 0 ;
49254 int res1 = 0 ;
49255 PyObject * obj0 = 0 ;
49256 PyObject * obj1 = 0 ;
49257 char * kwnames[] = {
49258 (char *) "self",(char *) "other", NULL
49259 };
49260
49261 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
49262 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49263 if (!SWIG_IsOK(res1)) {
49264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___eq__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49265 }
49266 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49267 arg2 = obj1;
49268 {
49269 result = (bool)wxGBSpan___eq__(arg1,arg2);
49270 if (PyErr_Occurred()) SWIG_fail;
49271 }
49272 {
49273 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49274 }
49275 return resultobj;
49276 fail:
49277 return NULL;
49278 }
49279
49280
49281 SWIGINTERN PyObject *_wrap_GBSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49282 PyObject *resultobj = 0;
49283 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49284 PyObject *arg2 = (PyObject *) 0 ;
49285 bool result;
49286 void *argp1 = 0 ;
49287 int res1 = 0 ;
49288 PyObject * obj0 = 0 ;
49289 PyObject * obj1 = 0 ;
49290 char * kwnames[] = {
49291 (char *) "self",(char *) "other", NULL
49292 };
49293
49294 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
49295 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49296 if (!SWIG_IsOK(res1)) {
49297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___ne__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49298 }
49299 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49300 arg2 = obj1;
49301 {
49302 result = (bool)wxGBSpan___ne__(arg1,arg2);
49303 if (PyErr_Occurred()) SWIG_fail;
49304 }
49305 {
49306 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49307 }
49308 return resultobj;
49309 fail:
49310 return NULL;
49311 }
49312
49313
49314 SWIGINTERN PyObject *_wrap_GBSpan_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49315 PyObject *resultobj = 0;
49316 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49317 int arg2 = (int) 1 ;
49318 int arg3 = (int) 1 ;
49319 void *argp1 = 0 ;
49320 int res1 = 0 ;
49321 int val2 ;
49322 int ecode2 = 0 ;
49323 int val3 ;
49324 int ecode3 = 0 ;
49325 PyObject * obj0 = 0 ;
49326 PyObject * obj1 = 0 ;
49327 PyObject * obj2 = 0 ;
49328 char * kwnames[] = {
49329 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
49330 };
49331
49332 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49333 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49334 if (!SWIG_IsOK(res1)) {
49335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Set" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49336 }
49337 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49338 if (obj1) {
49339 ecode2 = SWIG_AsVal_int(obj1, &val2);
49340 if (!SWIG_IsOK(ecode2)) {
49341 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_Set" "', expected argument " "2"" of type '" "int""'");
49342 }
49343 arg2 = static_cast< int >(val2);
49344 }
49345 if (obj2) {
49346 ecode3 = SWIG_AsVal_int(obj2, &val3);
49347 if (!SWIG_IsOK(ecode3)) {
49348 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBSpan_Set" "', expected argument " "3"" of type '" "int""'");
49349 }
49350 arg3 = static_cast< int >(val3);
49351 }
49352 {
49353 PyThreadState* __tstate = wxPyBeginAllowThreads();
49354 wxGBSpan_Set(arg1,arg2,arg3);
49355 wxPyEndAllowThreads(__tstate);
49356 if (PyErr_Occurred()) SWIG_fail;
49357 }
49358 resultobj = SWIG_Py_Void();
49359 return resultobj;
49360 fail:
49361 return NULL;
49362 }
49363
49364
49365 SWIGINTERN PyObject *_wrap_GBSpan_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49366 PyObject *resultobj = 0;
49367 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49368 PyObject *result = 0 ;
49369 void *argp1 = 0 ;
49370 int res1 = 0 ;
49371 PyObject *swig_obj[1] ;
49372
49373 if (!args) SWIG_fail;
49374 swig_obj[0] = args;
49375 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49376 if (!SWIG_IsOK(res1)) {
49377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Get" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49378 }
49379 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49380 {
49381 PyThreadState* __tstate = wxPyBeginAllowThreads();
49382 result = (PyObject *)wxGBSpan_Get(arg1);
49383 wxPyEndAllowThreads(__tstate);
49384 if (PyErr_Occurred()) SWIG_fail;
49385 }
49386 resultobj = result;
49387 return resultobj;
49388 fail:
49389 return NULL;
49390 }
49391
49392
49393 SWIGINTERN PyObject *GBSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49394 PyObject *obj;
49395 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49396 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSpan, SWIG_NewClientData(obj));
49397 return SWIG_Py_Void();
49398 }
49399
49400 SWIGINTERN PyObject *GBSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49401 return SWIG_Python_InitShadowInstance(args);
49402 }
49403
49404 SWIGINTERN int DefaultSpan_set(PyObject *) {
49405 SWIG_Error(SWIG_AttributeError,"Variable DefaultSpan is read-only.");
49406 return 1;
49407 }
49408
49409
49410 SWIGINTERN PyObject *DefaultSpan_get(void) {
49411 PyObject *pyobj = 0;
49412
49413 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0 );
49414 return pyobj;
49415 }
49416
49417
49418 SWIGINTERN PyObject *_wrap_new_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49419 PyObject *resultobj = 0;
49420 wxGBSizerItem *result = 0 ;
49421
49422 if (!SWIG_Python_UnpackTuple(args,"new_GBSizerItem",0,0,0)) SWIG_fail;
49423 {
49424 PyThreadState* __tstate = wxPyBeginAllowThreads();
49425 result = (wxGBSizerItem *)new wxGBSizerItem();
49426 wxPyEndAllowThreads(__tstate);
49427 if (PyErr_Occurred()) SWIG_fail;
49428 }
49429 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_NEW | 0 );
49430 return resultobj;
49431 fail:
49432 return NULL;
49433 }
49434
49435
49436 SWIGINTERN PyObject *_wrap_delete_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49437 PyObject *resultobj = 0;
49438 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49439 void *argp1 = 0 ;
49440 int res1 = 0 ;
49441 PyObject *swig_obj[1] ;
49442
49443 if (!args) SWIG_fail;
49444 swig_obj[0] = args;
49445 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
49446 if (!SWIG_IsOK(res1)) {
49447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSizerItem" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49448 }
49449 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49450 {
49451 PyThreadState* __tstate = wxPyBeginAllowThreads();
49452 delete arg1;
49453
49454 wxPyEndAllowThreads(__tstate);
49455 if (PyErr_Occurred()) SWIG_fail;
49456 }
49457 resultobj = SWIG_Py_Void();
49458 return resultobj;
49459 fail:
49460 return NULL;
49461 }
49462
49463
49464 SWIGINTERN PyObject *_wrap_new_GBSizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49465 PyObject *resultobj = 0;
49466 wxWindow *arg1 = (wxWindow *) 0 ;
49467 wxGBPosition *arg2 = 0 ;
49468 wxGBSpan *arg3 = 0 ;
49469 int arg4 ;
49470 int arg5 ;
49471 PyObject *arg6 = (PyObject *) NULL ;
49472 wxGBSizerItem *result = 0 ;
49473 void *argp1 = 0 ;
49474 int res1 = 0 ;
49475 wxGBPosition temp2 ;
49476 wxGBSpan temp3 ;
49477 int val4 ;
49478 int ecode4 = 0 ;
49479 int val5 ;
49480 int ecode5 = 0 ;
49481 PyObject * obj0 = 0 ;
49482 PyObject * obj1 = 0 ;
49483 PyObject * obj2 = 0 ;
49484 PyObject * obj3 = 0 ;
49485 PyObject * obj4 = 0 ;
49486 PyObject * obj5 = 0 ;
49487 char * kwnames[] = {
49488 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49489 };
49490
49491 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49492 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
49493 if (!SWIG_IsOK(res1)) {
49494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
49495 }
49496 arg1 = reinterpret_cast< wxWindow * >(argp1);
49497 {
49498 arg2 = &temp2;
49499 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49500 }
49501 {
49502 arg3 = &temp3;
49503 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
49504 }
49505 ecode4 = SWIG_AsVal_int(obj3, &val4);
49506 if (!SWIG_IsOK(ecode4)) {
49507 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemWindow" "', expected argument " "4"" of type '" "int""'");
49508 }
49509 arg4 = static_cast< int >(val4);
49510 ecode5 = SWIG_AsVal_int(obj4, &val5);
49511 if (!SWIG_IsOK(ecode5)) {
49512 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemWindow" "', expected argument " "5"" of type '" "int""'");
49513 }
49514 arg5 = static_cast< int >(val5);
49515 if (obj5) {
49516 arg6 = obj5;
49517 }
49518 {
49519 PyThreadState* __tstate = wxPyBeginAllowThreads();
49520 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
49521 wxPyEndAllowThreads(__tstate);
49522 if (PyErr_Occurred()) SWIG_fail;
49523 }
49524 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49525 return resultobj;
49526 fail:
49527 return NULL;
49528 }
49529
49530
49531 SWIGINTERN PyObject *_wrap_new_GBSizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49532 PyObject *resultobj = 0;
49533 wxSizer *arg1 = (wxSizer *) 0 ;
49534 wxGBPosition *arg2 = 0 ;
49535 wxGBSpan *arg3 = 0 ;
49536 int arg4 ;
49537 int arg5 ;
49538 PyObject *arg6 = (PyObject *) NULL ;
49539 wxGBSizerItem *result = 0 ;
49540 int res1 = 0 ;
49541 wxGBPosition temp2 ;
49542 wxGBSpan temp3 ;
49543 int val4 ;
49544 int ecode4 = 0 ;
49545 int val5 ;
49546 int ecode5 = 0 ;
49547 PyObject * obj0 = 0 ;
49548 PyObject * obj1 = 0 ;
49549 PyObject * obj2 = 0 ;
49550 PyObject * obj3 = 0 ;
49551 PyObject * obj4 = 0 ;
49552 PyObject * obj5 = 0 ;
49553 char * kwnames[] = {
49554 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49555 };
49556
49557 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49558 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
49559 if (!SWIG_IsOK(res1)) {
49560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
49561 }
49562 {
49563 arg2 = &temp2;
49564 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49565 }
49566 {
49567 arg3 = &temp3;
49568 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
49569 }
49570 ecode4 = SWIG_AsVal_int(obj3, &val4);
49571 if (!SWIG_IsOK(ecode4)) {
49572 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemSizer" "', expected argument " "4"" of type '" "int""'");
49573 }
49574 arg4 = static_cast< int >(val4);
49575 ecode5 = SWIG_AsVal_int(obj4, &val5);
49576 if (!SWIG_IsOK(ecode5)) {
49577 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSizer" "', expected argument " "5"" of type '" "int""'");
49578 }
49579 arg5 = static_cast< int >(val5);
49580 if (obj5) {
49581 arg6 = obj5;
49582 }
49583 {
49584 PyThreadState* __tstate = wxPyBeginAllowThreads();
49585 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
49586 wxPyEndAllowThreads(__tstate);
49587 if (PyErr_Occurred()) SWIG_fail;
49588 }
49589 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49590 return resultobj;
49591 fail:
49592 return NULL;
49593 }
49594
49595
49596 SWIGINTERN PyObject *_wrap_new_GBSizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49597 PyObject *resultobj = 0;
49598 int arg1 ;
49599 int arg2 ;
49600 wxGBPosition *arg3 = 0 ;
49601 wxGBSpan *arg4 = 0 ;
49602 int arg5 ;
49603 int arg6 ;
49604 PyObject *arg7 = (PyObject *) NULL ;
49605 wxGBSizerItem *result = 0 ;
49606 int val1 ;
49607 int ecode1 = 0 ;
49608 int val2 ;
49609 int ecode2 = 0 ;
49610 wxGBPosition temp3 ;
49611 wxGBSpan temp4 ;
49612 int val5 ;
49613 int ecode5 = 0 ;
49614 int val6 ;
49615 int ecode6 = 0 ;
49616 PyObject * obj0 = 0 ;
49617 PyObject * obj1 = 0 ;
49618 PyObject * obj2 = 0 ;
49619 PyObject * obj3 = 0 ;
49620 PyObject * obj4 = 0 ;
49621 PyObject * obj5 = 0 ;
49622 PyObject * obj6 = 0 ;
49623 char * kwnames[] = {
49624 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49625 };
49626
49627 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
49628 ecode1 = SWIG_AsVal_int(obj0, &val1);
49629 if (!SWIG_IsOK(ecode1)) {
49630 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
49631 }
49632 arg1 = static_cast< int >(val1);
49633 ecode2 = SWIG_AsVal_int(obj1, &val2);
49634 if (!SWIG_IsOK(ecode2)) {
49635 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
49636 }
49637 arg2 = static_cast< int >(val2);
49638 {
49639 arg3 = &temp3;
49640 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
49641 }
49642 {
49643 arg4 = &temp4;
49644 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
49645 }
49646 ecode5 = SWIG_AsVal_int(obj4, &val5);
49647 if (!SWIG_IsOK(ecode5)) {
49648 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
49649 }
49650 arg5 = static_cast< int >(val5);
49651 ecode6 = SWIG_AsVal_int(obj5, &val6);
49652 if (!SWIG_IsOK(ecode6)) {
49653 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GBSizerItemSpacer" "', expected argument " "6"" of type '" "int""'");
49654 }
49655 arg6 = static_cast< int >(val6);
49656 if (obj6) {
49657 arg7 = obj6;
49658 }
49659 {
49660 PyThreadState* __tstate = wxPyBeginAllowThreads();
49661 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
49662 wxPyEndAllowThreads(__tstate);
49663 if (PyErr_Occurred()) SWIG_fail;
49664 }
49665 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49666 return resultobj;
49667 fail:
49668 return NULL;
49669 }
49670
49671
49672 SWIGINTERN PyObject *_wrap_GBSizerItem_GetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49673 PyObject *resultobj = 0;
49674 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49675 wxGBPosition result;
49676 void *argp1 = 0 ;
49677 int res1 = 0 ;
49678 PyObject *swig_obj[1] ;
49679
49680 if (!args) SWIG_fail;
49681 swig_obj[0] = args;
49682 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49683 if (!SWIG_IsOK(res1)) {
49684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetPos" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
49685 }
49686 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49687 {
49688 PyThreadState* __tstate = wxPyBeginAllowThreads();
49689 result = ((wxGBSizerItem const *)arg1)->GetPos();
49690 wxPyEndAllowThreads(__tstate);
49691 if (PyErr_Occurred()) SWIG_fail;
49692 }
49693 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
49694 return resultobj;
49695 fail:
49696 return NULL;
49697 }
49698
49699
49700 SWIGINTERN PyObject *_wrap_GBSizerItem_GetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49701 PyObject *resultobj = 0;
49702 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49703 wxGBSpan result;
49704 void *argp1 = 0 ;
49705 int res1 = 0 ;
49706 PyObject *swig_obj[1] ;
49707
49708 if (!args) SWIG_fail;
49709 swig_obj[0] = args;
49710 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49711 if (!SWIG_IsOK(res1)) {
49712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
49713 }
49714 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49715 {
49716 PyThreadState* __tstate = wxPyBeginAllowThreads();
49717 result = ((wxGBSizerItem const *)arg1)->GetSpan();
49718 wxPyEndAllowThreads(__tstate);
49719 if (PyErr_Occurred()) SWIG_fail;
49720 }
49721 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
49722 return resultobj;
49723 fail:
49724 return NULL;
49725 }
49726
49727
49728 SWIGINTERN PyObject *_wrap_GBSizerItem_SetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49729 PyObject *resultobj = 0;
49730 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49731 wxGBPosition *arg2 = 0 ;
49732 bool result;
49733 void *argp1 = 0 ;
49734 int res1 = 0 ;
49735 wxGBPosition temp2 ;
49736 PyObject * obj0 = 0 ;
49737 PyObject * obj1 = 0 ;
49738 char * kwnames[] = {
49739 (char *) "self",(char *) "pos", NULL
49740 };
49741
49742 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) SWIG_fail;
49743 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49744 if (!SWIG_IsOK(res1)) {
49745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49746 }
49747 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49748 {
49749 arg2 = &temp2;
49750 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49751 }
49752 {
49753 PyThreadState* __tstate = wxPyBeginAllowThreads();
49754 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
49755 wxPyEndAllowThreads(__tstate);
49756 if (PyErr_Occurred()) SWIG_fail;
49757 }
49758 {
49759 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49760 }
49761 return resultobj;
49762 fail:
49763 return NULL;
49764 }
49765
49766
49767 SWIGINTERN PyObject *_wrap_GBSizerItem_SetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49768 PyObject *resultobj = 0;
49769 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49770 wxGBSpan *arg2 = 0 ;
49771 bool result;
49772 void *argp1 = 0 ;
49773 int res1 = 0 ;
49774 wxGBSpan temp2 ;
49775 PyObject * obj0 = 0 ;
49776 PyObject * obj1 = 0 ;
49777 char * kwnames[] = {
49778 (char *) "self",(char *) "span", NULL
49779 };
49780
49781 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) SWIG_fail;
49782 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49783 if (!SWIG_IsOK(res1)) {
49784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49785 }
49786 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49787 {
49788 arg2 = &temp2;
49789 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
49790 }
49791 {
49792 PyThreadState* __tstate = wxPyBeginAllowThreads();
49793 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
49794 wxPyEndAllowThreads(__tstate);
49795 if (PyErr_Occurred()) SWIG_fail;
49796 }
49797 {
49798 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49799 }
49800 return resultobj;
49801 fail:
49802 return NULL;
49803 }
49804
49805
49806 SWIGINTERN PyObject *_wrap_GBSizerItem_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49807 PyObject *resultobj = 0;
49808 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49809 wxGBSizerItem *arg2 = 0 ;
49810 bool result;
49811 void *argp1 = 0 ;
49812 int res1 = 0 ;
49813 void *argp2 = 0 ;
49814 int res2 = 0 ;
49815 PyObject * obj0 = 0 ;
49816 PyObject * obj1 = 0 ;
49817 char * kwnames[] = {
49818 (char *) "self",(char *) "other", NULL
49819 };
49820
49821 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
49822 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49823 if (!SWIG_IsOK(res1)) {
49824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_Intersects" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49825 }
49826 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49827 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGBSizerItem, 0 | 0);
49828 if (!SWIG_IsOK(res2)) {
49829 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
49830 }
49831 if (!argp2) {
49832 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
49833 }
49834 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
49835 {
49836 PyThreadState* __tstate = wxPyBeginAllowThreads();
49837 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
49838 wxPyEndAllowThreads(__tstate);
49839 if (PyErr_Occurred()) SWIG_fail;
49840 }
49841 {
49842 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49843 }
49844 return resultobj;
49845 fail:
49846 return NULL;
49847 }
49848
49849
49850 SWIGINTERN PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49851 PyObject *resultobj = 0;
49852 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49853 wxGBPosition *arg2 = 0 ;
49854 wxGBSpan *arg3 = 0 ;
49855 bool result;
49856 void *argp1 = 0 ;
49857 int res1 = 0 ;
49858 wxGBPosition temp2 ;
49859 wxGBSpan temp3 ;
49860 PyObject * obj0 = 0 ;
49861 PyObject * obj1 = 0 ;
49862 PyObject * obj2 = 0 ;
49863 char * kwnames[] = {
49864 (char *) "self",(char *) "pos",(char *) "span", NULL
49865 };
49866
49867 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49868 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49869 if (!SWIG_IsOK(res1)) {
49870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_IntersectsPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49871 }
49872 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49873 {
49874 arg2 = &temp2;
49875 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49876 }
49877 {
49878 arg3 = &temp3;
49879 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
49880 }
49881 {
49882 PyThreadState* __tstate = wxPyBeginAllowThreads();
49883 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
49884 wxPyEndAllowThreads(__tstate);
49885 if (PyErr_Occurred()) SWIG_fail;
49886 }
49887 {
49888 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49889 }
49890 return resultobj;
49891 fail:
49892 return NULL;
49893 }
49894
49895
49896 SWIGINTERN PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49897 PyObject *resultobj = 0;
49898 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49899 wxGBPosition result;
49900 void *argp1 = 0 ;
49901 int res1 = 0 ;
49902 PyObject *swig_obj[1] ;
49903
49904 if (!args) SWIG_fail;
49905 swig_obj[0] = args;
49906 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49907 if (!SWIG_IsOK(res1)) {
49908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetEndPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49909 }
49910 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49911 {
49912 PyThreadState* __tstate = wxPyBeginAllowThreads();
49913 result = wxGBSizerItem_GetEndPos(arg1);
49914 wxPyEndAllowThreads(__tstate);
49915 if (PyErr_Occurred()) SWIG_fail;
49916 }
49917 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
49918 return resultobj;
49919 fail:
49920 return NULL;
49921 }
49922
49923
49924 SWIGINTERN PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49925 PyObject *resultobj = 0;
49926 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49927 wxGridBagSizer *result = 0 ;
49928 void *argp1 = 0 ;
49929 int res1 = 0 ;
49930 PyObject *swig_obj[1] ;
49931
49932 if (!args) SWIG_fail;
49933 swig_obj[0] = args;
49934 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49935 if (!SWIG_IsOK(res1)) {
49936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
49937 }
49938 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49939 {
49940 PyThreadState* __tstate = wxPyBeginAllowThreads();
49941 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
49942 wxPyEndAllowThreads(__tstate);
49943 if (PyErr_Occurred()) SWIG_fail;
49944 }
49945 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
49946 return resultobj;
49947 fail:
49948 return NULL;
49949 }
49950
49951
49952 SWIGINTERN PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49953 PyObject *resultobj = 0;
49954 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49955 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
49956 void *argp1 = 0 ;
49957 int res1 = 0 ;
49958 void *argp2 = 0 ;
49959 int res2 = 0 ;
49960 PyObject * obj0 = 0 ;
49961 PyObject * obj1 = 0 ;
49962 char * kwnames[] = {
49963 (char *) "self",(char *) "sizer", NULL
49964 };
49965
49966 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) SWIG_fail;
49967 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49968 if (!SWIG_IsOK(res1)) {
49969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49970 }
49971 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49972 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
49973 if (!SWIG_IsOK(res2)) {
49974 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "2"" of type '" "wxGridBagSizer *""'");
49975 }
49976 arg2 = reinterpret_cast< wxGridBagSizer * >(argp2);
49977 {
49978 PyThreadState* __tstate = wxPyBeginAllowThreads();
49979 (arg1)->SetGBSizer(arg2);
49980 wxPyEndAllowThreads(__tstate);
49981 if (PyErr_Occurred()) SWIG_fail;
49982 }
49983 resultobj = SWIG_Py_Void();
49984 return resultobj;
49985 fail:
49986 return NULL;
49987 }
49988
49989
49990 SWIGINTERN PyObject *GBSizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49991 PyObject *obj;
49992 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49993 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSizerItem, SWIG_NewClientData(obj));
49994 return SWIG_Py_Void();
49995 }
49996
49997 SWIGINTERN PyObject *GBSizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49998 return SWIG_Python_InitShadowInstance(args);
49999 }
50000
50001 SWIGINTERN PyObject *_wrap_new_GridBagSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50002 PyObject *resultobj = 0;
50003 int arg1 = (int) 0 ;
50004 int arg2 = (int) 0 ;
50005 wxGridBagSizer *result = 0 ;
50006 int val1 ;
50007 int ecode1 = 0 ;
50008 int val2 ;
50009 int ecode2 = 0 ;
50010 PyObject * obj0 = 0 ;
50011 PyObject * obj1 = 0 ;
50012 char * kwnames[] = {
50013 (char *) "vgap",(char *) "hgap", NULL
50014 };
50015
50016 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) SWIG_fail;
50017 if (obj0) {
50018 ecode1 = SWIG_AsVal_int(obj0, &val1);
50019 if (!SWIG_IsOK(ecode1)) {
50020 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridBagSizer" "', expected argument " "1"" of type '" "int""'");
50021 }
50022 arg1 = static_cast< int >(val1);
50023 }
50024 if (obj1) {
50025 ecode2 = SWIG_AsVal_int(obj1, &val2);
50026 if (!SWIG_IsOK(ecode2)) {
50027 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridBagSizer" "', expected argument " "2"" of type '" "int""'");
50028 }
50029 arg2 = static_cast< int >(val2);
50030 }
50031 {
50032 PyThreadState* __tstate = wxPyBeginAllowThreads();
50033 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
50034 wxPyEndAllowThreads(__tstate);
50035 if (PyErr_Occurred()) SWIG_fail;
50036 }
50037 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_NEW | 0 );
50038 return resultobj;
50039 fail:
50040 return NULL;
50041 }
50042
50043
50044 SWIGINTERN PyObject *_wrap_GridBagSizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50045 PyObject *resultobj = 0;
50046 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50047 PyObject *arg2 = (PyObject *) 0 ;
50048 wxGBPosition *arg3 = 0 ;
50049 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
50050 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
50051 int arg5 = (int) 0 ;
50052 int arg6 = (int) 0 ;
50053 PyObject *arg7 = (PyObject *) NULL ;
50054 wxGBSizerItem *result = 0 ;
50055 void *argp1 = 0 ;
50056 int res1 = 0 ;
50057 wxGBPosition temp3 ;
50058 wxGBSpan temp4 ;
50059 int val5 ;
50060 int ecode5 = 0 ;
50061 int val6 ;
50062 int ecode6 = 0 ;
50063 PyObject * obj0 = 0 ;
50064 PyObject * obj1 = 0 ;
50065 PyObject * obj2 = 0 ;
50066 PyObject * obj3 = 0 ;
50067 PyObject * obj4 = 0 ;
50068 PyObject * obj5 = 0 ;
50069 PyObject * obj6 = 0 ;
50070 char * kwnames[] = {
50071 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
50072 };
50073
50074 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
50075 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50076 if (!SWIG_IsOK(res1)) {
50077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_Add" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50078 }
50079 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50080 arg2 = obj1;
50081 {
50082 arg3 = &temp3;
50083 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
50084 }
50085 if (obj3) {
50086 {
50087 arg4 = &temp4;
50088 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
50089 }
50090 }
50091 if (obj4) {
50092 ecode5 = SWIG_AsVal_int(obj4, &val5);
50093 if (!SWIG_IsOK(ecode5)) {
50094 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridBagSizer_Add" "', expected argument " "5"" of type '" "int""'");
50095 }
50096 arg5 = static_cast< int >(val5);
50097 }
50098 if (obj5) {
50099 ecode6 = SWIG_AsVal_int(obj5, &val6);
50100 if (!SWIG_IsOK(ecode6)) {
50101 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridBagSizer_Add" "', expected argument " "6"" of type '" "int""'");
50102 }
50103 arg6 = static_cast< int >(val6);
50104 }
50105 if (obj6) {
50106 arg7 = obj6;
50107 }
50108 {
50109 PyThreadState* __tstate = wxPyBeginAllowThreads();
50110 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
50111 wxPyEndAllowThreads(__tstate);
50112 if (PyErr_Occurred()) SWIG_fail;
50113 }
50114 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50115 return resultobj;
50116 fail:
50117 return NULL;
50118 }
50119
50120
50121 SWIGINTERN PyObject *_wrap_GridBagSizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50122 PyObject *resultobj = 0;
50123 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50124 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
50125 wxGBSizerItem *result = 0 ;
50126 void *argp1 = 0 ;
50127 int res1 = 0 ;
50128 int res2 = 0 ;
50129 PyObject * obj0 = 0 ;
50130 PyObject * obj1 = 0 ;
50131 char * kwnames[] = {
50132 (char *) "self",(char *) "item", NULL
50133 };
50134
50135 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
50136 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50137 if (!SWIG_IsOK(res1)) {
50138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_AddItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50139 }
50140 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50141 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
50142 if (!SWIG_IsOK(res2)) {
50143 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_AddItem" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
50144 }
50145 {
50146 PyThreadState* __tstate = wxPyBeginAllowThreads();
50147 result = (wxGBSizerItem *)(arg1)->Add(arg2);
50148 wxPyEndAllowThreads(__tstate);
50149 if (PyErr_Occurred()) SWIG_fail;
50150 }
50151 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50152 return resultobj;
50153 fail:
50154 return NULL;
50155 }
50156
50157
50158 SWIGINTERN PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50159 PyObject *resultobj = 0;
50160 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50161 int arg2 ;
50162 int arg3 ;
50163 wxSize result;
50164 void *argp1 = 0 ;
50165 int res1 = 0 ;
50166 int val2 ;
50167 int ecode2 = 0 ;
50168 int val3 ;
50169 int ecode3 = 0 ;
50170 PyObject * obj0 = 0 ;
50171 PyObject * obj1 = 0 ;
50172 PyObject * obj2 = 0 ;
50173 char * kwnames[] = {
50174 (char *) "self",(char *) "row",(char *) "col", NULL
50175 };
50176
50177 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50178 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50179 if (!SWIG_IsOK(res1)) {
50180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
50181 }
50182 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50183 ecode2 = SWIG_AsVal_int(obj1, &val2);
50184 if (!SWIG_IsOK(ecode2)) {
50185 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "2"" of type '" "int""'");
50186 }
50187 arg2 = static_cast< int >(val2);
50188 ecode3 = SWIG_AsVal_int(obj2, &val3);
50189 if (!SWIG_IsOK(ecode3)) {
50190 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "3"" of type '" "int""'");
50191 }
50192 arg3 = static_cast< int >(val3);
50193 {
50194 PyThreadState* __tstate = wxPyBeginAllowThreads();
50195 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
50196 wxPyEndAllowThreads(__tstate);
50197 if (PyErr_Occurred()) SWIG_fail;
50198 }
50199 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50200 return resultobj;
50201 fail:
50202 return NULL;
50203 }
50204
50205
50206 SWIGINTERN PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50207 PyObject *resultobj = 0;
50208 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50209 wxSize result;
50210 void *argp1 = 0 ;
50211 int res1 = 0 ;
50212 PyObject *swig_obj[1] ;
50213
50214 if (!args) SWIG_fail;
50215 swig_obj[0] = args;
50216 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50217 if (!SWIG_IsOK(res1)) {
50218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
50219 }
50220 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50221 {
50222 PyThreadState* __tstate = wxPyBeginAllowThreads();
50223 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
50224 wxPyEndAllowThreads(__tstate);
50225 if (PyErr_Occurred()) SWIG_fail;
50226 }
50227 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50228 return resultobj;
50229 fail:
50230 return NULL;
50231 }
50232
50233
50234 SWIGINTERN PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50235 PyObject *resultobj = 0;
50236 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50237 wxSize *arg2 = 0 ;
50238 void *argp1 = 0 ;
50239 int res1 = 0 ;
50240 wxSize temp2 ;
50241 PyObject * obj0 = 0 ;
50242 PyObject * obj1 = 0 ;
50243 char * kwnames[] = {
50244 (char *) "self",(char *) "sz", NULL
50245 };
50246
50247 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) SWIG_fail;
50248 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50249 if (!SWIG_IsOK(res1)) {
50250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50251 }
50252 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50253 {
50254 arg2 = &temp2;
50255 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
50256 }
50257 {
50258 PyThreadState* __tstate = wxPyBeginAllowThreads();
50259 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
50260 wxPyEndAllowThreads(__tstate);
50261 if (PyErr_Occurred()) SWIG_fail;
50262 }
50263 resultobj = SWIG_Py_Void();
50264 return resultobj;
50265 fail:
50266 return NULL;
50267 }
50268
50269
50270 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50271 PyObject *resultobj = 0;
50272 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50273 wxWindow *arg2 = (wxWindow *) 0 ;
50274 wxGBPosition result;
50275 void *argp1 = 0 ;
50276 int res1 = 0 ;
50277 void *argp2 = 0 ;
50278 int res2 = 0 ;
50279
50280 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50281 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50282 if (!SWIG_IsOK(res1)) {
50283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50284 }
50285 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50286 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50287 if (!SWIG_IsOK(res2)) {
50288 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
50289 }
50290 arg2 = reinterpret_cast< wxWindow * >(argp2);
50291 {
50292 PyThreadState* __tstate = wxPyBeginAllowThreads();
50293 result = (arg1)->GetItemPosition(arg2);
50294 wxPyEndAllowThreads(__tstate);
50295 if (PyErr_Occurred()) SWIG_fail;
50296 }
50297 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50298 return resultobj;
50299 fail:
50300 return NULL;
50301 }
50302
50303
50304 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50305 PyObject *resultobj = 0;
50306 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50307 wxSizer *arg2 = (wxSizer *) 0 ;
50308 wxGBPosition result;
50309 void *argp1 = 0 ;
50310 int res1 = 0 ;
50311 void *argp2 = 0 ;
50312 int res2 = 0 ;
50313
50314 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50315 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50316 if (!SWIG_IsOK(res1)) {
50317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50318 }
50319 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50320 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50321 if (!SWIG_IsOK(res2)) {
50322 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
50323 }
50324 arg2 = reinterpret_cast< wxSizer * >(argp2);
50325 {
50326 PyThreadState* __tstate = wxPyBeginAllowThreads();
50327 result = (arg1)->GetItemPosition(arg2);
50328 wxPyEndAllowThreads(__tstate);
50329 if (PyErr_Occurred()) SWIG_fail;
50330 }
50331 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50332 return resultobj;
50333 fail:
50334 return NULL;
50335 }
50336
50337
50338 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50339 PyObject *resultobj = 0;
50340 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50341 size_t arg2 ;
50342 wxGBPosition result;
50343 void *argp1 = 0 ;
50344 int res1 = 0 ;
50345 size_t val2 ;
50346 int ecode2 = 0 ;
50347
50348 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50349 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50350 if (!SWIG_IsOK(res1)) {
50351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50352 }
50353 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50354 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50355 if (!SWIG_IsOK(ecode2)) {
50356 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
50357 }
50358 arg2 = static_cast< size_t >(val2);
50359 {
50360 PyThreadState* __tstate = wxPyBeginAllowThreads();
50361 result = (arg1)->GetItemPosition(arg2);
50362 wxPyEndAllowThreads(__tstate);
50363 if (PyErr_Occurred()) SWIG_fail;
50364 }
50365 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50366 return resultobj;
50367 fail:
50368 return NULL;
50369 }
50370
50371
50372 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
50373 int argc;
50374 PyObject *argv[3];
50375
50376 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemPosition",0,2,argv))) SWIG_fail;
50377 --argc;
50378 if (argc == 2) {
50379 int _v = 0;
50380 {
50381 void *vptr = 0;
50382 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50383 _v = SWIG_CheckState(res);
50384 }
50385 if (!_v) goto check_1;
50386 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self, argc, argv);
50387 }
50388 check_1:
50389
50390 if (argc == 2) {
50391 int _v = 0;
50392 {
50393 void *vptr = 0;
50394 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50395 _v = SWIG_CheckState(res);
50396 }
50397 if (!_v) goto check_2;
50398 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self, argc, argv);
50399 }
50400 check_2:
50401
50402 if (argc == 2) {
50403 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self, argc, argv);
50404 }
50405
50406 fail:
50407 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
50408 return NULL;
50409 }
50410
50411
50412 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50413 PyObject *resultobj = 0;
50414 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50415 wxWindow *arg2 = (wxWindow *) 0 ;
50416 wxGBPosition *arg3 = 0 ;
50417 bool result;
50418 void *argp1 = 0 ;
50419 int res1 = 0 ;
50420 void *argp2 = 0 ;
50421 int res2 = 0 ;
50422 wxGBPosition temp3 ;
50423
50424 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50425 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50426 if (!SWIG_IsOK(res1)) {
50427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50428 }
50429 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50430 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50431 if (!SWIG_IsOK(res2)) {
50432 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
50433 }
50434 arg2 = reinterpret_cast< wxWindow * >(argp2);
50435 {
50436 arg3 = &temp3;
50437 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50438 }
50439 {
50440 PyThreadState* __tstate = wxPyBeginAllowThreads();
50441 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50442 wxPyEndAllowThreads(__tstate);
50443 if (PyErr_Occurred()) SWIG_fail;
50444 }
50445 {
50446 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50447 }
50448 return resultobj;
50449 fail:
50450 return NULL;
50451 }
50452
50453
50454 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50455 PyObject *resultobj = 0;
50456 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50457 wxSizer *arg2 = (wxSizer *) 0 ;
50458 wxGBPosition *arg3 = 0 ;
50459 bool result;
50460 void *argp1 = 0 ;
50461 int res1 = 0 ;
50462 void *argp2 = 0 ;
50463 int res2 = 0 ;
50464 wxGBPosition temp3 ;
50465
50466 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50467 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50468 if (!SWIG_IsOK(res1)) {
50469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50470 }
50471 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50472 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50473 if (!SWIG_IsOK(res2)) {
50474 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
50475 }
50476 arg2 = reinterpret_cast< wxSizer * >(argp2);
50477 {
50478 arg3 = &temp3;
50479 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50480 }
50481 {
50482 PyThreadState* __tstate = wxPyBeginAllowThreads();
50483 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50484 wxPyEndAllowThreads(__tstate);
50485 if (PyErr_Occurred()) SWIG_fail;
50486 }
50487 {
50488 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50489 }
50490 return resultobj;
50491 fail:
50492 return NULL;
50493 }
50494
50495
50496 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50497 PyObject *resultobj = 0;
50498 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50499 size_t arg2 ;
50500 wxGBPosition *arg3 = 0 ;
50501 bool result;
50502 void *argp1 = 0 ;
50503 int res1 = 0 ;
50504 size_t val2 ;
50505 int ecode2 = 0 ;
50506 wxGBPosition temp3 ;
50507
50508 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50509 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50510 if (!SWIG_IsOK(res1)) {
50511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50512 }
50513 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50514 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50515 if (!SWIG_IsOK(ecode2)) {
50516 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
50517 }
50518 arg2 = static_cast< size_t >(val2);
50519 {
50520 arg3 = &temp3;
50521 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50522 }
50523 {
50524 PyThreadState* __tstate = wxPyBeginAllowThreads();
50525 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50526 wxPyEndAllowThreads(__tstate);
50527 if (PyErr_Occurred()) SWIG_fail;
50528 }
50529 {
50530 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50531 }
50532 return resultobj;
50533 fail:
50534 return NULL;
50535 }
50536
50537
50538 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
50539 int argc;
50540 PyObject *argv[4];
50541
50542 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemPosition",0,3,argv))) SWIG_fail;
50543 --argc;
50544 if (argc == 3) {
50545 int _v = 0;
50546 {
50547 void *vptr = 0;
50548 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50549 _v = SWIG_CheckState(res);
50550 }
50551 if (!_v) goto check_1;
50552 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self, argc, argv);
50553 }
50554 check_1:
50555
50556 if (argc == 3) {
50557 int _v = 0;
50558 {
50559 void *vptr = 0;
50560 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50561 _v = SWIG_CheckState(res);
50562 }
50563 if (!_v) goto check_2;
50564 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self, argc, argv);
50565 }
50566 check_2:
50567
50568 if (argc == 3) {
50569 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self, argc, argv);
50570 }
50571
50572 fail:
50573 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
50574 return NULL;
50575 }
50576
50577
50578 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50579 PyObject *resultobj = 0;
50580 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50581 wxWindow *arg2 = (wxWindow *) 0 ;
50582 wxGBSpan result;
50583 void *argp1 = 0 ;
50584 int res1 = 0 ;
50585 void *argp2 = 0 ;
50586 int res2 = 0 ;
50587
50588 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50589 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50590 if (!SWIG_IsOK(res1)) {
50591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50592 }
50593 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50594 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50595 if (!SWIG_IsOK(res2)) {
50596 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
50597 }
50598 arg2 = reinterpret_cast< wxWindow * >(argp2);
50599 {
50600 PyThreadState* __tstate = wxPyBeginAllowThreads();
50601 result = (arg1)->GetItemSpan(arg2);
50602 wxPyEndAllowThreads(__tstate);
50603 if (PyErr_Occurred()) SWIG_fail;
50604 }
50605 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50606 return resultobj;
50607 fail:
50608 return NULL;
50609 }
50610
50611
50612 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50613 PyObject *resultobj = 0;
50614 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50615 wxSizer *arg2 = (wxSizer *) 0 ;
50616 wxGBSpan result;
50617 void *argp1 = 0 ;
50618 int res1 = 0 ;
50619 void *argp2 = 0 ;
50620 int res2 = 0 ;
50621
50622 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50623 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50624 if (!SWIG_IsOK(res1)) {
50625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50626 }
50627 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50628 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50629 if (!SWIG_IsOK(res2)) {
50630 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
50631 }
50632 arg2 = reinterpret_cast< wxSizer * >(argp2);
50633 {
50634 PyThreadState* __tstate = wxPyBeginAllowThreads();
50635 result = (arg1)->GetItemSpan(arg2);
50636 wxPyEndAllowThreads(__tstate);
50637 if (PyErr_Occurred()) SWIG_fail;
50638 }
50639 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50640 return resultobj;
50641 fail:
50642 return NULL;
50643 }
50644
50645
50646 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50647 PyObject *resultobj = 0;
50648 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50649 size_t arg2 ;
50650 wxGBSpan result;
50651 void *argp1 = 0 ;
50652 int res1 = 0 ;
50653 size_t val2 ;
50654 int ecode2 = 0 ;
50655
50656 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50657 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50658 if (!SWIG_IsOK(res1)) {
50659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50660 }
50661 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50662 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50663 if (!SWIG_IsOK(ecode2)) {
50664 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
50665 }
50666 arg2 = static_cast< size_t >(val2);
50667 {
50668 PyThreadState* __tstate = wxPyBeginAllowThreads();
50669 result = (arg1)->GetItemSpan(arg2);
50670 wxPyEndAllowThreads(__tstate);
50671 if (PyErr_Occurred()) SWIG_fail;
50672 }
50673 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50674 return resultobj;
50675 fail:
50676 return NULL;
50677 }
50678
50679
50680 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
50681 int argc;
50682 PyObject *argv[3];
50683
50684 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemSpan",0,2,argv))) SWIG_fail;
50685 --argc;
50686 if (argc == 2) {
50687 int _v = 0;
50688 {
50689 void *vptr = 0;
50690 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50691 _v = SWIG_CheckState(res);
50692 }
50693 if (!_v) goto check_1;
50694 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self, argc, argv);
50695 }
50696 check_1:
50697
50698 if (argc == 2) {
50699 int _v = 0;
50700 {
50701 void *vptr = 0;
50702 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50703 _v = SWIG_CheckState(res);
50704 }
50705 if (!_v) goto check_2;
50706 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self, argc, argv);
50707 }
50708 check_2:
50709
50710 if (argc == 2) {
50711 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self, argc, argv);
50712 }
50713
50714 fail:
50715 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
50716 return NULL;
50717 }
50718
50719
50720 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50721 PyObject *resultobj = 0;
50722 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50723 wxWindow *arg2 = (wxWindow *) 0 ;
50724 wxGBSpan *arg3 = 0 ;
50725 bool result;
50726 void *argp1 = 0 ;
50727 int res1 = 0 ;
50728 void *argp2 = 0 ;
50729 int res2 = 0 ;
50730 wxGBSpan temp3 ;
50731
50732 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50733 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50734 if (!SWIG_IsOK(res1)) {
50735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50736 }
50737 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50738 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50739 if (!SWIG_IsOK(res2)) {
50740 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
50741 }
50742 arg2 = reinterpret_cast< wxWindow * >(argp2);
50743 {
50744 arg3 = &temp3;
50745 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
50746 }
50747 {
50748 PyThreadState* __tstate = wxPyBeginAllowThreads();
50749 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
50750 wxPyEndAllowThreads(__tstate);
50751 if (PyErr_Occurred()) SWIG_fail;
50752 }
50753 {
50754 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50755 }
50756 return resultobj;
50757 fail:
50758 return NULL;
50759 }
50760
50761
50762 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50763 PyObject *resultobj = 0;
50764 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50765 wxSizer *arg2 = (wxSizer *) 0 ;
50766 wxGBSpan *arg3 = 0 ;
50767 bool result;
50768 void *argp1 = 0 ;
50769 int res1 = 0 ;
50770 void *argp2 = 0 ;
50771 int res2 = 0 ;
50772 wxGBSpan temp3 ;
50773
50774 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50775 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50776 if (!SWIG_IsOK(res1)) {
50777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50778 }
50779 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50780 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50781 if (!SWIG_IsOK(res2)) {
50782 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
50783 }
50784 arg2 = reinterpret_cast< wxSizer * >(argp2);
50785 {
50786 arg3 = &temp3;
50787 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
50788 }
50789 {
50790 PyThreadState* __tstate = wxPyBeginAllowThreads();
50791 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
50792 wxPyEndAllowThreads(__tstate);
50793 if (PyErr_Occurred()) SWIG_fail;
50794 }
50795 {
50796 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50797 }
50798 return resultobj;
50799 fail:
50800 return NULL;
50801 }
50802
50803
50804 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50805 PyObject *resultobj = 0;
50806 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50807 size_t arg2 ;
50808 wxGBSpan *arg3 = 0 ;
50809 bool result;
50810 void *argp1 = 0 ;
50811 int res1 = 0 ;
50812 size_t val2 ;
50813 int ecode2 = 0 ;
50814 wxGBSpan temp3 ;
50815
50816 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50817 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50818 if (!SWIG_IsOK(res1)) {
50819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50820 }
50821 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50822 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50823 if (!SWIG_IsOK(ecode2)) {
50824 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
50825 }
50826 arg2 = static_cast< size_t >(val2);
50827 {
50828 arg3 = &temp3;
50829 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
50830 }
50831 {
50832 PyThreadState* __tstate = wxPyBeginAllowThreads();
50833 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
50834 wxPyEndAllowThreads(__tstate);
50835 if (PyErr_Occurred()) SWIG_fail;
50836 }
50837 {
50838 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50839 }
50840 return resultobj;
50841 fail:
50842 return NULL;
50843 }
50844
50845
50846 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
50847 int argc;
50848 PyObject *argv[4];
50849
50850 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemSpan",0,3,argv))) SWIG_fail;
50851 --argc;
50852 if (argc == 3) {
50853 int _v = 0;
50854 {
50855 void *vptr = 0;
50856 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50857 _v = SWIG_CheckState(res);
50858 }
50859 if (!_v) goto check_1;
50860 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self, argc, argv);
50861 }
50862 check_1:
50863
50864 if (argc == 3) {
50865 int _v = 0;
50866 {
50867 void *vptr = 0;
50868 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50869 _v = SWIG_CheckState(res);
50870 }
50871 if (!_v) goto check_2;
50872 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self, argc, argv);
50873 }
50874 check_2:
50875
50876 if (argc == 3) {
50877 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self, argc, argv);
50878 }
50879
50880 fail:
50881 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
50882 return NULL;
50883 }
50884
50885
50886 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50887 PyObject *resultobj = 0;
50888 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50889 wxWindow *arg2 = (wxWindow *) 0 ;
50890 wxGBSizerItem *result = 0 ;
50891 void *argp1 = 0 ;
50892 int res1 = 0 ;
50893 void *argp2 = 0 ;
50894 int res2 = 0 ;
50895
50896 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50897 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50898 if (!SWIG_IsOK(res1)) {
50899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50900 }
50901 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50902 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50903 if (!SWIG_IsOK(res2)) {
50904 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxWindow *""'");
50905 }
50906 arg2 = reinterpret_cast< wxWindow * >(argp2);
50907 {
50908 PyThreadState* __tstate = wxPyBeginAllowThreads();
50909 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
50910 wxPyEndAllowThreads(__tstate);
50911 if (PyErr_Occurred()) SWIG_fail;
50912 }
50913 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50914 return resultobj;
50915 fail:
50916 return NULL;
50917 }
50918
50919
50920 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50921 PyObject *resultobj = 0;
50922 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50923 wxSizer *arg2 = (wxSizer *) 0 ;
50924 wxGBSizerItem *result = 0 ;
50925 void *argp1 = 0 ;
50926 int res1 = 0 ;
50927 void *argp2 = 0 ;
50928 int res2 = 0 ;
50929
50930 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50931 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50932 if (!SWIG_IsOK(res1)) {
50933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50934 }
50935 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50936 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50937 if (!SWIG_IsOK(res2)) {
50938 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxSizer *""'");
50939 }
50940 arg2 = reinterpret_cast< wxSizer * >(argp2);
50941 {
50942 PyThreadState* __tstate = wxPyBeginAllowThreads();
50943 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
50944 wxPyEndAllowThreads(__tstate);
50945 if (PyErr_Occurred()) SWIG_fail;
50946 }
50947 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50948 return resultobj;
50949 fail:
50950 return NULL;
50951 }
50952
50953
50954 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
50955 int argc;
50956 PyObject *argv[3];
50957
50958 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_FindItem",0,2,argv))) SWIG_fail;
50959 --argc;
50960 if (argc == 2) {
50961 int _v = 0;
50962 {
50963 void *vptr = 0;
50964 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50965 _v = SWIG_CheckState(res);
50966 }
50967 if (!_v) goto check_1;
50968 return _wrap_GridBagSizer_FindItem__SWIG_0(self, argc, argv);
50969 }
50970 check_1:
50971
50972 if (argc == 2) {
50973 return _wrap_GridBagSizer_FindItem__SWIG_1(self, argc, argv);
50974 }
50975
50976 fail:
50977 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
50978 return NULL;
50979 }
50980
50981
50982 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50983 PyObject *resultobj = 0;
50984 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50985 wxGBPosition *arg2 = 0 ;
50986 wxGBSizerItem *result = 0 ;
50987 void *argp1 = 0 ;
50988 int res1 = 0 ;
50989 wxGBPosition temp2 ;
50990 PyObject * obj0 = 0 ;
50991 PyObject * obj1 = 0 ;
50992 char * kwnames[] = {
50993 (char *) "self",(char *) "pos", NULL
50994 };
50995
50996 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) SWIG_fail;
50997 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50998 if (!SWIG_IsOK(res1)) {
50999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51000 }
51001 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51002 {
51003 arg2 = &temp2;
51004 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51005 }
51006 {
51007 PyThreadState* __tstate = wxPyBeginAllowThreads();
51008 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
51009 wxPyEndAllowThreads(__tstate);
51010 if (PyErr_Occurred()) SWIG_fail;
51011 }
51012 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51013 return resultobj;
51014 fail:
51015 return NULL;
51016 }
51017
51018
51019 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51020 PyObject *resultobj = 0;
51021 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51022 wxPoint *arg2 = 0 ;
51023 wxGBSizerItem *result = 0 ;
51024 void *argp1 = 0 ;
51025 int res1 = 0 ;
51026 wxPoint temp2 ;
51027 PyObject * obj0 = 0 ;
51028 PyObject * obj1 = 0 ;
51029 char * kwnames[] = {
51030 (char *) "self",(char *) "pt", NULL
51031 };
51032
51033 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) SWIG_fail;
51034 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51035 if (!SWIG_IsOK(res1)) {
51036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPoint" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51037 }
51038 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51039 {
51040 arg2 = &temp2;
51041 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
51042 }
51043 {
51044 PyThreadState* __tstate = wxPyBeginAllowThreads();
51045 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
51046 wxPyEndAllowThreads(__tstate);
51047 if (PyErr_Occurred()) SWIG_fail;
51048 }
51049 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51050 return resultobj;
51051 fail:
51052 return NULL;
51053 }
51054
51055
51056 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51057 PyObject *resultobj = 0;
51058 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51059 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
51060 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
51061 bool result;
51062 void *argp1 = 0 ;
51063 int res1 = 0 ;
51064 void *argp2 = 0 ;
51065 int res2 = 0 ;
51066 void *argp3 = 0 ;
51067 int res3 = 0 ;
51068 PyObject * obj0 = 0 ;
51069 PyObject * obj1 = 0 ;
51070 PyObject * obj2 = 0 ;
51071 char * kwnames[] = {
51072 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
51073 };
51074
51075 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51076 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51077 if (!SWIG_IsOK(res1)) {
51078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51079 }
51080 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51081 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51082 if (!SWIG_IsOK(res2)) {
51083 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
51084 }
51085 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
51086 if (obj2) {
51087 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51088 if (!SWIG_IsOK(res3)) {
51089 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "3"" of type '" "wxGBSizerItem *""'");
51090 }
51091 arg3 = reinterpret_cast< wxGBSizerItem * >(argp3);
51092 }
51093 {
51094 PyThreadState* __tstate = wxPyBeginAllowThreads();
51095 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
51096 wxPyEndAllowThreads(__tstate);
51097 if (PyErr_Occurred()) SWIG_fail;
51098 }
51099 {
51100 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51101 }
51102 return resultobj;
51103 fail:
51104 return NULL;
51105 }
51106
51107
51108 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51109 PyObject *resultobj = 0;
51110 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51111 wxGBPosition *arg2 = 0 ;
51112 wxGBSpan *arg3 = 0 ;
51113 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
51114 bool result;
51115 void *argp1 = 0 ;
51116 int res1 = 0 ;
51117 wxGBPosition temp2 ;
51118 wxGBSpan temp3 ;
51119 void *argp4 = 0 ;
51120 int res4 = 0 ;
51121 PyObject * obj0 = 0 ;
51122 PyObject * obj1 = 0 ;
51123 PyObject * obj2 = 0 ;
51124 PyObject * obj3 = 0 ;
51125 char * kwnames[] = {
51126 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
51127 };
51128
51129 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51130 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51131 if (!SWIG_IsOK(res1)) {
51132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51133 }
51134 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51135 {
51136 arg2 = &temp2;
51137 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51138 }
51139 {
51140 arg3 = &temp3;
51141 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
51142 }
51143 if (obj3) {
51144 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51145 if (!SWIG_IsOK(res4)) {
51146 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "4"" of type '" "wxGBSizerItem *""'");
51147 }
51148 arg4 = reinterpret_cast< wxGBSizerItem * >(argp4);
51149 }
51150 {
51151 PyThreadState* __tstate = wxPyBeginAllowThreads();
51152 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
51153 wxPyEndAllowThreads(__tstate);
51154 if (PyErr_Occurred()) SWIG_fail;
51155 }
51156 {
51157 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51158 }
51159 return resultobj;
51160 fail:
51161 return NULL;
51162 }
51163
51164
51165 SWIGINTERN PyObject *GridBagSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51166 PyObject *obj;
51167 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51168 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridBagSizer, SWIG_NewClientData(obj));
51169 return SWIG_Py_Void();
51170 }
51171
51172 SWIGINTERN PyObject *GridBagSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51173 return SWIG_Python_InitShadowInstance(args);
51174 }
51175
51176 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51177 PyObject *resultobj = 0;
51178 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51179 wxRelationship arg2 ;
51180 wxWindow *arg3 = (wxWindow *) 0 ;
51181 wxEdge arg4 ;
51182 int arg5 = (int) 0 ;
51183 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
51184 void *argp1 = 0 ;
51185 int res1 = 0 ;
51186 int val2 ;
51187 int ecode2 = 0 ;
51188 void *argp3 = 0 ;
51189 int res3 = 0 ;
51190 int val4 ;
51191 int ecode4 = 0 ;
51192 int val5 ;
51193 int ecode5 = 0 ;
51194 int val6 ;
51195 int ecode6 = 0 ;
51196 PyObject * obj0 = 0 ;
51197 PyObject * obj1 = 0 ;
51198 PyObject * obj2 = 0 ;
51199 PyObject * obj3 = 0 ;
51200 PyObject * obj4 = 0 ;
51201 PyObject * obj5 = 0 ;
51202 char * kwnames[] = {
51203 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
51204 };
51205
51206 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
51207 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51208 if (!SWIG_IsOK(res1)) {
51209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51210 }
51211 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51212 ecode2 = SWIG_AsVal_int(obj1, &val2);
51213 if (!SWIG_IsOK(ecode2)) {
51214 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "2"" of type '" "wxRelationship""'");
51215 }
51216 arg2 = static_cast< wxRelationship >(val2);
51217 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
51218 if (!SWIG_IsOK(res3)) {
51219 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "3"" of type '" "wxWindow *""'");
51220 }
51221 arg3 = reinterpret_cast< wxWindow * >(argp3);
51222 ecode4 = SWIG_AsVal_int(obj3, &val4);
51223 if (!SWIG_IsOK(ecode4)) {
51224 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "4"" of type '" "wxEdge""'");
51225 }
51226 arg4 = static_cast< wxEdge >(val4);
51227 if (obj4) {
51228 ecode5 = SWIG_AsVal_int(obj4, &val5);
51229 if (!SWIG_IsOK(ecode5)) {
51230 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "5"" of type '" "int""'");
51231 }
51232 arg5 = static_cast< int >(val5);
51233 }
51234 if (obj5) {
51235 ecode6 = SWIG_AsVal_int(obj5, &val6);
51236 if (!SWIG_IsOK(ecode6)) {
51237 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "6"" of type '" "int""'");
51238 }
51239 arg6 = static_cast< int >(val6);
51240 }
51241 {
51242 PyThreadState* __tstate = wxPyBeginAllowThreads();
51243 (arg1)->Set(arg2,arg3,arg4,arg5,arg6);
51244 wxPyEndAllowThreads(__tstate);
51245 if (PyErr_Occurred()) SWIG_fail;
51246 }
51247 resultobj = SWIG_Py_Void();
51248 return resultobj;
51249 fail:
51250 return NULL;
51251 }
51252
51253
51254 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51255 PyObject *resultobj = 0;
51256 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51257 wxWindow *arg2 = (wxWindow *) 0 ;
51258 int arg3 = (int) 0 ;
51259 void *argp1 = 0 ;
51260 int res1 = 0 ;
51261 void *argp2 = 0 ;
51262 int res2 = 0 ;
51263 int val3 ;
51264 int ecode3 = 0 ;
51265 PyObject * obj0 = 0 ;
51266 PyObject * obj1 = 0 ;
51267 PyObject * obj2 = 0 ;
51268 char * kwnames[] = {
51269 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51270 };
51271
51272 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51273 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51274 if (!SWIG_IsOK(res1)) {
51275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51276 }
51277 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51278 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51279 if (!SWIG_IsOK(res2)) {
51280 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51281 }
51282 arg2 = reinterpret_cast< wxWindow * >(argp2);
51283 if (obj2) {
51284 ecode3 = SWIG_AsVal_int(obj2, &val3);
51285 if (!SWIG_IsOK(ecode3)) {
51286 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "3"" of type '" "int""'");
51287 }
51288 arg3 = static_cast< int >(val3);
51289 }
51290 {
51291 PyThreadState* __tstate = wxPyBeginAllowThreads();
51292 (arg1)->LeftOf(arg2,arg3);
51293 wxPyEndAllowThreads(__tstate);
51294 if (PyErr_Occurred()) SWIG_fail;
51295 }
51296 resultobj = SWIG_Py_Void();
51297 return resultobj;
51298 fail:
51299 return NULL;
51300 }
51301
51302
51303 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51304 PyObject *resultobj = 0;
51305 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51306 wxWindow *arg2 = (wxWindow *) 0 ;
51307 int arg3 = (int) 0 ;
51308 void *argp1 = 0 ;
51309 int res1 = 0 ;
51310 void *argp2 = 0 ;
51311 int res2 = 0 ;
51312 int val3 ;
51313 int ecode3 = 0 ;
51314 PyObject * obj0 = 0 ;
51315 PyObject * obj1 = 0 ;
51316 PyObject * obj2 = 0 ;
51317 char * kwnames[] = {
51318 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51319 };
51320
51321 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51322 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51323 if (!SWIG_IsOK(res1)) {
51324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51325 }
51326 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51327 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51328 if (!SWIG_IsOK(res2)) {
51329 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51330 }
51331 arg2 = reinterpret_cast< wxWindow * >(argp2);
51332 if (obj2) {
51333 ecode3 = SWIG_AsVal_int(obj2, &val3);
51334 if (!SWIG_IsOK(ecode3)) {
51335 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "3"" of type '" "int""'");
51336 }
51337 arg3 = static_cast< int >(val3);
51338 }
51339 {
51340 PyThreadState* __tstate = wxPyBeginAllowThreads();
51341 (arg1)->RightOf(arg2,arg3);
51342 wxPyEndAllowThreads(__tstate);
51343 if (PyErr_Occurred()) SWIG_fail;
51344 }
51345 resultobj = SWIG_Py_Void();
51346 return resultobj;
51347 fail:
51348 return NULL;
51349 }
51350
51351
51352 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51353 PyObject *resultobj = 0;
51354 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51355 wxWindow *arg2 = (wxWindow *) 0 ;
51356 int arg3 = (int) 0 ;
51357 void *argp1 = 0 ;
51358 int res1 = 0 ;
51359 void *argp2 = 0 ;
51360 int res2 = 0 ;
51361 int val3 ;
51362 int ecode3 = 0 ;
51363 PyObject * obj0 = 0 ;
51364 PyObject * obj1 = 0 ;
51365 PyObject * obj2 = 0 ;
51366 char * kwnames[] = {
51367 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51368 };
51369
51370 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51371 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51372 if (!SWIG_IsOK(res1)) {
51373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51374 }
51375 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51376 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51377 if (!SWIG_IsOK(res2)) {
51378 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "2"" of type '" "wxWindow *""'");
51379 }
51380 arg2 = reinterpret_cast< wxWindow * >(argp2);
51381 if (obj2) {
51382 ecode3 = SWIG_AsVal_int(obj2, &val3);
51383 if (!SWIG_IsOK(ecode3)) {
51384 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "3"" of type '" "int""'");
51385 }
51386 arg3 = static_cast< int >(val3);
51387 }
51388 {
51389 PyThreadState* __tstate = wxPyBeginAllowThreads();
51390 (arg1)->Above(arg2,arg3);
51391 wxPyEndAllowThreads(__tstate);
51392 if (PyErr_Occurred()) SWIG_fail;
51393 }
51394 resultobj = SWIG_Py_Void();
51395 return resultobj;
51396 fail:
51397 return NULL;
51398 }
51399
51400
51401 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51402 PyObject *resultobj = 0;
51403 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51404 wxWindow *arg2 = (wxWindow *) 0 ;
51405 int arg3 = (int) 0 ;
51406 void *argp1 = 0 ;
51407 int res1 = 0 ;
51408 void *argp2 = 0 ;
51409 int res2 = 0 ;
51410 int val3 ;
51411 int ecode3 = 0 ;
51412 PyObject * obj0 = 0 ;
51413 PyObject * obj1 = 0 ;
51414 PyObject * obj2 = 0 ;
51415 char * kwnames[] = {
51416 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51417 };
51418
51419 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51420 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51421 if (!SWIG_IsOK(res1)) {
51422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51423 }
51424 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51425 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51426 if (!SWIG_IsOK(res2)) {
51427 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "2"" of type '" "wxWindow *""'");
51428 }
51429 arg2 = reinterpret_cast< wxWindow * >(argp2);
51430 if (obj2) {
51431 ecode3 = SWIG_AsVal_int(obj2, &val3);
51432 if (!SWIG_IsOK(ecode3)) {
51433 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "3"" of type '" "int""'");
51434 }
51435 arg3 = static_cast< int >(val3);
51436 }
51437 {
51438 PyThreadState* __tstate = wxPyBeginAllowThreads();
51439 (arg1)->Below(arg2,arg3);
51440 wxPyEndAllowThreads(__tstate);
51441 if (PyErr_Occurred()) SWIG_fail;
51442 }
51443 resultobj = SWIG_Py_Void();
51444 return resultobj;
51445 fail:
51446 return NULL;
51447 }
51448
51449
51450 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51451 PyObject *resultobj = 0;
51452 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51453 wxWindow *arg2 = (wxWindow *) 0 ;
51454 wxEdge arg3 ;
51455 int arg4 = (int) 0 ;
51456 void *argp1 = 0 ;
51457 int res1 = 0 ;
51458 void *argp2 = 0 ;
51459 int res2 = 0 ;
51460 int val3 ;
51461 int ecode3 = 0 ;
51462 int val4 ;
51463 int ecode4 = 0 ;
51464 PyObject * obj0 = 0 ;
51465 PyObject * obj1 = 0 ;
51466 PyObject * obj2 = 0 ;
51467 PyObject * obj3 = 0 ;
51468 char * kwnames[] = {
51469 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
51470 };
51471
51472 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51473 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51474 if (!SWIG_IsOK(res1)) {
51475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51476 }
51477 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51478 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51479 if (!SWIG_IsOK(res2)) {
51480 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "2"" of type '" "wxWindow *""'");
51481 }
51482 arg2 = reinterpret_cast< wxWindow * >(argp2);
51483 ecode3 = SWIG_AsVal_int(obj2, &val3);
51484 if (!SWIG_IsOK(ecode3)) {
51485 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "3"" of type '" "wxEdge""'");
51486 }
51487 arg3 = static_cast< wxEdge >(val3);
51488 if (obj3) {
51489 ecode4 = SWIG_AsVal_int(obj3, &val4);
51490 if (!SWIG_IsOK(ecode4)) {
51491 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "4"" of type '" "int""'");
51492 }
51493 arg4 = static_cast< int >(val4);
51494 }
51495 {
51496 PyThreadState* __tstate = wxPyBeginAllowThreads();
51497 (arg1)->SameAs(arg2,arg3,arg4);
51498 wxPyEndAllowThreads(__tstate);
51499 if (PyErr_Occurred()) SWIG_fail;
51500 }
51501 resultobj = SWIG_Py_Void();
51502 return resultobj;
51503 fail:
51504 return NULL;
51505 }
51506
51507
51508 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51509 PyObject *resultobj = 0;
51510 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51511 wxWindow *arg2 = (wxWindow *) 0 ;
51512 wxEdge arg3 ;
51513 int arg4 ;
51514 void *argp1 = 0 ;
51515 int res1 = 0 ;
51516 void *argp2 = 0 ;
51517 int res2 = 0 ;
51518 int val3 ;
51519 int ecode3 = 0 ;
51520 int val4 ;
51521 int ecode4 = 0 ;
51522 PyObject * obj0 = 0 ;
51523 PyObject * obj1 = 0 ;
51524 PyObject * obj2 = 0 ;
51525 PyObject * obj3 = 0 ;
51526 char * kwnames[] = {
51527 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
51528 };
51529
51530 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51531 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51532 if (!SWIG_IsOK(res1)) {
51533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51534 }
51535 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51536 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51537 if (!SWIG_IsOK(res2)) {
51538 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51539 }
51540 arg2 = reinterpret_cast< wxWindow * >(argp2);
51541 ecode3 = SWIG_AsVal_int(obj2, &val3);
51542 if (!SWIG_IsOK(ecode3)) {
51543 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "3"" of type '" "wxEdge""'");
51544 }
51545 arg3 = static_cast< wxEdge >(val3);
51546 ecode4 = SWIG_AsVal_int(obj3, &val4);
51547 if (!SWIG_IsOK(ecode4)) {
51548 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "4"" of type '" "int""'");
51549 }
51550 arg4 = static_cast< int >(val4);
51551 {
51552 PyThreadState* __tstate = wxPyBeginAllowThreads();
51553 (arg1)->PercentOf(arg2,arg3,arg4);
51554 wxPyEndAllowThreads(__tstate);
51555 if (PyErr_Occurred()) SWIG_fail;
51556 }
51557 resultobj = SWIG_Py_Void();
51558 return resultobj;
51559 fail:
51560 return NULL;
51561 }
51562
51563
51564 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51565 PyObject *resultobj = 0;
51566 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51567 int arg2 ;
51568 void *argp1 = 0 ;
51569 int res1 = 0 ;
51570 int val2 ;
51571 int ecode2 = 0 ;
51572 PyObject * obj0 = 0 ;
51573 PyObject * obj1 = 0 ;
51574 char * kwnames[] = {
51575 (char *) "self",(char *) "val", NULL
51576 };
51577
51578 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) SWIG_fail;
51579 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51580 if (!SWIG_IsOK(res1)) {
51581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51582 }
51583 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51584 ecode2 = SWIG_AsVal_int(obj1, &val2);
51585 if (!SWIG_IsOK(ecode2)) {
51586 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "2"" of type '" "int""'");
51587 }
51588 arg2 = static_cast< int >(val2);
51589 {
51590 PyThreadState* __tstate = wxPyBeginAllowThreads();
51591 (arg1)->Absolute(arg2);
51592 wxPyEndAllowThreads(__tstate);
51593 if (PyErr_Occurred()) SWIG_fail;
51594 }
51595 resultobj = SWIG_Py_Void();
51596 return resultobj;
51597 fail:
51598 return NULL;
51599 }
51600
51601
51602 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51603 PyObject *resultobj = 0;
51604 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51605 void *argp1 = 0 ;
51606 int res1 = 0 ;
51607 PyObject *swig_obj[1] ;
51608
51609 if (!args) SWIG_fail;
51610 swig_obj[0] = args;
51611 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51612 if (!SWIG_IsOK(res1)) {
51613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Unconstrained" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51614 }
51615 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51616 {
51617 PyThreadState* __tstate = wxPyBeginAllowThreads();
51618 (arg1)->Unconstrained();
51619 wxPyEndAllowThreads(__tstate);
51620 if (PyErr_Occurred()) SWIG_fail;
51621 }
51622 resultobj = SWIG_Py_Void();
51623 return resultobj;
51624 fail:
51625 return NULL;
51626 }
51627
51628
51629 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51630 PyObject *resultobj = 0;
51631 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51632 void *argp1 = 0 ;
51633 int res1 = 0 ;
51634 PyObject *swig_obj[1] ;
51635
51636 if (!args) SWIG_fail;
51637 swig_obj[0] = args;
51638 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51639 if (!SWIG_IsOK(res1)) {
51640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_AsIs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51641 }
51642 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51643 {
51644 PyThreadState* __tstate = wxPyBeginAllowThreads();
51645 (arg1)->AsIs();
51646 wxPyEndAllowThreads(__tstate);
51647 if (PyErr_Occurred()) SWIG_fail;
51648 }
51649 resultobj = SWIG_Py_Void();
51650 return resultobj;
51651 fail:
51652 return NULL;
51653 }
51654
51655
51656 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51657 PyObject *resultobj = 0;
51658 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51659 wxWindow *result = 0 ;
51660 void *argp1 = 0 ;
51661 int res1 = 0 ;
51662 PyObject *swig_obj[1] ;
51663
51664 if (!args) SWIG_fail;
51665 swig_obj[0] = args;
51666 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51667 if (!SWIG_IsOK(res1)) {
51668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherWindow" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51669 }
51670 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51671 {
51672 PyThreadState* __tstate = wxPyBeginAllowThreads();
51673 result = (wxWindow *)(arg1)->GetOtherWindow();
51674 wxPyEndAllowThreads(__tstate);
51675 if (PyErr_Occurred()) SWIG_fail;
51676 }
51677 {
51678 resultobj = wxPyMake_wxObject(result, 0);
51679 }
51680 return resultobj;
51681 fail:
51682 return NULL;
51683 }
51684
51685
51686 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51687 PyObject *resultobj = 0;
51688 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51689 wxEdge result;
51690 void *argp1 = 0 ;
51691 int res1 = 0 ;
51692 PyObject *swig_obj[1] ;
51693
51694 if (!args) SWIG_fail;
51695 swig_obj[0] = args;
51696 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51697 if (!SWIG_IsOK(res1)) {
51698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMyEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51699 }
51700 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51701 {
51702 PyThreadState* __tstate = wxPyBeginAllowThreads();
51703 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
51704 wxPyEndAllowThreads(__tstate);
51705 if (PyErr_Occurred()) SWIG_fail;
51706 }
51707 resultobj = SWIG_From_int(static_cast< int >(result));
51708 return resultobj;
51709 fail:
51710 return NULL;
51711 }
51712
51713
51714 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51715 PyObject *resultobj = 0;
51716 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51717 wxEdge arg2 ;
51718 void *argp1 = 0 ;
51719 int res1 = 0 ;
51720 int val2 ;
51721 int ecode2 = 0 ;
51722 PyObject * obj0 = 0 ;
51723 PyObject * obj1 = 0 ;
51724 char * kwnames[] = {
51725 (char *) "self",(char *) "which", NULL
51726 };
51727
51728 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) SWIG_fail;
51729 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51730 if (!SWIG_IsOK(res1)) {
51731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51732 }
51733 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51734 ecode2 = SWIG_AsVal_int(obj1, &val2);
51735 if (!SWIG_IsOK(ecode2)) {
51736 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
51737 }
51738 arg2 = static_cast< wxEdge >(val2);
51739 {
51740 PyThreadState* __tstate = wxPyBeginAllowThreads();
51741 (arg1)->SetEdge(arg2);
51742 wxPyEndAllowThreads(__tstate);
51743 if (PyErr_Occurred()) SWIG_fail;
51744 }
51745 resultobj = SWIG_Py_Void();
51746 return resultobj;
51747 fail:
51748 return NULL;
51749 }
51750
51751
51752 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51753 PyObject *resultobj = 0;
51754 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51755 int arg2 ;
51756 void *argp1 = 0 ;
51757 int res1 = 0 ;
51758 int val2 ;
51759 int ecode2 = 0 ;
51760 PyObject * obj0 = 0 ;
51761 PyObject * obj1 = 0 ;
51762 char * kwnames[] = {
51763 (char *) "self",(char *) "v", NULL
51764 };
51765
51766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
51767 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51768 if (!SWIG_IsOK(res1)) {
51769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51770 }
51771 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51772 ecode2 = SWIG_AsVal_int(obj1, &val2);
51773 if (!SWIG_IsOK(ecode2)) {
51774 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "2"" of type '" "int""'");
51775 }
51776 arg2 = static_cast< int >(val2);
51777 {
51778 PyThreadState* __tstate = wxPyBeginAllowThreads();
51779 (arg1)->SetValue(arg2);
51780 wxPyEndAllowThreads(__tstate);
51781 if (PyErr_Occurred()) SWIG_fail;
51782 }
51783 resultobj = SWIG_Py_Void();
51784 return resultobj;
51785 fail:
51786 return NULL;
51787 }
51788
51789
51790 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51791 PyObject *resultobj = 0;
51792 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51793 int result;
51794 void *argp1 = 0 ;
51795 int res1 = 0 ;
51796 PyObject *swig_obj[1] ;
51797
51798 if (!args) SWIG_fail;
51799 swig_obj[0] = args;
51800 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51801 if (!SWIG_IsOK(res1)) {
51802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51803 }
51804 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51805 {
51806 PyThreadState* __tstate = wxPyBeginAllowThreads();
51807 result = (int)(arg1)->GetMargin();
51808 wxPyEndAllowThreads(__tstate);
51809 if (PyErr_Occurred()) SWIG_fail;
51810 }
51811 resultobj = SWIG_From_int(static_cast< int >(result));
51812 return resultobj;
51813 fail:
51814 return NULL;
51815 }
51816
51817
51818 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51819 PyObject *resultobj = 0;
51820 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51821 int arg2 ;
51822 void *argp1 = 0 ;
51823 int res1 = 0 ;
51824 int val2 ;
51825 int ecode2 = 0 ;
51826 PyObject * obj0 = 0 ;
51827 PyObject * obj1 = 0 ;
51828 char * kwnames[] = {
51829 (char *) "self",(char *) "m", NULL
51830 };
51831
51832 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) SWIG_fail;
51833 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51834 if (!SWIG_IsOK(res1)) {
51835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51836 }
51837 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51838 ecode2 = SWIG_AsVal_int(obj1, &val2);
51839 if (!SWIG_IsOK(ecode2)) {
51840 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "2"" of type '" "int""'");
51841 }
51842 arg2 = static_cast< int >(val2);
51843 {
51844 PyThreadState* __tstate = wxPyBeginAllowThreads();
51845 (arg1)->SetMargin(arg2);
51846 wxPyEndAllowThreads(__tstate);
51847 if (PyErr_Occurred()) SWIG_fail;
51848 }
51849 resultobj = SWIG_Py_Void();
51850 return resultobj;
51851 fail:
51852 return NULL;
51853 }
51854
51855
51856 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51857 PyObject *resultobj = 0;
51858 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51859 int result;
51860 void *argp1 = 0 ;
51861 int res1 = 0 ;
51862 PyObject *swig_obj[1] ;
51863
51864 if (!args) SWIG_fail;
51865 swig_obj[0] = args;
51866 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51867 if (!SWIG_IsOK(res1)) {
51868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51869 }
51870 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51871 {
51872 PyThreadState* __tstate = wxPyBeginAllowThreads();
51873 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
51874 wxPyEndAllowThreads(__tstate);
51875 if (PyErr_Occurred()) SWIG_fail;
51876 }
51877 resultobj = SWIG_From_int(static_cast< int >(result));
51878 return resultobj;
51879 fail:
51880 return NULL;
51881 }
51882
51883
51884 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51885 PyObject *resultobj = 0;
51886 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51887 int result;
51888 void *argp1 = 0 ;
51889 int res1 = 0 ;
51890 PyObject *swig_obj[1] ;
51891
51892 if (!args) SWIG_fail;
51893 swig_obj[0] = args;
51894 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51895 if (!SWIG_IsOK(res1)) {
51896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetPercent" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51897 }
51898 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51899 {
51900 PyThreadState* __tstate = wxPyBeginAllowThreads();
51901 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
51902 wxPyEndAllowThreads(__tstate);
51903 if (PyErr_Occurred()) SWIG_fail;
51904 }
51905 resultobj = SWIG_From_int(static_cast< int >(result));
51906 return resultobj;
51907 fail:
51908 return NULL;
51909 }
51910
51911
51912 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51913 PyObject *resultobj = 0;
51914 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51915 int result;
51916 void *argp1 = 0 ;
51917 int res1 = 0 ;
51918 PyObject *swig_obj[1] ;
51919
51920 if (!args) SWIG_fail;
51921 swig_obj[0] = args;
51922 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51923 if (!SWIG_IsOK(res1)) {
51924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51925 }
51926 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51927 {
51928 PyThreadState* __tstate = wxPyBeginAllowThreads();
51929 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
51930 wxPyEndAllowThreads(__tstate);
51931 if (PyErr_Occurred()) SWIG_fail;
51932 }
51933 resultobj = SWIG_From_int(static_cast< int >(result));
51934 return resultobj;
51935 fail:
51936 return NULL;
51937 }
51938
51939
51940 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51941 PyObject *resultobj = 0;
51942 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51943 bool result;
51944 void *argp1 = 0 ;
51945 int res1 = 0 ;
51946 PyObject *swig_obj[1] ;
51947
51948 if (!args) SWIG_fail;
51949 swig_obj[0] = args;
51950 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51951 if (!SWIG_IsOK(res1)) {
51952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51953 }
51954 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51955 {
51956 PyThreadState* __tstate = wxPyBeginAllowThreads();
51957 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
51958 wxPyEndAllowThreads(__tstate);
51959 if (PyErr_Occurred()) SWIG_fail;
51960 }
51961 {
51962 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51963 }
51964 return resultobj;
51965 fail:
51966 return NULL;
51967 }
51968
51969
51970 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51971 PyObject *resultobj = 0;
51972 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51973 bool arg2 ;
51974 void *argp1 = 0 ;
51975 int res1 = 0 ;
51976 bool val2 ;
51977 int ecode2 = 0 ;
51978 PyObject * obj0 = 0 ;
51979 PyObject * obj1 = 0 ;
51980 char * kwnames[] = {
51981 (char *) "self",(char *) "d", NULL
51982 };
51983
51984 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) SWIG_fail;
51985 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51986 if (!SWIG_IsOK(res1)) {
51987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51988 }
51989 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51990 ecode2 = SWIG_AsVal_bool(obj1, &val2);
51991 if (!SWIG_IsOK(ecode2)) {
51992 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "2"" of type '" "bool""'");
51993 }
51994 arg2 = static_cast< bool >(val2);
51995 {
51996 PyThreadState* __tstate = wxPyBeginAllowThreads();
51997 (arg1)->SetDone(arg2);
51998 wxPyEndAllowThreads(__tstate);
51999 if (PyErr_Occurred()) SWIG_fail;
52000 }
52001 resultobj = SWIG_Py_Void();
52002 return resultobj;
52003 fail:
52004 return NULL;
52005 }
52006
52007
52008 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52009 PyObject *resultobj = 0;
52010 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52011 wxRelationship result;
52012 void *argp1 = 0 ;
52013 int res1 = 0 ;
52014 PyObject *swig_obj[1] ;
52015
52016 if (!args) SWIG_fail;
52017 swig_obj[0] = args;
52018 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52019 if (!SWIG_IsOK(res1)) {
52020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52021 }
52022 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52023 {
52024 PyThreadState* __tstate = wxPyBeginAllowThreads();
52025 result = (wxRelationship)(arg1)->GetRelationship();
52026 wxPyEndAllowThreads(__tstate);
52027 if (PyErr_Occurred()) SWIG_fail;
52028 }
52029 resultobj = SWIG_From_int(static_cast< int >(result));
52030 return resultobj;
52031 fail:
52032 return NULL;
52033 }
52034
52035
52036 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52037 PyObject *resultobj = 0;
52038 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52039 wxRelationship arg2 ;
52040 void *argp1 = 0 ;
52041 int res1 = 0 ;
52042 int val2 ;
52043 int ecode2 = 0 ;
52044 PyObject * obj0 = 0 ;
52045 PyObject * obj1 = 0 ;
52046 char * kwnames[] = {
52047 (char *) "self",(char *) "r", NULL
52048 };
52049
52050 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) SWIG_fail;
52051 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52052 if (!SWIG_IsOK(res1)) {
52053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52054 }
52055 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52056 ecode2 = SWIG_AsVal_int(obj1, &val2);
52057 if (!SWIG_IsOK(ecode2)) {
52058 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "2"" of type '" "wxRelationship""'");
52059 }
52060 arg2 = static_cast< wxRelationship >(val2);
52061 {
52062 PyThreadState* __tstate = wxPyBeginAllowThreads();
52063 (arg1)->SetRelationship(arg2);
52064 wxPyEndAllowThreads(__tstate);
52065 if (PyErr_Occurred()) SWIG_fail;
52066 }
52067 resultobj = SWIG_Py_Void();
52068 return resultobj;
52069 fail:
52070 return NULL;
52071 }
52072
52073
52074 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52075 PyObject *resultobj = 0;
52076 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52077 wxWindow *arg2 = (wxWindow *) 0 ;
52078 bool result;
52079 void *argp1 = 0 ;
52080 int res1 = 0 ;
52081 void *argp2 = 0 ;
52082 int res2 = 0 ;
52083 PyObject * obj0 = 0 ;
52084 PyObject * obj1 = 0 ;
52085 char * kwnames[] = {
52086 (char *) "self",(char *) "otherW", NULL
52087 };
52088
52089 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) SWIG_fail;
52090 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52091 if (!SWIG_IsOK(res1)) {
52092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52093 }
52094 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52095 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52096 if (!SWIG_IsOK(res2)) {
52097 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "2"" of type '" "wxWindow *""'");
52098 }
52099 arg2 = reinterpret_cast< wxWindow * >(argp2);
52100 {
52101 PyThreadState* __tstate = wxPyBeginAllowThreads();
52102 result = (bool)(arg1)->ResetIfWin(arg2);
52103 wxPyEndAllowThreads(__tstate);
52104 if (PyErr_Occurred()) SWIG_fail;
52105 }
52106 {
52107 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52108 }
52109 return resultobj;
52110 fail:
52111 return NULL;
52112 }
52113
52114
52115 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52116 PyObject *resultobj = 0;
52117 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52118 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
52119 wxWindow *arg3 = (wxWindow *) 0 ;
52120 bool result;
52121 void *argp1 = 0 ;
52122 int res1 = 0 ;
52123 void *argp2 = 0 ;
52124 int res2 = 0 ;
52125 void *argp3 = 0 ;
52126 int res3 = 0 ;
52127 PyObject * obj0 = 0 ;
52128 PyObject * obj1 = 0 ;
52129 PyObject * obj2 = 0 ;
52130 char * kwnames[] = {
52131 (char *) "self",(char *) "constraints",(char *) "win", NULL
52132 };
52133
52134 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52135 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52136 if (!SWIG_IsOK(res1)) {
52137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52138 }
52139 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52140 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52141 if (!SWIG_IsOK(res2)) {
52142 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
52143 }
52144 arg2 = reinterpret_cast< wxLayoutConstraints * >(argp2);
52145 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
52146 if (!SWIG_IsOK(res3)) {
52147 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "3"" of type '" "wxWindow *""'");
52148 }
52149 arg3 = reinterpret_cast< wxWindow * >(argp3);
52150 {
52151 PyThreadState* __tstate = wxPyBeginAllowThreads();
52152 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
52153 wxPyEndAllowThreads(__tstate);
52154 if (PyErr_Occurred()) SWIG_fail;
52155 }
52156 {
52157 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52158 }
52159 return resultobj;
52160 fail:
52161 return NULL;
52162 }
52163
52164
52165 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52166 PyObject *resultobj = 0;
52167 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52168 wxEdge arg2 ;
52169 wxWindow *arg3 = (wxWindow *) 0 ;
52170 wxWindow *arg4 = (wxWindow *) 0 ;
52171 int result;
52172 void *argp1 = 0 ;
52173 int res1 = 0 ;
52174 int val2 ;
52175 int ecode2 = 0 ;
52176 void *argp3 = 0 ;
52177 int res3 = 0 ;
52178 void *argp4 = 0 ;
52179 int res4 = 0 ;
52180 PyObject * obj0 = 0 ;
52181 PyObject * obj1 = 0 ;
52182 PyObject * obj2 = 0 ;
52183 PyObject * obj3 = 0 ;
52184 char * kwnames[] = {
52185 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
52186 };
52187
52188 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52189 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52190 if (!SWIG_IsOK(res1)) {
52191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52192 }
52193 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52194 ecode2 = SWIG_AsVal_int(obj1, &val2);
52195 if (!SWIG_IsOK(ecode2)) {
52196 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
52197 }
52198 arg2 = static_cast< wxEdge >(val2);
52199 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
52200 if (!SWIG_IsOK(res3)) {
52201 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "3"" of type '" "wxWindow *""'");
52202 }
52203 arg3 = reinterpret_cast< wxWindow * >(argp3);
52204 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
52205 if (!SWIG_IsOK(res4)) {
52206 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "4"" of type '" "wxWindow *""'");
52207 }
52208 arg4 = reinterpret_cast< wxWindow * >(argp4);
52209 {
52210 PyThreadState* __tstate = wxPyBeginAllowThreads();
52211 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge(arg2,arg3,arg4);
52212 wxPyEndAllowThreads(__tstate);
52213 if (PyErr_Occurred()) SWIG_fail;
52214 }
52215 resultobj = SWIG_From_int(static_cast< int >(result));
52216 return resultobj;
52217 fail:
52218 return NULL;
52219 }
52220
52221
52222 SWIGINTERN PyObject *IndividualLayoutConstraint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52223 PyObject *obj;
52224 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52225 SWIG_TypeNewClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_NewClientData(obj));
52226 return SWIG_Py_Void();
52227 }
52228
52229 SWIGINTERN PyObject *_wrap_LayoutConstraints_left_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52230 PyObject *resultobj = 0;
52231 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52232 wxIndividualLayoutConstraint *result = 0 ;
52233 void *argp1 = 0 ;
52234 int res1 = 0 ;
52235 PyObject *swig_obj[1] ;
52236
52237 if (!args) SWIG_fail;
52238 swig_obj[0] = args;
52239 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52240 if (!SWIG_IsOK(res1)) {
52241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_left_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52242 }
52243 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52244 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
52245 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52246 return resultobj;
52247 fail:
52248 return NULL;
52249 }
52250
52251
52252 SWIGINTERN PyObject *_wrap_LayoutConstraints_top_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52253 PyObject *resultobj = 0;
52254 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52255 wxIndividualLayoutConstraint *result = 0 ;
52256 void *argp1 = 0 ;
52257 int res1 = 0 ;
52258 PyObject *swig_obj[1] ;
52259
52260 if (!args) SWIG_fail;
52261 swig_obj[0] = args;
52262 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52263 if (!SWIG_IsOK(res1)) {
52264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_top_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52265 }
52266 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52267 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
52268 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52269 return resultobj;
52270 fail:
52271 return NULL;
52272 }
52273
52274
52275 SWIGINTERN PyObject *_wrap_LayoutConstraints_right_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52276 PyObject *resultobj = 0;
52277 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52278 wxIndividualLayoutConstraint *result = 0 ;
52279 void *argp1 = 0 ;
52280 int res1 = 0 ;
52281 PyObject *swig_obj[1] ;
52282
52283 if (!args) SWIG_fail;
52284 swig_obj[0] = args;
52285 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52286 if (!SWIG_IsOK(res1)) {
52287 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_right_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52288 }
52289 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52290 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
52291 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52292 return resultobj;
52293 fail:
52294 return NULL;
52295 }
52296
52297
52298 SWIGINTERN PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52299 PyObject *resultobj = 0;
52300 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52301 wxIndividualLayoutConstraint *result = 0 ;
52302 void *argp1 = 0 ;
52303 int res1 = 0 ;
52304 PyObject *swig_obj[1] ;
52305
52306 if (!args) SWIG_fail;
52307 swig_obj[0] = args;
52308 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52309 if (!SWIG_IsOK(res1)) {
52310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_bottom_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52311 }
52312 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52313 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
52314 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52315 return resultobj;
52316 fail:
52317 return NULL;
52318 }
52319
52320
52321 SWIGINTERN PyObject *_wrap_LayoutConstraints_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52322 PyObject *resultobj = 0;
52323 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52324 wxIndividualLayoutConstraint *result = 0 ;
52325 void *argp1 = 0 ;
52326 int res1 = 0 ;
52327 PyObject *swig_obj[1] ;
52328
52329 if (!args) SWIG_fail;
52330 swig_obj[0] = args;
52331 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52332 if (!SWIG_IsOK(res1)) {
52333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_width_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52334 }
52335 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52336 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
52337 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52338 return resultobj;
52339 fail:
52340 return NULL;
52341 }
52342
52343
52344 SWIGINTERN PyObject *_wrap_LayoutConstraints_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52345 PyObject *resultobj = 0;
52346 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52347 wxIndividualLayoutConstraint *result = 0 ;
52348 void *argp1 = 0 ;
52349 int res1 = 0 ;
52350 PyObject *swig_obj[1] ;
52351
52352 if (!args) SWIG_fail;
52353 swig_obj[0] = args;
52354 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52355 if (!SWIG_IsOK(res1)) {
52356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_height_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52357 }
52358 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52359 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
52360 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52361 return resultobj;
52362 fail:
52363 return NULL;
52364 }
52365
52366
52367 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52368 PyObject *resultobj = 0;
52369 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52370 wxIndividualLayoutConstraint *result = 0 ;
52371 void *argp1 = 0 ;
52372 int res1 = 0 ;
52373 PyObject *swig_obj[1] ;
52374
52375 if (!args) SWIG_fail;
52376 swig_obj[0] = args;
52377 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52378 if (!SWIG_IsOK(res1)) {
52379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreX_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52380 }
52381 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52382 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
52383 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52384 return resultobj;
52385 fail:
52386 return NULL;
52387 }
52388
52389
52390 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52391 PyObject *resultobj = 0;
52392 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52393 wxIndividualLayoutConstraint *result = 0 ;
52394 void *argp1 = 0 ;
52395 int res1 = 0 ;
52396 PyObject *swig_obj[1] ;
52397
52398 if (!args) SWIG_fail;
52399 swig_obj[0] = args;
52400 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52401 if (!SWIG_IsOK(res1)) {
52402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreY_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52403 }
52404 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52405 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
52406 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52407 return resultobj;
52408 fail:
52409 return NULL;
52410 }
52411
52412
52413 SWIGINTERN PyObject *_wrap_new_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52414 PyObject *resultobj = 0;
52415 wxLayoutConstraints *result = 0 ;
52416
52417 if (!SWIG_Python_UnpackTuple(args,"new_LayoutConstraints",0,0,0)) SWIG_fail;
52418 {
52419 PyThreadState* __tstate = wxPyBeginAllowThreads();
52420 result = (wxLayoutConstraints *)new wxLayoutConstraints();
52421 wxPyEndAllowThreads(__tstate);
52422 if (PyErr_Occurred()) SWIG_fail;
52423 }
52424 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_NEW | 0 );
52425 return resultobj;
52426 fail:
52427 return NULL;
52428 }
52429
52430
52431 SWIGINTERN PyObject *_wrap_delete_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52432 PyObject *resultobj = 0;
52433 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52434 void *argp1 = 0 ;
52435 int res1 = 0 ;
52436 PyObject *swig_obj[1] ;
52437
52438 if (!args) SWIG_fail;
52439 swig_obj[0] = args;
52440 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
52441 if (!SWIG_IsOK(res1)) {
52442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LayoutConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52443 }
52444 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52445 {
52446 PyThreadState* __tstate = wxPyBeginAllowThreads();
52447 delete arg1;
52448
52449 wxPyEndAllowThreads(__tstate);
52450 if (PyErr_Occurred()) SWIG_fail;
52451 }
52452 resultobj = SWIG_Py_Void();
52453 return resultobj;
52454 fail:
52455 return NULL;
52456 }
52457
52458
52459 SWIGINTERN PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52460 PyObject *resultobj = 0;
52461 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52462 wxWindow *arg2 = (wxWindow *) 0 ;
52463 int *arg3 = (int *) 0 ;
52464 bool result;
52465 void *argp1 = 0 ;
52466 int res1 = 0 ;
52467 void *argp2 = 0 ;
52468 int res2 = 0 ;
52469 int temp3 ;
52470 int res3 = SWIG_TMPOBJ ;
52471 PyObject * obj0 = 0 ;
52472 PyObject * obj1 = 0 ;
52473 char * kwnames[] = {
52474 (char *) "self",(char *) "win", NULL
52475 };
52476
52477 arg3 = &temp3;
52478 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
52479 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52480 if (!SWIG_IsOK(res1)) {
52481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52482 }
52483 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52484 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52485 if (!SWIG_IsOK(res2)) {
52486 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "2"" of type '" "wxWindow *""'");
52487 }
52488 arg2 = reinterpret_cast< wxWindow * >(argp2);
52489 {
52490 PyThreadState* __tstate = wxPyBeginAllowThreads();
52491 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
52492 wxPyEndAllowThreads(__tstate);
52493 if (PyErr_Occurred()) SWIG_fail;
52494 }
52495 {
52496 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52497 }
52498 if (SWIG_IsTmpObj(res3)) {
52499 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
52500 } else {
52501 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
52502 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
52503 }
52504 return resultobj;
52505 fail:
52506 return NULL;
52507 }
52508
52509
52510 SWIGINTERN PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52511 PyObject *resultobj = 0;
52512 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52513 bool result;
52514 void *argp1 = 0 ;
52515 int res1 = 0 ;
52516 PyObject *swig_obj[1] ;
52517
52518 if (!args) SWIG_fail;
52519 swig_obj[0] = args;
52520 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52521 if (!SWIG_IsOK(res1)) {
52522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_AreSatisfied" "', expected argument " "1"" of type '" "wxLayoutConstraints const *""'");
52523 }
52524 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52525 {
52526 PyThreadState* __tstate = wxPyBeginAllowThreads();
52527 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
52528 wxPyEndAllowThreads(__tstate);
52529 if (PyErr_Occurred()) SWIG_fail;
52530 }
52531 {
52532 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52533 }
52534 return resultobj;
52535 fail:
52536 return NULL;
52537 }
52538
52539
52540 SWIGINTERN PyObject *LayoutConstraints_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52541 PyObject *obj;
52542 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52543 SWIG_TypeNewClientData(SWIGTYPE_p_wxLayoutConstraints, SWIG_NewClientData(obj));
52544 return SWIG_Py_Void();
52545 }
52546
52547 SWIGINTERN PyObject *LayoutConstraints_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52548 return SWIG_Python_InitShadowInstance(args);
52549 }
52550
52551 static PyMethodDef SwigMethods[] = {
52552 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
52553 { (char *)"Object_GetClassName", (PyCFunction)_wrap_Object_GetClassName, METH_O, NULL},
52554 { (char *)"Object_Destroy", (PyCFunction)_wrap_Object_Destroy, METH_O, NULL},
52555 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
52556 { (char *)"Size_width_set", _wrap_Size_width_set, METH_VARARGS, NULL},
52557 { (char *)"Size_width_get", (PyCFunction)_wrap_Size_width_get, METH_O, NULL},
52558 { (char *)"Size_height_set", _wrap_Size_height_set, METH_VARARGS, NULL},
52559 { (char *)"Size_height_get", (PyCFunction)_wrap_Size_height_get, METH_O, NULL},
52560 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
52561 { (char *)"delete_Size", (PyCFunction)_wrap_delete_Size, METH_O, NULL},
52562 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52563 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52564 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52565 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52566 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
52567 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
52568 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52569 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
52570 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
52571 { (char *)"Size_GetWidth", (PyCFunction)_wrap_Size_GetWidth, METH_O, NULL},
52572 { (char *)"Size_GetHeight", (PyCFunction)_wrap_Size_GetHeight, METH_O, NULL},
52573 { (char *)"Size_IsFullySpecified", (PyCFunction)_wrap_Size_IsFullySpecified, METH_O, NULL},
52574 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
52575 { (char *)"Size_Get", (PyCFunction)_wrap_Size_Get, METH_O, NULL},
52576 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
52577 { (char *)"Size_swiginit", Size_swiginit, METH_VARARGS, NULL},
52578 { (char *)"RealPoint_x_set", _wrap_RealPoint_x_set, METH_VARARGS, NULL},
52579 { (char *)"RealPoint_x_get", (PyCFunction)_wrap_RealPoint_x_get, METH_O, NULL},
52580 { (char *)"RealPoint_y_set", _wrap_RealPoint_y_set, METH_VARARGS, NULL},
52581 { (char *)"RealPoint_y_get", (PyCFunction)_wrap_RealPoint_y_get, METH_O, NULL},
52582 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
52583 { (char *)"delete_RealPoint", (PyCFunction)_wrap_delete_RealPoint, METH_O, NULL},
52584 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52585 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52586 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52587 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52588 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52589 { (char *)"RealPoint_Get", (PyCFunction)_wrap_RealPoint_Get, METH_O, NULL},
52590 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
52591 { (char *)"RealPoint_swiginit", RealPoint_swiginit, METH_VARARGS, NULL},
52592 { (char *)"Point_x_set", _wrap_Point_x_set, METH_VARARGS, NULL},
52593 { (char *)"Point_x_get", (PyCFunction)_wrap_Point_x_get, METH_O, NULL},
52594 { (char *)"Point_y_set", _wrap_Point_y_set, METH_VARARGS, NULL},
52595 { (char *)"Point_y_get", (PyCFunction)_wrap_Point_y_get, METH_O, NULL},
52596 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
52597 { (char *)"delete_Point", (PyCFunction)_wrap_delete_Point, METH_O, NULL},
52598 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52599 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52600 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52601 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52602 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52603 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
52604 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52605 { (char *)"Point_Get", (PyCFunction)_wrap_Point_Get, METH_O, NULL},
52606 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
52607 { (char *)"Point_swiginit", Point_swiginit, METH_VARARGS, NULL},
52608 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
52609 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
52610 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
52611 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
52612 { (char *)"delete_Rect", (PyCFunction)_wrap_delete_Rect, METH_O, NULL},
52613 { (char *)"Rect_GetX", (PyCFunction)_wrap_Rect_GetX, METH_O, NULL},
52614 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
52615 { (char *)"Rect_GetY", (PyCFunction)_wrap_Rect_GetY, METH_O, NULL},
52616 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
52617 { (char *)"Rect_GetWidth", (PyCFunction)_wrap_Rect_GetWidth, METH_O, NULL},
52618 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
52619 { (char *)"Rect_GetHeight", (PyCFunction)_wrap_Rect_GetHeight, METH_O, NULL},
52620 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
52621 { (char *)"Rect_GetPosition", (PyCFunction)_wrap_Rect_GetPosition, METH_O, NULL},
52622 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
52623 { (char *)"Rect_GetSize", (PyCFunction)_wrap_Rect_GetSize, METH_O, NULL},
52624 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
52625 { (char *)"Rect_IsEmpty", (PyCFunction)_wrap_Rect_IsEmpty, METH_O, NULL},
52626 { (char *)"Rect_GetTopLeft", (PyCFunction)_wrap_Rect_GetTopLeft, METH_O, NULL},
52627 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
52628 { (char *)"Rect_GetBottomRight", (PyCFunction)_wrap_Rect_GetBottomRight, METH_O, NULL},
52629 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
52630 { (char *)"Rect_GetLeft", (PyCFunction)_wrap_Rect_GetLeft, METH_O, NULL},
52631 { (char *)"Rect_GetTop", (PyCFunction)_wrap_Rect_GetTop, METH_O, NULL},
52632 { (char *)"Rect_GetBottom", (PyCFunction)_wrap_Rect_GetBottom, METH_O, NULL},
52633 { (char *)"Rect_GetRight", (PyCFunction)_wrap_Rect_GetRight, METH_O, NULL},
52634 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
52635 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
52636 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
52637 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
52638 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
52639 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
52640 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
52641 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
52642 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
52643 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
52644 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52645 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52646 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52647 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52648 { (char *)"Rect_InsideXY", (PyCFunction) _wrap_Rect_InsideXY, METH_VARARGS | METH_KEYWORDS, NULL},
52649 { (char *)"Rect_Inside", (PyCFunction) _wrap_Rect_Inside, METH_VARARGS | METH_KEYWORDS, NULL},
52650 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
52651 { (char *)"Rect_CenterIn", (PyCFunction) _wrap_Rect_CenterIn, METH_VARARGS | METH_KEYWORDS, NULL},
52652 { (char *)"Rect_x_set", _wrap_Rect_x_set, METH_VARARGS, NULL},
52653 { (char *)"Rect_x_get", (PyCFunction)_wrap_Rect_x_get, METH_O, NULL},
52654 { (char *)"Rect_y_set", _wrap_Rect_y_set, METH_VARARGS, NULL},
52655 { (char *)"Rect_y_get", (PyCFunction)_wrap_Rect_y_get, METH_O, NULL},
52656 { (char *)"Rect_width_set", _wrap_Rect_width_set, METH_VARARGS, NULL},
52657 { (char *)"Rect_width_get", (PyCFunction)_wrap_Rect_width_get, METH_O, NULL},
52658 { (char *)"Rect_height_set", _wrap_Rect_height_set, METH_VARARGS, NULL},
52659 { (char *)"Rect_height_get", (PyCFunction)_wrap_Rect_height_get, METH_O, NULL},
52660 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52661 { (char *)"Rect_Get", (PyCFunction)_wrap_Rect_Get, METH_O, NULL},
52662 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
52663 { (char *)"Rect_swiginit", Rect_swiginit, METH_VARARGS, NULL},
52664 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
52665 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
52666 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
52667 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
52668 { (char *)"Point2D_GetFloor", (PyCFunction)_wrap_Point2D_GetFloor, METH_O, NULL},
52669 { (char *)"Point2D_GetRounded", (PyCFunction)_wrap_Point2D_GetRounded, METH_O, NULL},
52670 { (char *)"Point2D_GetVectorLength", (PyCFunction)_wrap_Point2D_GetVectorLength, METH_O, NULL},
52671 { (char *)"Point2D_GetVectorAngle", (PyCFunction)_wrap_Point2D_GetVectorAngle, METH_O, NULL},
52672 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
52673 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
52674 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
52675 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
52676 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
52677 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
52678 { (char *)"Point2D___neg__", (PyCFunction)_wrap_Point2D___neg__, METH_O, NULL},
52679 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52680 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
52681 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
52682 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
52683 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52684 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52685 { (char *)"Point2D_x_set", _wrap_Point2D_x_set, METH_VARARGS, NULL},
52686 { (char *)"Point2D_x_get", (PyCFunction)_wrap_Point2D_x_get, METH_O, NULL},
52687 { (char *)"Point2D_y_set", _wrap_Point2D_y_set, METH_VARARGS, NULL},
52688 { (char *)"Point2D_y_get", (PyCFunction)_wrap_Point2D_y_get, METH_O, NULL},
52689 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52690 { (char *)"Point2D_Get", (PyCFunction)_wrap_Point2D_Get, METH_O, NULL},
52691 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
52692 { (char *)"Point2D_swiginit", Point2D_swiginit, METH_VARARGS, NULL},
52693 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
52694 { (char *)"delete_InputStream", (PyCFunction)_wrap_delete_InputStream, METH_O, NULL},
52695 { (char *)"InputStream_close", (PyCFunction)_wrap_InputStream_close, METH_O, NULL},
52696 { (char *)"InputStream_flush", (PyCFunction)_wrap_InputStream_flush, METH_O, NULL},
52697 { (char *)"InputStream_eof", (PyCFunction)_wrap_InputStream_eof, METH_O, NULL},
52698 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
52699 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
52700 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
52701 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
52702 { (char *)"InputStream_tell", (PyCFunction)_wrap_InputStream_tell, METH_O, NULL},
52703 { (char *)"InputStream_Peek", (PyCFunction)_wrap_InputStream_Peek, METH_O, NULL},
52704 { (char *)"InputStream_GetC", (PyCFunction)_wrap_InputStream_GetC, METH_O, NULL},
52705 { (char *)"InputStream_LastRead", (PyCFunction)_wrap_InputStream_LastRead, METH_O, NULL},
52706 { (char *)"InputStream_CanRead", (PyCFunction)_wrap_InputStream_CanRead, METH_O, NULL},
52707 { (char *)"InputStream_Eof", (PyCFunction)_wrap_InputStream_Eof, METH_O, NULL},
52708 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
52709 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
52710 { (char *)"InputStream_TellI", (PyCFunction)_wrap_InputStream_TellI, METH_O, NULL},
52711 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
52712 { (char *)"InputStream_swiginit", InputStream_swiginit, METH_VARARGS, NULL},
52713 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
52714 { (char *)"OutputStream_LastWrite", (PyCFunction)_wrap_OutputStream_LastWrite, METH_O, NULL},
52715 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
52716 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
52717 { (char *)"delete_FSFile", (PyCFunction)_wrap_delete_FSFile, METH_O, NULL},
52718 { (char *)"FSFile_GetStream", (PyCFunction)_wrap_FSFile_GetStream, METH_O, NULL},
52719 { (char *)"FSFile_GetMimeType", (PyCFunction)_wrap_FSFile_GetMimeType, METH_O, NULL},
52720 { (char *)"FSFile_GetLocation", (PyCFunction)_wrap_FSFile_GetLocation, METH_O, NULL},
52721 { (char *)"FSFile_GetAnchor", (PyCFunction)_wrap_FSFile_GetAnchor, METH_O, NULL},
52722 { (char *)"FSFile_GetModificationTime", (PyCFunction)_wrap_FSFile_GetModificationTime, METH_O, NULL},
52723 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
52724 { (char *)"FSFile_swiginit", FSFile_swiginit, METH_VARARGS, NULL},
52725 { (char *)"delete_CPPFileSystemHandler", (PyCFunction)_wrap_delete_CPPFileSystemHandler, METH_O, NULL},
52726 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
52727 { (char *)"new_FileSystemHandler", (PyCFunction)_wrap_new_FileSystemHandler, METH_NOARGS, NULL},
52728 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
52729 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52730 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52731 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52732 { (char *)"FileSystemHandler_FindNext", (PyCFunction)_wrap_FileSystemHandler_FindNext, METH_O, NULL},
52733 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
52734 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
52735 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
52736 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
52737 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
52738 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
52739 { (char *)"FileSystemHandler_swiginit", FileSystemHandler_swiginit, METH_VARARGS, NULL},
52740 { (char *)"new_FileSystem", (PyCFunction)_wrap_new_FileSystem, METH_NOARGS, NULL},
52741 { (char *)"delete_FileSystem", (PyCFunction)_wrap_delete_FileSystem, METH_O, NULL},
52742 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
52743 { (char *)"FileSystem_GetPath", (PyCFunction)_wrap_FileSystem_GetPath, METH_O, NULL},
52744 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52745 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52746 { (char *)"FileSystem_FindNext", (PyCFunction)_wrap_FileSystem_FindNext, METH_O, NULL},
52747 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52748 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction)_wrap_FileSystem_CleanUpHandlers, METH_NOARGS, NULL},
52749 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
52750 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
52751 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
52752 { (char *)"FileSystem_swiginit", FileSystem_swiginit, METH_VARARGS, NULL},
52753 { (char *)"new_InternetFSHandler", (PyCFunction)_wrap_new_InternetFSHandler, METH_NOARGS, NULL},
52754 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52755 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52756 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
52757 { (char *)"InternetFSHandler_swiginit", InternetFSHandler_swiginit, METH_VARARGS, NULL},
52758 { (char *)"new_ZipFSHandler", (PyCFunction)_wrap_new_ZipFSHandler, METH_NOARGS, NULL},
52759 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52760 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52761 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52762 { (char *)"ZipFSHandler_FindNext", (PyCFunction)_wrap_ZipFSHandler_FindNext, METH_O, NULL},
52763 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
52764 { (char *)"ZipFSHandler_swiginit", ZipFSHandler_swiginit, METH_VARARGS, NULL},
52765 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
52766 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
52767 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
52768 { (char *)"new_MemoryFSHandler", (PyCFunction)_wrap_new_MemoryFSHandler, METH_NOARGS, NULL},
52769 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
52770 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52771 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52772 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52773 { (char *)"MemoryFSHandler_FindNext", (PyCFunction)_wrap_MemoryFSHandler_FindNext, METH_O, NULL},
52774 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
52775 { (char *)"MemoryFSHandler_swiginit", MemoryFSHandler_swiginit, METH_VARARGS, NULL},
52776 { (char *)"ImageHandler_GetName", (PyCFunction)_wrap_ImageHandler_GetName, METH_O, NULL},
52777 { (char *)"ImageHandler_GetExtension", (PyCFunction)_wrap_ImageHandler_GetExtension, METH_O, NULL},
52778 { (char *)"ImageHandler_GetType", (PyCFunction)_wrap_ImageHandler_GetType, METH_O, NULL},
52779 { (char *)"ImageHandler_GetMimeType", (PyCFunction)_wrap_ImageHandler_GetMimeType, METH_O, NULL},
52780 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
52781 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
52782 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
52783 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
52784 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
52785 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
52786 { (char *)"new_PyImageHandler", (PyCFunction)_wrap_new_PyImageHandler, METH_NOARGS, NULL},
52787 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
52788 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
52789 { (char *)"PyImageHandler_swiginit", PyImageHandler_swiginit, METH_VARARGS, NULL},
52790 { (char *)"new_ImageHistogram", (PyCFunction)_wrap_new_ImageHistogram, METH_NOARGS, NULL},
52791 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
52792 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
52793 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
52794 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
52795 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
52796 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
52797 { (char *)"ImageHistogram_swiginit", ImageHistogram_swiginit, METH_VARARGS, NULL},
52798 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
52799 { (char *)"Image_RGBValue_red_set", _wrap_Image_RGBValue_red_set, METH_VARARGS, NULL},
52800 { (char *)"Image_RGBValue_red_get", (PyCFunction)_wrap_Image_RGBValue_red_get, METH_O, NULL},
52801 { (char *)"Image_RGBValue_green_set", _wrap_Image_RGBValue_green_set, METH_VARARGS, NULL},
52802 { (char *)"Image_RGBValue_green_get", (PyCFunction)_wrap_Image_RGBValue_green_get, METH_O, NULL},
52803 { (char *)"Image_RGBValue_blue_set", _wrap_Image_RGBValue_blue_set, METH_VARARGS, NULL},
52804 { (char *)"Image_RGBValue_blue_get", (PyCFunction)_wrap_Image_RGBValue_blue_get, METH_O, NULL},
52805 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
52806 { (char *)"Image_RGBValue_swiginit", Image_RGBValue_swiginit, METH_VARARGS, NULL},
52807 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
52808 { (char *)"Image_HSVValue_hue_set", _wrap_Image_HSVValue_hue_set, METH_VARARGS, NULL},
52809 { (char *)"Image_HSVValue_hue_get", (PyCFunction)_wrap_Image_HSVValue_hue_get, METH_O, NULL},
52810 { (char *)"Image_HSVValue_saturation_set", _wrap_Image_HSVValue_saturation_set, METH_VARARGS, NULL},
52811 { (char *)"Image_HSVValue_saturation_get", (PyCFunction)_wrap_Image_HSVValue_saturation_get, METH_O, NULL},
52812 { (char *)"Image_HSVValue_value_set", _wrap_Image_HSVValue_value_set, METH_VARARGS, NULL},
52813 { (char *)"Image_HSVValue_value_get", (PyCFunction)_wrap_Image_HSVValue_value_get, METH_O, NULL},
52814 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
52815 { (char *)"Image_HSVValue_swiginit", Image_HSVValue_swiginit, METH_VARARGS, NULL},
52816 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
52817 { (char *)"delete_Image", (PyCFunction)_wrap_delete_Image, METH_O, NULL},
52818 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
52819 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
52820 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
52821 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
52822 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
52823 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
52824 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
52825 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
52826 { (char *)"Image_Destroy", (PyCFunction)_wrap_Image_Destroy, METH_O, NULL},
52827 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
52828 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
52829 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
52830 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
52831 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
52832 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
52833 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
52834 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
52835 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
52836 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
52837 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
52838 { (char *)"Image_HasAlpha", (PyCFunction)_wrap_Image_HasAlpha, METH_O, NULL},
52839 { (char *)"Image_InitAlpha", (PyCFunction)_wrap_Image_InitAlpha, METH_O, NULL},
52840 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
52841 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
52842 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
52843 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
52844 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
52845 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
52846 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
52847 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
52848 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
52849 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
52850 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
52851 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
52852 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
52853 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
52854 { (char *)"Image_Ok", (PyCFunction)_wrap_Image_Ok, METH_O, NULL},
52855 { (char *)"Image_GetWidth", (PyCFunction)_wrap_Image_GetWidth, METH_O, NULL},
52856 { (char *)"Image_GetHeight", (PyCFunction)_wrap_Image_GetHeight, METH_O, NULL},
52857 { (char *)"Image_GetSize", (PyCFunction)_wrap_Image_GetSize, METH_O, NULL},
52858 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
52859 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
52860 { (char *)"Image_Copy", (PyCFunction)_wrap_Image_Copy, METH_O, NULL},
52861 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
52862 { (char *)"Image_GetData", (PyCFunction)_wrap_Image_GetData, METH_O, NULL},
52863 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
52864 { (char *)"Image_GetDataBuffer", (PyCFunction)_wrap_Image_GetDataBuffer, METH_O, NULL},
52865 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
52866 { (char *)"Image_GetAlphaData", (PyCFunction)_wrap_Image_GetAlphaData, METH_O, NULL},
52867 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
52868 { (char *)"Image_GetAlphaBuffer", (PyCFunction)_wrap_Image_GetAlphaBuffer, METH_O, NULL},
52869 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
52870 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
52871 { (char *)"Image_GetOrFindMaskColour", (PyCFunction)_wrap_Image_GetOrFindMaskColour, METH_O, NULL},
52872 { (char *)"Image_GetMaskRed", (PyCFunction)_wrap_Image_GetMaskRed, METH_O, NULL},
52873 { (char *)"Image_GetMaskGreen", (PyCFunction)_wrap_Image_GetMaskGreen, METH_O, NULL},
52874 { (char *)"Image_GetMaskBlue", (PyCFunction)_wrap_Image_GetMaskBlue, METH_O, NULL},
52875 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
52876 { (char *)"Image_HasMask", (PyCFunction)_wrap_Image_HasMask, METH_O, NULL},
52877 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
52878 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
52879 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
52880 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
52881 { (char *)"Image_ConvertToGreyscale", (PyCFunction) _wrap_Image_ConvertToGreyscale, METH_VARARGS | METH_KEYWORDS, NULL},
52882 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
52883 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
52884 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
52885 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
52886 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
52887 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
52888 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
52889 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
52890 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52891 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52892 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52893 { (char *)"Image_GetHandlers", (PyCFunction)_wrap_Image_GetHandlers, METH_NOARGS, NULL},
52894 { (char *)"Image_GetImageExtWildcard", (PyCFunction)_wrap_Image_GetImageExtWildcard, METH_NOARGS, NULL},
52895 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
52896 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
52897 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
52898 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
52899 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
52900 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
52901 { (char *)"Image_swiginit", Image_swiginit, METH_VARARGS, NULL},
52902 { (char *)"new_BMPHandler", (PyCFunction)_wrap_new_BMPHandler, METH_NOARGS, NULL},
52903 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
52904 { (char *)"BMPHandler_swiginit", BMPHandler_swiginit, METH_VARARGS, NULL},
52905 { (char *)"new_ICOHandler", (PyCFunction)_wrap_new_ICOHandler, METH_NOARGS, NULL},
52906 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
52907 { (char *)"ICOHandler_swiginit", ICOHandler_swiginit, METH_VARARGS, NULL},
52908 { (char *)"new_CURHandler", (PyCFunction)_wrap_new_CURHandler, METH_NOARGS, NULL},
52909 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
52910 { (char *)"CURHandler_swiginit", CURHandler_swiginit, METH_VARARGS, NULL},
52911 { (char *)"new_ANIHandler", (PyCFunction)_wrap_new_ANIHandler, METH_NOARGS, NULL},
52912 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
52913 { (char *)"ANIHandler_swiginit", ANIHandler_swiginit, METH_VARARGS, NULL},
52914 { (char *)"new_PNGHandler", (PyCFunction)_wrap_new_PNGHandler, METH_NOARGS, NULL},
52915 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
52916 { (char *)"PNGHandler_swiginit", PNGHandler_swiginit, METH_VARARGS, NULL},
52917 { (char *)"new_GIFHandler", (PyCFunction)_wrap_new_GIFHandler, METH_NOARGS, NULL},
52918 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
52919 { (char *)"GIFHandler_swiginit", GIFHandler_swiginit, METH_VARARGS, NULL},
52920 { (char *)"new_PCXHandler", (PyCFunction)_wrap_new_PCXHandler, METH_NOARGS, NULL},
52921 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
52922 { (char *)"PCXHandler_swiginit", PCXHandler_swiginit, METH_VARARGS, NULL},
52923 { (char *)"new_JPEGHandler", (PyCFunction)_wrap_new_JPEGHandler, METH_NOARGS, NULL},
52924 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
52925 { (char *)"JPEGHandler_swiginit", JPEGHandler_swiginit, METH_VARARGS, NULL},
52926 { (char *)"new_PNMHandler", (PyCFunction)_wrap_new_PNMHandler, METH_NOARGS, NULL},
52927 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
52928 { (char *)"PNMHandler_swiginit", PNMHandler_swiginit, METH_VARARGS, NULL},
52929 { (char *)"new_XPMHandler", (PyCFunction)_wrap_new_XPMHandler, METH_NOARGS, NULL},
52930 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
52931 { (char *)"XPMHandler_swiginit", XPMHandler_swiginit, METH_VARARGS, NULL},
52932 { (char *)"new_TIFFHandler", (PyCFunction)_wrap_new_TIFFHandler, METH_NOARGS, NULL},
52933 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
52934 { (char *)"TIFFHandler_swiginit", TIFFHandler_swiginit, METH_VARARGS, NULL},
52935 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
52936 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
52937 { (char *)"new_EvtHandler", (PyCFunction)_wrap_new_EvtHandler, METH_NOARGS, NULL},
52938 { (char *)"EvtHandler_GetNextHandler", (PyCFunction)_wrap_EvtHandler_GetNextHandler, METH_O, NULL},
52939 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction)_wrap_EvtHandler_GetPreviousHandler, METH_O, NULL},
52940 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52941 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52942 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction)_wrap_EvtHandler_GetEvtHandlerEnabled, METH_O, NULL},
52943 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
52944 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52945 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52946 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction)_wrap_EvtHandler_ProcessPendingEvents, METH_O, NULL},
52947 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
52948 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
52949 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
52950 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
52951 { (char *)"EvtHandler_swiginit", EvtHandler_swiginit, METH_VARARGS, NULL},
52952 { (char *)"NewEventType", (PyCFunction)_wrap_NewEventType, METH_NOARGS, NULL},
52953 { (char *)"delete_Event", (PyCFunction)_wrap_delete_Event, METH_O, NULL},
52954 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
52955 { (char *)"Event_GetEventType", (PyCFunction)_wrap_Event_GetEventType, METH_O, NULL},
52956 { (char *)"Event_GetEventObject", (PyCFunction)_wrap_Event_GetEventObject, METH_O, NULL},
52957 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
52958 { (char *)"Event_GetTimestamp", (PyCFunction)_wrap_Event_GetTimestamp, METH_O, NULL},
52959 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
52960 { (char *)"Event_GetId", (PyCFunction)_wrap_Event_GetId, METH_O, NULL},
52961 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
52962 { (char *)"Event_IsCommandEvent", (PyCFunction)_wrap_Event_IsCommandEvent, METH_O, NULL},
52963 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
52964 { (char *)"Event_GetSkipped", (PyCFunction)_wrap_Event_GetSkipped, METH_O, NULL},
52965 { (char *)"Event_ShouldPropagate", (PyCFunction)_wrap_Event_ShouldPropagate, METH_O, NULL},
52966 { (char *)"Event_StopPropagation", (PyCFunction)_wrap_Event_StopPropagation, METH_O, NULL},
52967 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
52968 { (char *)"Event_Clone", (PyCFunction)_wrap_Event_Clone, METH_O, NULL},
52969 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
52970 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
52971 { (char *)"delete_PropagationDisabler", (PyCFunction)_wrap_delete_PropagationDisabler, METH_O, NULL},
52972 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
52973 { (char *)"PropagationDisabler_swiginit", PropagationDisabler_swiginit, METH_VARARGS, NULL},
52974 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
52975 { (char *)"delete_PropagateOnce", (PyCFunction)_wrap_delete_PropagateOnce, METH_O, NULL},
52976 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
52977 { (char *)"PropagateOnce_swiginit", PropagateOnce_swiginit, METH_VARARGS, NULL},
52978 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52979 { (char *)"CommandEvent_GetSelection", (PyCFunction)_wrap_CommandEvent_GetSelection, METH_O, NULL},
52980 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
52981 { (char *)"CommandEvent_GetString", (PyCFunction)_wrap_CommandEvent_GetString, METH_O, NULL},
52982 { (char *)"CommandEvent_IsChecked", (PyCFunction)_wrap_CommandEvent_IsChecked, METH_O, NULL},
52983 { (char *)"CommandEvent_IsSelection", (PyCFunction)_wrap_CommandEvent_IsSelection, METH_O, NULL},
52984 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
52985 { (char *)"CommandEvent_GetExtraLong", (PyCFunction)_wrap_CommandEvent_GetExtraLong, METH_O, NULL},
52986 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
52987 { (char *)"CommandEvent_GetInt", (PyCFunction)_wrap_CommandEvent_GetInt, METH_O, NULL},
52988 { (char *)"CommandEvent_GetClientData", (PyCFunction)_wrap_CommandEvent_GetClientData, METH_O, NULL},
52989 { (char *)"CommandEvent_SetClientData", (PyCFunction) _wrap_CommandEvent_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
52990 { (char *)"CommandEvent_Clone", (PyCFunction)_wrap_CommandEvent_Clone, METH_O, NULL},
52991 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
52992 { (char *)"CommandEvent_swiginit", CommandEvent_swiginit, METH_VARARGS, NULL},
52993 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52994 { (char *)"NotifyEvent_Veto", (PyCFunction)_wrap_NotifyEvent_Veto, METH_O, NULL},
52995 { (char *)"NotifyEvent_Allow", (PyCFunction)_wrap_NotifyEvent_Allow, METH_O, NULL},
52996 { (char *)"NotifyEvent_IsAllowed", (PyCFunction)_wrap_NotifyEvent_IsAllowed, METH_O, NULL},
52997 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
52998 { (char *)"NotifyEvent_swiginit", NotifyEvent_swiginit, METH_VARARGS, NULL},
52999 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53000 { (char *)"ScrollEvent_GetOrientation", (PyCFunction)_wrap_ScrollEvent_GetOrientation, METH_O, NULL},
53001 { (char *)"ScrollEvent_GetPosition", (PyCFunction)_wrap_ScrollEvent_GetPosition, METH_O, NULL},
53002 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
53003 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53004 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
53005 { (char *)"ScrollEvent_swiginit", ScrollEvent_swiginit, METH_VARARGS, NULL},
53006 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53007 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction)_wrap_ScrollWinEvent_GetOrientation, METH_O, NULL},
53008 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction)_wrap_ScrollWinEvent_GetPosition, METH_O, NULL},
53009 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
53010 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53011 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
53012 { (char *)"ScrollWinEvent_swiginit", ScrollWinEvent_swiginit, METH_VARARGS, NULL},
53013 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53014 { (char *)"MouseEvent_IsButton", (PyCFunction)_wrap_MouseEvent_IsButton, METH_O, NULL},
53015 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
53016 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
53017 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
53018 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
53019 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
53020 { (char *)"MouseEvent_GetButton", (PyCFunction)_wrap_MouseEvent_GetButton, METH_O, NULL},
53021 { (char *)"MouseEvent_ControlDown", (PyCFunction)_wrap_MouseEvent_ControlDown, METH_O, NULL},
53022 { (char *)"MouseEvent_MetaDown", (PyCFunction)_wrap_MouseEvent_MetaDown, METH_O, NULL},
53023 { (char *)"MouseEvent_AltDown", (PyCFunction)_wrap_MouseEvent_AltDown, METH_O, NULL},
53024 { (char *)"MouseEvent_ShiftDown", (PyCFunction)_wrap_MouseEvent_ShiftDown, METH_O, NULL},
53025 { (char *)"MouseEvent_CmdDown", (PyCFunction)_wrap_MouseEvent_CmdDown, METH_O, NULL},
53026 { (char *)"MouseEvent_LeftDown", (PyCFunction)_wrap_MouseEvent_LeftDown, METH_O, NULL},
53027 { (char *)"MouseEvent_MiddleDown", (PyCFunction)_wrap_MouseEvent_MiddleDown, METH_O, NULL},
53028 { (char *)"MouseEvent_RightDown", (PyCFunction)_wrap_MouseEvent_RightDown, METH_O, NULL},
53029 { (char *)"MouseEvent_LeftUp", (PyCFunction)_wrap_MouseEvent_LeftUp, METH_O, NULL},
53030 { (char *)"MouseEvent_MiddleUp", (PyCFunction)_wrap_MouseEvent_MiddleUp, METH_O, NULL},
53031 { (char *)"MouseEvent_RightUp", (PyCFunction)_wrap_MouseEvent_RightUp, METH_O, NULL},
53032 { (char *)"MouseEvent_LeftDClick", (PyCFunction)_wrap_MouseEvent_LeftDClick, METH_O, NULL},
53033 { (char *)"MouseEvent_MiddleDClick", (PyCFunction)_wrap_MouseEvent_MiddleDClick, METH_O, NULL},
53034 { (char *)"MouseEvent_RightDClick", (PyCFunction)_wrap_MouseEvent_RightDClick, METH_O, NULL},
53035 { (char *)"MouseEvent_LeftIsDown", (PyCFunction)_wrap_MouseEvent_LeftIsDown, METH_O, NULL},
53036 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction)_wrap_MouseEvent_MiddleIsDown, METH_O, NULL},
53037 { (char *)"MouseEvent_RightIsDown", (PyCFunction)_wrap_MouseEvent_RightIsDown, METH_O, NULL},
53038 { (char *)"MouseEvent_Dragging", (PyCFunction)_wrap_MouseEvent_Dragging, METH_O, NULL},
53039 { (char *)"MouseEvent_Moving", (PyCFunction)_wrap_MouseEvent_Moving, METH_O, NULL},
53040 { (char *)"MouseEvent_Entering", (PyCFunction)_wrap_MouseEvent_Entering, METH_O, NULL},
53041 { (char *)"MouseEvent_Leaving", (PyCFunction)_wrap_MouseEvent_Leaving, METH_O, NULL},
53042 { (char *)"MouseEvent_GetPosition", (PyCFunction)_wrap_MouseEvent_GetPosition, METH_O, NULL},
53043 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction)_wrap_MouseEvent_GetPositionTuple, METH_O, NULL},
53044 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53045 { (char *)"MouseEvent_GetX", (PyCFunction)_wrap_MouseEvent_GetX, METH_O, NULL},
53046 { (char *)"MouseEvent_GetY", (PyCFunction)_wrap_MouseEvent_GetY, METH_O, NULL},
53047 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction)_wrap_MouseEvent_GetWheelRotation, METH_O, NULL},
53048 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction)_wrap_MouseEvent_GetWheelDelta, METH_O, NULL},
53049 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction)_wrap_MouseEvent_GetLinesPerAction, METH_O, NULL},
53050 { (char *)"MouseEvent_IsPageScroll", (PyCFunction)_wrap_MouseEvent_IsPageScroll, METH_O, NULL},
53051 { (char *)"MouseEvent_m_x_set", _wrap_MouseEvent_m_x_set, METH_VARARGS, NULL},
53052 { (char *)"MouseEvent_m_x_get", (PyCFunction)_wrap_MouseEvent_m_x_get, METH_O, NULL},
53053 { (char *)"MouseEvent_m_y_set", _wrap_MouseEvent_m_y_set, METH_VARARGS, NULL},
53054 { (char *)"MouseEvent_m_y_get", (PyCFunction)_wrap_MouseEvent_m_y_get, METH_O, NULL},
53055 { (char *)"MouseEvent_m_leftDown_set", _wrap_MouseEvent_m_leftDown_set, METH_VARARGS, NULL},
53056 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction)_wrap_MouseEvent_m_leftDown_get, METH_O, NULL},
53057 { (char *)"MouseEvent_m_middleDown_set", _wrap_MouseEvent_m_middleDown_set, METH_VARARGS, NULL},
53058 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction)_wrap_MouseEvent_m_middleDown_get, METH_O, NULL},
53059 { (char *)"MouseEvent_m_rightDown_set", _wrap_MouseEvent_m_rightDown_set, METH_VARARGS, NULL},
53060 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction)_wrap_MouseEvent_m_rightDown_get, METH_O, NULL},
53061 { (char *)"MouseEvent_m_controlDown_set", _wrap_MouseEvent_m_controlDown_set, METH_VARARGS, NULL},
53062 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction)_wrap_MouseEvent_m_controlDown_get, METH_O, NULL},
53063 { (char *)"MouseEvent_m_shiftDown_set", _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS, NULL},
53064 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction)_wrap_MouseEvent_m_shiftDown_get, METH_O, NULL},
53065 { (char *)"MouseEvent_m_altDown_set", _wrap_MouseEvent_m_altDown_set, METH_VARARGS, NULL},
53066 { (char *)"MouseEvent_m_altDown_get", (PyCFunction)_wrap_MouseEvent_m_altDown_get, METH_O, NULL},
53067 { (char *)"MouseEvent_m_metaDown_set", _wrap_MouseEvent_m_metaDown_set, METH_VARARGS, NULL},
53068 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction)_wrap_MouseEvent_m_metaDown_get, METH_O, NULL},
53069 { (char *)"MouseEvent_m_wheelRotation_set", _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS, NULL},
53070 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction)_wrap_MouseEvent_m_wheelRotation_get, METH_O, NULL},
53071 { (char *)"MouseEvent_m_wheelDelta_set", _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS, NULL},
53072 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction)_wrap_MouseEvent_m_wheelDelta_get, METH_O, NULL},
53073 { (char *)"MouseEvent_m_linesPerAction_set", _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS, NULL},
53074 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction)_wrap_MouseEvent_m_linesPerAction_get, METH_O, NULL},
53075 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
53076 { (char *)"MouseEvent_swiginit", MouseEvent_swiginit, METH_VARARGS, NULL},
53077 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53078 { (char *)"SetCursorEvent_GetX", (PyCFunction)_wrap_SetCursorEvent_GetX, METH_O, NULL},
53079 { (char *)"SetCursorEvent_GetY", (PyCFunction)_wrap_SetCursorEvent_GetY, METH_O, NULL},
53080 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
53081 { (char *)"SetCursorEvent_GetCursor", (PyCFunction)_wrap_SetCursorEvent_GetCursor, METH_O, NULL},
53082 { (char *)"SetCursorEvent_HasCursor", (PyCFunction)_wrap_SetCursorEvent_HasCursor, METH_O, NULL},
53083 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
53084 { (char *)"SetCursorEvent_swiginit", SetCursorEvent_swiginit, METH_VARARGS, NULL},
53085 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53086 { (char *)"KeyEvent_GetModifiers", (PyCFunction)_wrap_KeyEvent_GetModifiers, METH_O, NULL},
53087 { (char *)"KeyEvent_ControlDown", (PyCFunction)_wrap_KeyEvent_ControlDown, METH_O, NULL},
53088 { (char *)"KeyEvent_MetaDown", (PyCFunction)_wrap_KeyEvent_MetaDown, METH_O, NULL},
53089 { (char *)"KeyEvent_AltDown", (PyCFunction)_wrap_KeyEvent_AltDown, METH_O, NULL},
53090 { (char *)"KeyEvent_ShiftDown", (PyCFunction)_wrap_KeyEvent_ShiftDown, METH_O, NULL},
53091 { (char *)"KeyEvent_CmdDown", (PyCFunction)_wrap_KeyEvent_CmdDown, METH_O, NULL},
53092 { (char *)"KeyEvent_HasModifiers", (PyCFunction)_wrap_KeyEvent_HasModifiers, METH_O, NULL},
53093 { (char *)"KeyEvent_GetKeyCode", (PyCFunction)_wrap_KeyEvent_GetKeyCode, METH_O, NULL},
53094 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction)_wrap_KeyEvent_GetUnicodeKey, METH_O, NULL},
53095 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction)_wrap_KeyEvent_GetRawKeyCode, METH_O, NULL},
53096 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction)_wrap_KeyEvent_GetRawKeyFlags, METH_O, NULL},
53097 { (char *)"KeyEvent_GetPosition", (PyCFunction)_wrap_KeyEvent_GetPosition, METH_O, NULL},
53098 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction)_wrap_KeyEvent_GetPositionTuple, METH_O, NULL},
53099 { (char *)"KeyEvent_GetX", (PyCFunction)_wrap_KeyEvent_GetX, METH_O, NULL},
53100 { (char *)"KeyEvent_GetY", (PyCFunction)_wrap_KeyEvent_GetY, METH_O, NULL},
53101 { (char *)"KeyEvent_m_x_set", _wrap_KeyEvent_m_x_set, METH_VARARGS, NULL},
53102 { (char *)"KeyEvent_m_x_get", (PyCFunction)_wrap_KeyEvent_m_x_get, METH_O, NULL},
53103 { (char *)"KeyEvent_m_y_set", _wrap_KeyEvent_m_y_set, METH_VARARGS, NULL},
53104 { (char *)"KeyEvent_m_y_get", (PyCFunction)_wrap_KeyEvent_m_y_get, METH_O, NULL},
53105 { (char *)"KeyEvent_m_keyCode_set", _wrap_KeyEvent_m_keyCode_set, METH_VARARGS, NULL},
53106 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction)_wrap_KeyEvent_m_keyCode_get, METH_O, NULL},
53107 { (char *)"KeyEvent_m_controlDown_set", _wrap_KeyEvent_m_controlDown_set, METH_VARARGS, NULL},
53108 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction)_wrap_KeyEvent_m_controlDown_get, METH_O, NULL},
53109 { (char *)"KeyEvent_m_shiftDown_set", _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS, NULL},
53110 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction)_wrap_KeyEvent_m_shiftDown_get, METH_O, NULL},
53111 { (char *)"KeyEvent_m_altDown_set", _wrap_KeyEvent_m_altDown_set, METH_VARARGS, NULL},
53112 { (char *)"KeyEvent_m_altDown_get", (PyCFunction)_wrap_KeyEvent_m_altDown_get, METH_O, NULL},
53113 { (char *)"KeyEvent_m_metaDown_set", _wrap_KeyEvent_m_metaDown_set, METH_VARARGS, NULL},
53114 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction)_wrap_KeyEvent_m_metaDown_get, METH_O, NULL},
53115 { (char *)"KeyEvent_m_scanCode_set", _wrap_KeyEvent_m_scanCode_set, METH_VARARGS, NULL},
53116 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction)_wrap_KeyEvent_m_scanCode_get, METH_O, NULL},
53117 { (char *)"KeyEvent_m_rawCode_set", _wrap_KeyEvent_m_rawCode_set, METH_VARARGS, NULL},
53118 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction)_wrap_KeyEvent_m_rawCode_get, METH_O, NULL},
53119 { (char *)"KeyEvent_m_rawFlags_set", _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS, NULL},
53120 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction)_wrap_KeyEvent_m_rawFlags_get, METH_O, NULL},
53121 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
53122 { (char *)"KeyEvent_swiginit", KeyEvent_swiginit, METH_VARARGS, NULL},
53123 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53124 { (char *)"SizeEvent_GetSize", (PyCFunction)_wrap_SizeEvent_GetSize, METH_O, NULL},
53125 { (char *)"SizeEvent_GetRect", (PyCFunction)_wrap_SizeEvent_GetRect, METH_O, NULL},
53126 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53127 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
53128 { (char *)"SizeEvent_m_size_set", _wrap_SizeEvent_m_size_set, METH_VARARGS, NULL},
53129 { (char *)"SizeEvent_m_size_get", (PyCFunction)_wrap_SizeEvent_m_size_get, METH_O, NULL},
53130 { (char *)"SizeEvent_m_rect_set", _wrap_SizeEvent_m_rect_set, METH_VARARGS, NULL},
53131 { (char *)"SizeEvent_m_rect_get", (PyCFunction)_wrap_SizeEvent_m_rect_get, METH_O, NULL},
53132 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
53133 { (char *)"SizeEvent_swiginit", SizeEvent_swiginit, METH_VARARGS, NULL},
53134 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53135 { (char *)"MoveEvent_GetPosition", (PyCFunction)_wrap_MoveEvent_GetPosition, METH_O, NULL},
53136 { (char *)"MoveEvent_GetRect", (PyCFunction)_wrap_MoveEvent_GetRect, METH_O, NULL},
53137 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53138 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53139 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
53140 { (char *)"MoveEvent_swiginit", MoveEvent_swiginit, METH_VARARGS, NULL},
53141 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53142 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
53143 { (char *)"PaintEvent_swiginit", PaintEvent_swiginit, METH_VARARGS, NULL},
53144 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53145 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
53146 { (char *)"NcPaintEvent_swiginit", NcPaintEvent_swiginit, METH_VARARGS, NULL},
53147 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53148 { (char *)"EraseEvent_GetDC", (PyCFunction)_wrap_EraseEvent_GetDC, METH_O, NULL},
53149 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
53150 { (char *)"EraseEvent_swiginit", EraseEvent_swiginit, METH_VARARGS, NULL},
53151 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53152 { (char *)"FocusEvent_GetWindow", (PyCFunction)_wrap_FocusEvent_GetWindow, METH_O, NULL},
53153 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53154 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
53155 { (char *)"FocusEvent_swiginit", FocusEvent_swiginit, METH_VARARGS, NULL},
53156 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53157 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction)_wrap_ChildFocusEvent_GetWindow, METH_O, NULL},
53158 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
53159 { (char *)"ChildFocusEvent_swiginit", ChildFocusEvent_swiginit, METH_VARARGS, NULL},
53160 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53161 { (char *)"ActivateEvent_GetActive", (PyCFunction)_wrap_ActivateEvent_GetActive, METH_O, NULL},
53162 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
53163 { (char *)"ActivateEvent_swiginit", ActivateEvent_swiginit, METH_VARARGS, NULL},
53164 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53165 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
53166 { (char *)"InitDialogEvent_swiginit", InitDialogEvent_swiginit, METH_VARARGS, NULL},
53167 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53168 { (char *)"MenuEvent_GetMenuId", (PyCFunction)_wrap_MenuEvent_GetMenuId, METH_O, NULL},
53169 { (char *)"MenuEvent_IsPopup", (PyCFunction)_wrap_MenuEvent_IsPopup, METH_O, NULL},
53170 { (char *)"MenuEvent_GetMenu", (PyCFunction)_wrap_MenuEvent_GetMenu, METH_O, NULL},
53171 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
53172 { (char *)"MenuEvent_swiginit", MenuEvent_swiginit, METH_VARARGS, NULL},
53173 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53174 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
53175 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction)_wrap_CloseEvent_GetLoggingOff, METH_O, NULL},
53176 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
53177 { (char *)"CloseEvent_GetVeto", (PyCFunction)_wrap_CloseEvent_GetVeto, METH_O, NULL},
53178 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
53179 { (char *)"CloseEvent_CanVeto", (PyCFunction)_wrap_CloseEvent_CanVeto, METH_O, NULL},
53180 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
53181 { (char *)"CloseEvent_swiginit", CloseEvent_swiginit, METH_VARARGS, NULL},
53182 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53183 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
53184 { (char *)"ShowEvent_GetShow", (PyCFunction)_wrap_ShowEvent_GetShow, METH_O, NULL},
53185 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
53186 { (char *)"ShowEvent_swiginit", ShowEvent_swiginit, METH_VARARGS, NULL},
53187 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53188 { (char *)"IconizeEvent_Iconized", (PyCFunction)_wrap_IconizeEvent_Iconized, METH_O, NULL},
53189 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
53190 { (char *)"IconizeEvent_swiginit", IconizeEvent_swiginit, METH_VARARGS, NULL},
53191 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53192 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
53193 { (char *)"MaximizeEvent_swiginit", MaximizeEvent_swiginit, METH_VARARGS, NULL},
53194 { (char *)"DropFilesEvent_GetPosition", (PyCFunction)_wrap_DropFilesEvent_GetPosition, METH_O, NULL},
53195 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction)_wrap_DropFilesEvent_GetNumberOfFiles, METH_O, NULL},
53196 { (char *)"DropFilesEvent_GetFiles", (PyCFunction)_wrap_DropFilesEvent_GetFiles, METH_O, NULL},
53197 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
53198 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53199 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetChecked, METH_O, NULL},
53200 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetEnabled, METH_O, NULL},
53201 { (char *)"UpdateUIEvent_GetShown", (PyCFunction)_wrap_UpdateUIEvent_GetShown, METH_O, NULL},
53202 { (char *)"UpdateUIEvent_GetText", (PyCFunction)_wrap_UpdateUIEvent_GetText, METH_O, NULL},
53203 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction)_wrap_UpdateUIEvent_GetSetText, METH_O, NULL},
53204 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetSetChecked, METH_O, NULL},
53205 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetSetEnabled, METH_O, NULL},
53206 { (char *)"UpdateUIEvent_GetSetShown", (PyCFunction)_wrap_UpdateUIEvent_GetSetShown, METH_O, NULL},
53207 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53208 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53209 { (char *)"UpdateUIEvent_Show", (PyCFunction) _wrap_UpdateUIEvent_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53210 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
53211 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
53212 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction)_wrap_UpdateUIEvent_GetUpdateInterval, METH_NOARGS, NULL},
53213 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
53214 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction)_wrap_UpdateUIEvent_ResetUpdateTime, METH_NOARGS, NULL},
53215 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
53216 { (char *)"UpdateUIEvent_GetMode", (PyCFunction)_wrap_UpdateUIEvent_GetMode, METH_NOARGS, NULL},
53217 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
53218 { (char *)"UpdateUIEvent_swiginit", UpdateUIEvent_swiginit, METH_VARARGS, NULL},
53219 { (char *)"new_SysColourChangedEvent", (PyCFunction)_wrap_new_SysColourChangedEvent, METH_NOARGS, NULL},
53220 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
53221 { (char *)"SysColourChangedEvent_swiginit", SysColourChangedEvent_swiginit, METH_VARARGS, NULL},
53222 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53223 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction)_wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_O, NULL},
53224 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
53225 { (char *)"MouseCaptureChangedEvent_swiginit", MouseCaptureChangedEvent_swiginit, METH_VARARGS, NULL},
53226 { (char *)"new_DisplayChangedEvent", (PyCFunction)_wrap_new_DisplayChangedEvent, METH_NOARGS, NULL},
53227 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
53228 { (char *)"DisplayChangedEvent_swiginit", DisplayChangedEvent_swiginit, METH_VARARGS, NULL},
53229 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53230 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53231 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction)_wrap_PaletteChangedEvent_GetChangedWindow, METH_O, NULL},
53232 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
53233 { (char *)"PaletteChangedEvent_swiginit", PaletteChangedEvent_swiginit, METH_VARARGS, NULL},
53234 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53235 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
53236 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction)_wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_O, NULL},
53237 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
53238 { (char *)"QueryNewPaletteEvent_swiginit", QueryNewPaletteEvent_swiginit, METH_VARARGS, NULL},
53239 { (char *)"new_NavigationKeyEvent", (PyCFunction)_wrap_new_NavigationKeyEvent, METH_NOARGS, NULL},
53240 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction)_wrap_NavigationKeyEvent_GetDirection, METH_O, NULL},
53241 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
53242 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction)_wrap_NavigationKeyEvent_IsWindowChange, METH_O, NULL},
53243 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
53244 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction)_wrap_NavigationKeyEvent_IsFromTab, METH_O, NULL},
53245 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
53246 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
53247 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction)_wrap_NavigationKeyEvent_GetCurrentFocus, METH_O, NULL},
53248 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
53249 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
53250 { (char *)"NavigationKeyEvent_swiginit", NavigationKeyEvent_swiginit, METH_VARARGS, NULL},
53251 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53252 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction)_wrap_WindowCreateEvent_GetWindow, METH_O, NULL},
53253 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
53254 { (char *)"WindowCreateEvent_swiginit", WindowCreateEvent_swiginit, METH_VARARGS, NULL},
53255 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53256 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction)_wrap_WindowDestroyEvent_GetWindow, METH_O, NULL},
53257 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
53258 { (char *)"WindowDestroyEvent_swiginit", WindowDestroyEvent_swiginit, METH_VARARGS, NULL},
53259 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53260 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction)_wrap_ContextMenuEvent_GetPosition, METH_O, NULL},
53261 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53262 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
53263 { (char *)"ContextMenuEvent_swiginit", ContextMenuEvent_swiginit, METH_VARARGS, NULL},
53264 { (char *)"new_IdleEvent", (PyCFunction)_wrap_new_IdleEvent, METH_NOARGS, NULL},
53265 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
53266 { (char *)"IdleEvent_MoreRequested", (PyCFunction)_wrap_IdleEvent_MoreRequested, METH_O, NULL},
53267 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
53268 { (char *)"IdleEvent_GetMode", (PyCFunction)_wrap_IdleEvent_GetMode, METH_NOARGS, NULL},
53269 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
53270 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
53271 { (char *)"IdleEvent_swiginit", IdleEvent_swiginit, METH_VARARGS, NULL},
53272 { (char *)"new_ClipboardTextEvent", (PyCFunction) _wrap_new_ClipboardTextEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53273 { (char *)"ClipboardTextEvent_swigregister", ClipboardTextEvent_swigregister, METH_VARARGS, NULL},
53274 { (char *)"ClipboardTextEvent_swiginit", ClipboardTextEvent_swiginit, METH_VARARGS, NULL},
53275 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53276 { (char *)"delete_PyEvent", (PyCFunction)_wrap_delete_PyEvent, METH_O, NULL},
53277 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53278 { (char *)"PyEvent__GetSelf", (PyCFunction)_wrap_PyEvent__GetSelf, METH_O, NULL},
53279 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
53280 { (char *)"PyEvent_swiginit", PyEvent_swiginit, METH_VARARGS, NULL},
53281 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53282 { (char *)"delete_PyCommandEvent", (PyCFunction)_wrap_delete_PyCommandEvent, METH_O, NULL},
53283 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53284 { (char *)"PyCommandEvent__GetSelf", (PyCFunction)_wrap_PyCommandEvent__GetSelf, METH_O, NULL},
53285 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
53286 { (char *)"PyCommandEvent_swiginit", PyCommandEvent_swiginit, METH_VARARGS, NULL},
53287 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53288 { (char *)"DateEvent_GetDate", (PyCFunction)_wrap_DateEvent_GetDate, METH_O, NULL},
53289 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
53290 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
53291 { (char *)"DateEvent_swiginit", DateEvent_swiginit, METH_VARARGS, NULL},
53292 { (char *)"new_PyApp", (PyCFunction)_wrap_new_PyApp, METH_NOARGS, NULL},
53293 { (char *)"delete_PyApp", (PyCFunction)_wrap_delete_PyApp, METH_O, NULL},
53294 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53295 { (char *)"PyApp_GetAppName", (PyCFunction)_wrap_PyApp_GetAppName, METH_O, NULL},
53296 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
53297 { (char *)"PyApp_GetClassName", (PyCFunction)_wrap_PyApp_GetClassName, METH_O, NULL},
53298 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
53299 { (char *)"PyApp_GetVendorName", (PyCFunction)_wrap_PyApp_GetVendorName, METH_O, NULL},
53300 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
53301 { (char *)"PyApp_GetTraits", (PyCFunction)_wrap_PyApp_GetTraits, METH_O, NULL},
53302 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction)_wrap_PyApp_ProcessPendingEvents, METH_O, NULL},
53303 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
53304 { (char *)"PyApp_WakeUpIdle", (PyCFunction)_wrap_PyApp_WakeUpIdle, METH_O, NULL},
53305 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction)_wrap_PyApp_IsMainLoopRunning, METH_NOARGS, NULL},
53306 { (char *)"PyApp_MainLoop", (PyCFunction)_wrap_PyApp_MainLoop, METH_O, NULL},
53307 { (char *)"PyApp_Exit", (PyCFunction)_wrap_PyApp_Exit, METH_O, NULL},
53308 { (char *)"PyApp_ExitMainLoop", (PyCFunction)_wrap_PyApp_ExitMainLoop, METH_O, NULL},
53309 { (char *)"PyApp_Pending", (PyCFunction)_wrap_PyApp_Pending, METH_O, NULL},
53310 { (char *)"PyApp_Dispatch", (PyCFunction)_wrap_PyApp_Dispatch, METH_O, NULL},
53311 { (char *)"PyApp_ProcessIdle", (PyCFunction)_wrap_PyApp_ProcessIdle, METH_O, NULL},
53312 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
53313 { (char *)"PyApp_IsActive", (PyCFunction)_wrap_PyApp_IsActive, METH_O, NULL},
53314 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53315 { (char *)"PyApp_GetTopWindow", (PyCFunction)_wrap_PyApp_GetTopWindow, METH_O, NULL},
53316 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
53317 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction)_wrap_PyApp_GetExitOnFrameDelete, METH_O, NULL},
53318 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
53319 { (char *)"PyApp_GetUseBestVisual", (PyCFunction)_wrap_PyApp_GetUseBestVisual, METH_O, NULL},
53320 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
53321 { (char *)"PyApp_GetPrintMode", (PyCFunction)_wrap_PyApp_GetPrintMode, METH_O, NULL},
53322 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
53323 { (char *)"PyApp_GetAssertMode", (PyCFunction)_wrap_PyApp_GetAssertMode, METH_O, NULL},
53324 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction)_wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_NOARGS, NULL},
53325 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction)_wrap_PyApp_GetMacAboutMenuItemId, METH_NOARGS, NULL},
53326 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction)_wrap_PyApp_GetMacPreferencesMenuItemId, METH_NOARGS, NULL},
53327 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction)_wrap_PyApp_GetMacExitMenuItemId, METH_NOARGS, NULL},
53328 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction)_wrap_PyApp_GetMacHelpMenuTitleName, METH_NOARGS, NULL},
53329 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
53330 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53331 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53332 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53333 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
53334 { (char *)"PyApp__BootstrapApp", (PyCFunction)_wrap_PyApp__BootstrapApp, METH_O, NULL},
53335 { (char *)"PyApp_GetComCtl32Version", (PyCFunction)_wrap_PyApp_GetComCtl32Version, METH_NOARGS, NULL},
53336 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
53337 { (char *)"PyApp_swiginit", PyApp_swiginit, METH_VARARGS, NULL},
53338 { (char *)"Exit", (PyCFunction)_wrap_Exit, METH_NOARGS, NULL},
53339 { (char *)"Yield", (PyCFunction)_wrap_Yield, METH_NOARGS, NULL},
53340 { (char *)"YieldIfNeeded", (PyCFunction)_wrap_YieldIfNeeded, METH_NOARGS, NULL},
53341 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
53342 { (char *)"WakeUpIdle", (PyCFunction)_wrap_WakeUpIdle, METH_NOARGS, NULL},
53343 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53344 { (char *)"App_CleanUp", (PyCFunction)_wrap_App_CleanUp, METH_NOARGS, NULL},
53345 { (char *)"GetApp", (PyCFunction)_wrap_GetApp, METH_NOARGS, NULL},
53346 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
53347 { (char *)"GetDefaultPyEncoding", (PyCFunction)_wrap_GetDefaultPyEncoding, METH_NOARGS, NULL},
53348 { (char *)"new_EventLoop", (PyCFunction)_wrap_new_EventLoop, METH_NOARGS, NULL},
53349 { (char *)"delete_EventLoop", (PyCFunction)_wrap_delete_EventLoop, METH_O, NULL},
53350 { (char *)"EventLoop_Run", (PyCFunction)_wrap_EventLoop_Run, METH_O, NULL},
53351 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
53352 { (char *)"EventLoop_Pending", (PyCFunction)_wrap_EventLoop_Pending, METH_O, NULL},
53353 { (char *)"EventLoop_Dispatch", (PyCFunction)_wrap_EventLoop_Dispatch, METH_O, NULL},
53354 { (char *)"EventLoop_IsRunning", (PyCFunction)_wrap_EventLoop_IsRunning, METH_O, NULL},
53355 { (char *)"EventLoop_GetActive", (PyCFunction)_wrap_EventLoop_GetActive, METH_NOARGS, NULL},
53356 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
53357 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
53358 { (char *)"EventLoop_swiginit", EventLoop_swiginit, METH_VARARGS, NULL},
53359 { (char *)"new_EventLoopActivator", (PyCFunction) _wrap_new_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
53360 { (char *)"delete_EventLoopActivator", (PyCFunction)_wrap_delete_EventLoopActivator, METH_O, NULL},
53361 { (char *)"EventLoopActivator_swigregister", EventLoopActivator_swigregister, METH_VARARGS, NULL},
53362 { (char *)"EventLoopActivator_swiginit", EventLoopActivator_swiginit, METH_VARARGS, NULL},
53363 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
53364 { (char *)"delete_AcceleratorEntry", (PyCFunction)_wrap_delete_AcceleratorEntry, METH_O, NULL},
53365 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53366 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction)_wrap_AcceleratorEntry_GetFlags, METH_O, NULL},
53367 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction)_wrap_AcceleratorEntry_GetKeyCode, METH_O, NULL},
53368 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction)_wrap_AcceleratorEntry_GetCommand, METH_O, NULL},
53369 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
53370 { (char *)"AcceleratorEntry_swiginit", AcceleratorEntry_swiginit, METH_VARARGS, NULL},
53371 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
53372 { (char *)"delete_AcceleratorTable", (PyCFunction)_wrap_delete_AcceleratorTable, METH_O, NULL},
53373 { (char *)"AcceleratorTable_Ok", (PyCFunction)_wrap_AcceleratorTable_Ok, METH_O, NULL},
53374 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
53375 { (char *)"AcceleratorTable_swiginit", AcceleratorTable_swiginit, METH_VARARGS, NULL},
53376 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
53377 { (char *)"new_VisualAttributes", (PyCFunction)_wrap_new_VisualAttributes, METH_NOARGS, NULL},
53378 { (char *)"delete_VisualAttributes", (PyCFunction)_wrap_delete_VisualAttributes, METH_O, NULL},
53379 { (char *)"VisualAttributes_font_set", _wrap_VisualAttributes_font_set, METH_VARARGS, NULL},
53380 { (char *)"VisualAttributes_font_get", (PyCFunction)_wrap_VisualAttributes_font_get, METH_O, NULL},
53381 { (char *)"VisualAttributes_colFg_set", _wrap_VisualAttributes_colFg_set, METH_VARARGS, NULL},
53382 { (char *)"VisualAttributes_colFg_get", (PyCFunction)_wrap_VisualAttributes_colFg_get, METH_O, NULL},
53383 { (char *)"VisualAttributes_colBg_set", _wrap_VisualAttributes_colBg_set, METH_VARARGS, NULL},
53384 { (char *)"VisualAttributes_colBg_get", (PyCFunction)_wrap_VisualAttributes_colBg_get, METH_O, NULL},
53385 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
53386 { (char *)"VisualAttributes_swiginit", VisualAttributes_swiginit, METH_VARARGS, NULL},
53387 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
53388 { (char *)"new_PreWindow", (PyCFunction)_wrap_new_PreWindow, METH_NOARGS, NULL},
53389 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
53390 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
53391 { (char *)"Window_Destroy", (PyCFunction)_wrap_Window_Destroy, METH_O, NULL},
53392 { (char *)"Window_DestroyChildren", (PyCFunction)_wrap_Window_DestroyChildren, METH_O, NULL},
53393 { (char *)"Window_IsBeingDeleted", (PyCFunction)_wrap_Window_IsBeingDeleted, METH_O, NULL},
53394 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53395 { (char *)"Window_GetLabel", (PyCFunction)_wrap_Window_GetLabel, METH_O, NULL},
53396 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
53397 { (char *)"Window_GetName", (PyCFunction)_wrap_Window_GetName, METH_O, NULL},
53398 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
53399 { (char *)"Window_GetWindowVariant", (PyCFunction)_wrap_Window_GetWindowVariant, METH_O, NULL},
53400 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53401 { (char *)"Window_GetId", (PyCFunction)_wrap_Window_GetId, METH_O, NULL},
53402 { (char *)"Window_NewControlId", (PyCFunction)_wrap_Window_NewControlId, METH_NOARGS, NULL},
53403 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
53404 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
53405 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
53406 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
53407 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53408 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53409 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
53410 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
53411 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
53412 { (char *)"Window_Raise", (PyCFunction)_wrap_Window_Raise, METH_O, NULL},
53413 { (char *)"Window_Lower", (PyCFunction)_wrap_Window_Lower, METH_O, NULL},
53414 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
53415 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53416 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
53417 { (char *)"Window_GetPosition", (PyCFunction)_wrap_Window_GetPosition, METH_O, NULL},
53418 { (char *)"Window_GetPositionTuple", (PyCFunction)_wrap_Window_GetPositionTuple, METH_O, NULL},
53419 { (char *)"Window_GetScreenPosition", (PyCFunction)_wrap_Window_GetScreenPosition, METH_O, NULL},
53420 { (char *)"Window_GetScreenPositionTuple", (PyCFunction)_wrap_Window_GetScreenPositionTuple, METH_O, NULL},
53421 { (char *)"Window_GetScreenRect", (PyCFunction)_wrap_Window_GetScreenRect, METH_O, NULL},
53422 { (char *)"Window_GetSize", (PyCFunction)_wrap_Window_GetSize, METH_O, NULL},
53423 { (char *)"Window_GetSizeTuple", (PyCFunction)_wrap_Window_GetSizeTuple, METH_O, NULL},
53424 { (char *)"Window_GetRect", (PyCFunction)_wrap_Window_GetRect, METH_O, NULL},
53425 { (char *)"Window_GetClientSize", (PyCFunction)_wrap_Window_GetClientSize, METH_O, NULL},
53426 { (char *)"Window_GetClientSizeTuple", (PyCFunction)_wrap_Window_GetClientSizeTuple, METH_O, NULL},
53427 { (char *)"Window_GetClientAreaOrigin", (PyCFunction)_wrap_Window_GetClientAreaOrigin, METH_O, NULL},
53428 { (char *)"Window_GetClientRect", (PyCFunction)_wrap_Window_GetClientRect, METH_O, NULL},
53429 { (char *)"Window_GetBestSize", (PyCFunction)_wrap_Window_GetBestSize, METH_O, NULL},
53430 { (char *)"Window_GetBestSizeTuple", (PyCFunction)_wrap_Window_GetBestSizeTuple, METH_O, NULL},
53431 { (char *)"Window_InvalidateBestSize", (PyCFunction)_wrap_Window_InvalidateBestSize, METH_O, NULL},
53432 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
53433 { (char *)"Window_GetBestFittingSize", (PyCFunction)_wrap_Window_GetBestFittingSize, METH_O, NULL},
53434 { (char *)"Window_GetAdjustedBestSize", (PyCFunction)_wrap_Window_GetAdjustedBestSize, METH_O, NULL},
53435 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
53436 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
53437 { (char *)"Window_Fit", (PyCFunction)_wrap_Window_Fit, METH_O, NULL},
53438 { (char *)"Window_FitInside", (PyCFunction)_wrap_Window_FitInside, METH_O, NULL},
53439 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53440 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
53441 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53442 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
53443 { (char *)"Window_GetMaxSize", (PyCFunction)_wrap_Window_GetMaxSize, METH_O, NULL},
53444 { (char *)"Window_GetMinSize", (PyCFunction)_wrap_Window_GetMinSize, METH_O, NULL},
53445 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
53446 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
53447 { (char *)"Window_GetMinWidth", (PyCFunction)_wrap_Window_GetMinWidth, METH_O, NULL},
53448 { (char *)"Window_GetMinHeight", (PyCFunction)_wrap_Window_GetMinHeight, METH_O, NULL},
53449 { (char *)"Window_GetMaxWidth", (PyCFunction)_wrap_Window_GetMaxWidth, METH_O, NULL},
53450 { (char *)"Window_GetMaxHeight", (PyCFunction)_wrap_Window_GetMaxHeight, METH_O, NULL},
53451 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
53452 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53453 { (char *)"Window_GetVirtualSize", (PyCFunction)_wrap_Window_GetVirtualSize, METH_O, NULL},
53454 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction)_wrap_Window_GetVirtualSizeTuple, METH_O, NULL},
53455 { (char *)"Window_GetBestVirtualSize", (PyCFunction)_wrap_Window_GetBestVirtualSize, METH_O, NULL},
53456 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53457 { (char *)"Window_Hide", (PyCFunction)_wrap_Window_Hide, METH_O, NULL},
53458 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53459 { (char *)"Window_Disable", (PyCFunction)_wrap_Window_Disable, METH_O, NULL},
53460 { (char *)"Window_IsShown", (PyCFunction)_wrap_Window_IsShown, METH_O, NULL},
53461 { (char *)"Window_IsEnabled", (PyCFunction)_wrap_Window_IsEnabled, METH_O, NULL},
53462 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53463 { (char *)"Window_GetWindowStyleFlag", (PyCFunction)_wrap_Window_GetWindowStyleFlag, METH_O, NULL},
53464 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53465 { (char *)"Window_IsRetained", (PyCFunction)_wrap_Window_IsRetained, METH_O, NULL},
53466 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
53467 { (char *)"Window_GetExtraStyle", (PyCFunction)_wrap_Window_GetExtraStyle, METH_O, NULL},
53468 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
53469 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53470 { (char *)"Window_GetThemeEnabled", (PyCFunction)_wrap_Window_GetThemeEnabled, METH_O, NULL},
53471 { (char *)"Window_SetFocus", (PyCFunction)_wrap_Window_SetFocus, METH_O, NULL},
53472 { (char *)"Window_SetFocusFromKbd", (PyCFunction)_wrap_Window_SetFocusFromKbd, METH_O, NULL},
53473 { (char *)"Window_FindFocus", (PyCFunction)_wrap_Window_FindFocus, METH_NOARGS, NULL},
53474 { (char *)"Window_AcceptsFocus", (PyCFunction)_wrap_Window_AcceptsFocus, METH_O, NULL},
53475 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction)_wrap_Window_AcceptsFocusFromKeyboard, METH_O, NULL},
53476 { (char *)"Window_GetDefaultItem", (PyCFunction)_wrap_Window_GetDefaultItem, METH_O, NULL},
53477 { (char *)"Window_SetDefaultItem", (PyCFunction) _wrap_Window_SetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
53478 { (char *)"Window_SetTmpDefaultItem", (PyCFunction) _wrap_Window_SetTmpDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
53479 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
53480 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
53481 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
53482 { (char *)"Window_GetChildren", (PyCFunction)_wrap_Window_GetChildren, METH_O, NULL},
53483 { (char *)"Window_GetParent", (PyCFunction)_wrap_Window_GetParent, METH_O, NULL},
53484 { (char *)"Window_GetGrandParent", (PyCFunction)_wrap_Window_GetGrandParent, METH_O, NULL},
53485 { (char *)"Window_IsTopLevel", (PyCFunction)_wrap_Window_IsTopLevel, METH_O, NULL},
53486 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
53487 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
53488 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
53489 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
53490 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
53491 { (char *)"Window_GetEventHandler", (PyCFunction)_wrap_Window_GetEventHandler, METH_O, NULL},
53492 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53493 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53494 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53495 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53496 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
53497 { (char *)"Window_GetValidator", (PyCFunction)_wrap_Window_GetValidator, METH_O, NULL},
53498 { (char *)"Window_Validate", (PyCFunction)_wrap_Window_Validate, METH_O, NULL},
53499 { (char *)"Window_TransferDataToWindow", (PyCFunction)_wrap_Window_TransferDataToWindow, METH_O, NULL},
53500 { (char *)"Window_TransferDataFromWindow", (PyCFunction)_wrap_Window_TransferDataFromWindow, METH_O, NULL},
53501 { (char *)"Window_InitDialog", (PyCFunction)_wrap_Window_InitDialog, METH_O, NULL},
53502 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
53503 { (char *)"Window_GetAcceleratorTable", (PyCFunction)_wrap_Window_GetAcceleratorTable, METH_O, NULL},
53504 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
53505 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
53506 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
53507 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
53508 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
53509 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
53510 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
53511 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
53512 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
53513 { (char *)"Window_CaptureMouse", (PyCFunction)_wrap_Window_CaptureMouse, METH_O, NULL},
53514 { (char *)"Window_ReleaseMouse", (PyCFunction)_wrap_Window_ReleaseMouse, METH_O, NULL},
53515 { (char *)"Window_GetCapture", (PyCFunction)_wrap_Window_GetCapture, METH_NOARGS, NULL},
53516 { (char *)"Window_HasCapture", (PyCFunction)_wrap_Window_HasCapture, METH_O, NULL},
53517 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
53518 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
53519 { (char *)"Window_Update", (PyCFunction)_wrap_Window_Update, METH_O, NULL},
53520 { (char *)"Window_ClearBackground", (PyCFunction)_wrap_Window_ClearBackground, METH_O, NULL},
53521 { (char *)"Window_Freeze", (PyCFunction)_wrap_Window_Freeze, METH_O, NULL},
53522 { (char *)"Window_Thaw", (PyCFunction)_wrap_Window_Thaw, METH_O, NULL},
53523 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
53524 { (char *)"Window_GetUpdateRegion", (PyCFunction)_wrap_Window_GetUpdateRegion, METH_O, NULL},
53525 { (char *)"Window_GetUpdateClientRect", (PyCFunction)_wrap_Window_GetUpdateClientRect, METH_O, NULL},
53526 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
53527 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53528 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
53529 { (char *)"Window_GetDefaultAttributes", (PyCFunction)_wrap_Window_GetDefaultAttributes, METH_O, NULL},
53530 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
53531 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53532 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53533 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53534 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53535 { (char *)"Window_GetBackgroundColour", (PyCFunction)_wrap_Window_GetBackgroundColour, METH_O, NULL},
53536 { (char *)"Window_GetForegroundColour", (PyCFunction)_wrap_Window_GetForegroundColour, METH_O, NULL},
53537 { (char *)"Window_InheritsBackgroundColour", (PyCFunction)_wrap_Window_InheritsBackgroundColour, METH_O, NULL},
53538 { (char *)"Window_UseBgCol", (PyCFunction)_wrap_Window_UseBgCol, METH_O, NULL},
53539 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
53540 { (char *)"Window_GetBackgroundStyle", (PyCFunction)_wrap_Window_GetBackgroundStyle, METH_O, NULL},
53541 { (char *)"Window_HasTransparentBackground", (PyCFunction)_wrap_Window_HasTransparentBackground, METH_O, NULL},
53542 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
53543 { (char *)"Window_GetCursor", (PyCFunction)_wrap_Window_GetCursor, METH_O, NULL},
53544 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
53545 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
53546 { (char *)"Window_GetFont", (PyCFunction)_wrap_Window_GetFont, METH_O, NULL},
53547 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
53548 { (char *)"Window_GetCaret", (PyCFunction)_wrap_Window_GetCaret, METH_O, NULL},
53549 { (char *)"Window_GetCharHeight", (PyCFunction)_wrap_Window_GetCharHeight, METH_O, NULL},
53550 { (char *)"Window_GetCharWidth", (PyCFunction)_wrap_Window_GetCharWidth, METH_O, NULL},
53551 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
53552 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
53553 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
53554 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
53555 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
53556 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
53557 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
53558 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
53559 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
53560 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
53561 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
53562 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53563 { (char *)"Window_GetHandle", (PyCFunction)_wrap_Window_GetHandle, METH_O, NULL},
53564 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
53565 { (char *)"Window_DissociateHandle", (PyCFunction)_wrap_Window_DissociateHandle, METH_O, NULL},
53566 { (char *)"Window_OnPaint", (PyCFunction) _wrap_Window_OnPaint, METH_VARARGS | METH_KEYWORDS, NULL},
53567 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
53568 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
53569 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
53570 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
53571 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
53572 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
53573 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53574 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
53575 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
53576 { (char *)"Window_LineUp", (PyCFunction)_wrap_Window_LineUp, METH_O, NULL},
53577 { (char *)"Window_LineDown", (PyCFunction)_wrap_Window_LineDown, METH_O, NULL},
53578 { (char *)"Window_PageUp", (PyCFunction)_wrap_Window_PageUp, METH_O, NULL},
53579 { (char *)"Window_PageDown", (PyCFunction)_wrap_Window_PageDown, METH_O, NULL},
53580 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
53581 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
53582 { (char *)"Window_GetHelpText", (PyCFunction)_wrap_Window_GetHelpText, METH_O, NULL},
53583 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
53584 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
53585 { (char *)"Window_GetToolTip", (PyCFunction)_wrap_Window_GetToolTip, METH_O, NULL},
53586 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
53587 { (char *)"Window_GetDropTarget", (PyCFunction)_wrap_Window_GetDropTarget, METH_O, NULL},
53588 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
53589 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
53590 { (char *)"Window_GetConstraints", (PyCFunction)_wrap_Window_GetConstraints, METH_O, NULL},
53591 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
53592 { (char *)"Window_GetAutoLayout", (PyCFunction)_wrap_Window_GetAutoLayout, METH_O, NULL},
53593 { (char *)"Window_Layout", (PyCFunction)_wrap_Window_Layout, METH_O, NULL},
53594 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53595 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
53596 { (char *)"Window_GetSizer", (PyCFunction)_wrap_Window_GetSizer, METH_O, NULL},
53597 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53598 { (char *)"Window_GetContainingSizer", (PyCFunction)_wrap_Window_GetContainingSizer, METH_O, NULL},
53599 { (char *)"Window_InheritAttributes", (PyCFunction)_wrap_Window_InheritAttributes, METH_O, NULL},
53600 { (char *)"Window_ShouldInheritColours", (PyCFunction)_wrap_Window_ShouldInheritColours, METH_O, NULL},
53601 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
53602 { (char *)"Window_swiginit", Window_swiginit, METH_VARARGS, NULL},
53603 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
53604 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
53605 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53606 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
53607 { (char *)"GetTopLevelWindows", (PyCFunction)_wrap_GetTopLevelWindows, METH_NOARGS, NULL},
53608 { (char *)"new_Validator", (PyCFunction)_wrap_new_Validator, METH_NOARGS, NULL},
53609 { (char *)"Validator_Clone", (PyCFunction)_wrap_Validator_Clone, METH_O, NULL},
53610 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
53611 { (char *)"Validator_TransferToWindow", (PyCFunction)_wrap_Validator_TransferToWindow, METH_O, NULL},
53612 { (char *)"Validator_TransferFromWindow", (PyCFunction)_wrap_Validator_TransferFromWindow, METH_O, NULL},
53613 { (char *)"Validator_GetWindow", (PyCFunction)_wrap_Validator_GetWindow, METH_O, NULL},
53614 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53615 { (char *)"Validator_IsSilent", (PyCFunction)_wrap_Validator_IsSilent, METH_NOARGS, NULL},
53616 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
53617 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
53618 { (char *)"Validator_swiginit", Validator_swiginit, METH_VARARGS, NULL},
53619 { (char *)"new_PyValidator", (PyCFunction)_wrap_new_PyValidator, METH_NOARGS, NULL},
53620 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53621 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
53622 { (char *)"PyValidator_swiginit", PyValidator_swiginit, METH_VARARGS, NULL},
53623 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
53624 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
53625 { (char *)"Menu_AppendSeparator", (PyCFunction)_wrap_Menu_AppendSeparator, METH_O, NULL},
53626 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53627 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53628 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53629 { (char *)"Menu_AppendSubMenu", (PyCFunction) _wrap_Menu_AppendSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53630 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
53631 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
53632 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
53633 { (char *)"Menu_Break", (PyCFunction)_wrap_Menu_Break, METH_O, NULL},
53634 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53635 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
53636 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53637 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53638 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53639 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
53640 { (char *)"Menu_PrependSeparator", (PyCFunction)_wrap_Menu_PrependSeparator, METH_O, NULL},
53641 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53642 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53643 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53644 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
53645 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
53646 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
53647 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
53648 { (char *)"Menu_Destroy", (PyCFunction)_wrap_Menu_Destroy, METH_O, NULL},
53649 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
53650 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
53651 { (char *)"Menu_GetMenuItemCount", (PyCFunction)_wrap_Menu_GetMenuItemCount, METH_O, NULL},
53652 { (char *)"Menu_GetMenuItems", (PyCFunction)_wrap_Menu_GetMenuItems, METH_O, NULL},
53653 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
53654 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
53655 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53656 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53657 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53658 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53659 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
53660 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53661 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53662 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53663 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53664 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
53665 { (char *)"Menu_GetTitle", (PyCFunction)_wrap_Menu_GetTitle, METH_O, NULL},
53666 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53667 { (char *)"Menu_GetEventHandler", (PyCFunction)_wrap_Menu_GetEventHandler, METH_O, NULL},
53668 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53669 { (char *)"Menu_GetInvokingWindow", (PyCFunction)_wrap_Menu_GetInvokingWindow, METH_O, NULL},
53670 { (char *)"Menu_GetStyle", (PyCFunction)_wrap_Menu_GetStyle, METH_O, NULL},
53671 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
53672 { (char *)"Menu_GetMenuBar", (PyCFunction)_wrap_Menu_GetMenuBar, METH_O, NULL},
53673 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
53674 { (char *)"Menu_Detach", (PyCFunction)_wrap_Menu_Detach, METH_O, NULL},
53675 { (char *)"Menu_IsAttached", (PyCFunction)_wrap_Menu_IsAttached, METH_O, NULL},
53676 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
53677 { (char *)"Menu_GetParent", (PyCFunction)_wrap_Menu_GetParent, METH_O, NULL},
53678 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
53679 { (char *)"Menu_swiginit", Menu_swiginit, METH_VARARGS, NULL},
53680 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
53681 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
53682 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53683 { (char *)"MenuBar_GetMenuCount", (PyCFunction)_wrap_MenuBar_GetMenuCount, METH_O, NULL},
53684 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53685 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
53686 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
53687 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
53688 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
53689 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
53690 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
53691 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
53692 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
53693 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53694 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53695 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53696 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
53697 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53698 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53699 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53700 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53701 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53702 { (char *)"MenuBar_GetFrame", (PyCFunction)_wrap_MenuBar_GetFrame, METH_O, NULL},
53703 { (char *)"MenuBar_IsAttached", (PyCFunction)_wrap_MenuBar_IsAttached, METH_O, NULL},
53704 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
53705 { (char *)"MenuBar_Detach", (PyCFunction)_wrap_MenuBar_Detach, METH_O, NULL},
53706 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53707 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction)_wrap_MenuBar_GetAutoWindowMenu, METH_NOARGS, NULL},
53708 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
53709 { (char *)"MenuBar_swiginit", MenuBar_swiginit, METH_VARARGS, NULL},
53710 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
53711 { (char *)"delete_MenuItem", (PyCFunction)_wrap_delete_MenuItem, METH_O, NULL},
53712 { (char *)"MenuItem_GetMenu", (PyCFunction)_wrap_MenuItem_GetMenu, METH_O, NULL},
53713 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53714 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53715 { (char *)"MenuItem_GetId", (PyCFunction)_wrap_MenuItem_GetId, METH_O, NULL},
53716 { (char *)"MenuItem_IsSeparator", (PyCFunction)_wrap_MenuItem_IsSeparator, METH_O, NULL},
53717 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
53718 { (char *)"MenuItem_GetLabel", (PyCFunction)_wrap_MenuItem_GetLabel, METH_O, NULL},
53719 { (char *)"MenuItem_GetText", (PyCFunction)_wrap_MenuItem_GetText, METH_O, NULL},
53720 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
53721 { (char *)"MenuItem_GetKind", (PyCFunction)_wrap_MenuItem_GetKind, METH_O, NULL},
53722 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
53723 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
53724 { (char *)"MenuItem_IsCheckable", (PyCFunction)_wrap_MenuItem_IsCheckable, METH_O, NULL},
53725 { (char *)"MenuItem_IsSubMenu", (PyCFunction)_wrap_MenuItem_IsSubMenu, METH_O, NULL},
53726 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53727 { (char *)"MenuItem_GetSubMenu", (PyCFunction)_wrap_MenuItem_GetSubMenu, METH_O, NULL},
53728 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53729 { (char *)"MenuItem_IsEnabled", (PyCFunction)_wrap_MenuItem_IsEnabled, METH_O, NULL},
53730 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53731 { (char *)"MenuItem_IsChecked", (PyCFunction)_wrap_MenuItem_IsChecked, METH_O, NULL},
53732 { (char *)"MenuItem_Toggle", (PyCFunction)_wrap_MenuItem_Toggle, METH_O, NULL},
53733 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
53734 { (char *)"MenuItem_GetHelp", (PyCFunction)_wrap_MenuItem_GetHelp, METH_O, NULL},
53735 { (char *)"MenuItem_GetAccel", (PyCFunction)_wrap_MenuItem_GetAccel, METH_O, NULL},
53736 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
53737 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53738 { (char *)"MenuItem_GetBitmap", (PyCFunction)_wrap_MenuItem_GetBitmap, METH_O, NULL},
53739 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
53740 { (char *)"MenuItem_GetFont", (PyCFunction)_wrap_MenuItem_GetFont, METH_O, NULL},
53741 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
53742 { (char *)"MenuItem_GetTextColour", (PyCFunction)_wrap_MenuItem_GetTextColour, METH_O, NULL},
53743 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53744 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction)_wrap_MenuItem_GetBackgroundColour, METH_O, NULL},
53745 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
53746 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53747 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction)_wrap_MenuItem_GetDisabledBitmap, METH_O, NULL},
53748 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
53749 { (char *)"MenuItem_GetMarginWidth", (PyCFunction)_wrap_MenuItem_GetMarginWidth, METH_O, NULL},
53750 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction)_wrap_MenuItem_GetDefaultMarginWidth, METH_NOARGS, NULL},
53751 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction)_wrap_MenuItem_IsOwnerDrawn, METH_O, NULL},
53752 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
53753 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction)_wrap_MenuItem_ResetOwnerDrawn, METH_O, NULL},
53754 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
53755 { (char *)"MenuItem_swiginit", MenuItem_swiginit, METH_VARARGS, NULL},
53756 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
53757 { (char *)"new_PreControl", (PyCFunction)_wrap_new_PreControl, METH_NOARGS, NULL},
53758 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
53759 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
53760 { (char *)"Control_GetLabel", (PyCFunction)_wrap_Control_GetLabel, METH_O, NULL},
53761 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
53762 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
53763 { (char *)"Control_swiginit", Control_swiginit, METH_VARARGS, NULL},
53764 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
53765 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
53766 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53767 { (char *)"ItemContainer_Clear", (PyCFunction)_wrap_ItemContainer_Clear, METH_O, NULL},
53768 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
53769 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
53770 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
53771 { (char *)"ItemContainer_GetCount", (PyCFunction)_wrap_ItemContainer_GetCount, METH_O, NULL},
53772 { (char *)"ItemContainer_IsEmpty", (PyCFunction)_wrap_ItemContainer_IsEmpty, METH_O, NULL},
53773 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
53774 { (char *)"ItemContainer_GetStrings", (PyCFunction)_wrap_ItemContainer_GetStrings, METH_O, NULL},
53775 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
53776 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
53777 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
53778 { (char *)"ItemContainer_GetSelection", (PyCFunction)_wrap_ItemContainer_GetSelection, METH_O, NULL},
53779 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
53780 { (char *)"ItemContainer_GetStringSelection", (PyCFunction)_wrap_ItemContainer_GetStringSelection, METH_O, NULL},
53781 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
53782 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
53783 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
53784 { (char *)"new_SizerItem", (PyCFunction)_wrap_new_SizerItem, METH_NOARGS, NULL},
53785 { (char *)"delete_SizerItem", (PyCFunction)_wrap_delete_SizerItem, METH_O, NULL},
53786 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53787 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
53788 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53789 { (char *)"SizerItem_DeleteWindows", (PyCFunction)_wrap_SizerItem_DeleteWindows, METH_O, NULL},
53790 { (char *)"SizerItem_DetachSizer", (PyCFunction)_wrap_SizerItem_DetachSizer, METH_O, NULL},
53791 { (char *)"SizerItem_GetSize", (PyCFunction)_wrap_SizerItem_GetSize, METH_O, NULL},
53792 { (char *)"SizerItem_CalcMin", (PyCFunction)_wrap_SizerItem_CalcMin, METH_O, NULL},
53793 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
53794 { (char *)"SizerItem_GetMinSize", (PyCFunction)_wrap_SizerItem_GetMinSize, METH_O, NULL},
53795 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction)_wrap_SizerItem_GetMinSizeWithBorder, METH_O, NULL},
53796 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
53797 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
53798 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
53799 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
53800 { (char *)"SizerItem_GetRatio", (PyCFunction)_wrap_SizerItem_GetRatio, METH_O, NULL},
53801 { (char *)"SizerItem_GetRect", (PyCFunction)_wrap_SizerItem_GetRect, METH_O, NULL},
53802 { (char *)"SizerItem_IsWindow", (PyCFunction)_wrap_SizerItem_IsWindow, METH_O, NULL},
53803 { (char *)"SizerItem_IsSizer", (PyCFunction)_wrap_SizerItem_IsSizer, METH_O, NULL},
53804 { (char *)"SizerItem_IsSpacer", (PyCFunction)_wrap_SizerItem_IsSpacer, METH_O, NULL},
53805 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
53806 { (char *)"SizerItem_GetProportion", (PyCFunction)_wrap_SizerItem_GetProportion, METH_O, NULL},
53807 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53808 { (char *)"SizerItem_GetFlag", (PyCFunction)_wrap_SizerItem_GetFlag, METH_O, NULL},
53809 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
53810 { (char *)"SizerItem_GetBorder", (PyCFunction)_wrap_SizerItem_GetBorder, METH_O, NULL},
53811 { (char *)"SizerItem_GetWindow", (PyCFunction)_wrap_SizerItem_GetWindow, METH_O, NULL},
53812 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53813 { (char *)"SizerItem_GetSizer", (PyCFunction)_wrap_SizerItem_GetSizer, METH_O, NULL},
53814 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53815 { (char *)"SizerItem_GetSpacer", (PyCFunction)_wrap_SizerItem_GetSpacer, METH_O, NULL},
53816 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
53817 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53818 { (char *)"SizerItem_IsShown", (PyCFunction)_wrap_SizerItem_IsShown, METH_O, NULL},
53819 { (char *)"SizerItem_GetPosition", (PyCFunction)_wrap_SizerItem_GetPosition, METH_O, NULL},
53820 { (char *)"SizerItem_GetUserData", (PyCFunction)_wrap_SizerItem_GetUserData, METH_O, NULL},
53821 { (char *)"SizerItem_SetUserData", (PyCFunction) _wrap_SizerItem_SetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
53822 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
53823 { (char *)"SizerItem_swiginit", SizerItem_swiginit, METH_VARARGS, NULL},
53824 { (char *)"delete_Sizer", (PyCFunction)_wrap_delete_Sizer, METH_O, NULL},
53825 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53826 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
53827 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53828 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
53829 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
53830 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
53831 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
53832 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
53833 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
53834 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
53835 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
53836 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
53837 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
53838 { (char *)"Sizer_GetSize", (PyCFunction)_wrap_Sizer_GetSize, METH_O, NULL},
53839 { (char *)"Sizer_GetPosition", (PyCFunction)_wrap_Sizer_GetPosition, METH_O, NULL},
53840 { (char *)"Sizer_GetMinSize", (PyCFunction)_wrap_Sizer_GetMinSize, METH_O, NULL},
53841 { (char *)"Sizer_RecalcSizes", (PyCFunction)_wrap_Sizer_RecalcSizes, METH_O, NULL},
53842 { (char *)"Sizer_CalcMin", (PyCFunction)_wrap_Sizer_CalcMin, METH_O, NULL},
53843 { (char *)"Sizer_Layout", (PyCFunction)_wrap_Sizer_Layout, METH_O, NULL},
53844 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
53845 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
53846 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53847 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53848 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
53849 { (char *)"Sizer_DeleteWindows", (PyCFunction)_wrap_Sizer_DeleteWindows, METH_O, NULL},
53850 { (char *)"Sizer_GetChildren", (PyCFunction)_wrap_Sizer_GetChildren, METH_O, NULL},
53851 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53852 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
53853 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
53854 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
53855 { (char *)"new_PySizer", (PyCFunction)_wrap_new_PySizer, METH_NOARGS, NULL},
53856 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53857 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
53858 { (char *)"PySizer_swiginit", PySizer_swiginit, METH_VARARGS, NULL},
53859 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53860 { (char *)"BoxSizer_GetOrientation", (PyCFunction)_wrap_BoxSizer_GetOrientation, METH_O, NULL},
53861 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
53862 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
53863 { (char *)"BoxSizer_swiginit", BoxSizer_swiginit, METH_VARARGS, NULL},
53864 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53865 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction)_wrap_StaticBoxSizer_GetStaticBox, METH_O, NULL},
53866 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
53867 { (char *)"StaticBoxSizer_swiginit", StaticBoxSizer_swiginit, METH_VARARGS, NULL},
53868 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53869 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
53870 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
53871 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
53872 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
53873 { (char *)"GridSizer_GetCols", (PyCFunction)_wrap_GridSizer_GetCols, METH_O, NULL},
53874 { (char *)"GridSizer_GetRows", (PyCFunction)_wrap_GridSizer_GetRows, METH_O, NULL},
53875 { (char *)"GridSizer_GetVGap", (PyCFunction)_wrap_GridSizer_GetVGap, METH_O, NULL},
53876 { (char *)"GridSizer_GetHGap", (PyCFunction)_wrap_GridSizer_GetHGap, METH_O, NULL},
53877 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
53878 { (char *)"GridSizer_swiginit", GridSizer_swiginit, METH_VARARGS, NULL},
53879 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53880 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
53881 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
53882 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
53883 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
53884 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
53885 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction)_wrap_FlexGridSizer_GetFlexibleDirection, METH_O, NULL},
53886 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
53887 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction)_wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_O, NULL},
53888 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction)_wrap_FlexGridSizer_GetRowHeights, METH_O, NULL},
53889 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction)_wrap_FlexGridSizer_GetColWidths, METH_O, NULL},
53890 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
53891 { (char *)"FlexGridSizer_swiginit", FlexGridSizer_swiginit, METH_VARARGS, NULL},
53892 { (char *)"new_StdDialogButtonSizer", (PyCFunction)_wrap_new_StdDialogButtonSizer, METH_NOARGS, NULL},
53893 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
53894 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction)_wrap_StdDialogButtonSizer_Realize, METH_O, NULL},
53895 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
53896 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
53897 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
53898 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_O, NULL},
53899 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetApplyButton, METH_O, NULL},
53900 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetNegativeButton, METH_O, NULL},
53901 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetCancelButton, METH_O, NULL},
53902 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetHelpButton, METH_O, NULL},
53903 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
53904 { (char *)"StdDialogButtonSizer_swiginit", StdDialogButtonSizer_swiginit, METH_VARARGS, NULL},
53905 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53906 { (char *)"delete_GBPosition", (PyCFunction)_wrap_delete_GBPosition, METH_O, NULL},
53907 { (char *)"GBPosition_GetRow", (PyCFunction)_wrap_GBPosition_GetRow, METH_O, NULL},
53908 { (char *)"GBPosition_GetCol", (PyCFunction)_wrap_GBPosition_GetCol, METH_O, NULL},
53909 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
53910 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
53911 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53912 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53913 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53914 { (char *)"GBPosition_Get", (PyCFunction)_wrap_GBPosition_Get, METH_O, NULL},
53915 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
53916 { (char *)"GBPosition_swiginit", GBPosition_swiginit, METH_VARARGS, NULL},
53917 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
53918 { (char *)"delete_GBSpan", (PyCFunction)_wrap_delete_GBSpan, METH_O, NULL},
53919 { (char *)"GBSpan_GetRowspan", (PyCFunction)_wrap_GBSpan_GetRowspan, METH_O, NULL},
53920 { (char *)"GBSpan_GetColspan", (PyCFunction)_wrap_GBSpan_GetColspan, METH_O, NULL},
53921 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
53922 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
53923 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53924 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53925 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53926 { (char *)"GBSpan_Get", (PyCFunction)_wrap_GBSpan_Get, METH_O, NULL},
53927 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
53928 { (char *)"GBSpan_swiginit", GBSpan_swiginit, METH_VARARGS, NULL},
53929 { (char *)"new_GBSizerItem", (PyCFunction)_wrap_new_GBSizerItem, METH_NOARGS, NULL},
53930 { (char *)"delete_GBSizerItem", (PyCFunction)_wrap_delete_GBSizerItem, METH_O, NULL},
53931 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53932 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53933 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
53934 { (char *)"GBSizerItem_GetPos", (PyCFunction)_wrap_GBSizerItem_GetPos, METH_O, NULL},
53935 { (char *)"GBSizerItem_GetSpan", (PyCFunction)_wrap_GBSizerItem_GetSpan, METH_O, NULL},
53936 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
53937 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
53938 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
53939 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
53940 { (char *)"GBSizerItem_GetEndPos", (PyCFunction)_wrap_GBSizerItem_GetEndPos, METH_O, NULL},
53941 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction)_wrap_GBSizerItem_GetGBSizer, METH_O, NULL},
53942 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53943 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
53944 { (char *)"GBSizerItem_swiginit", GBSizerItem_swiginit, METH_VARARGS, NULL},
53945 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53946 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
53947 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
53948 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
53949 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction)_wrap_GridBagSizer_GetEmptyCellSize, METH_O, NULL},
53950 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
53951 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
53952 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
53953 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
53954 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
53955 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
53956 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53957 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53958 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
53959 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
53960 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
53961 { (char *)"GridBagSizer_swiginit", GridBagSizer_swiginit, METH_VARARGS, NULL},
53962 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53963 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
53964 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
53965 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
53966 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
53967 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
53968 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
53969 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
53970 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction)_wrap_IndividualLayoutConstraint_Unconstrained, METH_O, NULL},
53971 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction)_wrap_IndividualLayoutConstraint_AsIs, METH_O, NULL},
53972 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherWindow, METH_O, NULL},
53973 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMyEdge, METH_O, NULL},
53974 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
53975 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
53976 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMargin, METH_O, NULL},
53977 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
53978 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction)_wrap_IndividualLayoutConstraint_GetValue, METH_O, NULL},
53979 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction)_wrap_IndividualLayoutConstraint_GetPercent, METH_O, NULL},
53980 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherEdge, METH_O, NULL},
53981 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction)_wrap_IndividualLayoutConstraint_GetDone, METH_O, NULL},
53982 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
53983 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction)_wrap_IndividualLayoutConstraint_GetRelationship, METH_O, NULL},
53984 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
53985 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
53986 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
53987 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
53988 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
53989 { (char *)"LayoutConstraints_left_get", (PyCFunction)_wrap_LayoutConstraints_left_get, METH_O, NULL},
53990 { (char *)"LayoutConstraints_top_get", (PyCFunction)_wrap_LayoutConstraints_top_get, METH_O, NULL},
53991 { (char *)"LayoutConstraints_right_get", (PyCFunction)_wrap_LayoutConstraints_right_get, METH_O, NULL},
53992 { (char *)"LayoutConstraints_bottom_get", (PyCFunction)_wrap_LayoutConstraints_bottom_get, METH_O, NULL},
53993 { (char *)"LayoutConstraints_width_get", (PyCFunction)_wrap_LayoutConstraints_width_get, METH_O, NULL},
53994 { (char *)"LayoutConstraints_height_get", (PyCFunction)_wrap_LayoutConstraints_height_get, METH_O, NULL},
53995 { (char *)"LayoutConstraints_centreX_get", (PyCFunction)_wrap_LayoutConstraints_centreX_get, METH_O, NULL},
53996 { (char *)"LayoutConstraints_centreY_get", (PyCFunction)_wrap_LayoutConstraints_centreY_get, METH_O, NULL},
53997 { (char *)"new_LayoutConstraints", (PyCFunction)_wrap_new_LayoutConstraints, METH_NOARGS, NULL},
53998 { (char *)"delete_LayoutConstraints", (PyCFunction)_wrap_delete_LayoutConstraints, METH_O, NULL},
53999 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
54000 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction)_wrap_LayoutConstraints_AreSatisfied, METH_O, NULL},
54001 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
54002 { (char *)"LayoutConstraints_swiginit", LayoutConstraints_swiginit, METH_VARARGS, NULL},
54003 { NULL, NULL, 0, NULL }
54004 };
54005
54006
54007 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
54008
54009 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
54010 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
54011 }
54012 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
54013 return (void *)((wxSizer *) ((wxBoxSizer *) x));
54014 }
54015 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
54016 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
54017 }
54018 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
54019 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54020 }
54021 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
54022 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
54023 }
54024 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
54025 return (void *)((wxSizer *) ((wxGridSizer *) x));
54026 }
54027 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
54028 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
54029 }
54030 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
54031 return (void *)((wxSizer *) ((wxPySizer *) x));
54032 }
54033 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
54034 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
54035 }
54036 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
54037 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54038 }
54039 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
54040 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
54041 }
54042 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
54043 return (void *)((wxEvent *) ((wxMenuEvent *) x));
54044 }
54045 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
54046 return (void *)((wxEvent *) ((wxCloseEvent *) x));
54047 }
54048 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
54049 return (void *)((wxEvent *) ((wxMouseEvent *) x));
54050 }
54051 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
54052 return (void *)((wxEvent *) ((wxEraseEvent *) x));
54053 }
54054 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
54055 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
54056 }
54057 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
54058 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
54059 }
54060 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
54061 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
54062 }
54063 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
54064 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
54065 }
54066 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
54067 return (void *)((wxEvent *) ((wxPyEvent *) x));
54068 }
54069 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
54070 return (void *)((wxEvent *) ((wxIdleEvent *) x));
54071 }
54072 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
54073 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
54074 }
54075 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
54076 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
54077 }
54078 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
54079 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
54080 }
54081 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
54082 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
54083 }
54084 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
54085 return (void *)((wxEvent *) ((wxActivateEvent *) x));
54086 }
54087 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
54088 return (void *)((wxEvent *) ((wxSizeEvent *) x));
54089 }
54090 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
54091 return (void *)((wxEvent *) ((wxMoveEvent *) x));
54092 }
54093 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
54094 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
54095 }
54096 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
54097 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
54098 }
54099 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
54100 return (void *)((wxEvent *) ((wxPaintEvent *) x));
54101 }
54102 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
54103 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
54104 }
54105 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
54106 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
54107 }
54108 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
54109 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
54110 }
54111 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
54112 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
54113 }
54114 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
54115 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
54116 }
54117 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
54118 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
54119 }
54120 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
54121 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
54122 }
54123 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
54124 return (void *)((wxEvent *) ((wxFocusEvent *) x));
54125 }
54126 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
54127 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
54128 }
54129 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
54130 return (void *)((wxEvent *) ((wxShowEvent *) x));
54131 }
54132 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
54133 return (void *)((wxEvent *) ((wxCommandEvent *) x));
54134 }
54135 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
54136 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
54137 }
54138 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
54139 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54140 }
54141 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
54142 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
54143 }
54144 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
54145 return (void *)((wxEvent *) ((wxKeyEvent *) x));
54146 }
54147 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
54148 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
54149 }
54150 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
54151 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
54152 }
54153 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
54154 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
54155 }
54156 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
54157 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
54158 }
54159 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
54160 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
54161 }
54162 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
54163 return (void *)((wxControl *) ((wxControlWithItems *) x));
54164 }
54165 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
54166 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
54167 }
54168 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
54169 return (void *)((wxEvtHandler *) ((wxWindow *) x));
54170 }
54171 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
54172 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
54173 }
54174 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
54175 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
54176 }
54177 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
54178 return (void *)((wxEvtHandler *) ((wxValidator *) x));
54179 }
54180 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
54181 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
54182 }
54183 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
54184 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
54185 }
54186 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
54187 return (void *)((wxEvtHandler *) ((wxMenu *) x));
54188 }
54189 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
54190 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
54191 }
54192 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
54193 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
54194 }
54195 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
54196 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
54197 }
54198 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
54199 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
54200 }
54201 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
54202 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
54203 }
54204 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
54205 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54206 }
54207 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
54208 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
54209 }
54210 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
54211 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
54212 }
54213 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
54214 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
54215 }
54216 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
54217 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
54218 }
54219 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
54220 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54221 }
54222 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
54223 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
54224 }
54225 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
54226 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
54227 }
54228 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
54229 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
54230 }
54231 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
54232 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
54233 }
54234 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
54235 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
54236 }
54237 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
54238 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
54239 }
54240 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
54241 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
54242 }
54243 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
54244 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
54245 }
54246 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
54247 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
54248 }
54249 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
54250 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
54251 }
54252 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
54253 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
54254 }
54255 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
54256 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
54257 }
54258 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
54259 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
54260 }
54261 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
54262 return (void *)((wxObject *) ((wxSizerItem *) x));
54263 }
54264 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
54265 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
54266 }
54267 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
54268 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
54269 }
54270 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
54271 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
54272 }
54273 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
54274 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
54275 }
54276 static void *_p_wxSizerTo_p_wxObject(void *x) {
54277 return (void *)((wxObject *) ((wxSizer *) x));
54278 }
54279 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
54280 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
54281 }
54282 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
54283 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
54284 }
54285 static void *_p_wxEventTo_p_wxObject(void *x) {
54286 return (void *)((wxObject *) ((wxEvent *) x));
54287 }
54288 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
54289 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
54290 }
54291 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
54292 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
54293 }
54294 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
54295 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
54296 }
54297 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
54298 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
54299 }
54300 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
54301 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
54302 }
54303 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
54304 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
54305 }
54306 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
54307 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
54308 }
54309 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
54310 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
54311 }
54312 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
54313 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
54314 }
54315 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
54316 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
54317 }
54318 static void *_p_wxControlTo_p_wxObject(void *x) {
54319 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
54320 }
54321 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
54322 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
54323 }
54324 static void *_p_wxFSFileTo_p_wxObject(void *x) {
54325 return (void *)((wxObject *) ((wxFSFile *) x));
54326 }
54327 static void *_p_wxPySizerTo_p_wxObject(void *x) {
54328 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
54329 }
54330 static void *_p_wxPyEventTo_p_wxObject(void *x) {
54331 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
54332 }
54333 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
54334 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
54335 }
54336 static void *_p_wxShowEventTo_p_wxObject(void *x) {
54337 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
54338 }
54339 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
54340 return (void *)((wxObject *) ((wxMenuItem *) x));
54341 }
54342 static void *_p_wxDateEventTo_p_wxObject(void *x) {
54343 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
54344 }
54345 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
54346 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
54347 }
54348 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
54349 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
54350 }
54351 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
54352 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
54353 }
54354 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
54355 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
54356 }
54357 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
54358 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
54359 }
54360 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
54361 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
54362 }
54363 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
54364 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
54365 }
54366 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
54367 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
54368 }
54369 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
54370 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
54371 }
54372 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
54373 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
54374 }
54375 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
54376 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
54377 }
54378 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
54379 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
54380 }
54381 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
54382 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
54383 }
54384 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
54385 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54386 }
54387 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
54388 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
54389 }
54390 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
54391 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
54392 }
54393 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
54394 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
54395 }
54396 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
54397 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
54398 }
54399 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
54400 return (void *)((wxObject *) ((wxImageHandler *) x));
54401 }
54402 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
54403 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
54404 }
54405 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
54406 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
54407 }
54408 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
54409 return (void *)((wxObject *) ((wxEvtHandler *) x));
54410 }
54411 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
54412 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54413 }
54414 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
54415 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
54416 }
54417 static void *_p_wxImageTo_p_wxObject(void *x) {
54418 return (void *)((wxObject *) ((wxImage *) x));
54419 }
54420 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
54421 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
54422 }
54423 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
54424 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54425 }
54426 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
54427 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
54428 }
54429 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
54430 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
54431 }
54432 static void *_p_wxWindowTo_p_wxObject(void *x) {
54433 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
54434 }
54435 static void *_p_wxMenuTo_p_wxObject(void *x) {
54436 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
54437 }
54438 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
54439 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
54440 }
54441 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
54442 return (void *)((wxObject *) ((wxFileSystem *) x));
54443 }
54444 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
54445 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
54446 }
54447 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
54448 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
54449 }
54450 static void *_p_wxPyAppTo_p_wxObject(void *x) {
54451 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
54452 }
54453 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
54454 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
54455 }
54456 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
54457 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
54458 }
54459 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
54460 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
54461 }
54462 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
54463 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
54464 }
54465 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
54466 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
54467 }
54468 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
54469 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
54470 }
54471 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
54472 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
54473 }
54474 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
54475 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
54476 }
54477 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
54478 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
54479 }
54480 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
54481 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
54482 }
54483 static void *_p_wxValidatorTo_p_wxObject(void *x) {
54484 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
54485 }
54486 static void *_p_wxControlTo_p_wxWindow(void *x) {
54487 return (void *)((wxWindow *) ((wxControl *) x));
54488 }
54489 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
54490 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
54491 }
54492 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
54493 return (void *)((wxWindow *) ((wxMenuBar *) x));
54494 }
54495 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
54496 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
54497 }
54498 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
54499 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
54500 }
54501 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
54502 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
54503 }
54504 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
54505 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
54506 }
54507 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
54508 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
54509 }
54510 static void *_p_wxClipboardTextEventTo_p_wxCommandEvent(void *x) {
54511 return (void *)((wxCommandEvent *) ((wxClipboardTextEvent *) x));
54512 }
54513 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
54514 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54515 }
54516 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
54517 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
54518 }
54519 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
54520 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
54521 }
54522 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
54523 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
54524 }
54525 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
54526 return (void *)((wxValidator *) ((wxPyValidator *) x));
54527 }
54528 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, (void*)0, 0};
54529 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
54530 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};
54531 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
54532 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
54533 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
54534 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
54535 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
54536 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", "wxANIHandler *", 0, 0, (void*)0, 0};
54537 static swig_type_info _swigt__p_wxAcceleratorEntry = {"_p_wxAcceleratorEntry", "wxAcceleratorEntry *", 0, 0, (void*)0, 0};
54538 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", "wxAcceleratorTable *", 0, 0, (void*)0, 0};
54539 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", "wxActivateEvent *", 0, 0, (void*)0, 0};
54540 static swig_type_info _swigt__p_wxAppTraits = {"_p_wxAppTraits", "wxAppTraits *", 0, 0, (void*)0, 0};
54541 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
54542 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", "wxBMPHandler *", 0, 0, (void*)0, 0};
54543 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
54544 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", "wxBoxSizer *", 0, 0, (void*)0, 0};
54545 static swig_type_info _swigt__p_wxButton = {"_p_wxButton", "wxButton *", 0, 0, (void*)0, 0};
54546 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", "wxCURHandler *", 0, 0, (void*)0, 0};
54547 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
54548 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", "wxChildFocusEvent *", 0, 0, (void*)0, 0};
54549 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", "wxClipboardTextEvent *", 0, 0, (void*)0, 0};
54550 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", "wxCloseEvent *", 0, 0, (void*)0, 0};
54551 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
54552 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
54553 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", "wxContextMenuEvent *", 0, 0, (void*)0, 0};
54554 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
54555 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", "wxControlWithItems *", 0, 0, (void*)0, 0};
54556 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
54557 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
54558 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", "wxDateEvent *", 0, 0, (void*)0, 0};
54559 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
54560 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", "wxDisplayChangedEvent *", 0, 0, (void*)0, 0};
54561 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", "wxDropFilesEvent *", 0, 0, (void*)0, 0};
54562 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
54563 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", "wxEraseEvent *", 0, 0, (void*)0, 0};
54564 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
54565 static swig_type_info _swigt__p_wxEventLoop = {"_p_wxEventLoop", "wxEventLoop *", 0, 0, (void*)0, 0};
54566 static swig_type_info _swigt__p_wxEventLoopActivator = {"_p_wxEventLoopActivator", "wxEventLoopActivator *", 0, 0, (void*)0, 0};
54567 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
54568 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", "wxFSFile *", 0, 0, (void*)0, 0};
54569 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, (void*)0, 0};
54570 static swig_type_info _swigt__p_wxFileSystemHandler = {"_p_wxFileSystemHandler", "wxFileSystemHandler *", 0, 0, (void*)0, 0};
54571 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", "wxFlexGridSizer *", 0, 0, (void*)0, 0};
54572 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", "wxFocusEvent *", 0, 0, (void*)0, 0};
54573 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
54574 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
54575 static swig_type_info _swigt__p_wxGBPosition = {"_p_wxGBPosition", "wxGBPosition *", 0, 0, (void*)0, 0};
54576 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", "wxGBSizerItem *", 0, 0, (void*)0, 0};
54577 static swig_type_info _swigt__p_wxGBSpan = {"_p_wxGBSpan", "wxGBSpan *", 0, 0, (void*)0, 0};
54578 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", "wxGIFHandler *", 0, 0, (void*)0, 0};
54579 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", "wxGridBagSizer *", 0, 0, (void*)0, 0};
54580 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", "wxGridSizer *", 0, 0, (void*)0, 0};
54581 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", "wxICOHandler *", 0, 0, (void*)0, 0};
54582 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", "wxIconizeEvent *", 0, 0, (void*)0, 0};
54583 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", "wxIdleEvent *", 0, 0, (void*)0, 0};
54584 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, (void*)0, 0};
54585 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", "wxImageHandler *", 0, 0, (void*)0, 0};
54586 static swig_type_info _swigt__p_wxImageHistogram = {"_p_wxImageHistogram", "wxImageHistogram *", 0, 0, (void*)0, 0};
54587 static swig_type_info _swigt__p_wxImage_HSVValue = {"_p_wxImage_HSVValue", "wxImage_HSVValue *", 0, 0, (void*)0, 0};
54588 static swig_type_info _swigt__p_wxImage_RGBValue = {"_p_wxImage_RGBValue", "wxImage_RGBValue *", 0, 0, (void*)0, 0};
54589 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", "wxIndividualLayoutConstraint *", 0, 0, (void*)0, 0};
54590 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", "wxInitDialogEvent *", 0, 0, (void*)0, 0};
54591 static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, (void*)0, 0};
54592 static swig_type_info _swigt__p_wxInternetFSHandler = {"_p_wxInternetFSHandler", "wxInternetFSHandler *", 0, 0, (void*)0, 0};
54593 static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, (void*)0, 0};
54594 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", "wxJPEGHandler *", 0, 0, (void*)0, 0};
54595 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
54596 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", "wxLayoutConstraints *", 0, 0, (void*)0, 0};
54597 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", "wxMaximizeEvent *", 0, 0, (void*)0, 0};
54598 static swig_type_info _swigt__p_wxMemoryFSHandler = {"_p_wxMemoryFSHandler", "wxMemoryFSHandler *", 0, 0, (void*)0, 0};
54599 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
54600 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", "wxMenuBar *", 0, 0, (void*)0, 0};
54601 static swig_type_info _swigt__p_wxMenuBarBase = {"_p_wxMenuBarBase", "wxMenuBarBase *", 0, 0, (void*)0, 0};
54602 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", "wxMenuEvent *", 0, 0, (void*)0, 0};
54603 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", "wxMenuItem *", 0, 0, (void*)0, 0};
54604 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", "wxMouseCaptureChangedEvent *", 0, 0, (void*)0, 0};
54605 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", "wxMouseEvent *", 0, 0, (void*)0, 0};
54606 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", "wxMoveEvent *", 0, 0, (void*)0, 0};
54607 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", "wxNavigationKeyEvent *", 0, 0, (void*)0, 0};
54608 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", "wxNcPaintEvent *", 0, 0, (void*)0, 0};
54609 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
54610 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
54611 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
54612 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", "wxPCXHandler *", 0, 0, (void*)0, 0};
54613 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", "wxPNGHandler *", 0, 0, (void*)0, 0};
54614 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", "wxPNMHandler *", 0, 0, (void*)0, 0};
54615 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", "wxPaintEvent *", 0, 0, (void*)0, 0};
54616 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", "wxPaletteChangedEvent *", 0, 0, (void*)0, 0};
54617 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
54618 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
54619 static swig_type_info _swigt__p_wxPoint2D = {"_p_wxPoint2D", "wxPoint2D *", 0, 0, (void*)0, 0};
54620 static swig_type_info _swigt__p_wxPropagateOnce = {"_p_wxPropagateOnce", "wxPropagateOnce *", 0, 0, (void*)0, 0};
54621 static swig_type_info _swigt__p_wxPropagationDisabler = {"_p_wxPropagationDisabler", "wxPropagationDisabler *", 0, 0, (void*)0, 0};
54622 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", "wxPyApp *", 0, 0, (void*)0, 0};
54623 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", "wxPyCommandEvent *", 0, 0, (void*)0, 0};
54624 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
54625 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", "wxPyEvent *", 0, 0, (void*)0, 0};
54626 static swig_type_info _swigt__p_wxPyFileSystemHandler = {"_p_wxPyFileSystemHandler", "wxPyFileSystemHandler *", 0, 0, (void*)0, 0};
54627 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", "wxPyImageHandler *", 0, 0, (void*)0, 0};
54628 static swig_type_info _swigt__p_wxPyInputStream = {"_p_wxPyInputStream", "wxPyInputStream *", 0, 0, (void*)0, 0};
54629 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", "wxPySizer *", 0, 0, (void*)0, 0};
54630 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", "wxPyValidator *", 0, 0, (void*)0, 0};
54631 static swig_type_info _swigt__p_wxQuantize = {"_p_wxQuantize", "wxQuantize *", 0, 0, (void*)0, 0};
54632 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", "wxQueryNewPaletteEvent *", 0, 0, (void*)0, 0};
54633 static swig_type_info _swigt__p_wxRealPoint = {"_p_wxRealPoint", "wxRealPoint *", 0, 0, (void*)0, 0};
54634 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
54635 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, (void*)0, 0};
54636 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", "wxScrollEvent *", 0, 0, (void*)0, 0};
54637 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", "wxScrollWinEvent *", 0, 0, (void*)0, 0};
54638 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", "wxSetCursorEvent *", 0, 0, (void*)0, 0};
54639 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", "wxShowEvent *", 0, 0, (void*)0, 0};
54640 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
54641 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", "wxSizeEvent *", 0, 0, (void*)0, 0};
54642 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", "wxSizer *", 0, 0, (void*)0, 0};
54643 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", "wxSizerItem *", 0, 0, (void*)0, 0};
54644 static swig_type_info _swigt__p_wxStaticBox = {"_p_wxStaticBox", "wxStaticBox *", 0, 0, (void*)0, 0};
54645 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", "wxStaticBoxSizer *", 0, 0, (void*)0, 0};
54646 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", "wxStdDialogButtonSizer *", 0, 0, (void*)0, 0};
54647 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", "wxSysColourChangedEvent *", 0, 0, (void*)0, 0};
54648 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", "wxTIFFHandler *", 0, 0, (void*)0, 0};
54649 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
54650 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", "wxUpdateUIEvent *", 0, 0, (void*)0, 0};
54651 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, (void*)0, 0};
54652 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
54653 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
54654 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", "wxWindowCreateEvent *", 0, 0, (void*)0, 0};
54655 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", "wxWindowDestroyEvent *", 0, 0, (void*)0, 0};
54656 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", "wxXPMHandler *", 0, 0, (void*)0, 0};
54657 static swig_type_info _swigt__p_wxZipFSHandler = {"_p_wxZipFSHandler", "wxZipFSHandler *", 0, 0, (void*)0, 0};
54658
54659 static swig_type_info *swig_type_initial[] = {
54660 &_swigt__p_buffer,
54661 &_swigt__p_char,
54662 &_swigt__p_form_ops_t,
54663 &_swigt__p_int,
54664 &_swigt__p_long,
54665 &_swigt__p_unsigned_char,
54666 &_swigt__p_unsigned_int,
54667 &_swigt__p_unsigned_long,
54668 &_swigt__p_wxANIHandler,
54669 &_swigt__p_wxAcceleratorEntry,
54670 &_swigt__p_wxAcceleratorTable,
54671 &_swigt__p_wxActivateEvent,
54672 &_swigt__p_wxAppTraits,
54673 &_swigt__p_wxArrayString,
54674 &_swigt__p_wxBMPHandler,
54675 &_swigt__p_wxBitmap,
54676 &_swigt__p_wxBoxSizer,
54677 &_swigt__p_wxButton,
54678 &_swigt__p_wxCURHandler,
54679 &_swigt__p_wxCaret,
54680 &_swigt__p_wxChildFocusEvent,
54681 &_swigt__p_wxClipboardTextEvent,
54682 &_swigt__p_wxCloseEvent,
54683 &_swigt__p_wxColour,
54684 &_swigt__p_wxCommandEvent,
54685 &_swigt__p_wxContextMenuEvent,
54686 &_swigt__p_wxControl,
54687 &_swigt__p_wxControlWithItems,
54688 &_swigt__p_wxCursor,
54689 &_swigt__p_wxDC,
54690 &_swigt__p_wxDateEvent,
54691 &_swigt__p_wxDateTime,
54692 &_swigt__p_wxDisplayChangedEvent,
54693 &_swigt__p_wxDropFilesEvent,
54694 &_swigt__p_wxDuplexMode,
54695 &_swigt__p_wxEraseEvent,
54696 &_swigt__p_wxEvent,
54697 &_swigt__p_wxEventLoop,
54698 &_swigt__p_wxEventLoopActivator,
54699 &_swigt__p_wxEvtHandler,
54700 &_swigt__p_wxFSFile,
54701 &_swigt__p_wxFileSystem,
54702 &_swigt__p_wxFileSystemHandler,
54703 &_swigt__p_wxFlexGridSizer,
54704 &_swigt__p_wxFocusEvent,
54705 &_swigt__p_wxFont,
54706 &_swigt__p_wxFrame,
54707 &_swigt__p_wxGBPosition,
54708 &_swigt__p_wxGBSizerItem,
54709 &_swigt__p_wxGBSpan,
54710 &_swigt__p_wxGIFHandler,
54711 &_swigt__p_wxGridBagSizer,
54712 &_swigt__p_wxGridSizer,
54713 &_swigt__p_wxICOHandler,
54714 &_swigt__p_wxIconizeEvent,
54715 &_swigt__p_wxIdleEvent,
54716 &_swigt__p_wxImage,
54717 &_swigt__p_wxImageHandler,
54718 &_swigt__p_wxImageHistogram,
54719 &_swigt__p_wxImage_HSVValue,
54720 &_swigt__p_wxImage_RGBValue,
54721 &_swigt__p_wxIndividualLayoutConstraint,
54722 &_swigt__p_wxInitDialogEvent,
54723 &_swigt__p_wxInputStream,
54724 &_swigt__p_wxInternetFSHandler,
54725 &_swigt__p_wxItemContainer,
54726 &_swigt__p_wxJPEGHandler,
54727 &_swigt__p_wxKeyEvent,
54728 &_swigt__p_wxLayoutConstraints,
54729 &_swigt__p_wxMaximizeEvent,
54730 &_swigt__p_wxMemoryFSHandler,
54731 &_swigt__p_wxMenu,
54732 &_swigt__p_wxMenuBar,
54733 &_swigt__p_wxMenuBarBase,
54734 &_swigt__p_wxMenuEvent,
54735 &_swigt__p_wxMenuItem,
54736 &_swigt__p_wxMouseCaptureChangedEvent,
54737 &_swigt__p_wxMouseEvent,
54738 &_swigt__p_wxMoveEvent,
54739 &_swigt__p_wxNavigationKeyEvent,
54740 &_swigt__p_wxNcPaintEvent,
54741 &_swigt__p_wxNotifyEvent,
54742 &_swigt__p_wxObject,
54743 &_swigt__p_wxOutputStream,
54744 &_swigt__p_wxPCXHandler,
54745 &_swigt__p_wxPNGHandler,
54746 &_swigt__p_wxPNMHandler,
54747 &_swigt__p_wxPaintEvent,
54748 &_swigt__p_wxPaletteChangedEvent,
54749 &_swigt__p_wxPaperSize,
54750 &_swigt__p_wxPoint,
54751 &_swigt__p_wxPoint2D,
54752 &_swigt__p_wxPropagateOnce,
54753 &_swigt__p_wxPropagationDisabler,
54754 &_swigt__p_wxPyApp,
54755 &_swigt__p_wxPyCommandEvent,
54756 &_swigt__p_wxPyDropTarget,
54757 &_swigt__p_wxPyEvent,
54758 &_swigt__p_wxPyFileSystemHandler,
54759 &_swigt__p_wxPyImageHandler,
54760 &_swigt__p_wxPyInputStream,
54761 &_swigt__p_wxPySizer,
54762 &_swigt__p_wxPyValidator,
54763 &_swigt__p_wxQuantize,
54764 &_swigt__p_wxQueryNewPaletteEvent,
54765 &_swigt__p_wxRealPoint,
54766 &_swigt__p_wxRect,
54767 &_swigt__p_wxRegion,
54768 &_swigt__p_wxScrollEvent,
54769 &_swigt__p_wxScrollWinEvent,
54770 &_swigt__p_wxSetCursorEvent,
54771 &_swigt__p_wxShowEvent,
54772 &_swigt__p_wxSize,
54773 &_swigt__p_wxSizeEvent,
54774 &_swigt__p_wxSizer,
54775 &_swigt__p_wxSizerItem,
54776 &_swigt__p_wxStaticBox,
54777 &_swigt__p_wxStaticBoxSizer,
54778 &_swigt__p_wxStdDialogButtonSizer,
54779 &_swigt__p_wxSysColourChangedEvent,
54780 &_swigt__p_wxTIFFHandler,
54781 &_swigt__p_wxToolTip,
54782 &_swigt__p_wxUpdateUIEvent,
54783 &_swigt__p_wxValidator,
54784 &_swigt__p_wxVisualAttributes,
54785 &_swigt__p_wxWindow,
54786 &_swigt__p_wxWindowCreateEvent,
54787 &_swigt__p_wxWindowDestroyEvent,
54788 &_swigt__p_wxXPMHandler,
54789 &_swigt__p_wxZipFSHandler,
54790 };
54791
54792 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
54793 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
54794 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
54795 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
54796 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
54797 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
54798 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
54799 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
54800 static swig_cast_info _swigc__p_wxANIHandler[] = { {&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
54801 static swig_cast_info _swigc__p_wxAcceleratorEntry[] = { {&_swigt__p_wxAcceleratorEntry, 0, 0, 0},{0, 0, 0, 0}};
54802 static swig_cast_info _swigc__p_wxAcceleratorTable[] = { {&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
54803 static swig_cast_info _swigc__p_wxActivateEvent[] = { {&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
54804 static swig_cast_info _swigc__p_wxAppTraits[] = { {&_swigt__p_wxAppTraits, 0, 0, 0},{0, 0, 0, 0}};
54805 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
54806 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}};
54807 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
54808 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}};
54809 static swig_cast_info _swigc__p_wxButton[] = { {&_swigt__p_wxButton, 0, 0, 0},{0, 0, 0, 0}};
54810 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}};
54811 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
54812 static swig_cast_info _swigc__p_wxChildFocusEvent[] = { {&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
54813 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = { {&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
54814 static swig_cast_info _swigc__p_wxCloseEvent[] = { {&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
54815 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
54816 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}};
54817 static swig_cast_info _swigc__p_wxContextMenuEvent[] = { {&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
54818 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}};
54819 static swig_cast_info _swigc__p_wxControlWithItems[] = { {&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
54820 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
54821 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
54822 static swig_cast_info _swigc__p_wxDateEvent[] = { {&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
54823 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
54824 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = { {&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
54825 static swig_cast_info _swigc__p_wxDropFilesEvent[] = { {&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
54826 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
54827 static swig_cast_info _swigc__p_wxEraseEvent[] = { {&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
54828 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}};
54829 static swig_cast_info _swigc__p_wxEventLoop[] = { {&_swigt__p_wxEventLoop, 0, 0, 0},{0, 0, 0, 0}};
54830 static swig_cast_info _swigc__p_wxEventLoopActivator[] = { {&_swigt__p_wxEventLoopActivator, 0, 0, 0},{0, 0, 0, 0}};
54831 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}};
54832 static swig_cast_info _swigc__p_wxFSFile[] = { {&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
54833 static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
54834 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}};
54835 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}};
54836 static swig_cast_info _swigc__p_wxFocusEvent[] = { {&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
54837 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
54838 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
54839 static swig_cast_info _swigc__p_wxGBPosition[] = { {&_swigt__p_wxGBPosition, 0, 0, 0},{0, 0, 0, 0}};
54840 static swig_cast_info _swigc__p_wxGBSizerItem[] = { {&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
54841 static swig_cast_info _swigc__p_wxGBSpan[] = { {&_swigt__p_wxGBSpan, 0, 0, 0},{0, 0, 0, 0}};
54842 static swig_cast_info _swigc__p_wxGIFHandler[] = { {&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
54843 static swig_cast_info _swigc__p_wxGridBagSizer[] = { {&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
54844 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}};
54845 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}};
54846 static swig_cast_info _swigc__p_wxIconizeEvent[] = { {&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
54847 static swig_cast_info _swigc__p_wxIdleEvent[] = { {&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
54848 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
54849 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}};
54850 static swig_cast_info _swigc__p_wxImageHistogram[] = { {&_swigt__p_wxImageHistogram, 0, 0, 0},{0, 0, 0, 0}};
54851 static swig_cast_info _swigc__p_wxImage_HSVValue[] = { {&_swigt__p_wxImage_HSVValue, 0, 0, 0},{0, 0, 0, 0}};
54852 static swig_cast_info _swigc__p_wxImage_RGBValue[] = { {&_swigt__p_wxImage_RGBValue, 0, 0, 0},{0, 0, 0, 0}};
54853 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = { {&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
54854 static swig_cast_info _swigc__p_wxInitDialogEvent[] = { {&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
54855 static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
54856 static swig_cast_info _swigc__p_wxInternetFSHandler[] = { {&_swigt__p_wxInternetFSHandler, 0, 0, 0},{0, 0, 0, 0}};
54857 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}};
54858 static swig_cast_info _swigc__p_wxJPEGHandler[] = { {&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
54859 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
54860 static swig_cast_info _swigc__p_wxLayoutConstraints[] = { {&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
54861 static swig_cast_info _swigc__p_wxMaximizeEvent[] = { {&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
54862 static swig_cast_info _swigc__p_wxMemoryFSHandler[] = { {&_swigt__p_wxMemoryFSHandler, 0, 0, 0},{0, 0, 0, 0}};
54863 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
54864 static swig_cast_info _swigc__p_wxMenuBar[] = { {&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
54865 static swig_cast_info _swigc__p_wxMenuBarBase[] = { {&_swigt__p_wxMenuBarBase, 0, 0, 0},{0, 0, 0, 0}};
54866 static swig_cast_info _swigc__p_wxMenuEvent[] = { {&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
54867 static swig_cast_info _swigc__p_wxMenuItem[] = { {&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
54868 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = { {&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
54869 static swig_cast_info _swigc__p_wxMouseEvent[] = { {&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
54870 static swig_cast_info _swigc__p_wxMoveEvent[] = { {&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
54871 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = { {&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
54872 static swig_cast_info _swigc__p_wxNcPaintEvent[] = { {&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
54873 static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
54874 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}};
54875 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
54876 static swig_cast_info _swigc__p_wxPCXHandler[] = { {&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
54877 static swig_cast_info _swigc__p_wxPNGHandler[] = { {&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
54878 static swig_cast_info _swigc__p_wxPNMHandler[] = { {&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
54879 static swig_cast_info _swigc__p_wxPaintEvent[] = { {&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
54880 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = { {&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
54881 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
54882 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
54883 static swig_cast_info _swigc__p_wxPoint2D[] = { {&_swigt__p_wxPoint2D, 0, 0, 0},{0, 0, 0, 0}};
54884 static swig_cast_info _swigc__p_wxPropagateOnce[] = { {&_swigt__p_wxPropagateOnce, 0, 0, 0},{0, 0, 0, 0}};
54885 static swig_cast_info _swigc__p_wxPropagationDisabler[] = { {&_swigt__p_wxPropagationDisabler, 0, 0, 0},{0, 0, 0, 0}};
54886 static swig_cast_info _swigc__p_wxPyApp[] = { {&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
54887 static swig_cast_info _swigc__p_wxPyCommandEvent[] = { {&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
54888 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0},{0, 0, 0, 0}};
54889 static swig_cast_info _swigc__p_wxPyEvent[] = { {&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
54890 static swig_cast_info _swigc__p_wxPyFileSystemHandler[] = { {&_swigt__p_wxPyFileSystemHandler, 0, 0, 0},{0, 0, 0, 0}};
54891 static swig_cast_info _swigc__p_wxPyImageHandler[] = { {&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
54892 static swig_cast_info _swigc__p_wxPyInputStream[] = { {&_swigt__p_wxPyInputStream, 0, 0, 0},{0, 0, 0, 0}};
54893 static swig_cast_info _swigc__p_wxPySizer[] = { {&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
54894 static swig_cast_info _swigc__p_wxPyValidator[] = { {&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
54895 static swig_cast_info _swigc__p_wxQuantize[] = { {&_swigt__p_wxQuantize, 0, 0, 0},{0, 0, 0, 0}};
54896 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = { {&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
54897 static swig_cast_info _swigc__p_wxRealPoint[] = { {&_swigt__p_wxRealPoint, 0, 0, 0},{0, 0, 0, 0}};
54898 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
54899 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
54900 static swig_cast_info _swigc__p_wxScrollEvent[] = { {&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
54901 static swig_cast_info _swigc__p_wxScrollWinEvent[] = { {&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
54902 static swig_cast_info _swigc__p_wxSetCursorEvent[] = { {&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
54903 static swig_cast_info _swigc__p_wxShowEvent[] = { {&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
54904 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
54905 static swig_cast_info _swigc__p_wxSizeEvent[] = { {&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
54906 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}};
54907 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}};
54908 static swig_cast_info _swigc__p_wxStaticBox[] = { {&_swigt__p_wxStaticBox, 0, 0, 0},{0, 0, 0, 0}};
54909 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = { {&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
54910 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = { {&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
54911 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = { {&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
54912 static swig_cast_info _swigc__p_wxTIFFHandler[] = { {&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
54913 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
54914 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = { {&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
54915 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}};
54916 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
54917 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}};
54918 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = { {&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
54919 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = { {&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
54920 static swig_cast_info _swigc__p_wxXPMHandler[] = { {&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
54921 static swig_cast_info _swigc__p_wxZipFSHandler[] = { {&_swigt__p_wxZipFSHandler, 0, 0, 0},{0, 0, 0, 0}};
54922
54923 static swig_cast_info *swig_cast_initial[] = {
54924 _swigc__p_buffer,
54925 _swigc__p_char,
54926 _swigc__p_form_ops_t,
54927 _swigc__p_int,
54928 _swigc__p_long,
54929 _swigc__p_unsigned_char,
54930 _swigc__p_unsigned_int,
54931 _swigc__p_unsigned_long,
54932 _swigc__p_wxANIHandler,
54933 _swigc__p_wxAcceleratorEntry,
54934 _swigc__p_wxAcceleratorTable,
54935 _swigc__p_wxActivateEvent,
54936 _swigc__p_wxAppTraits,
54937 _swigc__p_wxArrayString,
54938 _swigc__p_wxBMPHandler,
54939 _swigc__p_wxBitmap,
54940 _swigc__p_wxBoxSizer,
54941 _swigc__p_wxButton,
54942 _swigc__p_wxCURHandler,
54943 _swigc__p_wxCaret,
54944 _swigc__p_wxChildFocusEvent,
54945 _swigc__p_wxClipboardTextEvent,
54946 _swigc__p_wxCloseEvent,
54947 _swigc__p_wxColour,
54948 _swigc__p_wxCommandEvent,
54949 _swigc__p_wxContextMenuEvent,
54950 _swigc__p_wxControl,
54951 _swigc__p_wxControlWithItems,
54952 _swigc__p_wxCursor,
54953 _swigc__p_wxDC,
54954 _swigc__p_wxDateEvent,
54955 _swigc__p_wxDateTime,
54956 _swigc__p_wxDisplayChangedEvent,
54957 _swigc__p_wxDropFilesEvent,
54958 _swigc__p_wxDuplexMode,
54959 _swigc__p_wxEraseEvent,
54960 _swigc__p_wxEvent,
54961 _swigc__p_wxEventLoop,
54962 _swigc__p_wxEventLoopActivator,
54963 _swigc__p_wxEvtHandler,
54964 _swigc__p_wxFSFile,
54965 _swigc__p_wxFileSystem,
54966 _swigc__p_wxFileSystemHandler,
54967 _swigc__p_wxFlexGridSizer,
54968 _swigc__p_wxFocusEvent,
54969 _swigc__p_wxFont,
54970 _swigc__p_wxFrame,
54971 _swigc__p_wxGBPosition,
54972 _swigc__p_wxGBSizerItem,
54973 _swigc__p_wxGBSpan,
54974 _swigc__p_wxGIFHandler,
54975 _swigc__p_wxGridBagSizer,
54976 _swigc__p_wxGridSizer,
54977 _swigc__p_wxICOHandler,
54978 _swigc__p_wxIconizeEvent,
54979 _swigc__p_wxIdleEvent,
54980 _swigc__p_wxImage,
54981 _swigc__p_wxImageHandler,
54982 _swigc__p_wxImageHistogram,
54983 _swigc__p_wxImage_HSVValue,
54984 _swigc__p_wxImage_RGBValue,
54985 _swigc__p_wxIndividualLayoutConstraint,
54986 _swigc__p_wxInitDialogEvent,
54987 _swigc__p_wxInputStream,
54988 _swigc__p_wxInternetFSHandler,
54989 _swigc__p_wxItemContainer,
54990 _swigc__p_wxJPEGHandler,
54991 _swigc__p_wxKeyEvent,
54992 _swigc__p_wxLayoutConstraints,
54993 _swigc__p_wxMaximizeEvent,
54994 _swigc__p_wxMemoryFSHandler,
54995 _swigc__p_wxMenu,
54996 _swigc__p_wxMenuBar,
54997 _swigc__p_wxMenuBarBase,
54998 _swigc__p_wxMenuEvent,
54999 _swigc__p_wxMenuItem,
55000 _swigc__p_wxMouseCaptureChangedEvent,
55001 _swigc__p_wxMouseEvent,
55002 _swigc__p_wxMoveEvent,
55003 _swigc__p_wxNavigationKeyEvent,
55004 _swigc__p_wxNcPaintEvent,
55005 _swigc__p_wxNotifyEvent,
55006 _swigc__p_wxObject,
55007 _swigc__p_wxOutputStream,
55008 _swigc__p_wxPCXHandler,
55009 _swigc__p_wxPNGHandler,
55010 _swigc__p_wxPNMHandler,
55011 _swigc__p_wxPaintEvent,
55012 _swigc__p_wxPaletteChangedEvent,
55013 _swigc__p_wxPaperSize,
55014 _swigc__p_wxPoint,
55015 _swigc__p_wxPoint2D,
55016 _swigc__p_wxPropagateOnce,
55017 _swigc__p_wxPropagationDisabler,
55018 _swigc__p_wxPyApp,
55019 _swigc__p_wxPyCommandEvent,
55020 _swigc__p_wxPyDropTarget,
55021 _swigc__p_wxPyEvent,
55022 _swigc__p_wxPyFileSystemHandler,
55023 _swigc__p_wxPyImageHandler,
55024 _swigc__p_wxPyInputStream,
55025 _swigc__p_wxPySizer,
55026 _swigc__p_wxPyValidator,
55027 _swigc__p_wxQuantize,
55028 _swigc__p_wxQueryNewPaletteEvent,
55029 _swigc__p_wxRealPoint,
55030 _swigc__p_wxRect,
55031 _swigc__p_wxRegion,
55032 _swigc__p_wxScrollEvent,
55033 _swigc__p_wxScrollWinEvent,
55034 _swigc__p_wxSetCursorEvent,
55035 _swigc__p_wxShowEvent,
55036 _swigc__p_wxSize,
55037 _swigc__p_wxSizeEvent,
55038 _swigc__p_wxSizer,
55039 _swigc__p_wxSizerItem,
55040 _swigc__p_wxStaticBox,
55041 _swigc__p_wxStaticBoxSizer,
55042 _swigc__p_wxStdDialogButtonSizer,
55043 _swigc__p_wxSysColourChangedEvent,
55044 _swigc__p_wxTIFFHandler,
55045 _swigc__p_wxToolTip,
55046 _swigc__p_wxUpdateUIEvent,
55047 _swigc__p_wxValidator,
55048 _swigc__p_wxVisualAttributes,
55049 _swigc__p_wxWindow,
55050 _swigc__p_wxWindowCreateEvent,
55051 _swigc__p_wxWindowDestroyEvent,
55052 _swigc__p_wxXPMHandler,
55053 _swigc__p_wxZipFSHandler,
55054 };
55055
55056
55057 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
55058
55059 static swig_const_info swig_const_table[] = {
55060 {0, 0, 0, 0.0, 0, 0}};
55061
55062 #ifdef __cplusplus
55063 }
55064 #endif
55065 /* -----------------------------------------------------------------------------
55066 * Type initialization:
55067 * This problem is tough by the requirement that no dynamic
55068 * memory is used. Also, since swig_type_info structures store pointers to
55069 * swig_cast_info structures and swig_cast_info structures store pointers back
55070 * to swig_type_info structures, we need some lookup code at initialization.
55071 * The idea is that swig generates all the structures that are needed.
55072 * The runtime then collects these partially filled structures.
55073 * The SWIG_InitializeModule function takes these initial arrays out of
55074 * swig_module, and does all the lookup, filling in the swig_module.types
55075 * array with the correct data and linking the correct swig_cast_info
55076 * structures together.
55077 *
55078 * The generated swig_type_info structures are assigned staticly to an initial
55079 * array. We just loop though that array, and handle each type individually.
55080 * First we lookup if this type has been already loaded, and if so, use the
55081 * loaded structure instead of the generated one. Then we have to fill in the
55082 * cast linked list. The cast data is initially stored in something like a
55083 * two-dimensional array. Each row corresponds to a type (there are the same
55084 * number of rows as there are in the swig_type_initial array). Each entry in
55085 * a column is one of the swig_cast_info structures for that type.
55086 * The cast_initial array is actually an array of arrays, because each row has
55087 * a variable number of columns. So to actually build the cast linked list,
55088 * we find the array of casts associated with the type, and loop through it
55089 * adding the casts to the list. The one last trick we need to do is making
55090 * sure the type pointer in the swig_cast_info struct is correct.
55091 *
55092 * First off, we lookup the cast->type name to see if it is already loaded.
55093 * There are three cases to handle:
55094 * 1) If the cast->type has already been loaded AND the type we are adding
55095 * casting info to has not been loaded (it is in this module), THEN we
55096 * replace the cast->type pointer with the type pointer that has already
55097 * been loaded.
55098 * 2) If BOTH types (the one we are adding casting info to, and the
55099 * cast->type) are loaded, THEN the cast info has already been loaded by
55100 * the previous module so we just ignore it.
55101 * 3) Finally, if cast->type has not already been loaded, then we add that
55102 * swig_cast_info to the linked list (because the cast->type) pointer will
55103 * be correct.
55104 * ----------------------------------------------------------------------------- */
55105
55106 #ifdef __cplusplus
55107 extern "C" {
55108 #if 0
55109 } /* c-mode */
55110 #endif
55111 #endif
55112
55113 #if 0
55114 #define SWIGRUNTIME_DEBUG
55115 #endif
55116
55117 SWIGRUNTIME void
55118 SWIG_InitializeModule(void *clientdata) {
55119 size_t i;
55120 swig_module_info *module_head;
55121 static int init_run = 0;
55122
55123 clientdata = clientdata;
55124
55125 if (init_run) return;
55126 init_run = 1;
55127
55128 /* Initialize the swig_module */
55129 swig_module.type_initial = swig_type_initial;
55130 swig_module.cast_initial = swig_cast_initial;
55131
55132 /* Try and load any already created modules */
55133 module_head = SWIG_GetModule(clientdata);
55134 if (module_head) {
55135 swig_module.next = module_head->next;
55136 module_head->next = &swig_module;
55137 } else {
55138 /* This is the first module loaded */
55139 swig_module.next = &swig_module;
55140 SWIG_SetModule(clientdata, &swig_module);
55141 }
55142
55143 /* Now work on filling in swig_module.types */
55144 #ifdef SWIGRUNTIME_DEBUG
55145 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
55146 #endif
55147 for (i = 0; i < swig_module.size; ++i) {
55148 swig_type_info *type = 0;
55149 swig_type_info *ret;
55150 swig_cast_info *cast;
55151
55152 #ifdef SWIGRUNTIME_DEBUG
55153 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
55154 #endif
55155
55156 /* if there is another module already loaded */
55157 if (swig_module.next != &swig_module) {
55158 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
55159 }
55160 if (type) {
55161 /* Overwrite clientdata field */
55162 #ifdef SWIGRUNTIME_DEBUG
55163 printf("SWIG_InitializeModule: found type %s\n", type->name);
55164 #endif
55165 if (swig_module.type_initial[i]->clientdata) {
55166 type->clientdata = swig_module.type_initial[i]->clientdata;
55167 #ifdef SWIGRUNTIME_DEBUG
55168 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
55169 #endif
55170 }
55171 } else {
55172 type = swig_module.type_initial[i];
55173 }
55174
55175 /* Insert casting types */
55176 cast = swig_module.cast_initial[i];
55177 while (cast->type) {
55178 /* Don't need to add information already in the list */
55179 ret = 0;
55180 #ifdef SWIGRUNTIME_DEBUG
55181 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
55182 #endif
55183 if (swig_module.next != &swig_module) {
55184 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
55185 #ifdef SWIGRUNTIME_DEBUG
55186 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
55187 #endif
55188 }
55189 if (ret) {
55190 if (type == swig_module.type_initial[i]) {
55191 #ifdef SWIGRUNTIME_DEBUG
55192 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
55193 #endif
55194 cast->type = ret;
55195 ret = 0;
55196 } else {
55197 /* Check for casting already in the list */
55198 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
55199 #ifdef SWIGRUNTIME_DEBUG
55200 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
55201 #endif
55202 if (!ocast) ret = 0;
55203 }
55204 }
55205
55206 if (!ret) {
55207 #ifdef SWIGRUNTIME_DEBUG
55208 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
55209 #endif
55210 if (type->cast) {
55211 type->cast->prev = cast;
55212 cast->next = type->cast;
55213 }
55214 type->cast = cast;
55215 }
55216 cast++;
55217 }
55218 /* Set entry in modules->types array equal to the type */
55219 swig_module.types[i] = type;
55220 }
55221 swig_module.types[i] = 0;
55222
55223 #ifdef SWIGRUNTIME_DEBUG
55224 printf("**** SWIG_InitializeModule: Cast List ******\n");
55225 for (i = 0; i < swig_module.size; ++i) {
55226 int j = 0;
55227 swig_cast_info *cast = swig_module.cast_initial[i];
55228 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
55229 while (cast->type) {
55230 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
55231 cast++;
55232 ++j;
55233 }
55234 printf("---- Total casts: %d\n",j);
55235 }
55236 printf("**** SWIG_InitializeModule: Cast List ******\n");
55237 #endif
55238 }
55239
55240 /* This function will propagate the clientdata field of type to
55241 * any new swig_type_info structures that have been added into the list
55242 * of equivalent types. It is like calling
55243 * SWIG_TypeClientData(type, clientdata) a second time.
55244 */
55245 SWIGRUNTIME void
55246 SWIG_PropagateClientData(void) {
55247 size_t i;
55248 swig_cast_info *equiv;
55249 static int init_run = 0;
55250
55251 if (init_run) return;
55252 init_run = 1;
55253
55254 for (i = 0; i < swig_module.size; i++) {
55255 if (swig_module.types[i]->clientdata) {
55256 equiv = swig_module.types[i]->cast;
55257 while (equiv) {
55258 if (!equiv->converter) {
55259 if (equiv->type && !equiv->type->clientdata)
55260 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
55261 }
55262 equiv = equiv->next;
55263 }
55264 }
55265 }
55266 }
55267
55268 #ifdef __cplusplus
55269 #if 0
55270 {
55271 /* c-mode */
55272 #endif
55273 }
55274 #endif
55275
55276
55277
55278 #ifdef __cplusplus
55279 extern "C" {
55280 #endif
55281
55282 /* Python-specific SWIG API */
55283 #define SWIG_newvarlink() SWIG_Python_newvarlink()
55284 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
55285 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
55286
55287 /* -----------------------------------------------------------------------------
55288 * global variable support code.
55289 * ----------------------------------------------------------------------------- */
55290
55291 typedef struct swig_globalvar {
55292 char *name; /* Name of global variable */
55293 PyObject *(*get_attr)(void); /* Return the current value */
55294 int (*set_attr)(PyObject *); /* Set the value */
55295 struct swig_globalvar *next;
55296 } swig_globalvar;
55297
55298 typedef struct swig_varlinkobject {
55299 PyObject_HEAD
55300 swig_globalvar *vars;
55301 } swig_varlinkobject;
55302
55303 SWIGINTERN PyObject *
55304 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
55305 return PyString_FromString("<Swig global variables>");
55306 }
55307
55308 SWIGINTERN PyObject *
55309 swig_varlink_str(swig_varlinkobject *v) {
55310 PyObject *str = PyString_FromString("(");
55311 swig_globalvar *var;
55312 for (var = v->vars; var; var=var->next) {
55313 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
55314 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
55315 }
55316 PyString_ConcatAndDel(&str,PyString_FromString(")"));
55317 return str;
55318 }
55319
55320 SWIGINTERN int
55321 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
55322 PyObject *str = swig_varlink_str(v);
55323 fprintf(fp,"Swig global variables ");
55324 fprintf(fp,"%s\n", PyString_AsString(str));
55325 Py_DECREF(str);
55326 return 0;
55327 }
55328
55329 SWIGINTERN void
55330 swig_varlink_dealloc(swig_varlinkobject *v) {
55331 swig_globalvar *var = v->vars;
55332 while (var) {
55333 swig_globalvar *n = var->next;
55334 free(var->name);
55335 free(var);
55336 var = n;
55337 }
55338 }
55339
55340 SWIGINTERN PyObject *
55341 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
55342 PyObject *res = NULL;
55343 swig_globalvar *var = v->vars;
55344 while (var) {
55345 if (strcmp(var->name,n) == 0) {
55346 res = (*var->get_attr)();
55347 break;
55348 }
55349 var = var->next;
55350 }
55351 if (res == NULL && !PyErr_Occurred()) {
55352 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
55353 }
55354 return res;
55355 }
55356
55357 SWIGINTERN int
55358 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
55359 int res = 1;
55360 swig_globalvar *var = v->vars;
55361 while (var) {
55362 if (strcmp(var->name,n) == 0) {
55363 res = (*var->set_attr)(p);
55364 break;
55365 }
55366 var = var->next;
55367 }
55368 if (res == 1 && !PyErr_Occurred()) {
55369 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
55370 }
55371 return res;
55372 }
55373
55374 SWIGINTERN PyTypeObject*
55375 swig_varlink_type(void) {
55376 static char varlink__doc__[] = "Swig var link object";
55377 static PyTypeObject varlink_type;
55378 static int type_init = 0;
55379 if (!type_init) {
55380 const PyTypeObject tmp
55381 = {
55382 PyObject_HEAD_INIT(NULL)
55383 0, /* Number of items in variable part (ob_size) */
55384 (char *)"swigvarlink", /* Type name (tp_name) */
55385 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
55386 0, /* Itemsize (tp_itemsize) */
55387 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
55388 (printfunc) swig_varlink_print, /* Print (tp_print) */
55389 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
55390 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
55391 0, /* tp_compare */
55392 (reprfunc) swig_varlink_repr, /* tp_repr */
55393 0, /* tp_as_number */
55394 0, /* tp_as_sequence */
55395 0, /* tp_as_mapping */
55396 0, /* tp_hash */
55397 0, /* tp_call */
55398 (reprfunc)swig_varlink_str, /* tp_str */
55399 0, /* tp_getattro */
55400 0, /* tp_setattro */
55401 0, /* tp_as_buffer */
55402 0, /* tp_flags */
55403 varlink__doc__, /* tp_doc */
55404 0, /* tp_traverse */
55405 0, /* tp_clear */
55406 0, /* tp_richcompare */
55407 0, /* tp_weaklistoffset */
55408 #if PY_VERSION_HEX >= 0x02020000
55409 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
55410 #endif
55411 #if PY_VERSION_HEX >= 0x02030000
55412 0, /* tp_del */
55413 #endif
55414 #ifdef COUNT_ALLOCS
55415 0,0,0,0 /* tp_alloc -> tp_next */
55416 #endif
55417 };
55418 varlink_type = tmp;
55419 varlink_type.ob_type = &PyType_Type;
55420 type_init = 1;
55421 }
55422 return &varlink_type;
55423 }
55424
55425 /* Create a variable linking object for use later */
55426 SWIGINTERN PyObject *
55427 SWIG_Python_newvarlink(void) {
55428 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
55429 if (result) {
55430 result->vars = 0;
55431 }
55432 return ((PyObject*) result);
55433 }
55434
55435 SWIGINTERN void
55436 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
55437 swig_varlinkobject *v = (swig_varlinkobject *) p;
55438 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
55439 if (gv) {
55440 size_t size = strlen(name)+1;
55441 gv->name = (char *)malloc(size);
55442 if (gv->name) {
55443 strncpy(gv->name,name,size);
55444 gv->get_attr = get_attr;
55445 gv->set_attr = set_attr;
55446 gv->next = v->vars;
55447 }
55448 }
55449 v->vars = gv;
55450 }
55451
55452 SWIGINTERN PyObject *
55453 SWIG_globals() {
55454 static PyObject *_SWIG_globals = 0;
55455 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
55456 return _SWIG_globals;
55457 }
55458
55459 /* -----------------------------------------------------------------------------
55460 * constants/methods manipulation
55461 * ----------------------------------------------------------------------------- */
55462
55463 /* Install Constants */
55464 SWIGINTERN void
55465 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
55466 PyObject *obj = 0;
55467 size_t i;
55468 for (i = 0; constants[i].type; ++i) {
55469 switch(constants[i].type) {
55470 case SWIG_PY_POINTER:
55471 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
55472 break;
55473 case SWIG_PY_BINARY:
55474 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
55475 break;
55476 default:
55477 obj = 0;
55478 break;
55479 }
55480 if (obj) {
55481 PyDict_SetItemString(d, constants[i].name, obj);
55482 Py_DECREF(obj);
55483 }
55484 }
55485 }
55486
55487 /* -----------------------------------------------------------------------------*/
55488 /* Fix SwigMethods to carry the callback ptrs when needed */
55489 /* -----------------------------------------------------------------------------*/
55490
55491 SWIGINTERN void
55492 SWIG_Python_FixMethods(PyMethodDef *methods,
55493 swig_const_info *const_table,
55494 swig_type_info **types,
55495 swig_type_info **types_initial) {
55496 size_t i;
55497 for (i = 0; methods[i].ml_name; ++i) {
55498 char *c = methods[i].ml_doc;
55499 if (c && (c = strstr(c, "swig_ptr: "))) {
55500 int j;
55501 swig_const_info *ci = 0;
55502 char *name = c + 10;
55503 for (j = 0; const_table[j].type; ++j) {
55504 if (strncmp(const_table[j].name, name,
55505 strlen(const_table[j].name)) == 0) {
55506 ci = &(const_table[j]);
55507 break;
55508 }
55509 }
55510 if (ci) {
55511 size_t shift = (ci->ptype) - types;
55512 swig_type_info *ty = types_initial[shift];
55513 size_t ldoc = (c - methods[i].ml_doc);
55514 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
55515 char *ndoc = (char*)malloc(ldoc + lptr + 10);
55516 if (ndoc) {
55517 char *buff = ndoc;
55518 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
55519 if (ptr) {
55520 strncpy(buff, methods[i].ml_doc, ldoc);
55521 buff += ldoc;
55522 strncpy(buff, "swig_ptr: ", 10);
55523 buff += 10;
55524 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
55525 methods[i].ml_doc = ndoc;
55526 }
55527 }
55528 }
55529 }
55530 }
55531 }
55532
55533 #ifdef __cplusplus
55534 }
55535 #endif
55536
55537 /* -----------------------------------------------------------------------------*
55538 * Partial Init method
55539 * -----------------------------------------------------------------------------*/
55540
55541 #ifdef __cplusplus
55542 extern "C"
55543 #endif
55544 SWIGEXPORT void SWIG_init(void) {
55545 PyObject *m, *d;
55546
55547 /* Fix SwigMethods to carry the callback ptrs when needed */
55548 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
55549
55550 m = Py_InitModule((char *) SWIG_name, SwigMethods);
55551 d = PyModule_GetDict(m);
55552
55553 SWIG_InitializeModule(0);
55554 SWIG_InstallConstants(d,swig_const_table);
55555
55556
55557
55558 #ifndef wxPyUSE_EXPORT
55559 // Make our API structure a CObject so other modules can import it
55560 // from this module.
55561 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
55562 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
55563 Py_XDECREF(cobj);
55564 #endif
55565
55566 SWIG_Python_SetConstant(d, "NOT_FOUND",SWIG_From_int(static_cast< int >(wxNOT_FOUND)));
55567 SWIG_Python_SetConstant(d, "VSCROLL",SWIG_From_int(static_cast< int >(wxVSCROLL)));
55568 SWIG_Python_SetConstant(d, "HSCROLL",SWIG_From_int(static_cast< int >(wxHSCROLL)));
55569 SWIG_Python_SetConstant(d, "CAPTION",SWIG_From_int(static_cast< int >(wxCAPTION)));
55570 SWIG_Python_SetConstant(d, "DOUBLE_BORDER",SWIG_From_int(static_cast< int >(wxDOUBLE_BORDER)));
55571 SWIG_Python_SetConstant(d, "SUNKEN_BORDER",SWIG_From_int(static_cast< int >(wxSUNKEN_BORDER)));
55572 SWIG_Python_SetConstant(d, "RAISED_BORDER",SWIG_From_int(static_cast< int >(wxRAISED_BORDER)));
55573 SWIG_Python_SetConstant(d, "BORDER",SWIG_From_int(static_cast< int >(wxBORDER)));
55574 SWIG_Python_SetConstant(d, "SIMPLE_BORDER",SWIG_From_int(static_cast< int >(wxSIMPLE_BORDER)));
55575 SWIG_Python_SetConstant(d, "STATIC_BORDER",SWIG_From_int(static_cast< int >(wxSTATIC_BORDER)));
55576 SWIG_Python_SetConstant(d, "TRANSPARENT_WINDOW",SWIG_From_int(static_cast< int >(wxTRANSPARENT_WINDOW)));
55577 SWIG_Python_SetConstant(d, "NO_BORDER",SWIG_From_int(static_cast< int >(wxNO_BORDER)));
55578 SWIG_Python_SetConstant(d, "DEFAULT_CONTROL_BORDER",SWIG_From_int(static_cast< int >(wxDEFAULT_CONTROL_BORDER)));
55579 SWIG_Python_SetConstant(d, "DEFAULT_STATUSBAR_STYLE",SWIG_From_int(static_cast< int >(wxDEFAULT_STATUSBAR_STYLE)));
55580 SWIG_Python_SetConstant(d, "TAB_TRAVERSAL",SWIG_From_int(static_cast< int >(wxTAB_TRAVERSAL)));
55581 SWIG_Python_SetConstant(d, "WANTS_CHARS",SWIG_From_int(static_cast< int >(wxWANTS_CHARS)));
55582 SWIG_Python_SetConstant(d, "POPUP_WINDOW",SWIG_From_int(static_cast< int >(wxPOPUP_WINDOW)));
55583 SWIG_Python_SetConstant(d, "CENTER_FRAME",SWIG_From_int(static_cast< int >(wxCENTER_FRAME)));
55584 SWIG_Python_SetConstant(d, "CENTRE_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTRE_ON_SCREEN)));
55585 SWIG_Python_SetConstant(d, "CENTER_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTER_ON_SCREEN)));
55586 SWIG_Python_SetConstant(d, "CLIP_CHILDREN",SWIG_From_int(static_cast< int >(wxCLIP_CHILDREN)));
55587 SWIG_Python_SetConstant(d, "CLIP_SIBLINGS",SWIG_From_int(static_cast< int >(wxCLIP_SIBLINGS)));
55588 SWIG_Python_SetConstant(d, "ALWAYS_SHOW_SB",SWIG_From_int(static_cast< int >(wxALWAYS_SHOW_SB)));
55589 SWIG_Python_SetConstant(d, "RETAINED",SWIG_From_int(static_cast< int >(wxRETAINED)));
55590 SWIG_Python_SetConstant(d, "BACKINGSTORE",SWIG_From_int(static_cast< int >(wxBACKINGSTORE)));
55591 SWIG_Python_SetConstant(d, "COLOURED",SWIG_From_int(static_cast< int >(wxCOLOURED)));
55592 SWIG_Python_SetConstant(d, "FIXED_LENGTH",SWIG_From_int(static_cast< int >(wxFIXED_LENGTH)));
55593 SWIG_Python_SetConstant(d, "LB_NEEDED_SB",SWIG_From_int(static_cast< int >(wxLB_NEEDED_SB)));
55594 SWIG_Python_SetConstant(d, "LB_ALWAYS_SB",SWIG_From_int(static_cast< int >(wxLB_ALWAYS_SB)));
55595 SWIG_Python_SetConstant(d, "LB_SORT",SWIG_From_int(static_cast< int >(wxLB_SORT)));
55596 SWIG_Python_SetConstant(d, "LB_SINGLE",SWIG_From_int(static_cast< int >(wxLB_SINGLE)));
55597 SWIG_Python_SetConstant(d, "LB_MULTIPLE",SWIG_From_int(static_cast< int >(wxLB_MULTIPLE)));
55598 SWIG_Python_SetConstant(d, "LB_EXTENDED",SWIG_From_int(static_cast< int >(wxLB_EXTENDED)));
55599 SWIG_Python_SetConstant(d, "LB_OWNERDRAW",SWIG_From_int(static_cast< int >(wxLB_OWNERDRAW)));
55600 SWIG_Python_SetConstant(d, "LB_HSCROLL",SWIG_From_int(static_cast< int >(wxLB_HSCROLL)));
55601 SWIG_Python_SetConstant(d, "PROCESS_ENTER",SWIG_From_int(static_cast< int >(wxPROCESS_ENTER)));
55602 SWIG_Python_SetConstant(d, "PASSWORD",SWIG_From_int(static_cast< int >(wxPASSWORD)));
55603 SWIG_Python_SetConstant(d, "CB_SIMPLE",SWIG_From_int(static_cast< int >(wxCB_SIMPLE)));
55604 SWIG_Python_SetConstant(d, "CB_DROPDOWN",SWIG_From_int(static_cast< int >(wxCB_DROPDOWN)));
55605 SWIG_Python_SetConstant(d, "CB_SORT",SWIG_From_int(static_cast< int >(wxCB_SORT)));
55606 SWIG_Python_SetConstant(d, "CB_READONLY",SWIG_From_int(static_cast< int >(wxCB_READONLY)));
55607 SWIG_Python_SetConstant(d, "RA_HORIZONTAL",SWIG_From_int(static_cast< int >(wxRA_HORIZONTAL)));
55608 SWIG_Python_SetConstant(d, "RA_VERTICAL",SWIG_From_int(static_cast< int >(wxRA_VERTICAL)));
55609 SWIG_Python_SetConstant(d, "RA_SPECIFY_ROWS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_ROWS)));
55610 SWIG_Python_SetConstant(d, "RA_SPECIFY_COLS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_COLS)));
55611 SWIG_Python_SetConstant(d, "RA_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRA_USE_CHECKBOX)));
55612 SWIG_Python_SetConstant(d, "RB_GROUP",SWIG_From_int(static_cast< int >(wxRB_GROUP)));
55613 SWIG_Python_SetConstant(d, "RB_SINGLE",SWIG_From_int(static_cast< int >(wxRB_SINGLE)));
55614 SWIG_Python_SetConstant(d, "SB_HORIZONTAL",SWIG_From_int(static_cast< int >(wxSB_HORIZONTAL)));
55615 SWIG_Python_SetConstant(d, "SB_VERTICAL",SWIG_From_int(static_cast< int >(wxSB_VERTICAL)));
55616 SWIG_Python_SetConstant(d, "RB_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRB_USE_CHECKBOX)));
55617 SWIG_Python_SetConstant(d, "ST_SIZEGRIP",SWIG_From_int(static_cast< int >(wxST_SIZEGRIP)));
55618 SWIG_Python_SetConstant(d, "ST_NO_AUTORESIZE",SWIG_From_int(static_cast< int >(wxST_NO_AUTORESIZE)));
55619 SWIG_Python_SetConstant(d, "ST_DOTS_MIDDLE",SWIG_From_int(static_cast< int >(wxST_DOTS_MIDDLE)));
55620 SWIG_Python_SetConstant(d, "ST_DOTS_END",SWIG_From_int(static_cast< int >(wxST_DOTS_END)));
55621 SWIG_Python_SetConstant(d, "FLOOD_SURFACE",SWIG_From_int(static_cast< int >(wxFLOOD_SURFACE)));
55622 SWIG_Python_SetConstant(d, "FLOOD_BORDER",SWIG_From_int(static_cast< int >(wxFLOOD_BORDER)));
55623 SWIG_Python_SetConstant(d, "ODDEVEN_RULE",SWIG_From_int(static_cast< int >(wxODDEVEN_RULE)));
55624 SWIG_Python_SetConstant(d, "WINDING_RULE",SWIG_From_int(static_cast< int >(wxWINDING_RULE)));
55625 SWIG_Python_SetConstant(d, "TOOL_TOP",SWIG_From_int(static_cast< int >(wxTOOL_TOP)));
55626 SWIG_Python_SetConstant(d, "TOOL_BOTTOM",SWIG_From_int(static_cast< int >(wxTOOL_BOTTOM)));
55627 SWIG_Python_SetConstant(d, "TOOL_LEFT",SWIG_From_int(static_cast< int >(wxTOOL_LEFT)));
55628 SWIG_Python_SetConstant(d, "TOOL_RIGHT",SWIG_From_int(static_cast< int >(wxTOOL_RIGHT)));
55629 SWIG_Python_SetConstant(d, "OK",SWIG_From_int(static_cast< int >(wxOK)));
55630 SWIG_Python_SetConstant(d, "YES_NO",SWIG_From_int(static_cast< int >(wxYES_NO)));
55631 SWIG_Python_SetConstant(d, "CANCEL",SWIG_From_int(static_cast< int >(wxCANCEL)));
55632 SWIG_Python_SetConstant(d, "YES",SWIG_From_int(static_cast< int >(wxYES)));
55633 SWIG_Python_SetConstant(d, "NO",SWIG_From_int(static_cast< int >(wxNO)));
55634 SWIG_Python_SetConstant(d, "NO_DEFAULT",SWIG_From_int(static_cast< int >(wxNO_DEFAULT)));
55635 SWIG_Python_SetConstant(d, "YES_DEFAULT",SWIG_From_int(static_cast< int >(wxYES_DEFAULT)));
55636 SWIG_Python_SetConstant(d, "ICON_EXCLAMATION",SWIG_From_int(static_cast< int >(wxICON_EXCLAMATION)));
55637 SWIG_Python_SetConstant(d, "ICON_HAND",SWIG_From_int(static_cast< int >(wxICON_HAND)));
55638 SWIG_Python_SetConstant(d, "ICON_QUESTION",SWIG_From_int(static_cast< int >(wxICON_QUESTION)));
55639 SWIG_Python_SetConstant(d, "ICON_INFORMATION",SWIG_From_int(static_cast< int >(wxICON_INFORMATION)));
55640 SWIG_Python_SetConstant(d, "ICON_STOP",SWIG_From_int(static_cast< int >(wxICON_STOP)));
55641 SWIG_Python_SetConstant(d, "ICON_ASTERISK",SWIG_From_int(static_cast< int >(wxICON_ASTERISK)));
55642 SWIG_Python_SetConstant(d, "ICON_MASK",SWIG_From_int(static_cast< int >(wxICON_MASK)));
55643 SWIG_Python_SetConstant(d, "ICON_WARNING",SWIG_From_int(static_cast< int >(wxICON_WARNING)));
55644 SWIG_Python_SetConstant(d, "ICON_ERROR",SWIG_From_int(static_cast< int >(wxICON_ERROR)));
55645 SWIG_Python_SetConstant(d, "FORWARD",SWIG_From_int(static_cast< int >(wxFORWARD)));
55646 SWIG_Python_SetConstant(d, "BACKWARD",SWIG_From_int(static_cast< int >(wxBACKWARD)));
55647 SWIG_Python_SetConstant(d, "RESET",SWIG_From_int(static_cast< int >(wxRESET)));
55648 SWIG_Python_SetConstant(d, "HELP",SWIG_From_int(static_cast< int >(wxHELP)));
55649 SWIG_Python_SetConstant(d, "MORE",SWIG_From_int(static_cast< int >(wxMORE)));
55650 SWIG_Python_SetConstant(d, "SETUP",SWIG_From_int(static_cast< int >(wxSETUP)));
55651 SWIG_Python_SetConstant(d, "SIZE_AUTO_WIDTH",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_WIDTH)));
55652 SWIG_Python_SetConstant(d, "SIZE_AUTO_HEIGHT",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_HEIGHT)));
55653 SWIG_Python_SetConstant(d, "SIZE_AUTO",SWIG_From_int(static_cast< int >(wxSIZE_AUTO)));
55654 SWIG_Python_SetConstant(d, "SIZE_USE_EXISTING",SWIG_From_int(static_cast< int >(wxSIZE_USE_EXISTING)));
55655 SWIG_Python_SetConstant(d, "SIZE_ALLOW_MINUS_ONE",SWIG_From_int(static_cast< int >(wxSIZE_ALLOW_MINUS_ONE)));
55656 SWIG_Python_SetConstant(d, "SIZE_FORCE",SWIG_From_int(static_cast< int >(wxSIZE_FORCE)));
55657 SWIG_Python_SetConstant(d, "PORTRAIT",SWIG_From_int(static_cast< int >(wxPORTRAIT)));
55658 SWIG_Python_SetConstant(d, "LANDSCAPE",SWIG_From_int(static_cast< int >(wxLANDSCAPE)));
55659 SWIG_Python_SetConstant(d, "PRINT_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_HIGH)));
55660 SWIG_Python_SetConstant(d, "PRINT_QUALITY_MEDIUM",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_MEDIUM)));
55661 SWIG_Python_SetConstant(d, "PRINT_QUALITY_LOW",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_LOW)));
55662 SWIG_Python_SetConstant(d, "PRINT_QUALITY_DRAFT",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_DRAFT)));
55663 SWIG_Python_SetConstant(d, "ID_ANY",SWIG_From_int(static_cast< int >(wxID_ANY)));
55664 SWIG_Python_SetConstant(d, "ID_SEPARATOR",SWIG_From_int(static_cast< int >(wxID_SEPARATOR)));
55665 SWIG_Python_SetConstant(d, "ID_NONE",SWIG_From_int(static_cast< int >(wxID_NONE)));
55666 SWIG_Python_SetConstant(d, "ID_LOWEST",SWIG_From_int(static_cast< int >(wxID_LOWEST)));
55667 SWIG_Python_SetConstant(d, "ID_OPEN",SWIG_From_int(static_cast< int >(wxID_OPEN)));
55668 SWIG_Python_SetConstant(d, "ID_CLOSE",SWIG_From_int(static_cast< int >(wxID_CLOSE)));
55669 SWIG_Python_SetConstant(d, "ID_NEW",SWIG_From_int(static_cast< int >(wxID_NEW)));
55670 SWIG_Python_SetConstant(d, "ID_SAVE",SWIG_From_int(static_cast< int >(wxID_SAVE)));
55671 SWIG_Python_SetConstant(d, "ID_SAVEAS",SWIG_From_int(static_cast< int >(wxID_SAVEAS)));
55672 SWIG_Python_SetConstant(d, "ID_REVERT",SWIG_From_int(static_cast< int >(wxID_REVERT)));
55673 SWIG_Python_SetConstant(d, "ID_EXIT",SWIG_From_int(static_cast< int >(wxID_EXIT)));
55674 SWIG_Python_SetConstant(d, "ID_UNDO",SWIG_From_int(static_cast< int >(wxID_UNDO)));
55675 SWIG_Python_SetConstant(d, "ID_REDO",SWIG_From_int(static_cast< int >(wxID_REDO)));
55676 SWIG_Python_SetConstant(d, "ID_HELP",SWIG_From_int(static_cast< int >(wxID_HELP)));
55677 SWIG_Python_SetConstant(d, "ID_PRINT",SWIG_From_int(static_cast< int >(wxID_PRINT)));
55678 SWIG_Python_SetConstant(d, "ID_PRINT_SETUP",SWIG_From_int(static_cast< int >(wxID_PRINT_SETUP)));
55679 SWIG_Python_SetConstant(d, "ID_PREVIEW",SWIG_From_int(static_cast< int >(wxID_PREVIEW)));
55680 SWIG_Python_SetConstant(d, "ID_ABOUT",SWIG_From_int(static_cast< int >(wxID_ABOUT)));
55681 SWIG_Python_SetConstant(d, "ID_HELP_CONTENTS",SWIG_From_int(static_cast< int >(wxID_HELP_CONTENTS)));
55682 SWIG_Python_SetConstant(d, "ID_HELP_COMMANDS",SWIG_From_int(static_cast< int >(wxID_HELP_COMMANDS)));
55683 SWIG_Python_SetConstant(d, "ID_HELP_PROCEDURES",SWIG_From_int(static_cast< int >(wxID_HELP_PROCEDURES)));
55684 SWIG_Python_SetConstant(d, "ID_HELP_CONTEXT",SWIG_From_int(static_cast< int >(wxID_HELP_CONTEXT)));
55685 SWIG_Python_SetConstant(d, "ID_CLOSE_ALL",SWIG_From_int(static_cast< int >(wxID_CLOSE_ALL)));
55686 SWIG_Python_SetConstant(d, "ID_PREFERENCES",SWIG_From_int(static_cast< int >(wxID_PREFERENCES)));
55687 SWIG_Python_SetConstant(d, "ID_CUT",SWIG_From_int(static_cast< int >(wxID_CUT)));
55688 SWIG_Python_SetConstant(d, "ID_COPY",SWIG_From_int(static_cast< int >(wxID_COPY)));
55689 SWIG_Python_SetConstant(d, "ID_PASTE",SWIG_From_int(static_cast< int >(wxID_PASTE)));
55690 SWIG_Python_SetConstant(d, "ID_CLEAR",SWIG_From_int(static_cast< int >(wxID_CLEAR)));
55691 SWIG_Python_SetConstant(d, "ID_FIND",SWIG_From_int(static_cast< int >(wxID_FIND)));
55692 SWIG_Python_SetConstant(d, "ID_DUPLICATE",SWIG_From_int(static_cast< int >(wxID_DUPLICATE)));
55693 SWIG_Python_SetConstant(d, "ID_SELECTALL",SWIG_From_int(static_cast< int >(wxID_SELECTALL)));
55694 SWIG_Python_SetConstant(d, "ID_DELETE",SWIG_From_int(static_cast< int >(wxID_DELETE)));
55695 SWIG_Python_SetConstant(d, "ID_REPLACE",SWIG_From_int(static_cast< int >(wxID_REPLACE)));
55696 SWIG_Python_SetConstant(d, "ID_REPLACE_ALL",SWIG_From_int(static_cast< int >(wxID_REPLACE_ALL)));
55697 SWIG_Python_SetConstant(d, "ID_PROPERTIES",SWIG_From_int(static_cast< int >(wxID_PROPERTIES)));
55698 SWIG_Python_SetConstant(d, "ID_VIEW_DETAILS",SWIG_From_int(static_cast< int >(wxID_VIEW_DETAILS)));
55699 SWIG_Python_SetConstant(d, "ID_VIEW_LARGEICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_LARGEICONS)));
55700 SWIG_Python_SetConstant(d, "ID_VIEW_SMALLICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_SMALLICONS)));
55701 SWIG_Python_SetConstant(d, "ID_VIEW_LIST",SWIG_From_int(static_cast< int >(wxID_VIEW_LIST)));
55702 SWIG_Python_SetConstant(d, "ID_VIEW_SORTDATE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTDATE)));
55703 SWIG_Python_SetConstant(d, "ID_VIEW_SORTNAME",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTNAME)));
55704 SWIG_Python_SetConstant(d, "ID_VIEW_SORTSIZE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTSIZE)));
55705 SWIG_Python_SetConstant(d, "ID_VIEW_SORTTYPE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTTYPE)));
55706 SWIG_Python_SetConstant(d, "ID_FILE1",SWIG_From_int(static_cast< int >(wxID_FILE1)));
55707 SWIG_Python_SetConstant(d, "ID_FILE2",SWIG_From_int(static_cast< int >(wxID_FILE2)));
55708 SWIG_Python_SetConstant(d, "ID_FILE3",SWIG_From_int(static_cast< int >(wxID_FILE3)));
55709 SWIG_Python_SetConstant(d, "ID_FILE4",SWIG_From_int(static_cast< int >(wxID_FILE4)));
55710 SWIG_Python_SetConstant(d, "ID_FILE5",SWIG_From_int(static_cast< int >(wxID_FILE5)));
55711 SWIG_Python_SetConstant(d, "ID_FILE6",SWIG_From_int(static_cast< int >(wxID_FILE6)));
55712 SWIG_Python_SetConstant(d, "ID_FILE7",SWIG_From_int(static_cast< int >(wxID_FILE7)));
55713 SWIG_Python_SetConstant(d, "ID_FILE8",SWIG_From_int(static_cast< int >(wxID_FILE8)));
55714 SWIG_Python_SetConstant(d, "ID_FILE9",SWIG_From_int(static_cast< int >(wxID_FILE9)));
55715 SWIG_Python_SetConstant(d, "ID_OK",SWIG_From_int(static_cast< int >(wxID_OK)));
55716 SWIG_Python_SetConstant(d, "ID_CANCEL",SWIG_From_int(static_cast< int >(wxID_CANCEL)));
55717 SWIG_Python_SetConstant(d, "ID_APPLY",SWIG_From_int(static_cast< int >(wxID_APPLY)));
55718 SWIG_Python_SetConstant(d, "ID_YES",SWIG_From_int(static_cast< int >(wxID_YES)));
55719 SWIG_Python_SetConstant(d, "ID_NO",SWIG_From_int(static_cast< int >(wxID_NO)));
55720 SWIG_Python_SetConstant(d, "ID_STATIC",SWIG_From_int(static_cast< int >(wxID_STATIC)));
55721 SWIG_Python_SetConstant(d, "ID_FORWARD",SWIG_From_int(static_cast< int >(wxID_FORWARD)));
55722 SWIG_Python_SetConstant(d, "ID_BACKWARD",SWIG_From_int(static_cast< int >(wxID_BACKWARD)));
55723 SWIG_Python_SetConstant(d, "ID_DEFAULT",SWIG_From_int(static_cast< int >(wxID_DEFAULT)));
55724 SWIG_Python_SetConstant(d, "ID_MORE",SWIG_From_int(static_cast< int >(wxID_MORE)));
55725 SWIG_Python_SetConstant(d, "ID_SETUP",SWIG_From_int(static_cast< int >(wxID_SETUP)));
55726 SWIG_Python_SetConstant(d, "ID_RESET",SWIG_From_int(static_cast< int >(wxID_RESET)));
55727 SWIG_Python_SetConstant(d, "ID_CONTEXT_HELP",SWIG_From_int(static_cast< int >(wxID_CONTEXT_HELP)));
55728 SWIG_Python_SetConstant(d, "ID_YESTOALL",SWIG_From_int(static_cast< int >(wxID_YESTOALL)));
55729 SWIG_Python_SetConstant(d, "ID_NOTOALL",SWIG_From_int(static_cast< int >(wxID_NOTOALL)));
55730 SWIG_Python_SetConstant(d, "ID_ABORT",SWIG_From_int(static_cast< int >(wxID_ABORT)));
55731 SWIG_Python_SetConstant(d, "ID_RETRY",SWIG_From_int(static_cast< int >(wxID_RETRY)));
55732 SWIG_Python_SetConstant(d, "ID_IGNORE",SWIG_From_int(static_cast< int >(wxID_IGNORE)));
55733 SWIG_Python_SetConstant(d, "ID_ADD",SWIG_From_int(static_cast< int >(wxID_ADD)));
55734 SWIG_Python_SetConstant(d, "ID_REMOVE",SWIG_From_int(static_cast< int >(wxID_REMOVE)));
55735 SWIG_Python_SetConstant(d, "ID_UP",SWIG_From_int(static_cast< int >(wxID_UP)));
55736 SWIG_Python_SetConstant(d, "ID_DOWN",SWIG_From_int(static_cast< int >(wxID_DOWN)));
55737 SWIG_Python_SetConstant(d, "ID_HOME",SWIG_From_int(static_cast< int >(wxID_HOME)));
55738 SWIG_Python_SetConstant(d, "ID_REFRESH",SWIG_From_int(static_cast< int >(wxID_REFRESH)));
55739 SWIG_Python_SetConstant(d, "ID_STOP",SWIG_From_int(static_cast< int >(wxID_STOP)));
55740 SWIG_Python_SetConstant(d, "ID_INDEX",SWIG_From_int(static_cast< int >(wxID_INDEX)));
55741 SWIG_Python_SetConstant(d, "ID_BOLD",SWIG_From_int(static_cast< int >(wxID_BOLD)));
55742 SWIG_Python_SetConstant(d, "ID_ITALIC",SWIG_From_int(static_cast< int >(wxID_ITALIC)));
55743 SWIG_Python_SetConstant(d, "ID_JUSTIFY_CENTER",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_CENTER)));
55744 SWIG_Python_SetConstant(d, "ID_JUSTIFY_FILL",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_FILL)));
55745 SWIG_Python_SetConstant(d, "ID_JUSTIFY_RIGHT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_RIGHT)));
55746 SWIG_Python_SetConstant(d, "ID_JUSTIFY_LEFT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_LEFT)));
55747 SWIG_Python_SetConstant(d, "ID_UNDERLINE",SWIG_From_int(static_cast< int >(wxID_UNDERLINE)));
55748 SWIG_Python_SetConstant(d, "ID_INDENT",SWIG_From_int(static_cast< int >(wxID_INDENT)));
55749 SWIG_Python_SetConstant(d, "ID_UNINDENT",SWIG_From_int(static_cast< int >(wxID_UNINDENT)));
55750 SWIG_Python_SetConstant(d, "ID_ZOOM_100",SWIG_From_int(static_cast< int >(wxID_ZOOM_100)));
55751 SWIG_Python_SetConstant(d, "ID_ZOOM_FIT",SWIG_From_int(static_cast< int >(wxID_ZOOM_FIT)));
55752 SWIG_Python_SetConstant(d, "ID_ZOOM_IN",SWIG_From_int(static_cast< int >(wxID_ZOOM_IN)));
55753 SWIG_Python_SetConstant(d, "ID_ZOOM_OUT",SWIG_From_int(static_cast< int >(wxID_ZOOM_OUT)));
55754 SWIG_Python_SetConstant(d, "ID_UNDELETE",SWIG_From_int(static_cast< int >(wxID_UNDELETE)));
55755 SWIG_Python_SetConstant(d, "ID_REVERT_TO_SAVED",SWIG_From_int(static_cast< int >(wxID_REVERT_TO_SAVED)));
55756 SWIG_Python_SetConstant(d, "ID_HIGHEST",SWIG_From_int(static_cast< int >(wxID_HIGHEST)));
55757 SWIG_Python_SetConstant(d, "OPEN",SWIG_From_int(static_cast< int >(wxOPEN)));
55758 SWIG_Python_SetConstant(d, "SAVE",SWIG_From_int(static_cast< int >(wxSAVE)));
55759 SWIG_Python_SetConstant(d, "HIDE_READONLY",SWIG_From_int(static_cast< int >(wxHIDE_READONLY)));
55760 SWIG_Python_SetConstant(d, "OVERWRITE_PROMPT",SWIG_From_int(static_cast< int >(wxOVERWRITE_PROMPT)));
55761 SWIG_Python_SetConstant(d, "FILE_MUST_EXIST",SWIG_From_int(static_cast< int >(wxFILE_MUST_EXIST)));
55762 SWIG_Python_SetConstant(d, "MULTIPLE",SWIG_From_int(static_cast< int >(wxMULTIPLE)));
55763 SWIG_Python_SetConstant(d, "CHANGE_DIR",SWIG_From_int(static_cast< int >(wxCHANGE_DIR)));
55764 SWIG_Python_SetConstant(d, "ACCEL_ALT",SWIG_From_int(static_cast< int >(wxACCEL_ALT)));
55765 SWIG_Python_SetConstant(d, "ACCEL_CTRL",SWIG_From_int(static_cast< int >(wxACCEL_CTRL)));
55766 SWIG_Python_SetConstant(d, "ACCEL_SHIFT",SWIG_From_int(static_cast< int >(wxACCEL_SHIFT)));
55767 SWIG_Python_SetConstant(d, "ACCEL_NORMAL",SWIG_From_int(static_cast< int >(wxACCEL_NORMAL)));
55768 SWIG_Python_SetConstant(d, "PD_AUTO_HIDE",SWIG_From_int(static_cast< int >(wxPD_AUTO_HIDE)));
55769 SWIG_Python_SetConstant(d, "PD_APP_MODAL",SWIG_From_int(static_cast< int >(wxPD_APP_MODAL)));
55770 SWIG_Python_SetConstant(d, "PD_CAN_ABORT",SWIG_From_int(static_cast< int >(wxPD_CAN_ABORT)));
55771 SWIG_Python_SetConstant(d, "PD_ELAPSED_TIME",SWIG_From_int(static_cast< int >(wxPD_ELAPSED_TIME)));
55772 SWIG_Python_SetConstant(d, "PD_ESTIMATED_TIME",SWIG_From_int(static_cast< int >(wxPD_ESTIMATED_TIME)));
55773 SWIG_Python_SetConstant(d, "PD_REMAINING_TIME",SWIG_From_int(static_cast< int >(wxPD_REMAINING_TIME)));
55774 SWIG_Python_SetConstant(d, "PD_SMOOTH",SWIG_From_int(static_cast< int >(wxPD_SMOOTH)));
55775 SWIG_Python_SetConstant(d, "PD_CAN_SKIP",SWIG_From_int(static_cast< int >(wxPD_CAN_SKIP)));
55776 SWIG_Python_SetConstant(d, "DD_NEW_DIR_BUTTON",SWIG_From_int(static_cast< int >(wxDD_NEW_DIR_BUTTON)));
55777 SWIG_Python_SetConstant(d, "DD_DEFAULT_STYLE",SWIG_From_int(static_cast< int >(wxDD_DEFAULT_STYLE)));
55778 SWIG_Python_SetConstant(d, "DD_CHANGE_DIR",SWIG_From_int(static_cast< int >(wxDD_CHANGE_DIR)));
55779 SWIG_Python_SetConstant(d, "MENU_TEAROFF",SWIG_From_int(static_cast< int >(wxMENU_TEAROFF)));
55780 SWIG_Python_SetConstant(d, "MB_DOCKABLE",SWIG_From_int(static_cast< int >(wxMB_DOCKABLE)));
55781 SWIG_Python_SetConstant(d, "NO_FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxNO_FULL_REPAINT_ON_RESIZE)));
55782 SWIG_Python_SetConstant(d, "FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxFULL_REPAINT_ON_RESIZE)));
55783 SWIG_Python_SetConstant(d, "LI_HORIZONTAL",SWIG_From_int(static_cast< int >(wxLI_HORIZONTAL)));
55784 SWIG_Python_SetConstant(d, "LI_VERTICAL",SWIG_From_int(static_cast< int >(wxLI_VERTICAL)));
55785 SWIG_Python_SetConstant(d, "WS_EX_VALIDATE_RECURSIVELY",SWIG_From_int(static_cast< int >(wxWS_EX_VALIDATE_RECURSIVELY)));
55786 SWIG_Python_SetConstant(d, "WS_EX_BLOCK_EVENTS",SWIG_From_int(static_cast< int >(wxWS_EX_BLOCK_EVENTS)));
55787 SWIG_Python_SetConstant(d, "WS_EX_TRANSIENT",SWIG_From_int(static_cast< int >(wxWS_EX_TRANSIENT)));
55788 SWIG_Python_SetConstant(d, "WS_EX_THEMED_BACKGROUND",SWIG_From_int(static_cast< int >(wxWS_EX_THEMED_BACKGROUND)));
55789 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_IDLE",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_IDLE)));
55790 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_UI_UPDATES",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_UI_UPDATES)));
55791 SWIG_Python_SetConstant(d, "MM_TEXT",SWIG_From_int(static_cast< int >(wxMM_TEXT)));
55792 SWIG_Python_SetConstant(d, "MM_LOMETRIC",SWIG_From_int(static_cast< int >(wxMM_LOMETRIC)));
55793 SWIG_Python_SetConstant(d, "MM_HIMETRIC",SWIG_From_int(static_cast< int >(wxMM_HIMETRIC)));
55794 SWIG_Python_SetConstant(d, "MM_LOENGLISH",SWIG_From_int(static_cast< int >(wxMM_LOENGLISH)));
55795 SWIG_Python_SetConstant(d, "MM_HIENGLISH",SWIG_From_int(static_cast< int >(wxMM_HIENGLISH)));
55796 SWIG_Python_SetConstant(d, "MM_TWIPS",SWIG_From_int(static_cast< int >(wxMM_TWIPS)));
55797 SWIG_Python_SetConstant(d, "MM_ISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ISOTROPIC)));
55798 SWIG_Python_SetConstant(d, "MM_ANISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ANISOTROPIC)));
55799 SWIG_Python_SetConstant(d, "MM_POINTS",SWIG_From_int(static_cast< int >(wxMM_POINTS)));
55800 SWIG_Python_SetConstant(d, "MM_METRIC",SWIG_From_int(static_cast< int >(wxMM_METRIC)));
55801 SWIG_Python_SetConstant(d, "CENTRE",SWIG_From_int(static_cast< int >(wxCENTRE)));
55802 SWIG_Python_SetConstant(d, "CENTER",SWIG_From_int(static_cast< int >(wxCENTER)));
55803 SWIG_Python_SetConstant(d, "HORIZONTAL",SWIG_From_int(static_cast< int >(wxHORIZONTAL)));
55804 SWIG_Python_SetConstant(d, "VERTICAL",SWIG_From_int(static_cast< int >(wxVERTICAL)));
55805 SWIG_Python_SetConstant(d, "BOTH",SWIG_From_int(static_cast< int >(wxBOTH)));
55806 SWIG_Python_SetConstant(d, "LEFT",SWIG_From_int(static_cast< int >(wxLEFT)));
55807 SWIG_Python_SetConstant(d, "RIGHT",SWIG_From_int(static_cast< int >(wxRIGHT)));
55808 SWIG_Python_SetConstant(d, "UP",SWIG_From_int(static_cast< int >(wxUP)));
55809 SWIG_Python_SetConstant(d, "DOWN",SWIG_From_int(static_cast< int >(wxDOWN)));
55810 SWIG_Python_SetConstant(d, "TOP",SWIG_From_int(static_cast< int >(wxTOP)));
55811 SWIG_Python_SetConstant(d, "BOTTOM",SWIG_From_int(static_cast< int >(wxBOTTOM)));
55812 SWIG_Python_SetConstant(d, "NORTH",SWIG_From_int(static_cast< int >(wxNORTH)));
55813 SWIG_Python_SetConstant(d, "SOUTH",SWIG_From_int(static_cast< int >(wxSOUTH)));
55814 SWIG_Python_SetConstant(d, "WEST",SWIG_From_int(static_cast< int >(wxWEST)));
55815 SWIG_Python_SetConstant(d, "EAST",SWIG_From_int(static_cast< int >(wxEAST)));
55816 SWIG_Python_SetConstant(d, "ALL",SWIG_From_int(static_cast< int >(wxALL)));
55817 SWIG_Python_SetConstant(d, "ALIGN_NOT",SWIG_From_int(static_cast< int >(wxALIGN_NOT)));
55818 SWIG_Python_SetConstant(d, "ALIGN_CENTER_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_HORIZONTAL)));
55819 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_HORIZONTAL)));
55820 SWIG_Python_SetConstant(d, "ALIGN_LEFT",SWIG_From_int(static_cast< int >(wxALIGN_LEFT)));
55821 SWIG_Python_SetConstant(d, "ALIGN_TOP",SWIG_From_int(static_cast< int >(wxALIGN_TOP)));
55822 SWIG_Python_SetConstant(d, "ALIGN_RIGHT",SWIG_From_int(static_cast< int >(wxALIGN_RIGHT)));
55823 SWIG_Python_SetConstant(d, "ALIGN_BOTTOM",SWIG_From_int(static_cast< int >(wxALIGN_BOTTOM)));
55824 SWIG_Python_SetConstant(d, "ALIGN_CENTER_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_VERTICAL)));
55825 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_VERTICAL)));
55826 SWIG_Python_SetConstant(d, "ALIGN_CENTER",SWIG_From_int(static_cast< int >(wxALIGN_CENTER)));
55827 SWIG_Python_SetConstant(d, "ALIGN_CENTRE",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE)));
55828 SWIG_Python_SetConstant(d, "ALIGN_MASK",SWIG_From_int(static_cast< int >(wxALIGN_MASK)));
55829 SWIG_Python_SetConstant(d, "STRETCH_NOT",SWIG_From_int(static_cast< int >(wxSTRETCH_NOT)));
55830 SWIG_Python_SetConstant(d, "SHRINK",SWIG_From_int(static_cast< int >(wxSHRINK)));
55831 SWIG_Python_SetConstant(d, "GROW",SWIG_From_int(static_cast< int >(wxGROW)));
55832 SWIG_Python_SetConstant(d, "EXPAND",SWIG_From_int(static_cast< int >(wxEXPAND)));
55833 SWIG_Python_SetConstant(d, "SHAPED",SWIG_From_int(static_cast< int >(wxSHAPED)));
55834 SWIG_Python_SetConstant(d, "FIXED_MINSIZE",SWIG_From_int(static_cast< int >(wxFIXED_MINSIZE)));
55835 SWIG_Python_SetConstant(d, "TILE",SWIG_From_int(static_cast< int >(wxTILE)));
55836 SWIG_Python_SetConstant(d, "ADJUST_MINSIZE",SWIG_From_int(static_cast< int >(wxADJUST_MINSIZE)));
55837 SWIG_Python_SetConstant(d, "BORDER_DEFAULT",SWIG_From_int(static_cast< int >(wxBORDER_DEFAULT)));
55838 SWIG_Python_SetConstant(d, "BORDER_NONE",SWIG_From_int(static_cast< int >(wxBORDER_NONE)));
55839 SWIG_Python_SetConstant(d, "BORDER_STATIC",SWIG_From_int(static_cast< int >(wxBORDER_STATIC)));
55840 SWIG_Python_SetConstant(d, "BORDER_SIMPLE",SWIG_From_int(static_cast< int >(wxBORDER_SIMPLE)));
55841 SWIG_Python_SetConstant(d, "BORDER_RAISED",SWIG_From_int(static_cast< int >(wxBORDER_RAISED)));
55842 SWIG_Python_SetConstant(d, "BORDER_SUNKEN",SWIG_From_int(static_cast< int >(wxBORDER_SUNKEN)));
55843 SWIG_Python_SetConstant(d, "BORDER_DOUBLE",SWIG_From_int(static_cast< int >(wxBORDER_DOUBLE)));
55844 SWIG_Python_SetConstant(d, "BORDER_MASK",SWIG_From_int(static_cast< int >(wxBORDER_MASK)));
55845 SWIG_Python_SetConstant(d, "BG_STYLE_SYSTEM",SWIG_From_int(static_cast< int >(wxBG_STYLE_SYSTEM)));
55846 SWIG_Python_SetConstant(d, "BG_STYLE_COLOUR",SWIG_From_int(static_cast< int >(wxBG_STYLE_COLOUR)));
55847 SWIG_Python_SetConstant(d, "BG_STYLE_CUSTOM",SWIG_From_int(static_cast< int >(wxBG_STYLE_CUSTOM)));
55848 SWIG_Python_SetConstant(d, "DEFAULT",SWIG_From_int(static_cast< int >(wxDEFAULT)));
55849 SWIG_Python_SetConstant(d, "DECORATIVE",SWIG_From_int(static_cast< int >(wxDECORATIVE)));
55850 SWIG_Python_SetConstant(d, "ROMAN",SWIG_From_int(static_cast< int >(wxROMAN)));
55851 SWIG_Python_SetConstant(d, "SCRIPT",SWIG_From_int(static_cast< int >(wxSCRIPT)));
55852 SWIG_Python_SetConstant(d, "SWISS",SWIG_From_int(static_cast< int >(wxSWISS)));
55853 SWIG_Python_SetConstant(d, "MODERN",SWIG_From_int(static_cast< int >(wxMODERN)));
55854 SWIG_Python_SetConstant(d, "TELETYPE",SWIG_From_int(static_cast< int >(wxTELETYPE)));
55855 SWIG_Python_SetConstant(d, "VARIABLE",SWIG_From_int(static_cast< int >(wxVARIABLE)));
55856 SWIG_Python_SetConstant(d, "FIXED",SWIG_From_int(static_cast< int >(wxFIXED)));
55857 SWIG_Python_SetConstant(d, "NORMAL",SWIG_From_int(static_cast< int >(wxNORMAL)));
55858 SWIG_Python_SetConstant(d, "LIGHT",SWIG_From_int(static_cast< int >(wxLIGHT)));
55859 SWIG_Python_SetConstant(d, "BOLD",SWIG_From_int(static_cast< int >(wxBOLD)));
55860 SWIG_Python_SetConstant(d, "ITALIC",SWIG_From_int(static_cast< int >(wxITALIC)));
55861 SWIG_Python_SetConstant(d, "SLANT",SWIG_From_int(static_cast< int >(wxSLANT)));
55862 SWIG_Python_SetConstant(d, "SOLID",SWIG_From_int(static_cast< int >(wxSOLID)));
55863 SWIG_Python_SetConstant(d, "DOT",SWIG_From_int(static_cast< int >(wxDOT)));
55864 SWIG_Python_SetConstant(d, "LONG_DASH",SWIG_From_int(static_cast< int >(wxLONG_DASH)));
55865 SWIG_Python_SetConstant(d, "SHORT_DASH",SWIG_From_int(static_cast< int >(wxSHORT_DASH)));
55866 SWIG_Python_SetConstant(d, "DOT_DASH",SWIG_From_int(static_cast< int >(wxDOT_DASH)));
55867 SWIG_Python_SetConstant(d, "USER_DASH",SWIG_From_int(static_cast< int >(wxUSER_DASH)));
55868 SWIG_Python_SetConstant(d, "TRANSPARENT",SWIG_From_int(static_cast< int >(wxTRANSPARENT)));
55869 SWIG_Python_SetConstant(d, "STIPPLE",SWIG_From_int(static_cast< int >(wxSTIPPLE)));
55870 SWIG_Python_SetConstant(d, "STIPPLE_MASK",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK)));
55871 SWIG_Python_SetConstant(d, "STIPPLE_MASK_OPAQUE",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK_OPAQUE)));
55872 SWIG_Python_SetConstant(d, "BDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxBDIAGONAL_HATCH)));
55873 SWIG_Python_SetConstant(d, "CROSSDIAG_HATCH",SWIG_From_int(static_cast< int >(wxCROSSDIAG_HATCH)));
55874 SWIG_Python_SetConstant(d, "FDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxFDIAGONAL_HATCH)));
55875 SWIG_Python_SetConstant(d, "CROSS_HATCH",SWIG_From_int(static_cast< int >(wxCROSS_HATCH)));
55876 SWIG_Python_SetConstant(d, "HORIZONTAL_HATCH",SWIG_From_int(static_cast< int >(wxHORIZONTAL_HATCH)));
55877 SWIG_Python_SetConstant(d, "VERTICAL_HATCH",SWIG_From_int(static_cast< int >(wxVERTICAL_HATCH)));
55878 SWIG_Python_SetConstant(d, "JOIN_BEVEL",SWIG_From_int(static_cast< int >(wxJOIN_BEVEL)));
55879 SWIG_Python_SetConstant(d, "JOIN_MITER",SWIG_From_int(static_cast< int >(wxJOIN_MITER)));
55880 SWIG_Python_SetConstant(d, "JOIN_ROUND",SWIG_From_int(static_cast< int >(wxJOIN_ROUND)));
55881 SWIG_Python_SetConstant(d, "CAP_ROUND",SWIG_From_int(static_cast< int >(wxCAP_ROUND)));
55882 SWIG_Python_SetConstant(d, "CAP_PROJECTING",SWIG_From_int(static_cast< int >(wxCAP_PROJECTING)));
55883 SWIG_Python_SetConstant(d, "CAP_BUTT",SWIG_From_int(static_cast< int >(wxCAP_BUTT)));
55884 SWIG_Python_SetConstant(d, "CLEAR",SWIG_From_int(static_cast< int >(wxCLEAR)));
55885 SWIG_Python_SetConstant(d, "XOR",SWIG_From_int(static_cast< int >(wxXOR)));
55886 SWIG_Python_SetConstant(d, "INVERT",SWIG_From_int(static_cast< int >(wxINVERT)));
55887 SWIG_Python_SetConstant(d, "OR_REVERSE",SWIG_From_int(static_cast< int >(wxOR_REVERSE)));
55888 SWIG_Python_SetConstant(d, "AND_REVERSE",SWIG_From_int(static_cast< int >(wxAND_REVERSE)));
55889 SWIG_Python_SetConstant(d, "COPY",SWIG_From_int(static_cast< int >(wxCOPY)));
55890 SWIG_Python_SetConstant(d, "AND",SWIG_From_int(static_cast< int >(wxAND)));
55891 SWIG_Python_SetConstant(d, "AND_INVERT",SWIG_From_int(static_cast< int >(wxAND_INVERT)));
55892 SWIG_Python_SetConstant(d, "NO_OP",SWIG_From_int(static_cast< int >(wxNO_OP)));
55893 SWIG_Python_SetConstant(d, "NOR",SWIG_From_int(static_cast< int >(wxNOR)));
55894 SWIG_Python_SetConstant(d, "EQUIV",SWIG_From_int(static_cast< int >(wxEQUIV)));
55895 SWIG_Python_SetConstant(d, "SRC_INVERT",SWIG_From_int(static_cast< int >(wxSRC_INVERT)));
55896 SWIG_Python_SetConstant(d, "OR_INVERT",SWIG_From_int(static_cast< int >(wxOR_INVERT)));
55897 SWIG_Python_SetConstant(d, "NAND",SWIG_From_int(static_cast< int >(wxNAND)));
55898 SWIG_Python_SetConstant(d, "OR",SWIG_From_int(static_cast< int >(wxOR)));
55899 SWIG_Python_SetConstant(d, "SET",SWIG_From_int(static_cast< int >(wxSET)));
55900 SWIG_Python_SetConstant(d, "WXK_BACK",SWIG_From_int(static_cast< int >(WXK_BACK)));
55901 SWIG_Python_SetConstant(d, "WXK_TAB",SWIG_From_int(static_cast< int >(WXK_TAB)));
55902 SWIG_Python_SetConstant(d, "WXK_RETURN",SWIG_From_int(static_cast< int >(WXK_RETURN)));
55903 SWIG_Python_SetConstant(d, "WXK_ESCAPE",SWIG_From_int(static_cast< int >(WXK_ESCAPE)));
55904 SWIG_Python_SetConstant(d, "WXK_SPACE",SWIG_From_int(static_cast< int >(WXK_SPACE)));
55905 SWIG_Python_SetConstant(d, "WXK_DELETE",SWIG_From_int(static_cast< int >(WXK_DELETE)));
55906 SWIG_Python_SetConstant(d, "WXK_START",SWIG_From_int(static_cast< int >(WXK_START)));
55907 SWIG_Python_SetConstant(d, "WXK_LBUTTON",SWIG_From_int(static_cast< int >(WXK_LBUTTON)));
55908 SWIG_Python_SetConstant(d, "WXK_RBUTTON",SWIG_From_int(static_cast< int >(WXK_RBUTTON)));
55909 SWIG_Python_SetConstant(d, "WXK_CANCEL",SWIG_From_int(static_cast< int >(WXK_CANCEL)));
55910 SWIG_Python_SetConstant(d, "WXK_MBUTTON",SWIG_From_int(static_cast< int >(WXK_MBUTTON)));
55911 SWIG_Python_SetConstant(d, "WXK_CLEAR",SWIG_From_int(static_cast< int >(WXK_CLEAR)));
55912 SWIG_Python_SetConstant(d, "WXK_SHIFT",SWIG_From_int(static_cast< int >(WXK_SHIFT)));
55913 SWIG_Python_SetConstant(d, "WXK_ALT",SWIG_From_int(static_cast< int >(WXK_ALT)));
55914 SWIG_Python_SetConstant(d, "WXK_CONTROL",SWIG_From_int(static_cast< int >(WXK_CONTROL)));
55915 SWIG_Python_SetConstant(d, "WXK_MENU",SWIG_From_int(static_cast< int >(WXK_MENU)));
55916 SWIG_Python_SetConstant(d, "WXK_PAUSE",SWIG_From_int(static_cast< int >(WXK_PAUSE)));
55917 SWIG_Python_SetConstant(d, "WXK_CAPITAL",SWIG_From_int(static_cast< int >(WXK_CAPITAL)));
55918 SWIG_Python_SetConstant(d, "WXK_PRIOR",SWIG_From_int(static_cast< int >(WXK_PRIOR)));
55919 SWIG_Python_SetConstant(d, "WXK_NEXT",SWIG_From_int(static_cast< int >(WXK_NEXT)));
55920 SWIG_Python_SetConstant(d, "WXK_END",SWIG_From_int(static_cast< int >(WXK_END)));
55921 SWIG_Python_SetConstant(d, "WXK_HOME",SWIG_From_int(static_cast< int >(WXK_HOME)));
55922 SWIG_Python_SetConstant(d, "WXK_LEFT",SWIG_From_int(static_cast< int >(WXK_LEFT)));
55923 SWIG_Python_SetConstant(d, "WXK_UP",SWIG_From_int(static_cast< int >(WXK_UP)));
55924 SWIG_Python_SetConstant(d, "WXK_RIGHT",SWIG_From_int(static_cast< int >(WXK_RIGHT)));
55925 SWIG_Python_SetConstant(d, "WXK_DOWN",SWIG_From_int(static_cast< int >(WXK_DOWN)));
55926 SWIG_Python_SetConstant(d, "WXK_SELECT",SWIG_From_int(static_cast< int >(WXK_SELECT)));
55927 SWIG_Python_SetConstant(d, "WXK_PRINT",SWIG_From_int(static_cast< int >(WXK_PRINT)));
55928 SWIG_Python_SetConstant(d, "WXK_EXECUTE",SWIG_From_int(static_cast< int >(WXK_EXECUTE)));
55929 SWIG_Python_SetConstant(d, "WXK_SNAPSHOT",SWIG_From_int(static_cast< int >(WXK_SNAPSHOT)));
55930 SWIG_Python_SetConstant(d, "WXK_INSERT",SWIG_From_int(static_cast< int >(WXK_INSERT)));
55931 SWIG_Python_SetConstant(d, "WXK_HELP",SWIG_From_int(static_cast< int >(WXK_HELP)));
55932 SWIG_Python_SetConstant(d, "WXK_NUMPAD0",SWIG_From_int(static_cast< int >(WXK_NUMPAD0)));
55933 SWIG_Python_SetConstant(d, "WXK_NUMPAD1",SWIG_From_int(static_cast< int >(WXK_NUMPAD1)));
55934 SWIG_Python_SetConstant(d, "WXK_NUMPAD2",SWIG_From_int(static_cast< int >(WXK_NUMPAD2)));
55935 SWIG_Python_SetConstant(d, "WXK_NUMPAD3",SWIG_From_int(static_cast< int >(WXK_NUMPAD3)));
55936 SWIG_Python_SetConstant(d, "WXK_NUMPAD4",SWIG_From_int(static_cast< int >(WXK_NUMPAD4)));
55937 SWIG_Python_SetConstant(d, "WXK_NUMPAD5",SWIG_From_int(static_cast< int >(WXK_NUMPAD5)));
55938 SWIG_Python_SetConstant(d, "WXK_NUMPAD6",SWIG_From_int(static_cast< int >(WXK_NUMPAD6)));
55939 SWIG_Python_SetConstant(d, "WXK_NUMPAD7",SWIG_From_int(static_cast< int >(WXK_NUMPAD7)));
55940 SWIG_Python_SetConstant(d, "WXK_NUMPAD8",SWIG_From_int(static_cast< int >(WXK_NUMPAD8)));
55941 SWIG_Python_SetConstant(d, "WXK_NUMPAD9",SWIG_From_int(static_cast< int >(WXK_NUMPAD9)));
55942 SWIG_Python_SetConstant(d, "WXK_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_MULTIPLY)));
55943 SWIG_Python_SetConstant(d, "WXK_ADD",SWIG_From_int(static_cast< int >(WXK_ADD)));
55944 SWIG_Python_SetConstant(d, "WXK_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_SEPARATOR)));
55945 SWIG_Python_SetConstant(d, "WXK_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_SUBTRACT)));
55946 SWIG_Python_SetConstant(d, "WXK_DECIMAL",SWIG_From_int(static_cast< int >(WXK_DECIMAL)));
55947 SWIG_Python_SetConstant(d, "WXK_DIVIDE",SWIG_From_int(static_cast< int >(WXK_DIVIDE)));
55948 SWIG_Python_SetConstant(d, "WXK_F1",SWIG_From_int(static_cast< int >(WXK_F1)));
55949 SWIG_Python_SetConstant(d, "WXK_F2",SWIG_From_int(static_cast< int >(WXK_F2)));
55950 SWIG_Python_SetConstant(d, "WXK_F3",SWIG_From_int(static_cast< int >(WXK_F3)));
55951 SWIG_Python_SetConstant(d, "WXK_F4",SWIG_From_int(static_cast< int >(WXK_F4)));
55952 SWIG_Python_SetConstant(d, "WXK_F5",SWIG_From_int(static_cast< int >(WXK_F5)));
55953 SWIG_Python_SetConstant(d, "WXK_F6",SWIG_From_int(static_cast< int >(WXK_F6)));
55954 SWIG_Python_SetConstant(d, "WXK_F7",SWIG_From_int(static_cast< int >(WXK_F7)));
55955 SWIG_Python_SetConstant(d, "WXK_F8",SWIG_From_int(static_cast< int >(WXK_F8)));
55956 SWIG_Python_SetConstant(d, "WXK_F9",SWIG_From_int(static_cast< int >(WXK_F9)));
55957 SWIG_Python_SetConstant(d, "WXK_F10",SWIG_From_int(static_cast< int >(WXK_F10)));
55958 SWIG_Python_SetConstant(d, "WXK_F11",SWIG_From_int(static_cast< int >(WXK_F11)));
55959 SWIG_Python_SetConstant(d, "WXK_F12",SWIG_From_int(static_cast< int >(WXK_F12)));
55960 SWIG_Python_SetConstant(d, "WXK_F13",SWIG_From_int(static_cast< int >(WXK_F13)));
55961 SWIG_Python_SetConstant(d, "WXK_F14",SWIG_From_int(static_cast< int >(WXK_F14)));
55962 SWIG_Python_SetConstant(d, "WXK_F15",SWIG_From_int(static_cast< int >(WXK_F15)));
55963 SWIG_Python_SetConstant(d, "WXK_F16",SWIG_From_int(static_cast< int >(WXK_F16)));
55964 SWIG_Python_SetConstant(d, "WXK_F17",SWIG_From_int(static_cast< int >(WXK_F17)));
55965 SWIG_Python_SetConstant(d, "WXK_F18",SWIG_From_int(static_cast< int >(WXK_F18)));
55966 SWIG_Python_SetConstant(d, "WXK_F19",SWIG_From_int(static_cast< int >(WXK_F19)));
55967 SWIG_Python_SetConstant(d, "WXK_F20",SWIG_From_int(static_cast< int >(WXK_F20)));
55968 SWIG_Python_SetConstant(d, "WXK_F21",SWIG_From_int(static_cast< int >(WXK_F21)));
55969 SWIG_Python_SetConstant(d, "WXK_F22",SWIG_From_int(static_cast< int >(WXK_F22)));
55970 SWIG_Python_SetConstant(d, "WXK_F23",SWIG_From_int(static_cast< int >(WXK_F23)));
55971 SWIG_Python_SetConstant(d, "WXK_F24",SWIG_From_int(static_cast< int >(WXK_F24)));
55972 SWIG_Python_SetConstant(d, "WXK_NUMLOCK",SWIG_From_int(static_cast< int >(WXK_NUMLOCK)));
55973 SWIG_Python_SetConstant(d, "WXK_SCROLL",SWIG_From_int(static_cast< int >(WXK_SCROLL)));
55974 SWIG_Python_SetConstant(d, "WXK_PAGEUP",SWIG_From_int(static_cast< int >(WXK_PAGEUP)));
55975 SWIG_Python_SetConstant(d, "WXK_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_PAGEDOWN)));
55976 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SPACE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SPACE)));
55977 SWIG_Python_SetConstant(d, "WXK_NUMPAD_TAB",SWIG_From_int(static_cast< int >(WXK_NUMPAD_TAB)));
55978 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ENTER",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ENTER)));
55979 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F1",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F1)));
55980 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F2",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F2)));
55981 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F3",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F3)));
55982 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F4",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F4)));
55983 SWIG_Python_SetConstant(d, "WXK_NUMPAD_HOME",SWIG_From_int(static_cast< int >(WXK_NUMPAD_HOME)));
55984 SWIG_Python_SetConstant(d, "WXK_NUMPAD_LEFT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_LEFT)));
55985 SWIG_Python_SetConstant(d, "WXK_NUMPAD_UP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_UP)));
55986 SWIG_Python_SetConstant(d, "WXK_NUMPAD_RIGHT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_RIGHT)));
55987 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DOWN)));
55988 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PRIOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PRIOR)));
55989 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEUP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEUP)));
55990 SWIG_Python_SetConstant(d, "WXK_NUMPAD_NEXT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_NEXT)));
55991 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEDOWN)));
55992 SWIG_Python_SetConstant(d, "WXK_NUMPAD_END",SWIG_From_int(static_cast< int >(WXK_NUMPAD_END)));
55993 SWIG_Python_SetConstant(d, "WXK_NUMPAD_BEGIN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_BEGIN)));
55994 SWIG_Python_SetConstant(d, "WXK_NUMPAD_INSERT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_INSERT)));
55995 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DELETE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DELETE)));
55996 SWIG_Python_SetConstant(d, "WXK_NUMPAD_EQUAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_EQUAL)));
55997 SWIG_Python_SetConstant(d, "WXK_NUMPAD_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_NUMPAD_MULTIPLY)));
55998 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ADD",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ADD)));
55999 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SEPARATOR)));
56000 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SUBTRACT)));
56001 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DECIMAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DECIMAL)));
56002 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DIVIDE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DIVIDE)));
56003 SWIG_Python_SetConstant(d, "WXK_WINDOWS_LEFT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_LEFT)));
56004 SWIG_Python_SetConstant(d, "WXK_WINDOWS_RIGHT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_RIGHT)));
56005 SWIG_Python_SetConstant(d, "WXK_WINDOWS_MENU",SWIG_From_int(static_cast< int >(WXK_WINDOWS_MENU)));
56006 SWIG_Python_SetConstant(d, "WXK_COMMAND",SWIG_From_int(static_cast< int >(WXK_COMMAND)));
56007 SWIG_Python_SetConstant(d, "WXK_SPECIAL1",SWIG_From_int(static_cast< int >(WXK_SPECIAL1)));
56008 SWIG_Python_SetConstant(d, "WXK_SPECIAL2",SWIG_From_int(static_cast< int >(WXK_SPECIAL2)));
56009 SWIG_Python_SetConstant(d, "WXK_SPECIAL3",SWIG_From_int(static_cast< int >(WXK_SPECIAL3)));
56010 SWIG_Python_SetConstant(d, "WXK_SPECIAL4",SWIG_From_int(static_cast< int >(WXK_SPECIAL4)));
56011 SWIG_Python_SetConstant(d, "WXK_SPECIAL5",SWIG_From_int(static_cast< int >(WXK_SPECIAL5)));
56012 SWIG_Python_SetConstant(d, "WXK_SPECIAL6",SWIG_From_int(static_cast< int >(WXK_SPECIAL6)));
56013 SWIG_Python_SetConstant(d, "WXK_SPECIAL7",SWIG_From_int(static_cast< int >(WXK_SPECIAL7)));
56014 SWIG_Python_SetConstant(d, "WXK_SPECIAL8",SWIG_From_int(static_cast< int >(WXK_SPECIAL8)));
56015 SWIG_Python_SetConstant(d, "WXK_SPECIAL9",SWIG_From_int(static_cast< int >(WXK_SPECIAL9)));
56016 SWIG_Python_SetConstant(d, "WXK_SPECIAL10",SWIG_From_int(static_cast< int >(WXK_SPECIAL10)));
56017 SWIG_Python_SetConstant(d, "WXK_SPECIAL11",SWIG_From_int(static_cast< int >(WXK_SPECIAL11)));
56018 SWIG_Python_SetConstant(d, "WXK_SPECIAL12",SWIG_From_int(static_cast< int >(WXK_SPECIAL12)));
56019 SWIG_Python_SetConstant(d, "WXK_SPECIAL13",SWIG_From_int(static_cast< int >(WXK_SPECIAL13)));
56020 SWIG_Python_SetConstant(d, "WXK_SPECIAL14",SWIG_From_int(static_cast< int >(WXK_SPECIAL14)));
56021 SWIG_Python_SetConstant(d, "WXK_SPECIAL15",SWIG_From_int(static_cast< int >(WXK_SPECIAL15)));
56022 SWIG_Python_SetConstant(d, "WXK_SPECIAL16",SWIG_From_int(static_cast< int >(WXK_SPECIAL16)));
56023 SWIG_Python_SetConstant(d, "WXK_SPECIAL17",SWIG_From_int(static_cast< int >(WXK_SPECIAL17)));
56024 SWIG_Python_SetConstant(d, "WXK_SPECIAL18",SWIG_From_int(static_cast< int >(WXK_SPECIAL18)));
56025 SWIG_Python_SetConstant(d, "WXK_SPECIAL19",SWIG_From_int(static_cast< int >(WXK_SPECIAL19)));
56026 SWIG_Python_SetConstant(d, "WXK_SPECIAL20",SWIG_From_int(static_cast< int >(WXK_SPECIAL20)));
56027 SWIG_Python_SetConstant(d, "PAPER_NONE",SWIG_From_int(static_cast< int >(wxPAPER_NONE)));
56028 SWIG_Python_SetConstant(d, "PAPER_LETTER",SWIG_From_int(static_cast< int >(wxPAPER_LETTER)));
56029 SWIG_Python_SetConstant(d, "PAPER_LEGAL",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL)));
56030 SWIG_Python_SetConstant(d, "PAPER_A4",SWIG_From_int(static_cast< int >(wxPAPER_A4)));
56031 SWIG_Python_SetConstant(d, "PAPER_CSHEET",SWIG_From_int(static_cast< int >(wxPAPER_CSHEET)));
56032 SWIG_Python_SetConstant(d, "PAPER_DSHEET",SWIG_From_int(static_cast< int >(wxPAPER_DSHEET)));
56033 SWIG_Python_SetConstant(d, "PAPER_ESHEET",SWIG_From_int(static_cast< int >(wxPAPER_ESHEET)));
56034 SWIG_Python_SetConstant(d, "PAPER_LETTERSMALL",SWIG_From_int(static_cast< int >(wxPAPER_LETTERSMALL)));
56035 SWIG_Python_SetConstant(d, "PAPER_TABLOID",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID)));
56036 SWIG_Python_SetConstant(d, "PAPER_LEDGER",SWIG_From_int(static_cast< int >(wxPAPER_LEDGER)));
56037 SWIG_Python_SetConstant(d, "PAPER_STATEMENT",SWIG_From_int(static_cast< int >(wxPAPER_STATEMENT)));
56038 SWIG_Python_SetConstant(d, "PAPER_EXECUTIVE",SWIG_From_int(static_cast< int >(wxPAPER_EXECUTIVE)));
56039 SWIG_Python_SetConstant(d, "PAPER_A3",SWIG_From_int(static_cast< int >(wxPAPER_A3)));
56040 SWIG_Python_SetConstant(d, "PAPER_A4SMALL",SWIG_From_int(static_cast< int >(wxPAPER_A4SMALL)));
56041 SWIG_Python_SetConstant(d, "PAPER_A5",SWIG_From_int(static_cast< int >(wxPAPER_A5)));
56042 SWIG_Python_SetConstant(d, "PAPER_B4",SWIG_From_int(static_cast< int >(wxPAPER_B4)));
56043 SWIG_Python_SetConstant(d, "PAPER_B5",SWIG_From_int(static_cast< int >(wxPAPER_B5)));
56044 SWIG_Python_SetConstant(d, "PAPER_FOLIO",SWIG_From_int(static_cast< int >(wxPAPER_FOLIO)));
56045 SWIG_Python_SetConstant(d, "PAPER_QUARTO",SWIG_From_int(static_cast< int >(wxPAPER_QUARTO)));
56046 SWIG_Python_SetConstant(d, "PAPER_10X14",SWIG_From_int(static_cast< int >(wxPAPER_10X14)));
56047 SWIG_Python_SetConstant(d, "PAPER_11X17",SWIG_From_int(static_cast< int >(wxPAPER_11X17)));
56048 SWIG_Python_SetConstant(d, "PAPER_NOTE",SWIG_From_int(static_cast< int >(wxPAPER_NOTE)));
56049 SWIG_Python_SetConstant(d, "PAPER_ENV_9",SWIG_From_int(static_cast< int >(wxPAPER_ENV_9)));
56050 SWIG_Python_SetConstant(d, "PAPER_ENV_10",SWIG_From_int(static_cast< int >(wxPAPER_ENV_10)));
56051 SWIG_Python_SetConstant(d, "PAPER_ENV_11",SWIG_From_int(static_cast< int >(wxPAPER_ENV_11)));
56052 SWIG_Python_SetConstant(d, "PAPER_ENV_12",SWIG_From_int(static_cast< int >(wxPAPER_ENV_12)));
56053 SWIG_Python_SetConstant(d, "PAPER_ENV_14",SWIG_From_int(static_cast< int >(wxPAPER_ENV_14)));
56054 SWIG_Python_SetConstant(d, "PAPER_ENV_DL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_DL)));
56055 SWIG_Python_SetConstant(d, "PAPER_ENV_C5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C5)));
56056 SWIG_Python_SetConstant(d, "PAPER_ENV_C3",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C3)));
56057 SWIG_Python_SetConstant(d, "PAPER_ENV_C4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C4)));
56058 SWIG_Python_SetConstant(d, "PAPER_ENV_C6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C6)));
56059 SWIG_Python_SetConstant(d, "PAPER_ENV_C65",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C65)));
56060 SWIG_Python_SetConstant(d, "PAPER_ENV_B4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B4)));
56061 SWIG_Python_SetConstant(d, "PAPER_ENV_B5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B5)));
56062 SWIG_Python_SetConstant(d, "PAPER_ENV_B6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B6)));
56063 SWIG_Python_SetConstant(d, "PAPER_ENV_ITALY",SWIG_From_int(static_cast< int >(wxPAPER_ENV_ITALY)));
56064 SWIG_Python_SetConstant(d, "PAPER_ENV_MONARCH",SWIG_From_int(static_cast< int >(wxPAPER_ENV_MONARCH)));
56065 SWIG_Python_SetConstant(d, "PAPER_ENV_PERSONAL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_PERSONAL)));
56066 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_US",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_US)));
56067 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_STD_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_STD_GERMAN)));
56068 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_LGL_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_LGL_GERMAN)));
56069 SWIG_Python_SetConstant(d, "PAPER_ISO_B4",SWIG_From_int(static_cast< int >(wxPAPER_ISO_B4)));
56070 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD)));
56071 SWIG_Python_SetConstant(d, "PAPER_9X11",SWIG_From_int(static_cast< int >(wxPAPER_9X11)));
56072 SWIG_Python_SetConstant(d, "PAPER_10X11",SWIG_From_int(static_cast< int >(wxPAPER_10X11)));
56073 SWIG_Python_SetConstant(d, "PAPER_15X11",SWIG_From_int(static_cast< int >(wxPAPER_15X11)));
56074 SWIG_Python_SetConstant(d, "PAPER_ENV_INVITE",SWIG_From_int(static_cast< int >(wxPAPER_ENV_INVITE)));
56075 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA)));
56076 SWIG_Python_SetConstant(d, "PAPER_LEGAL_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL_EXTRA)));
56077 SWIG_Python_SetConstant(d, "PAPER_TABLOID_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID_EXTRA)));
56078 SWIG_Python_SetConstant(d, "PAPER_A4_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A4_EXTRA)));
56079 SWIG_Python_SetConstant(d, "PAPER_LETTER_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_TRANSVERSE)));
56080 SWIG_Python_SetConstant(d, "PAPER_A4_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A4_TRANSVERSE)));
56081 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
56082 SWIG_Python_SetConstant(d, "PAPER_A_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A_PLUS)));
56083 SWIG_Python_SetConstant(d, "PAPER_B_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_B_PLUS)));
56084 SWIG_Python_SetConstant(d, "PAPER_LETTER_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_PLUS)));
56085 SWIG_Python_SetConstant(d, "PAPER_A4_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A4_PLUS)));
56086 SWIG_Python_SetConstant(d, "PAPER_A5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A5_TRANSVERSE)));
56087 SWIG_Python_SetConstant(d, "PAPER_B5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_B5_TRANSVERSE)));
56088 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA)));
56089 SWIG_Python_SetConstant(d, "PAPER_A5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A5_EXTRA)));
56090 SWIG_Python_SetConstant(d, "PAPER_B5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_B5_EXTRA)));
56091 SWIG_Python_SetConstant(d, "PAPER_A2",SWIG_From_int(static_cast< int >(wxPAPER_A2)));
56092 SWIG_Python_SetConstant(d, "PAPER_A3_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_TRANSVERSE)));
56093 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA_TRANSVERSE)));
56094 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD)));
56095 SWIG_Python_SetConstant(d, "PAPER_A6",SWIG_From_int(static_cast< int >(wxPAPER_A6)));
56096 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2)));
56097 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3)));
56098 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3)));
56099 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4)));
56100 SWIG_Python_SetConstant(d, "PAPER_LETTER_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_ROTATED)));
56101 SWIG_Python_SetConstant(d, "PAPER_A3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A3_ROTATED)));
56102 SWIG_Python_SetConstant(d, "PAPER_A4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A4_ROTATED)));
56103 SWIG_Python_SetConstant(d, "PAPER_A5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A5_ROTATED)));
56104 SWIG_Python_SetConstant(d, "PAPER_B4_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B4_JIS_ROTATED)));
56105 SWIG_Python_SetConstant(d, "PAPER_B5_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B5_JIS_ROTATED)));
56106 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
56107 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
56108 SWIG_Python_SetConstant(d, "PAPER_A6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A6_ROTATED)));
56109 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2_ROTATED)));
56110 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3_ROTATED)));
56111 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3_ROTATED)));
56112 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4_ROTATED)));
56113 SWIG_Python_SetConstant(d, "PAPER_B6_JIS",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS)));
56114 SWIG_Python_SetConstant(d, "PAPER_B6_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS_ROTATED)));
56115 SWIG_Python_SetConstant(d, "PAPER_12X11",SWIG_From_int(static_cast< int >(wxPAPER_12X11)));
56116 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4)));
56117 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4_ROTATED)));
56118 SWIG_Python_SetConstant(d, "PAPER_P16K",SWIG_From_int(static_cast< int >(wxPAPER_P16K)));
56119 SWIG_Python_SetConstant(d, "PAPER_P32K",SWIG_From_int(static_cast< int >(wxPAPER_P32K)));
56120 SWIG_Python_SetConstant(d, "PAPER_P32KBIG",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG)));
56121 SWIG_Python_SetConstant(d, "PAPER_PENV_1",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1)));
56122 SWIG_Python_SetConstant(d, "PAPER_PENV_2",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2)));
56123 SWIG_Python_SetConstant(d, "PAPER_PENV_3",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3)));
56124 SWIG_Python_SetConstant(d, "PAPER_PENV_4",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4)));
56125 SWIG_Python_SetConstant(d, "PAPER_PENV_5",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5)));
56126 SWIG_Python_SetConstant(d, "PAPER_PENV_6",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6)));
56127 SWIG_Python_SetConstant(d, "PAPER_PENV_7",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7)));
56128 SWIG_Python_SetConstant(d, "PAPER_PENV_8",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8)));
56129 SWIG_Python_SetConstant(d, "PAPER_PENV_9",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9)));
56130 SWIG_Python_SetConstant(d, "PAPER_PENV_10",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10)));
56131 SWIG_Python_SetConstant(d, "PAPER_P16K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P16K_ROTATED)));
56132 SWIG_Python_SetConstant(d, "PAPER_P32K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32K_ROTATED)));
56133 SWIG_Python_SetConstant(d, "PAPER_P32KBIG_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG_ROTATED)));
56134 SWIG_Python_SetConstant(d, "PAPER_PENV_1_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1_ROTATED)));
56135 SWIG_Python_SetConstant(d, "PAPER_PENV_2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2_ROTATED)));
56136 SWIG_Python_SetConstant(d, "PAPER_PENV_3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3_ROTATED)));
56137 SWIG_Python_SetConstant(d, "PAPER_PENV_4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4_ROTATED)));
56138 SWIG_Python_SetConstant(d, "PAPER_PENV_5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5_ROTATED)));
56139 SWIG_Python_SetConstant(d, "PAPER_PENV_6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6_ROTATED)));
56140 SWIG_Python_SetConstant(d, "PAPER_PENV_7_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7_ROTATED)));
56141 SWIG_Python_SetConstant(d, "PAPER_PENV_8_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8_ROTATED)));
56142 SWIG_Python_SetConstant(d, "PAPER_PENV_9_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9_ROTATED)));
56143 SWIG_Python_SetConstant(d, "PAPER_PENV_10_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10_ROTATED)));
56144 SWIG_Python_SetConstant(d, "DUPLEX_SIMPLEX",SWIG_From_int(static_cast< int >(wxDUPLEX_SIMPLEX)));
56145 SWIG_Python_SetConstant(d, "DUPLEX_HORIZONTAL",SWIG_From_int(static_cast< int >(wxDUPLEX_HORIZONTAL)));
56146 SWIG_Python_SetConstant(d, "DUPLEX_VERTICAL",SWIG_From_int(static_cast< int >(wxDUPLEX_VERTICAL)));
56147 SWIG_Python_SetConstant(d, "ITEM_SEPARATOR",SWIG_From_int(static_cast< int >(wxITEM_SEPARATOR)));
56148 SWIG_Python_SetConstant(d, "ITEM_NORMAL",SWIG_From_int(static_cast< int >(wxITEM_NORMAL)));
56149 SWIG_Python_SetConstant(d, "ITEM_CHECK",SWIG_From_int(static_cast< int >(wxITEM_CHECK)));
56150 SWIG_Python_SetConstant(d, "ITEM_RADIO",SWIG_From_int(static_cast< int >(wxITEM_RADIO)));
56151 SWIG_Python_SetConstant(d, "ITEM_MAX",SWIG_From_int(static_cast< int >(wxITEM_MAX)));
56152 SWIG_Python_SetConstant(d, "HT_NOWHERE",SWIG_From_int(static_cast< int >(wxHT_NOWHERE)));
56153 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_FIRST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_FIRST)));
56154 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_1)));
56155 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_2)));
56156 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_1)));
56157 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_2)));
56158 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_THUMB",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_THUMB)));
56159 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_1)));
56160 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_2)));
56161 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_LAST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_LAST)));
56162 SWIG_Python_SetConstant(d, "HT_WINDOW_OUTSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_OUTSIDE)));
56163 SWIG_Python_SetConstant(d, "HT_WINDOW_INSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_INSIDE)));
56164 SWIG_Python_SetConstant(d, "HT_WINDOW_VERT_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_VERT_SCROLLBAR)));
56165 SWIG_Python_SetConstant(d, "HT_WINDOW_HORZ_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_HORZ_SCROLLBAR)));
56166 SWIG_Python_SetConstant(d, "HT_WINDOW_CORNER",SWIG_From_int(static_cast< int >(wxHT_WINDOW_CORNER)));
56167 SWIG_Python_SetConstant(d, "HT_MAX",SWIG_From_int(static_cast< int >(wxHT_MAX)));
56168 SWIG_Python_SetConstant(d, "MOD_NONE",SWIG_From_int(static_cast< int >(wxMOD_NONE)));
56169 SWIG_Python_SetConstant(d, "MOD_ALT",SWIG_From_int(static_cast< int >(wxMOD_ALT)));
56170 SWIG_Python_SetConstant(d, "MOD_CONTROL",SWIG_From_int(static_cast< int >(wxMOD_CONTROL)));
56171 SWIG_Python_SetConstant(d, "MOD_ALTGR",SWIG_From_int(static_cast< int >(wxMOD_ALTGR)));
56172 SWIG_Python_SetConstant(d, "MOD_SHIFT",SWIG_From_int(static_cast< int >(wxMOD_SHIFT)));
56173 SWIG_Python_SetConstant(d, "MOD_META",SWIG_From_int(static_cast< int >(wxMOD_META)));
56174 SWIG_Python_SetConstant(d, "MOD_WIN",SWIG_From_int(static_cast< int >(wxMOD_WIN)));
56175 SWIG_Python_SetConstant(d, "MOD_CMD",SWIG_From_int(static_cast< int >(wxMOD_CMD)));
56176 SWIG_Python_SetConstant(d, "MOD_ALL",SWIG_From_int(static_cast< int >(wxMOD_ALL)));
56177 SWIG_Python_SetConstant(d, "UPDATE_UI_NONE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_NONE)));
56178 SWIG_Python_SetConstant(d, "UPDATE_UI_RECURSE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_RECURSE)));
56179 SWIG_Python_SetConstant(d, "UPDATE_UI_FROMIDLE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_FROMIDLE)));
56180 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
56181 SWIG_addvarlink(SWIG_globals(),(char*)"EmptyString",EmptyString_get, EmptyString_set);
56182 SWIG_Python_SetConstant(d, "BITMAP_TYPE_INVALID",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_INVALID)));
56183 SWIG_Python_SetConstant(d, "BITMAP_TYPE_BMP",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_BMP)));
56184 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICO",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICO)));
56185 SWIG_Python_SetConstant(d, "BITMAP_TYPE_CUR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_CUR)));
56186 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM)));
56187 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM_DATA)));
56188 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM)));
56189 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM_DATA)));
56190 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TIF)));
56191 SWIG_Python_SetConstant(d, "BITMAP_TYPE_GIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_GIF)));
56192 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNG)));
56193 SWIG_Python_SetConstant(d, "BITMAP_TYPE_JPEG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_JPEG)));
56194 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNM)));
56195 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PCX",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PCX)));
56196 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PICT",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PICT)));
56197 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICON",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICON)));
56198 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANI",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANI)));
56199 SWIG_Python_SetConstant(d, "BITMAP_TYPE_IFF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_IFF)));
56200 SWIG_Python_SetConstant(d, "BITMAP_TYPE_MACCURSOR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_MACCURSOR)));
56201 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANY",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANY)));
56202 SWIG_Python_SetConstant(d, "CURSOR_NONE",SWIG_From_int(static_cast< int >(wxCURSOR_NONE)));
56203 SWIG_Python_SetConstant(d, "CURSOR_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_ARROW)));
56204 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_ARROW)));
56205 SWIG_Python_SetConstant(d, "CURSOR_BULLSEYE",SWIG_From_int(static_cast< int >(wxCURSOR_BULLSEYE)));
56206 SWIG_Python_SetConstant(d, "CURSOR_CHAR",SWIG_From_int(static_cast< int >(wxCURSOR_CHAR)));
56207 SWIG_Python_SetConstant(d, "CURSOR_CROSS",SWIG_From_int(static_cast< int >(wxCURSOR_CROSS)));
56208 SWIG_Python_SetConstant(d, "CURSOR_HAND",SWIG_From_int(static_cast< int >(wxCURSOR_HAND)));
56209 SWIG_Python_SetConstant(d, "CURSOR_IBEAM",SWIG_From_int(static_cast< int >(wxCURSOR_IBEAM)));
56210 SWIG_Python_SetConstant(d, "CURSOR_LEFT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_LEFT_BUTTON)));
56211 SWIG_Python_SetConstant(d, "CURSOR_MAGNIFIER",SWIG_From_int(static_cast< int >(wxCURSOR_MAGNIFIER)));
56212 SWIG_Python_SetConstant(d, "CURSOR_MIDDLE_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_MIDDLE_BUTTON)));
56213 SWIG_Python_SetConstant(d, "CURSOR_NO_ENTRY",SWIG_From_int(static_cast< int >(wxCURSOR_NO_ENTRY)));
56214 SWIG_Python_SetConstant(d, "CURSOR_PAINT_BRUSH",SWIG_From_int(static_cast< int >(wxCURSOR_PAINT_BRUSH)));
56215 SWIG_Python_SetConstant(d, "CURSOR_PENCIL",SWIG_From_int(static_cast< int >(wxCURSOR_PENCIL)));
56216 SWIG_Python_SetConstant(d, "CURSOR_POINT_LEFT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_LEFT)));
56217 SWIG_Python_SetConstant(d, "CURSOR_POINT_RIGHT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_RIGHT)));
56218 SWIG_Python_SetConstant(d, "CURSOR_QUESTION_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_QUESTION_ARROW)));
56219 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_BUTTON)));
56220 SWIG_Python_SetConstant(d, "CURSOR_SIZENESW",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENESW)));
56221 SWIG_Python_SetConstant(d, "CURSOR_SIZENS",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENS)));
56222 SWIG_Python_SetConstant(d, "CURSOR_SIZENWSE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENWSE)));
56223 SWIG_Python_SetConstant(d, "CURSOR_SIZEWE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZEWE)));
56224 SWIG_Python_SetConstant(d, "CURSOR_SIZING",SWIG_From_int(static_cast< int >(wxCURSOR_SIZING)));
56225 SWIG_Python_SetConstant(d, "CURSOR_SPRAYCAN",SWIG_From_int(static_cast< int >(wxCURSOR_SPRAYCAN)));
56226 SWIG_Python_SetConstant(d, "CURSOR_WAIT",SWIG_From_int(static_cast< int >(wxCURSOR_WAIT)));
56227 SWIG_Python_SetConstant(d, "CURSOR_WATCH",SWIG_From_int(static_cast< int >(wxCURSOR_WATCH)));
56228 SWIG_Python_SetConstant(d, "CURSOR_BLANK",SWIG_From_int(static_cast< int >(wxCURSOR_BLANK)));
56229 SWIG_Python_SetConstant(d, "CURSOR_DEFAULT",SWIG_From_int(static_cast< int >(wxCURSOR_DEFAULT)));
56230 SWIG_Python_SetConstant(d, "CURSOR_COPY_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_COPY_ARROW)));
56231 SWIG_Python_SetConstant(d, "CURSOR_ARROWWAIT",SWIG_From_int(static_cast< int >(wxCURSOR_ARROWWAIT)));
56232 SWIG_Python_SetConstant(d, "CURSOR_MAX",SWIG_From_int(static_cast< int >(wxCURSOR_MAX)));
56233 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultPosition",DefaultPosition_get, DefaultPosition_set);
56234 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSize",DefaultSize_get, DefaultSize_set);
56235 SWIG_Python_SetConstant(d, "FromStart",SWIG_From_int(static_cast< int >(wxFromStart)));
56236 SWIG_Python_SetConstant(d, "FromCurrent",SWIG_From_int(static_cast< int >(wxFromCurrent)));
56237 SWIG_Python_SetConstant(d, "FromEnd",SWIG_From_int(static_cast< int >(wxFromEnd)));
56238
56239 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
56240
56241
56242 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
56243
56244 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_TRANSPARENT",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_TRANSPARENT)));
56245 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_THRESHOLD",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_THRESHOLD)));
56246 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_OPAQUE",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_OPAQUE)));
56247 SWIG_addvarlink(SWIG_globals(),(char*)"NullImage",NullImage_get, NullImage_set);
56248 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_FILENAME",IMAGE_OPTION_FILENAME_get, IMAGE_OPTION_FILENAME_set);
56249 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BMP_FORMAT",IMAGE_OPTION_BMP_FORMAT_get, IMAGE_OPTION_BMP_FORMAT_set);
56250 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",IMAGE_OPTION_CUR_HOTSPOT_X_get, IMAGE_OPTION_CUR_HOTSPOT_X_set);
56251 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",IMAGE_OPTION_CUR_HOTSPOT_Y_get, IMAGE_OPTION_CUR_HOTSPOT_Y_set);
56252 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTION",IMAGE_OPTION_RESOLUTION_get, IMAGE_OPTION_RESOLUTION_set);
56253 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONX",IMAGE_OPTION_RESOLUTIONX_get, IMAGE_OPTION_RESOLUTIONX_set);
56254 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONY",IMAGE_OPTION_RESOLUTIONY_get, IMAGE_OPTION_RESOLUTIONY_set);
56255 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONUNIT",IMAGE_OPTION_RESOLUTIONUNIT_get, IMAGE_OPTION_RESOLUTIONUNIT_set);
56256 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_QUALITY",IMAGE_OPTION_QUALITY_get, IMAGE_OPTION_QUALITY_set);
56257 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_INCHES",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_INCHES)));
56258 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_CM",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_CM)));
56259 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BITSPERSAMPLE",IMAGE_OPTION_BITSPERSAMPLE_get, IMAGE_OPTION_BITSPERSAMPLE_set);
56260 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",IMAGE_OPTION_SAMPLESPERPIXEL_get, IMAGE_OPTION_SAMPLESPERPIXEL_set);
56261 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_COMPRESSION",IMAGE_OPTION_COMPRESSION_get, IMAGE_OPTION_COMPRESSION_set);
56262 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",IMAGE_OPTION_IMAGEDESCRIPTOR_get, IMAGE_OPTION_IMAGEDESCRIPTOR_set);
56263 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_FORMAT",IMAGE_OPTION_PNG_FORMAT_get, IMAGE_OPTION_PNG_FORMAT_set);
56264 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_BITDEPTH",IMAGE_OPTION_PNG_BITDEPTH_get, IMAGE_OPTION_PNG_BITDEPTH_set);
56265 SWIG_Python_SetConstant(d, "PNG_TYPE_COLOUR",SWIG_From_int(static_cast< int >(wxPNG_TYPE_COLOUR)));
56266 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY)));
56267 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY_RED",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY_RED)));
56268 SWIG_Python_SetConstant(d, "BMP_24BPP",SWIG_From_int(static_cast< int >(wxBMP_24BPP)));
56269 SWIG_Python_SetConstant(d, "BMP_8BPP",SWIG_From_int(static_cast< int >(wxBMP_8BPP)));
56270 SWIG_Python_SetConstant(d, "BMP_8BPP_GREY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GREY)));
56271 SWIG_Python_SetConstant(d, "BMP_8BPP_GRAY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GRAY)));
56272 SWIG_Python_SetConstant(d, "BMP_8BPP_RED",SWIG_From_int(static_cast< int >(wxBMP_8BPP_RED)));
56273 SWIG_Python_SetConstant(d, "BMP_8BPP_PALETTE",SWIG_From_int(static_cast< int >(wxBMP_8BPP_PALETTE)));
56274 SWIG_Python_SetConstant(d, "BMP_4BPP",SWIG_From_int(static_cast< int >(wxBMP_4BPP)));
56275 SWIG_Python_SetConstant(d, "BMP_1BPP",SWIG_From_int(static_cast< int >(wxBMP_1BPP)));
56276 SWIG_Python_SetConstant(d, "BMP_1BPP_BW",SWIG_From_int(static_cast< int >(wxBMP_1BPP_BW)));
56277 SWIG_Python_SetConstant(d, "QUANTIZE_INCLUDE_WINDOWS_COLOURS",SWIG_From_int(static_cast< int >(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
56278 SWIG_Python_SetConstant(d, "QUANTIZE_FILL_DESTINATION_IMAGE",SWIG_From_int(static_cast< int >(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
56279 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_NONE",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_NONE)));
56280 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_MAX",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_MAX)));
56281 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
56282 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
56283 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
56284 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
56285 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
56286 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
56287 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
56288 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
56289 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
56290 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
56291 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
56292 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
56293 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
56294 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
56295 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
56296 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
56297 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
56298 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
56299 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
56300 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
56301 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
56302 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
56303 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
56304 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
56305 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
56306 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
56307 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
56308 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
56309 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
56310 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
56311 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
56312 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
56313 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
56314 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
56315 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
56316 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
56317 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
56318 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
56319 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
56320 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
56321 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
56322 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
56323 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
56324 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
56325 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
56326 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
56327 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
56328 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
56329 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
56330 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
56331 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
56332 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
56333 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
56334 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
56335 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
56336 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
56337 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
56338 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
56339 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
56340 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
56341 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
56342 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
56343 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
56344 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
56345 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
56346 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
56347 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
56348 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
56349 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
56350 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
56351 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
56352 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
56353 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
56354 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
56355 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
56356 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
56357 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
56358 PyDict_SetItemString(d, "wxEVT_POWER", PyInt_FromLong(wxEVT_POWER));
56359 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
56360 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
56361 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
56362 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
56363 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
56364 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
56365 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
56366 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
56367 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
56368 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
56369 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
56370 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
56371 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
56372 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
56373 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
56374 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
56375 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
56376 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
56377 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
56378 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
56379 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
56380 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
56381 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
56382 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
56383 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
56384 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
56385 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
56386 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
56387 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
56388 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
56389 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_COPY", PyInt_FromLong(wxEVT_COMMAND_TEXT_COPY));
56390 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_CUT", PyInt_FromLong(wxEVT_COMMAND_TEXT_CUT));
56391 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_PASTE", PyInt_FromLong(wxEVT_COMMAND_TEXT_PASTE));
56392 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
56393 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
56394 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
56395 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
56396 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
56397 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
56398 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
56399 SWIG_Python_SetConstant(d, "MOUSE_BTN_ANY",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_ANY)));
56400 SWIG_Python_SetConstant(d, "MOUSE_BTN_NONE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_NONE)));
56401 SWIG_Python_SetConstant(d, "MOUSE_BTN_LEFT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_LEFT)));
56402 SWIG_Python_SetConstant(d, "MOUSE_BTN_MIDDLE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_MIDDLE)));
56403 SWIG_Python_SetConstant(d, "MOUSE_BTN_RIGHT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_RIGHT)));
56404 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_ALL)));
56405 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_SPECIFIED)));
56406 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsBackward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsBackward)));
56407 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsForward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsForward)));
56408 SWIG_Python_SetConstant(d, "NavigationKeyEvent_WinChange",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::WinChange)));
56409 SWIG_Python_SetConstant(d, "NavigationKeyEvent_FromTab",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::FromTab)));
56410 SWIG_Python_SetConstant(d, "IDLE_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_ALL)));
56411 SWIG_Python_SetConstant(d, "IDLE_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_SPECIFIED)));
56412 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
56413 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_SUPPRESS",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_SUPPRESS)));
56414 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_EXCEPTION",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_EXCEPTION)));
56415 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_DIALOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_DIALOG)));
56416 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_LOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_LOG)));
56417 SWIG_Python_SetConstant(d, "PRINT_WINDOWS",SWIG_From_int(static_cast< int >(wxPRINT_WINDOWS)));
56418 SWIG_Python_SetConstant(d, "PRINT_POSTSCRIPT",SWIG_From_int(static_cast< int >(wxPRINT_POSTSCRIPT)));
56419 SWIG_addvarlink(SWIG_globals(),(char*)"NullAcceleratorTable",NullAcceleratorTable_get, NullAcceleratorTable_set);
56420 SWIG_addvarlink(SWIG_globals(),(char*)"PanelNameStr",PanelNameStr_get, PanelNameStr_set);
56421 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_NORMAL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_NORMAL)));
56422 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_SMALL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_SMALL)));
56423 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MINI",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MINI)));
56424 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_LARGE",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_LARGE)));
56425 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MAX",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MAX)));
56426 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultValidator",DefaultValidator_get, DefaultValidator_set);
56427 SWIG_addvarlink(SWIG_globals(),(char*)"ControlNameStr",ControlNameStr_get, ControlNameStr_set);
56428 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_NONE",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_NONE)));
56429 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_SPECIFIED",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_SPECIFIED)));
56430 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_ALL",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_ALL)));
56431 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSpan",DefaultSpan_get, DefaultSpan_set);
56432 SWIG_Python_SetConstant(d, "Left",SWIG_From_int(static_cast< int >(wxLeft)));
56433 SWIG_Python_SetConstant(d, "Top",SWIG_From_int(static_cast< int >(wxTop)));
56434 SWIG_Python_SetConstant(d, "Right",SWIG_From_int(static_cast< int >(wxRight)));
56435 SWIG_Python_SetConstant(d, "Bottom",SWIG_From_int(static_cast< int >(wxBottom)));
56436 SWIG_Python_SetConstant(d, "Width",SWIG_From_int(static_cast< int >(wxWidth)));
56437 SWIG_Python_SetConstant(d, "Height",SWIG_From_int(static_cast< int >(wxHeight)));
56438 SWIG_Python_SetConstant(d, "Centre",SWIG_From_int(static_cast< int >(wxCentre)));
56439 SWIG_Python_SetConstant(d, "Center",SWIG_From_int(static_cast< int >(wxCenter)));
56440 SWIG_Python_SetConstant(d, "CentreX",SWIG_From_int(static_cast< int >(wxCentreX)));
56441 SWIG_Python_SetConstant(d, "CentreY",SWIG_From_int(static_cast< int >(wxCentreY)));
56442 SWIG_Python_SetConstant(d, "Unconstrained",SWIG_From_int(static_cast< int >(wxUnconstrained)));
56443 SWIG_Python_SetConstant(d, "AsIs",SWIG_From_int(static_cast< int >(wxAsIs)));
56444 SWIG_Python_SetConstant(d, "PercentOf",SWIG_From_int(static_cast< int >(wxPercentOf)));
56445 SWIG_Python_SetConstant(d, "Above",SWIG_From_int(static_cast< int >(wxAbove)));
56446 SWIG_Python_SetConstant(d, "Below",SWIG_From_int(static_cast< int >(wxBelow)));
56447 SWIG_Python_SetConstant(d, "LeftOf",SWIG_From_int(static_cast< int >(wxLeftOf)));
56448 SWIG_Python_SetConstant(d, "RightOf",SWIG_From_int(static_cast< int >(wxRightOf)));
56449 SWIG_Python_SetConstant(d, "SameAs",SWIG_From_int(static_cast< int >(wxSameAs)));
56450 SWIG_Python_SetConstant(d, "Absolute",SWIG_From_int(static_cast< int >(wxAbsolute)));
56451
56452 // Initialize threading, some globals and such
56453 __wxPyPreStart(d);
56454
56455
56456 // Although these are defined in __version__ they need to be here too so
56457 // that an assert can be done to ensure that the wxPython and the wxWindows
56458 // versions match.
56459 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
56460 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
56461 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
56462
56463 }
56464
wxWidgets (Impactor)