]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/gtk/_core_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
I haven't taught SWIG about wxChar, so pretend it's a wxString
[wxWidgets.git] / wxPython / src / gtk / _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_wxCloseEvent swig_types[21]
2484 #define SWIGTYPE_p_wxColour swig_types[22]
2485 #define SWIGTYPE_p_wxCommandEvent swig_types[23]
2486 #define SWIGTYPE_p_wxContextMenuEvent swig_types[24]
2487 #define SWIGTYPE_p_wxControl swig_types[25]
2488 #define SWIGTYPE_p_wxControlWithItems swig_types[26]
2489 #define SWIGTYPE_p_wxCursor swig_types[27]
2490 #define SWIGTYPE_p_wxDC swig_types[28]
2491 #define SWIGTYPE_p_wxDateEvent swig_types[29]
2492 #define SWIGTYPE_p_wxDateTime swig_types[30]
2493 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[31]
2494 #define SWIGTYPE_p_wxDropFilesEvent swig_types[32]
2495 #define SWIGTYPE_p_wxDuplexMode swig_types[33]
2496 #define SWIGTYPE_p_wxEraseEvent swig_types[34]
2497 #define SWIGTYPE_p_wxEvent swig_types[35]
2498 #define SWIGTYPE_p_wxEventLoop swig_types[36]
2499 #define SWIGTYPE_p_wxEventLoopActivator swig_types[37]
2500 #define SWIGTYPE_p_wxEvtHandler swig_types[38]
2501 #define SWIGTYPE_p_wxFSFile swig_types[39]
2502 #define SWIGTYPE_p_wxFileSystem swig_types[40]
2503 #define SWIGTYPE_p_wxFileSystemHandler swig_types[41]
2504 #define SWIGTYPE_p_wxFlexGridSizer swig_types[42]
2505 #define SWIGTYPE_p_wxFocusEvent swig_types[43]
2506 #define SWIGTYPE_p_wxFont swig_types[44]
2507 #define SWIGTYPE_p_wxFrame swig_types[45]
2508 #define SWIGTYPE_p_wxGBPosition swig_types[46]
2509 #define SWIGTYPE_p_wxGBSizerItem swig_types[47]
2510 #define SWIGTYPE_p_wxGBSpan swig_types[48]
2511 #define SWIGTYPE_p_wxGIFHandler swig_types[49]
2512 #define SWIGTYPE_p_wxGridBagSizer swig_types[50]
2513 #define SWIGTYPE_p_wxGridSizer swig_types[51]
2514 #define SWIGTYPE_p_wxICOHandler swig_types[52]
2515 #define SWIGTYPE_p_wxIconizeEvent swig_types[53]
2516 #define SWIGTYPE_p_wxIdleEvent swig_types[54]
2517 #define SWIGTYPE_p_wxImage swig_types[55]
2518 #define SWIGTYPE_p_wxImageHandler swig_types[56]
2519 #define SWIGTYPE_p_wxImageHistogram swig_types[57]
2520 #define SWIGTYPE_p_wxImage_HSVValue swig_types[58]
2521 #define SWIGTYPE_p_wxImage_RGBValue swig_types[59]
2522 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[60]
2523 #define SWIGTYPE_p_wxInitDialogEvent swig_types[61]
2524 #define SWIGTYPE_p_wxInputStream swig_types[62]
2525 #define SWIGTYPE_p_wxInternetFSHandler swig_types[63]
2526 #define SWIGTYPE_p_wxItemContainer swig_types[64]
2527 #define SWIGTYPE_p_wxJPEGHandler swig_types[65]
2528 #define SWIGTYPE_p_wxKeyEvent swig_types[66]
2529 #define SWIGTYPE_p_wxLayoutConstraints swig_types[67]
2530 #define SWIGTYPE_p_wxMaximizeEvent swig_types[68]
2531 #define SWIGTYPE_p_wxMemoryFSHandler swig_types[69]
2532 #define SWIGTYPE_p_wxMenu swig_types[70]
2533 #define SWIGTYPE_p_wxMenuBar swig_types[71]
2534 #define SWIGTYPE_p_wxMenuBarBase swig_types[72]
2535 #define SWIGTYPE_p_wxMenuEvent swig_types[73]
2536 #define SWIGTYPE_p_wxMenuItem swig_types[74]
2537 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[75]
2538 #define SWIGTYPE_p_wxMouseEvent swig_types[76]
2539 #define SWIGTYPE_p_wxMoveEvent swig_types[77]
2540 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[78]
2541 #define SWIGTYPE_p_wxNcPaintEvent swig_types[79]
2542 #define SWIGTYPE_p_wxNotifyEvent swig_types[80]
2543 #define SWIGTYPE_p_wxObject swig_types[81]
2544 #define SWIGTYPE_p_wxOutputStream swig_types[82]
2545 #define SWIGTYPE_p_wxPCXHandler swig_types[83]
2546 #define SWIGTYPE_p_wxPNGHandler swig_types[84]
2547 #define SWIGTYPE_p_wxPNMHandler swig_types[85]
2548 #define SWIGTYPE_p_wxPaintEvent swig_types[86]
2549 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[87]
2550 #define SWIGTYPE_p_wxPaperSize swig_types[88]
2551 #define SWIGTYPE_p_wxPoint swig_types[89]
2552 #define SWIGTYPE_p_wxPoint2D swig_types[90]
2553 #define SWIGTYPE_p_wxPropagateOnce swig_types[91]
2554 #define SWIGTYPE_p_wxPropagationDisabler swig_types[92]
2555 #define SWIGTYPE_p_wxPyApp swig_types[93]
2556 #define SWIGTYPE_p_wxPyCommandEvent swig_types[94]
2557 #define SWIGTYPE_p_wxPyDropTarget swig_types[95]
2558 #define SWIGTYPE_p_wxPyEvent swig_types[96]
2559 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[97]
2560 #define SWIGTYPE_p_wxPyImageHandler swig_types[98]
2561 #define SWIGTYPE_p_wxPyInputStream swig_types[99]
2562 #define SWIGTYPE_p_wxPySizer swig_types[100]
2563 #define SWIGTYPE_p_wxPyValidator swig_types[101]
2564 #define SWIGTYPE_p_wxQuantize swig_types[102]
2565 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[103]
2566 #define SWIGTYPE_p_wxRealPoint swig_types[104]
2567 #define SWIGTYPE_p_wxRect swig_types[105]
2568 #define SWIGTYPE_p_wxRegion swig_types[106]
2569 #define SWIGTYPE_p_wxScrollEvent swig_types[107]
2570 #define SWIGTYPE_p_wxScrollWinEvent swig_types[108]
2571 #define SWIGTYPE_p_wxSetCursorEvent swig_types[109]
2572 #define SWIGTYPE_p_wxShowEvent swig_types[110]
2573 #define SWIGTYPE_p_wxSize swig_types[111]
2574 #define SWIGTYPE_p_wxSizeEvent swig_types[112]
2575 #define SWIGTYPE_p_wxSizer swig_types[113]
2576 #define SWIGTYPE_p_wxSizerItem swig_types[114]
2577 #define SWIGTYPE_p_wxStaticBox swig_types[115]
2578 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[116]
2579 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[117]
2580 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[118]
2581 #define SWIGTYPE_p_wxTIFFHandler swig_types[119]
2582 #define SWIGTYPE_p_wxToolTip swig_types[120]
2583 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[121]
2584 #define SWIGTYPE_p_wxValidator swig_types[122]
2585 #define SWIGTYPE_p_wxVisualAttributes swig_types[123]
2586 #define SWIGTYPE_p_wxWindow swig_types[124]
2587 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[125]
2588 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[126]
2589 #define SWIGTYPE_p_wxXPMHandler swig_types[127]
2590 #define SWIGTYPE_p_wxZipFSHandler swig_types[128]
2591 static swig_type_info *swig_types[130];
2592 static swig_module_info swig_module = {swig_types, 129, 0, 0, 0, 0};
2593 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2594 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2595
2596 /* -------- TYPES TABLE (END) -------- */
2597
2598 #if (PY_VERSION_HEX <= 0x02000000)
2599 # if !defined(SWIG_PYTHON_CLASSIC)
2600 # error "This python version requires to use swig with the '-classic' option"
2601 # endif
2602 #endif
2603 #if (PY_VERSION_HEX <= 0x02020000)
2604 # error "This python version requires to use swig with the '-nomodern' option"
2605 #endif
2606 #if (PY_VERSION_HEX <= 0x02020000)
2607 # error "This python version requires to use swig with the '-nomodernargs' option"
2608 #endif
2609 #ifndef METH_O
2610 # error "This python version requires to use swig with the '-nofastunpack' option"
2611 #endif
2612
2613 /*-----------------------------------------------
2614 @(target):= _core_.so
2615 ------------------------------------------------*/
2616 #define SWIG_init init_core_
2617
2618 #define SWIG_name "_core_"
2619
2620 #define SWIGVERSION 0x010329
2621
2622
2623 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2624 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2625
2626
2627 #include <stdexcept>
2628
2629
2630 namespace swig {
2631 class PyObject_ptr {
2632 protected:
2633 PyObject *_obj;
2634
2635 public:
2636 PyObject_ptr() :_obj(0)
2637 {
2638 }
2639
2640 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2641 {
2642 Py_XINCREF(_obj);
2643 }
2644
2645 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2646 {
2647 if (initial_ref) Py_XINCREF(_obj);
2648 }
2649
2650 PyObject_ptr & operator=(const PyObject_ptr& item)
2651 {
2652 Py_XINCREF(item._obj);
2653 Py_XDECREF(_obj);
2654 _obj = item._obj;
2655 return *this;
2656 }
2657
2658 ~PyObject_ptr()
2659 {
2660 Py_XDECREF(_obj);
2661 }
2662
2663 operator PyObject *() const
2664 {
2665 return _obj;
2666 }
2667
2668 PyObject *operator->() const
2669 {
2670 return _obj;
2671 }
2672 };
2673 }
2674
2675
2676 namespace swig {
2677 struct PyObject_var : PyObject_ptr {
2678 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2679
2680 PyObject_var & operator = (PyObject* obj)
2681 {
2682 Py_XDECREF(_obj);
2683 _obj = obj;
2684 return *this;
2685 }
2686 };
2687 }
2688
2689
2690 #include "wx/wxPython/wxPython_int.h"
2691 #include "wx/wxPython/pyclasses.h"
2692 #include "wx/wxPython/twoitem.h"
2693
2694
2695 #ifndef wxPyUSE_EXPORT
2696 // Helper functions for dealing with SWIG objects and such. These are
2697 // located here so they know about the SWIG types and functions declared
2698 // in the wrapper code.
2699
2700 #include <wx/hashmap.h>
2701 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
2702
2703
2704 // Maintains a hashmap of className to swig_type_info pointers. Given the
2705 // name of a class either looks up the type info in the cache, or scans the
2706 // SWIG tables for it.
2707 extern PyObject* wxPyPtrTypeMap;
2708 static
2709 swig_type_info* wxPyFindSwigType(const wxChar* className) {
2710
2711 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
2712
2713 if (typeInfoCache == NULL)
2714 typeInfoCache = new wxPyTypeInfoHashMap;
2715
2716 wxString name(className);
2717 swig_type_info* swigType = (*typeInfoCache)[name];
2718
2719 if (! swigType) {
2720 // it wasn't in the cache, so look it up from SWIG
2721 name.Append(wxT(" *"));
2722 swigType = SWIG_TypeQuery(name.mb_str());
2723
2724 // if it still wasn't found, try looking for a mapped name
2725 if (!swigType) {
2726 PyObject* item;
2727 name = className;
2728
2729 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
2730 (char*)(const char*)name.mbc_str())) != NULL) {
2731 name = wxString(PyString_AsString(item), *wxConvCurrent);
2732 name.Append(wxT(" *"));
2733 swigType = SWIG_TypeQuery(name.mb_str());
2734 }
2735 }
2736 if (swigType) {
2737 // and add it to the map if found
2738 (*typeInfoCache)[className] = swigType;
2739 }
2740 }
2741 return swigType;
2742 }
2743
2744
2745 // Check if a class name is a type known to SWIG
2746 bool wxPyCheckSwigType(const wxChar* className) {
2747
2748 swig_type_info* swigType = wxPyFindSwigType(className);
2749 return swigType != NULL;
2750 }
2751
2752
2753 // Given a pointer to a C++ object and a class name, construct a Python proxy
2754 // object for it.
2755 PyObject* wxPyConstructObject(void* ptr,
2756 const wxChar* className,
2757 int setThisOwn) {
2758
2759 swig_type_info* swigType = wxPyFindSwigType(className);
2760 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
2761
2762 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
2763 }
2764
2765
2766 // Extract a pointer to the wrapped C++ object from a Python proxy object.
2767 // Ensures that the proxy object is of the specified (or derived) type. If
2768 // not able to perform the conversion then a Python exception is set and the
2769 // error should be handled properly in the caller. Returns True on success.
2770 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
2771 const wxChar* className) {
2772
2773 swig_type_info* swigType = wxPyFindSwigType(className);
2774 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
2775
2776 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
2777 }
2778
2779
2780
2781 // Make a SWIGified pointer object suitable for a .this attribute
2782 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
2783
2784 PyObject* robj = NULL;
2785
2786 swig_type_info* swigType = wxPyFindSwigType(className);
2787 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyMakeSwigPtr"));
2788
2789 robj = PySwigObject_New(ptr, swigType, 0);
2790 return robj;
2791 }
2792
2793
2794 // Python's PyInstance_Check does not return True for instances of new-style
2795 // classes. This should get close enough for both new and old classes but I
2796 // should re-evaluate the need for doing instance checks...
2797 bool wxPyInstance_Check(PyObject* obj) {
2798 return PyObject_HasAttrString(obj, "__class__") != 0;
2799 }
2800
2801
2802 // This one checks if the object is an instance of a SWIG proxy class (it has
2803 // a .this attribute, and the .this attribute is a PySwigObject.)
2804 bool wxPySwigInstance_Check(PyObject* obj) {
2805 static PyObject* this_str = NULL;
2806 if (this_str == NULL)
2807 this_str = PyString_FromString("this");
2808
2809 PyObject* this_attr = PyObject_GetAttr(obj, this_str);
2810 if (this_attr) {
2811 bool retval = (PySwigObject_Check(this_attr) != 0);
2812 Py_DECREF(this_attr);
2813 return retval;
2814 }
2815
2816 PyErr_Clear();
2817 return false;
2818 }
2819
2820
2821 // Export a C API in a struct. Other modules will be able to load this from
2822 // the wx._core_ module and will then have safe access to these functions,
2823 // even if they are located in another shared library.
2824 static wxPyCoreAPI API = {
2825
2826 wxPyCheckSwigType,
2827 wxPyConstructObject,
2828 wxPyConvertSwigPtr,
2829 wxPyMakeSwigPtr,
2830
2831 wxPyBeginAllowThreads,
2832 wxPyEndAllowThreads,
2833 wxPyBeginBlockThreads,
2834 wxPyEndBlockThreads,
2835
2836 wxPy_ConvertList,
2837
2838 wxString_in_helper,
2839 Py2wxString,
2840 wx2PyString,
2841
2842 byte_LIST_helper,
2843 int_LIST_helper,
2844 long_LIST_helper,
2845 string_LIST_helper,
2846 wxPoint_LIST_helper,
2847 wxBitmap_LIST_helper,
2848 wxString_LIST_helper,
2849 wxAcceleratorEntry_LIST_helper,
2850
2851 wxSize_helper,
2852 wxPoint_helper,
2853 wxRealPoint_helper,
2854 wxRect_helper,
2855 wxColour_helper,
2856 wxPoint2D_helper,
2857
2858 wxPySimple_typecheck,
2859 wxColour_typecheck,
2860
2861 wxPyCBH_setCallbackInfo,
2862 wxPyCBH_findCallback,
2863 wxPyCBH_callCallback,
2864 wxPyCBH_callCallbackObj,
2865 wxPyCBH_delete,
2866
2867 wxPyMake_wxObject,
2868 wxPyMake_wxSizer,
2869 wxPyPtrTypeMap_Add,
2870 wxPy2int_seq_helper,
2871 wxPy4int_seq_helper,
2872 wxArrayString2PyList_helper,
2873 wxArrayInt2PyList_helper,
2874
2875 wxPyClientData_dtor,
2876 wxPyUserData_dtor,
2877 wxPyOORClientData_dtor,
2878
2879 wxPyCBInputStream_create,
2880 wxPyCBInputStream_copy,
2881
2882 wxPyInstance_Check,
2883 wxPySwigInstance_Check,
2884
2885 wxPyCheckForApp
2886
2887 };
2888
2889 #endif
2890
2891
2892 #if !WXWIN_COMPATIBILITY_2_4
2893 #define wxHIDE_READONLY 0
2894 #endif
2895
2896
2897 #define SWIG_From_long PyInt_FromLong
2898
2899
2900 SWIGINTERNINLINE PyObject *
2901 SWIG_From_int (int value)
2902 {
2903 return SWIG_From_long (value);
2904 }
2905
2906 static const wxString wxPyEmptyString(wxEmptyString);
2907 SWIGINTERN wxString wxObject_GetClassName(wxObject *self){
2908 return self->GetClassInfo()->GetClassName();
2909 }
2910 SWIGINTERN void wxObject_Destroy(wxObject *self){
2911 delete self;
2912 }
2913
2914 #ifndef __WXMAC__
2915 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
2916 #endif
2917
2918
2919 #include <limits.h>
2920 #ifndef LLONG_MIN
2921 # define LLONG_MIN LONG_LONG_MIN
2922 #endif
2923 #ifndef LLONG_MAX
2924 # define LLONG_MAX LONG_LONG_MAX
2925 #endif
2926 #ifndef ULLONG_MAX
2927 # define ULLONG_MAX ULONG_LONG_MAX
2928 #endif
2929
2930
2931 SWIGINTERN int
2932 SWIG_AsVal_long (PyObject* obj, long* val)
2933 {
2934 if (PyNumber_Check(obj)) {
2935 if (val) *val = PyInt_AsLong(obj);
2936 return SWIG_OK;
2937 }
2938 return SWIG_TypeError;
2939 }
2940
2941
2942 SWIGINTERN int
2943 SWIG_AsVal_int (PyObject * obj, int *val)
2944 {
2945 long v;
2946 int res = SWIG_AsVal_long (obj, &v);
2947 if (SWIG_IsOK(res)) {
2948 if ((v < INT_MIN || v > INT_MAX)) {
2949 return SWIG_OverflowError;
2950 } else {
2951 if (val) *val = static_cast< int >(v);
2952 }
2953 }
2954 return res;
2955 }
2956
2957 SWIGINTERN bool wxSize___eq__(wxSize *self,PyObject *other){
2958 wxSize temp, *obj = &temp;
2959 if ( other == Py_None ) return false;
2960 if ( ! wxSize_helper(other, &obj) ) {
2961 PyErr_Clear();
2962 return false;
2963 }
2964 return self->operator==(*obj);
2965 }
2966 SWIGINTERN bool wxSize___ne__(wxSize *self,PyObject *other){
2967 wxSize temp, *obj = &temp;
2968 if ( other == Py_None ) return true;
2969 if ( ! wxSize_helper(other, &obj)) {
2970 PyErr_Clear();
2971 return true;
2972 }
2973 return self->operator!=(*obj);
2974 }
2975 SWIGINTERN PyObject *wxSize_Get(wxSize *self){
2976 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2977 PyObject* tup = PyTuple_New(2);
2978 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
2979 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
2980 wxPyEndBlockThreads(blocked);
2981 return tup;
2982 }
2983
2984 SWIGINTERN int
2985 SWIG_AsVal_double (PyObject *obj, double* val)
2986 {
2987 if (PyNumber_Check(obj)) {
2988 if (val) *val = PyFloat_AsDouble(obj);
2989 return SWIG_OK;
2990 }
2991 return SWIG_TypeError;
2992 }
2993
2994
2995 #define SWIG_From_double PyFloat_FromDouble
2996
2997 SWIGINTERN bool wxRealPoint___eq__(wxRealPoint *self,PyObject *other){
2998 wxRealPoint temp, *obj = &temp;
2999 if ( other == Py_None ) return false;
3000 if ( ! wxRealPoint_helper(other, &obj) ) {
3001 PyErr_Clear();
3002 return false;
3003 }
3004 return self->operator==(*obj);
3005 }
3006 SWIGINTERN bool wxRealPoint___ne__(wxRealPoint *self,PyObject *other){
3007 wxRealPoint temp, *obj = &temp;
3008 if ( other == Py_None ) return true;
3009 if ( ! wxRealPoint_helper(other, &obj)) {
3010 PyErr_Clear();
3011 return true;
3012 }
3013 return self->operator!=(*obj);
3014 }
3015 SWIGINTERN void wxRealPoint_Set(wxRealPoint *self,double x,double y){
3016 self->x = x;
3017 self->y = y;
3018 }
3019 SWIGINTERN PyObject *wxRealPoint_Get(wxRealPoint *self){
3020 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3021 PyObject* tup = PyTuple_New(2);
3022 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
3023 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
3024 wxPyEndBlockThreads(blocked);
3025 return tup;
3026 }
3027 SWIGINTERN bool wxPoint___eq__(wxPoint *self,PyObject *other){
3028 wxPoint temp, *obj = &temp;
3029 if ( other == Py_None ) return false;
3030 if ( ! wxPoint_helper(other, &obj) ) {
3031 PyErr_Clear();
3032 return false;
3033 }
3034 return self->operator==(*obj);
3035 }
3036 SWIGINTERN bool wxPoint___ne__(wxPoint *self,PyObject *other){
3037 wxPoint temp, *obj = &temp;
3038 if ( other == Py_None ) return true;
3039 if ( ! wxPoint_helper(other, &obj)) {
3040 PyErr_Clear();
3041 return true;
3042 }
3043 return self->operator!=(*obj);
3044 }
3045 SWIGINTERN void wxPoint_Set(wxPoint *self,long x,long y){
3046 self->x = x;
3047 self->y = y;
3048 }
3049 SWIGINTERN PyObject *wxPoint_Get(wxPoint *self){
3050 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3051 PyObject* tup = PyTuple_New(2);
3052 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3053 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3054 wxPyEndBlockThreads(blocked);
3055 return tup;
3056 }
3057 SWIGINTERN bool wxRect___eq__(wxRect *self,PyObject *other){
3058 wxRect temp, *obj = &temp;
3059 if ( other == Py_None ) return false;
3060 if ( ! wxRect_helper(other, &obj) ) {
3061 PyErr_Clear();
3062 return false;
3063 }
3064 return self->operator==(*obj);
3065 }
3066 SWIGINTERN bool wxRect___ne__(wxRect *self,PyObject *other){
3067 wxRect temp, *obj = &temp;
3068 if ( other == Py_None ) return true;
3069 if ( ! wxRect_helper(other, &obj)) {
3070 PyErr_Clear();
3071 return true;
3072 }
3073 return self->operator!=(*obj);
3074 }
3075 SWIGINTERN void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
3076 self->x = x;
3077 self->y = y;
3078 self->width = width;
3079 self->height = height;
3080 }
3081 SWIGINTERN PyObject *wxRect_Get(wxRect *self){
3082 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3083 PyObject* tup = PyTuple_New(4);
3084 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3085 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3086 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
3087 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
3088 wxPyEndBlockThreads(blocked);
3089 return tup;
3090 }
3091
3092 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
3093 wxRegion reg1(*r1);
3094 wxRegion reg2(*r2);
3095 wxRect dest(0,0,0,0);
3096 PyObject* obj;
3097
3098 reg1.Intersect(reg2);
3099 dest = reg1.GetBox();
3100
3101 if (dest != wxRect(0,0,0,0)) {
3102 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3103 wxRect* newRect = new wxRect(dest);
3104 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
3105 wxPyEndBlockThreads(blocked);
3106 return obj;
3107 }
3108 Py_INCREF(Py_None);
3109 return Py_None;
3110 }
3111
3112 SWIGINTERN bool wxPoint2D___eq__(wxPoint2D *self,PyObject *other){
3113 wxPoint2D temp, *obj = &temp;
3114 if ( other == Py_None ) return false;
3115 if ( ! wxPoint2D_helper(other, &obj) ) {
3116 PyErr_Clear();
3117 return false;
3118 }
3119 return self->operator==(*obj);
3120 }
3121 SWIGINTERN bool wxPoint2D___ne__(wxPoint2D *self,PyObject *other){
3122 wxPoint2D temp, *obj = &temp;
3123 if ( other == Py_None ) return true;
3124 if ( ! wxPoint2D_helper(other, &obj)) {
3125 PyErr_Clear();
3126 return true;
3127 }
3128 return self->operator!=(*obj);
3129 }
3130 SWIGINTERN void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
3131 self->m_x = x;
3132 self->m_y = y;
3133 }
3134 SWIGINTERN PyObject *wxPoint2D_Get(wxPoint2D *self){
3135 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3136 PyObject* tup = PyTuple_New(2);
3137 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
3138 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
3139 wxPyEndBlockThreads(blocked);
3140 return tup;
3141 }
3142
3143 #include "wx/wxPython/pyistream.h"
3144
3145 SWIGINTERN wxPyInputStream *new_wxPyInputStream(PyObject *p){
3146 wxInputStream* wxis = wxPyCBInputStream::create(p);
3147 if (wxis)
3148 return new wxPyInputStream(wxis);
3149 else
3150 return NULL;
3151 }
3152
3153 SWIGINTERN swig_type_info*
3154 SWIG_pchar_descriptor()
3155 {
3156 static int init = 0;
3157 static swig_type_info* info = 0;
3158 if (!init) {
3159 info = SWIG_TypeQuery("_p_char");
3160 init = 1;
3161 }
3162 return info;
3163 }
3164
3165
3166 SWIGINTERNINLINE PyObject *
3167 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3168 {
3169 if (carray) {
3170 if (size > INT_MAX) {
3171 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3172 return pchar_descriptor ?
3173 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3174 } else {
3175 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3176 }
3177 } else {
3178 return SWIG_Py_Void();
3179 }
3180 }
3181
3182
3183 SWIGINTERNINLINE PyObject *
3184 SWIG_From_char (char c)
3185 {
3186 return SWIG_FromCharPtrAndSize(&c,1);
3187 }
3188
3189
3190 SWIGINTERNINLINE PyObject*
3191 SWIG_From_unsigned_SS_long (unsigned long value)
3192 {
3193 return (value > LONG_MAX) ?
3194 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
3195 }
3196
3197
3198 SWIGINTERNINLINE PyObject *
3199 SWIG_From_size_t (size_t value)
3200 {
3201 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
3202 }
3203
3204
3205 SWIGINTERN int
3206 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
3207 {
3208 if (PyString_Check(obj)) {
3209 char *cstr; int len;
3210 PyString_AsStringAndSize(obj, &cstr, &len);
3211 if (cptr) {
3212 if (alloc) {
3213 /*
3214 In python the user should not be able to modify the inner
3215 string representation. To warranty that, if you define
3216 SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
3217 buffer is always returned.
3218
3219 The default behavior is just to return the pointer value,
3220 so, be careful.
3221 */
3222 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
3223 if (*alloc != SWIG_OLDOBJ)
3224 #else
3225 if (*alloc == SWIG_NEWOBJ)
3226 #endif
3227 {
3228 *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
3229 *alloc = SWIG_NEWOBJ;
3230 }
3231 else {
3232 *cptr = cstr;
3233 *alloc = SWIG_OLDOBJ;
3234 }
3235 } else {
3236 *cptr = PyString_AsString(obj);
3237 }
3238 }
3239 if (psize) *psize = len + 1;
3240 return SWIG_OK;
3241 } else {
3242 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3243 if (pchar_descriptor) {
3244 void* vptr = 0;
3245 if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3246 if (cptr) *cptr = (char *) vptr;
3247 if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3248 if (alloc) *alloc = SWIG_OLDOBJ;
3249 return SWIG_OK;
3250 }
3251 }
3252 }
3253 return SWIG_TypeError;
3254 }
3255
3256
3257 SWIGINTERN int
3258 SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
3259 {
3260 char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3261 int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3262 if (SWIG_IsOK(res)) {
3263 if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
3264 if (csize <= size) {
3265 if (val) {
3266 if (csize) memcpy(val, cptr, csize*sizeof(char));
3267 if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3268 }
3269 if (alloc == SWIG_NEWOBJ) {
3270 delete[] cptr;
3271 res = SWIG_DelNewMask(res);
3272 }
3273 return res;
3274 }
3275 if (alloc == SWIG_NEWOBJ) delete[] cptr;
3276 }
3277 return SWIG_TypeError;
3278 }
3279
3280
3281 SWIGINTERN int
3282 SWIG_AsVal_char (PyObject * obj, char *val)
3283 {
3284 int res = SWIG_AsCharArray(obj, val, 1);
3285 if (!SWIG_IsOK(res)) {
3286 long v;
3287 res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3288 if (SWIG_IsOK(res)) {
3289 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3290 if (val) *val = static_cast< char >(v);
3291 } else {
3292 res = SWIG_OverflowError;
3293 }
3294 }
3295 }
3296 return res;
3297 }
3298
3299 SWIGINTERN void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
3300 // We use only strings for the streams, not unicode
3301 PyObject* str = PyObject_Str(obj);
3302 if (! str) {
3303 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
3304 return;
3305 }
3306 self->Write(PyString_AS_STRING(str),
3307 PyString_GET_SIZE(str));
3308 Py_DECREF(str);
3309 }
3310
3311 #include "wx/wxPython/pyistream.h"
3312
3313
3314 class wxPyFileSystemHandler : public wxFileSystemHandler
3315 {
3316 public:
3317 wxPyFileSystemHandler() : wxFileSystemHandler() {}
3318
3319 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
3320 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
3321 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
3322 DEC_PYCALLBACK_STRING__pure(FindNext);
3323
3324 wxString GetProtocol(const wxString& location) {
3325 return wxFileSystemHandler::GetProtocol(location);
3326 }
3327
3328 wxString GetLeftLocation(const wxString& location) {
3329 return wxFileSystemHandler::GetLeftLocation(location);
3330 }
3331
3332 wxString GetAnchor(const wxString& location) {
3333 return wxFileSystemHandler::GetAnchor(location);
3334 }
3335
3336 wxString GetRightLocation(const wxString& location) {
3337 return wxFileSystemHandler::GetRightLocation(location);
3338 }
3339
3340 wxString GetMimeTypeFromExt(const wxString& location) {
3341 return wxFileSystemHandler::GetMimeTypeFromExt(location);
3342 }
3343
3344 PYPRIVATE;
3345 };
3346
3347
3348 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
3349 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
3350 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
3351 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
3352
3353
3354 SWIGINTERN int
3355 SWIG_AsVal_bool (PyObject *obj, bool *val)
3356 {
3357 if (obj == Py_True) {
3358 if (val) *val = true;
3359 return SWIG_OK;
3360 } else if (obj == Py_False) {
3361 if (val) *val = false;
3362 return SWIG_OK;
3363 } else {
3364 long v = 0;
3365 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
3366 if (SWIG_IsOK(res) && val) *val = v ? true : false;
3367 return res;
3368 }
3369 }
3370
3371 SWIGINTERN wxString wxFileSystem_URLToFileName(wxString const &url){
3372 wxFileName fname = wxFileSystem::URLToFileName(url);
3373 return fname.GetFullPath();
3374 }
3375
3376 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
3377 wxImage& image,
3378 long type) {
3379 wxMemoryFSHandler::AddFile(filename, image, type);
3380 }
3381
3382 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
3383 const wxBitmap& bitmap,
3384 long type) {
3385 wxMemoryFSHandler::AddFile(filename, bitmap, type);
3386 }
3387
3388 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
3389 PyObject* data) {
3390 if (! PyString_Check(data)) {
3391 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
3392 "Expected string object"));
3393 return;
3394 }
3395
3396 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3397 void* ptr = (void*)PyString_AsString(data);
3398 size_t size = PyString_Size(data);
3399 wxPyEndBlockThreads(blocked);
3400
3401 wxMemoryFSHandler::AddFile(filename, ptr, size);
3402 }
3403
3404
3405 #include "wx/wxPython/pyistream.h"
3406
3407
3408 SWIGINTERN int
3409 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
3410 {
3411 long v = 0;
3412 if (SWIG_AsVal_long(obj, &v) && v < 0) {
3413 return SWIG_TypeError;
3414 }
3415 else if (val)
3416 *val = (unsigned long)v;
3417 return SWIG_OK;
3418 }
3419
3420
3421 SWIGINTERN int
3422 SWIG_AsVal_unsigned_SS_char (PyObject * obj, unsigned char *val)
3423 {
3424 unsigned long v;
3425 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3426 if (SWIG_IsOK(res)) {
3427 if ((v > UCHAR_MAX)) {
3428 return SWIG_OverflowError;
3429 } else {
3430 if (val) *val = static_cast< unsigned char >(v);
3431 }
3432 }
3433 return res;
3434 }
3435
3436
3437 SWIGINTERNINLINE PyObject *
3438 SWIG_From_unsigned_SS_char (unsigned char value)
3439 {
3440 return SWIG_From_unsigned_SS_long (value);
3441 }
3442
3443 SWIGINTERN unsigned long wxImageHistogram_GetCount(wxImageHistogram *self,unsigned long key){
3444 wxImageHistogramEntry e = (*self)[key];
3445 return e.value;
3446 }
3447 SWIGINTERN unsigned long wxImageHistogram_GetCountRGB(wxImageHistogram *self,byte r,byte g,byte b){
3448 unsigned long key = wxImageHistogram::MakeKey(r, g, b);
3449 wxImageHistogramEntry e = (*self)[key];
3450 return e.value;
3451 }
3452 SWIGINTERN unsigned long wxImageHistogram_GetCountColour(wxImageHistogram *self,wxColour const &colour){
3453 unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
3454 colour.Green(),
3455 colour.Blue());
3456 wxImageHistogramEntry e = (*self)[key];
3457 return e.value;
3458 }
3459
3460 typedef unsigned char* buffer;
3461
3462
3463 // Pull the nested class out to the top level for SWIG's sake
3464 #define wxImage_RGBValue wxImage::RGBValue
3465 #define wxImage_HSVValue wxImage::HSVValue
3466
3467 SWIGINTERN wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
3468 if (width > 0 && height > 0)
3469 return new wxImage(width, height, clear);
3470 else
3471 return new wxImage;
3472 }
3473 SWIGINTERN wxImage *new_wxImage(wxBitmap const &bitmap){
3474 return new wxImage(bitmap.ConvertToImage());
3475 }
3476 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE){
3477 if (DATASIZE != width*height*3) {
3478 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3479 return NULL;
3480 }
3481
3482 // Copy the source data so the wxImage can clean it up later
3483 buffer copy = (buffer)malloc(DATASIZE);
3484 if (copy == NULL) {
3485 wxPyBLOCK_THREADS(PyErr_NoMemory());
3486 return NULL;
3487 }
3488 memcpy(copy, data, DATASIZE);
3489 return new wxImage(width, height, copy, false);
3490 }
3491 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE,buffer alpha,int ALPHASIZE){
3492 if (DATASIZE != width*height*3) {
3493 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3494 return NULL;
3495 }
3496 if (ALPHASIZE != width*height) {
3497 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3498 return NULL;
3499 }
3500
3501 // Copy the source data so the wxImage can clean it up later
3502 buffer dcopy = (buffer)malloc(DATASIZE);
3503 if (dcopy == NULL) {
3504 wxPyBLOCK_THREADS(PyErr_NoMemory());
3505 return NULL;
3506 }
3507 memcpy(dcopy, data, DATASIZE);
3508
3509 buffer acopy = (buffer)malloc(ALPHASIZE);
3510 if (acopy == NULL) {
3511 wxPyBLOCK_THREADS(PyErr_NoMemory());
3512 return NULL;
3513 }
3514 memcpy(acopy, alpha, ALPHASIZE);
3515
3516 return new wxImage(width, height, dcopy, acopy, false);
3517 }
3518 SWIGINTERN wxSize wxImage_GetSize(wxImage *self){
3519 wxSize size(self->GetWidth(), self->GetHeight());
3520 return size;
3521 }
3522 SWIGINTERN PyObject *wxImage_GetData(wxImage *self){
3523 buffer data = self->GetData();
3524 int len = self->GetWidth() * self->GetHeight() * 3;
3525 PyObject* rv;
3526 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
3527 return rv;
3528 }
3529 SWIGINTERN void wxImage_SetData(wxImage *self,buffer data,int DATASIZE){
3530 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3531 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3532 return;
3533 }
3534 buffer copy = (buffer)malloc(DATASIZE);
3535 if (copy == NULL) {
3536 wxPyBLOCK_THREADS(PyErr_NoMemory());
3537 return;
3538 }
3539 memcpy(copy, data, DATASIZE);
3540 self->SetData(copy, false);
3541 // wxImage takes ownership of copy...
3542 }
3543 SWIGINTERN PyObject *wxImage_GetDataBuffer(wxImage *self){
3544 buffer data = self->GetData();
3545 int len = self->GetWidth() * self->GetHeight() * 3;
3546 PyObject* rv;
3547 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3548 return rv;
3549 }
3550 SWIGINTERN void wxImage_SetDataBuffer(wxImage *self,buffer data,int DATASIZE){
3551 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3552 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3553 return;
3554 }
3555 self->SetData(data, true);
3556 }
3557 SWIGINTERN PyObject *wxImage_GetAlphaData(wxImage *self){
3558 buffer data = self->GetAlpha();
3559 if (! data) {
3560 RETURN_NONE();
3561 } else {
3562 int len = self->GetWidth() * self->GetHeight();
3563 PyObject* rv;
3564 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
3565 return rv;
3566 }
3567 }
3568 SWIGINTERN void wxImage_SetAlphaData(wxImage *self,buffer alpha,int ALPHASIZE){
3569 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3570 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3571 return;
3572 }
3573 buffer acopy = (buffer)malloc(ALPHASIZE);
3574 if (acopy == NULL) {
3575 wxPyBLOCK_THREADS(PyErr_NoMemory());
3576 return;
3577 }
3578 memcpy(acopy, alpha, ALPHASIZE);
3579 self->SetAlpha(acopy, false);
3580 // wxImage takes ownership of acopy...
3581 }
3582 SWIGINTERN PyObject *wxImage_GetAlphaBuffer(wxImage *self){
3583 buffer data = self->GetAlpha();
3584 int len = self->GetWidth() * self->GetHeight();
3585 PyObject* rv;
3586 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3587 return rv;
3588 }
3589 SWIGINTERN void wxImage_SetAlphaBuffer(wxImage *self,buffer alpha,int ALPHASIZE){
3590 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3591 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3592 return;
3593 }
3594 self->SetAlpha(alpha, true);
3595 }
3596 SWIGINTERN PyObject *wxImage_GetHandlers(){
3597 wxList& list = wxImage::GetHandlers();
3598 return wxPy_ConvertList(&list);
3599 }
3600 SWIGINTERN wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
3601 wxBitmap bitmap(*self, depth);
3602 return bitmap;
3603 }
3604 SWIGINTERN wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,byte red,byte green,byte blue){
3605 wxImage mono = self->ConvertToMono( red, green, blue );
3606 wxBitmap bitmap( mono, 1 );
3607 return bitmap;
3608 }
3609 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
3610 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
3611 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
3612 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
3613 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
3614 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
3615 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
3616 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
3617 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
3618 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
3619 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
3620 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
3621 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
3622 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
3623 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
3624
3625 #include <wx/quantize.h>
3626
3627 SWIGINTERN bool wxQuantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
3628 return wxQuantize::Quantize(src, dest,
3629 //NULL, // palette
3630 desiredNoColours,
3631 NULL, // eightBitData
3632 flags);
3633 }
3634 SWIGINTERN void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
3635 if (PyCallable_Check(func)) {
3636 self->Connect(id, lastId, eventType,
3637 (wxObjectEventFunction) &wxPyCallback::EventThunker,
3638 new wxPyCallback(func));
3639 }
3640 else if (func == Py_None) {
3641 self->Disconnect(id, lastId, eventType,
3642 (wxObjectEventFunction)
3643 &wxPyCallback::EventThunker);
3644 }
3645 else {
3646 wxPyBLOCK_THREADS(
3647 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
3648 }
3649 }
3650 SWIGINTERN bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
3651 return self->Disconnect(id, lastId, eventType,
3652 (wxObjectEventFunction)
3653 &wxPyCallback::EventThunker);
3654 }
3655 SWIGINTERN void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
3656 if (_self && _self != Py_None) {
3657 self->SetClientObject(new wxPyOORClientData(_self, incref));
3658 }
3659 else {
3660 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
3661 if (data) {
3662 self->SetClientObject(NULL); // This will delete it too
3663 }
3664 }
3665 }
3666
3667 #if ! wxUSE_HOTKEY
3668 #define wxEVT_HOTKEY -9999
3669 #endif
3670
3671 SWIGINTERN PyObject *wxCommandEvent_GetClientData(wxCommandEvent *self){
3672 wxPyClientData* data = (wxPyClientData*)self->GetClientObject();
3673 if (data) {
3674 Py_INCREF(data->m_obj);
3675 return data->m_obj;
3676 } else {
3677 Py_INCREF(Py_None);
3678 return Py_None;
3679 }
3680 }
3681 SWIGINTERN void wxCommandEvent_SetClientData(wxCommandEvent *self,PyObject *clientData){
3682 wxPyClientData* data = new wxPyClientData(clientData);
3683 self->SetClientObject(data);
3684 }
3685 SWIGINTERN int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
3686 #if wxUSE_UNICODE
3687 return self->GetUnicodeKey();
3688 #else
3689 return 0;
3690 #endif
3691 }
3692
3693 SWIGINTERNINLINE PyObject *
3694 SWIG_From_unsigned_SS_int (unsigned int value)
3695 {
3696 return SWIG_From_unsigned_SS_long (value);
3697 }
3698
3699
3700 SWIGINTERN int
3701 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3702 {
3703 unsigned long v;
3704 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3705 if (SWIG_IsOK(res)) {
3706 if ((v > UINT_MAX)) {
3707 return SWIG_OverflowError;
3708 } else {
3709 if (val) *val = static_cast< unsigned int >(v);
3710 }
3711 }
3712 return res;
3713 }
3714
3715 SWIGINTERN void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
3716 self->m_size = size;
3717 }
3718 SWIGINTERN PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
3719 int count = self->GetNumberOfFiles();
3720 wxString* files = self->GetFiles();
3721 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3722 PyObject* list = PyList_New(count);
3723
3724 if (!list) {
3725 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
3726 wxPyEndBlockThreads(blocked);
3727 return NULL;
3728 }
3729
3730 for (int i=0; i<count; i++) {
3731 PyList_SetItem(list, i, wx2PyString(files[i]));
3732 }
3733 wxPyEndBlockThreads(blocked);
3734 return list;
3735 }
3736
3737
3738 SWIGINTERN wxPyApp *new_wxPyApp(){
3739 wxPythonApp = new wxPyApp();
3740 return wxPythonApp;
3741 }
3742 SWIGINTERN int wxPyApp_GetComCtl32Version(){ wxPyRaiseNotImplemented(); return 0; }
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 SWIGINTERN void wxWindow_DragAcceptFiles(wxWindow *self,bool accept){}
3814
3815 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
3816 return wxWindow::FindWindowById(id, parent);
3817 }
3818
3819 wxWindow* wxFindWindowByName( const wxString& name,
3820 const wxWindow *parent = NULL ) {
3821 return wxWindow::FindWindowByName(name, parent);
3822 }
3823
3824 wxWindow* wxFindWindowByLabel( const wxString& label,
3825 const wxWindow *parent = NULL ) {
3826 return wxWindow::FindWindowByLabel(label, parent);
3827 }
3828
3829
3830 #ifdef __WXMSW__
3831 #include <wx/msw/private.h> // to get wxGetWindowId
3832 #endif
3833
3834
3835 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
3836 #ifdef __WXMSW__
3837 WXHWND hWnd = (WXHWND)_hWnd;
3838 long id = wxGetWindowId(hWnd);
3839 wxWindow* win = new wxWindow;
3840 if (parent)
3841 parent->AddChild(win);
3842 win->SetEventHandler(win);
3843 win->SetHWND(hWnd);
3844 win->SetId(id);
3845 win->SubclassWin(hWnd);
3846 win->AdoptAttributesFromHWND();
3847 win->SetupColours();
3848 return win;
3849 #else
3850 wxPyRaiseNotImplemented();
3851 return NULL;
3852 #endif
3853 }
3854
3855
3856 PyObject* GetTopLevelWindows() {
3857 return wxPy_ConvertList(&wxTopLevelWindows);
3858 }
3859
3860
3861 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
3862 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
3863 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
3864
3865 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
3866
3867
3868 SWIGINTERNINLINE int
3869 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3870 {
3871 unsigned long v;
3872 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3873 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3874 return res;
3875 }
3876
3877 SWIGINTERN void wxMenu_Destroy(wxMenu *self){ delete self; }
3878 SWIGINTERN PyObject *wxMenu_GetMenuItems(wxMenu *self){
3879 wxMenuItemList& list = self->GetMenuItems();
3880 return wxPy_ConvertList(&list);
3881 }
3882 SWIGINTERN void wxMenuBar_SetAutoWindowMenu(bool enable){}
3883 SWIGINTERN bool wxMenuBar_GetAutoWindowMenu(){ return false; }
3884 SWIGINTERN void wxMenuItem_SetFont(wxMenuItem *self,wxFont const &font){}
3885 SWIGINTERN wxFont wxMenuItem_GetFont(wxMenuItem *self){ return wxNullFont; }
3886 SWIGINTERN void wxMenuItem_SetTextColour(wxMenuItem *self,wxColour const &colText){}
3887 SWIGINTERN wxColour wxMenuItem_GetTextColour(wxMenuItem *self){ return wxNullColour; }
3888 SWIGINTERN void wxMenuItem_SetBackgroundColour(wxMenuItem *self,wxColour const &colBack){}
3889 SWIGINTERN wxColour wxMenuItem_GetBackgroundColour(wxMenuItem *self){ return wxNullColour; }
3890 SWIGINTERN void wxMenuItem_SetBitmaps(wxMenuItem *self,wxBitmap const &bmpChecked,wxBitmap const &bmpUnchecked=wxNullBitmap){ self->SetBitmap( bmpChecked ); }
3891 SWIGINTERN void wxMenuItem_SetDisabledBitmap(wxMenuItem *self,wxBitmap const &bmpDisabled){}
3892 SWIGINTERN wxBitmap const &wxMenuItem_GetDisabledBitmap(wxMenuItem const *self){ return wxNullBitmap; }
3893 SWIGINTERN void wxMenuItem_SetMarginWidth(wxMenuItem *self,int nWidth){}
3894 SWIGINTERN int wxMenuItem_GetMarginWidth(wxMenuItem *self){ return 0; }
3895 SWIGINTERN int wxMenuItem_GetDefaultMarginWidth(){ return 0; }
3896 SWIGINTERN bool wxMenuItem_IsOwnerDrawn(wxMenuItem *self){ return false; }
3897 SWIGINTERN void wxMenuItem_SetOwnerDrawn(wxMenuItem *self,bool ownerDrawn=true){}
3898 SWIGINTERN void wxMenuItem_ResetOwnerDrawn(wxMenuItem *self){}
3899 static const wxString wxPyControlNameStr(wxControlNameStr);
3900 SWIGINTERN int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
3901 if (clientData) {
3902 wxPyClientData* data = new wxPyClientData(clientData);
3903 return self->Append(item, data);
3904 } else
3905 return self->Append(item);
3906 }
3907 SWIGINTERN int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,unsigned int pos,PyObject *clientData=NULL){
3908 if (clientData) {
3909 wxPyClientData* data = new wxPyClientData(clientData);
3910 return self->Insert(item, pos, data);
3911 } else
3912 return self->Insert(item, pos);
3913 }
3914 SWIGINTERN PyObject *wxItemContainer_GetClientData(wxItemContainer *self,unsigned int n){
3915 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
3916 if (data) {
3917 Py_INCREF(data->m_obj);
3918 return data->m_obj;
3919 } else {
3920 Py_INCREF(Py_None);
3921 return Py_None;
3922 }
3923 }
3924 SWIGINTERN void wxItemContainer_SetClientData(wxItemContainer *self,unsigned int n,PyObject *clientData){
3925 wxPyClientData* data = new wxPyClientData(clientData);
3926 self->SetClientObject(n, data);
3927 }
3928
3929
3930 SWIGINTERN wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
3931 wxPyUserData* data = NULL;
3932 if ( userData ) {
3933 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3934 data = new wxPyUserData(userData);
3935 wxPyEndBlockThreads(blocked);
3936 }
3937 return new wxSizerItem(window, proportion, flag, border, data);
3938 }
3939 SWIGINTERN wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
3940 wxPyUserData* data = NULL;
3941 if ( userData ) {
3942 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3943 data = new wxPyUserData(userData);
3944 wxPyEndBlockThreads(blocked);
3945 }
3946 return new wxSizerItem(width, height, proportion, flag, border, data);
3947 }
3948 SWIGINTERN wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
3949 wxPyUserData* data = NULL;
3950 if ( userData ) {
3951 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3952 data = new wxPyUserData(userData);
3953 wxPyEndBlockThreads(blocked);
3954 }
3955 return new wxSizerItem(sizer, proportion, flag, border, data);
3956 }
3957
3958 #include <float.h>
3959
3960
3961 SWIGINTERN int
3962 SWIG_AsVal_float (PyObject * obj, float *val)
3963 {
3964 double v;
3965 int res = SWIG_AsVal_double (obj, &v);
3966 if (SWIG_IsOK(res)) {
3967 if ((v < -FLT_MAX || v > FLT_MAX)) {
3968 return SWIG_OverflowError;
3969 } else {
3970 if (val) *val = static_cast< float >(v);
3971 }
3972 }
3973 return res;
3974 }
3975
3976
3977 SWIGINTERNINLINE PyObject *
3978 SWIG_From_float (float value)
3979 {
3980 return SWIG_From_double (value);
3981 }
3982
3983 SWIGINTERN PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
3984 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
3985 if (data) {
3986 Py_INCREF(data->m_obj);
3987 return data->m_obj;
3988 } else {
3989 Py_INCREF(Py_None);
3990 return Py_None;
3991 }
3992 }
3993 SWIGINTERN void wxSizerItem_SetUserData(wxSizerItem *self,PyObject *userData){
3994 wxPyUserData* data = NULL;
3995 if ( userData ) {
3996 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3997 data = new wxPyUserData(userData);
3998 wxPyEndBlockThreads(blocked);
3999 }
4000 self->SetUserData(data);
4001 }
4002
4003 // Figure out the type of the sizer item
4004
4005 struct wxPySizerItemInfo {
4006 wxPySizerItemInfo()
4007 : window(NULL), sizer(NULL), gotSize(false),
4008 size(wxDefaultSize), gotPos(false), pos(-1)
4009 {}
4010
4011 wxWindow* window;
4012 wxSizer* sizer;
4013 bool gotSize;
4014 wxSize size;
4015 bool gotPos;
4016 int pos;
4017 };
4018
4019 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
4020
4021 wxPySizerItemInfo info;
4022 wxSize size;
4023 wxSize* sizePtr = &size;
4024
4025 // Find out what the type of the item is
4026 // try wxWindow
4027 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
4028 PyErr_Clear();
4029 info.window = NULL;
4030
4031 // try wxSizer
4032 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
4033 PyErr_Clear();
4034 info.sizer = NULL;
4035
4036 // try wxSize or (w,h)
4037 if ( checkSize && wxSize_helper(item, &sizePtr)) {
4038 info.size = *sizePtr;
4039 info.gotSize = true;
4040 }
4041
4042 // or a single int
4043 if (checkIdx && PyInt_Check(item)) {
4044 info.pos = PyInt_AsLong(item);
4045 info.gotPos = true;
4046 }
4047 }
4048 }
4049
4050 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
4051 // no expected type, figure out what kind of error message to generate
4052 if ( !checkSize && !checkIdx )
4053 PyErr_SetString(PyExc_TypeError, "wx.Window or wx.Sizer expected for item");
4054 else if ( checkSize && !checkIdx )
4055 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) expected for item");
4056 else if ( !checkSize && checkIdx)
4057 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer or int (position) expected for item");
4058 else
4059 // can this one happen?
4060 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) or int (position) expected for item");
4061 }
4062
4063 return info;
4064 }
4065
4066 SWIGINTERN void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
4067 if (!self->GetClientObject())
4068 self->SetClientObject(new wxPyOORClientData(_self));
4069 }
4070 SWIGINTERN wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4071
4072 wxPyUserData* data = NULL;
4073 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4074 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4075 if ( userData && (info.window || info.sizer || info.gotSize) )
4076 data = new wxPyUserData(userData);
4077 if ( info.sizer )
4078 PyObject_SetAttrString(item,"thisown",Py_False);
4079 wxPyEndBlockThreads(blocked);
4080
4081 // Now call the real Add method if a valid item type was found
4082 if ( info.window )
4083 return self->Add(info.window, proportion, flag, border, data);
4084 else if ( info.sizer )
4085 return self->Add(info.sizer, proportion, flag, border, data);
4086 else if (info.gotSize)
4087 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
4088 proportion, flag, border, data);
4089 else
4090 return NULL;
4091 }
4092 SWIGINTERN wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4093
4094 wxPyUserData* data = NULL;
4095 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4096 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4097 if ( userData && (info.window || info.sizer || info.gotSize) )
4098 data = new wxPyUserData(userData);
4099 if ( info.sizer )
4100 PyObject_SetAttrString(item,"thisown",Py_False);
4101 wxPyEndBlockThreads(blocked);
4102
4103 // Now call the real Insert method if a valid item type was found
4104 if ( info.window )
4105 return self->Insert(before, info.window, proportion, flag, border, data);
4106 else if ( info.sizer )
4107 return self->Insert(before, info.sizer, proportion, flag, border, data);
4108 else if (info.gotSize)
4109 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
4110 proportion, flag, border, data);
4111 else
4112 return NULL;
4113 }
4114 SWIGINTERN wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4115
4116 wxPyUserData* data = NULL;
4117 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4118 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4119 if ( userData && (info.window || info.sizer || info.gotSize) )
4120 data = new wxPyUserData(userData);
4121 if ( info.sizer )
4122 PyObject_SetAttrString(item,"thisown",Py_False);
4123 wxPyEndBlockThreads(blocked);
4124
4125 // Now call the real Prepend method if a valid item type was found
4126 if ( info.window )
4127 return self->Prepend(info.window, proportion, flag, border, data);
4128 else if ( info.sizer )
4129 return self->Prepend(info.sizer, proportion, flag, border, data);
4130 else if (info.gotSize)
4131 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
4132 proportion, flag, border, data);
4133 else
4134 return NULL;
4135 }
4136 SWIGINTERN bool wxSizer_Remove(wxSizer *self,PyObject *item){
4137 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4138 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4139 wxPyEndBlockThreads(blocked);
4140 if ( info.window )
4141 return self->Remove(info.window);
4142 else if ( info.sizer )
4143 return self->Remove(info.sizer);
4144 else if ( info.gotPos )
4145 return self->Remove(info.pos);
4146 else
4147 return false;
4148 }
4149 SWIGINTERN bool wxSizer_Detach(wxSizer *self,PyObject *item){
4150 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4151 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4152 wxPyEndBlockThreads(blocked);
4153 if ( info.window )
4154 return self->Detach(info.window);
4155 else if ( info.sizer )
4156 return self->Detach(info.sizer);
4157 else if ( info.gotPos )
4158 return self->Detach(info.pos);
4159 else
4160 return false;
4161 }
4162 SWIGINTERN wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
4163 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4164 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4165 wxPyEndBlockThreads(blocked);
4166 if ( info.window )
4167 return self->GetItem(info.window);
4168 else if ( info.sizer )
4169 return self->GetItem(info.sizer);
4170 else if ( info.gotPos )
4171 return self->GetItem(info.pos);
4172 else
4173 return NULL;
4174 }
4175 SWIGINTERN void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
4176 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4177 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4178 wxPyEndBlockThreads(blocked);
4179 if ( info.window )
4180 self->SetItemMinSize(info.window, size);
4181 else if ( info.sizer )
4182 self->SetItemMinSize(info.sizer, size);
4183 else if ( info.gotPos )
4184 self->SetItemMinSize(info.pos, size);
4185 }
4186 SWIGINTERN PyObject *wxSizer_GetChildren(wxSizer *self){
4187 wxSizerItemList& list = self->GetChildren();
4188 return wxPy_ConvertList(&list);
4189 }
4190 SWIGINTERN bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
4191 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4192 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4193 wxPyEndBlockThreads(blocked);
4194 if ( info.window )
4195 return self->Show(info.window, show, recursive);
4196 else if ( info.sizer )
4197 return self->Show(info.sizer, show, recursive);
4198 else if ( info.gotPos )
4199 return self->Show(info.pos, show);
4200 else
4201 return false;
4202 }
4203 SWIGINTERN bool wxSizer_IsShown(wxSizer *self,PyObject *item){
4204 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4205 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
4206 wxPyEndBlockThreads(blocked);
4207 if ( info.window )
4208 return self->IsShown(info.window);
4209 else if ( info.sizer )
4210 return self->IsShown(info.sizer);
4211 else if ( info.gotPos )
4212 return self->IsShown(info.pos);
4213 else
4214 return false;
4215 }
4216
4217 // See pyclasses.h
4218 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
4219 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
4220 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
4221
4222
4223
4224
4225 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
4226 {
4227 if (source == Py_None) {
4228 **obj = wxGBPosition(-1,-1);
4229 return true;
4230 }
4231 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
4232 }
4233
4234 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
4235 {
4236 if (source == Py_None) {
4237 **obj = wxGBSpan(-1,-1);
4238 return true;
4239 }
4240 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
4241 }
4242
4243
4244 SWIGINTERN bool wxGBPosition___eq__(wxGBPosition *self,PyObject *other){
4245 wxGBPosition temp, *obj = &temp;
4246 if ( other == Py_None ) return false;
4247 if ( ! wxGBPosition_helper(other, &obj) ) {
4248 PyErr_Clear();
4249 return false;
4250 }
4251 return self->operator==(*obj);
4252 }
4253 SWIGINTERN bool wxGBPosition___ne__(wxGBPosition *self,PyObject *other){
4254 wxGBPosition temp, *obj = &temp;
4255 if ( other == Py_None ) return true;
4256 if ( ! wxGBPosition_helper(other, &obj)) {
4257 PyErr_Clear();
4258 return true;
4259 }
4260 return self->operator!=(*obj);
4261 }
4262 SWIGINTERN void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
4263 self->SetRow(row);
4264 self->SetCol(col);
4265 }
4266 SWIGINTERN PyObject *wxGBPosition_Get(wxGBPosition *self){
4267 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4268 PyObject* tup = PyTuple_New(2);
4269 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
4270 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
4271 wxPyEndBlockThreads(blocked);
4272 return tup;
4273 }
4274 SWIGINTERN bool wxGBSpan___eq__(wxGBSpan *self,PyObject *other){
4275 wxGBSpan temp, *obj = &temp;
4276 if ( other == Py_None ) return false;
4277 if ( ! wxGBSpan_helper(other, &obj) ) {
4278 PyErr_Clear();
4279 return false;
4280 }
4281 return self->operator==(*obj);
4282 }
4283 SWIGINTERN bool wxGBSpan___ne__(wxGBSpan *self,PyObject *other){
4284 wxGBSpan temp, *obj = &temp;
4285 if ( other == Py_None ) return true;
4286 if ( ! wxGBSpan_helper(other, &obj)) {
4287 PyErr_Clear();
4288 return true;
4289 }
4290 return self->operator!=(*obj);
4291 }
4292 SWIGINTERN void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
4293 self->SetRowspan(rowspan);
4294 self->SetColspan(colspan);
4295 }
4296 SWIGINTERN PyObject *wxGBSpan_Get(wxGBSpan *self){
4297 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4298 PyObject* tup = PyTuple_New(2);
4299 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
4300 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
4301 wxPyEndBlockThreads(blocked);
4302 return tup;
4303 }
4304 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4305 wxPyUserData* data = NULL;
4306 if ( userData ) {
4307 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4308 data = new wxPyUserData(userData);
4309 wxPyEndBlockThreads(blocked);
4310 }
4311 return new wxGBSizerItem(window, pos, span, flag, border, data);
4312 }
4313 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4314 wxPyUserData* data = NULL;
4315 if ( userData ) {
4316 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4317 data = new wxPyUserData(userData);
4318 wxPyEndBlockThreads(blocked);
4319 }
4320 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
4321 }
4322 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4323 wxPyUserData* data = NULL;
4324 if ( userData ) {
4325 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4326 data = new wxPyUserData(userData);
4327 wxPyEndBlockThreads(blocked);
4328 }
4329 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
4330 }
4331 SWIGINTERN wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
4332 int row, col;
4333 self->GetEndPos(row, col);
4334 return wxGBPosition(row, col);
4335 }
4336 SWIGINTERN wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
4337
4338 wxPyUserData* data = NULL;
4339 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4340 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4341 if ( userData && (info.window || info.sizer || info.gotSize) )
4342 data = new wxPyUserData(userData);
4343 if ( info.sizer )
4344 PyObject_SetAttrString(item,"thisown",Py_False);
4345 wxPyEndBlockThreads(blocked);
4346
4347 // Now call the real Add method if a valid item type was found
4348 if ( info.window )
4349 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
4350 else if ( info.sizer )
4351 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
4352 else if (info.gotSize)
4353 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
4354 pos, span, flag, border, data);
4355 return NULL;
4356 }
4357
4358
4359 #ifdef __cplusplus
4360 extern "C" {
4361 #endif
4362 SWIGINTERN int EmptyString_set(PyObject *) {
4363 SWIG_Error(SWIG_AttributeError,"Variable EmptyString is read-only.");
4364 return 1;
4365 }
4366
4367
4368 SWIGINTERN PyObject *EmptyString_get(void) {
4369 PyObject *pyobj = 0;
4370
4371 {
4372 #if wxUSE_UNICODE
4373 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4374 #else
4375 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4376 #endif
4377 }
4378 return pyobj;
4379 }
4380
4381
4382 SWIGINTERN PyObject *_wrap_Object_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4383 PyObject *resultobj = 0;
4384 wxObject *arg1 = (wxObject *) 0 ;
4385 wxString result;
4386 void *argp1 = 0 ;
4387 int res1 = 0 ;
4388 PyObject *swig_obj[1] ;
4389
4390 if (!args) SWIG_fail;
4391 swig_obj[0] = args;
4392 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4393 if (!SWIG_IsOK(res1)) {
4394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_GetClassName" "', expected argument " "1"" of type '" "wxObject *""'");
4395 }
4396 arg1 = reinterpret_cast< wxObject * >(argp1);
4397 {
4398 PyThreadState* __tstate = wxPyBeginAllowThreads();
4399 result = wxObject_GetClassName(arg1);
4400 wxPyEndAllowThreads(__tstate);
4401 if (PyErr_Occurred()) SWIG_fail;
4402 }
4403 {
4404 #if wxUSE_UNICODE
4405 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4406 #else
4407 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4408 #endif
4409 }
4410 return resultobj;
4411 fail:
4412 return NULL;
4413 }
4414
4415
4416 SWIGINTERN PyObject *_wrap_Object_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4417 PyObject *resultobj = 0;
4418 wxObject *arg1 = (wxObject *) 0 ;
4419 void *argp1 = 0 ;
4420 int res1 = 0 ;
4421 PyObject *swig_obj[1] ;
4422
4423 if (!args) SWIG_fail;
4424 swig_obj[0] = args;
4425 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4426 if (!SWIG_IsOK(res1)) {
4427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_Destroy" "', expected argument " "1"" of type '" "wxObject *""'");
4428 }
4429 arg1 = reinterpret_cast< wxObject * >(argp1);
4430 {
4431 PyThreadState* __tstate = wxPyBeginAllowThreads();
4432 wxObject_Destroy(arg1);
4433 wxPyEndAllowThreads(__tstate);
4434 if (PyErr_Occurred()) SWIG_fail;
4435 }
4436 resultobj = SWIG_Py_Void();
4437 return resultobj;
4438 fail:
4439 return NULL;
4440 }
4441
4442
4443 SWIGINTERN PyObject *Object_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4444 PyObject *obj;
4445 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4446 SWIG_TypeNewClientData(SWIGTYPE_p_wxObject, SWIG_NewClientData(obj));
4447 return SWIG_Py_Void();
4448 }
4449
4450 SWIGINTERN PyObject *_wrap_Size_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4451 PyObject *resultobj = 0;
4452 wxSize *arg1 = (wxSize *) 0 ;
4453 int arg2 ;
4454 void *argp1 = 0 ;
4455 int res1 = 0 ;
4456 int val2 ;
4457 int ecode2 = 0 ;
4458 PyObject *swig_obj[2] ;
4459
4460 if (!SWIG_Python_UnpackTuple(args,"Size_width_set",2,2,swig_obj)) SWIG_fail;
4461 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4462 if (!SWIG_IsOK(res1)) {
4463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_set" "', expected argument " "1"" of type '" "wxSize *""'");
4464 }
4465 arg1 = reinterpret_cast< wxSize * >(argp1);
4466 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4467 if (!SWIG_IsOK(ecode2)) {
4468 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_width_set" "', expected argument " "2"" of type '" "int""'");
4469 }
4470 arg2 = static_cast< int >(val2);
4471 if (arg1) (arg1)->x = arg2;
4472
4473 resultobj = SWIG_Py_Void();
4474 return resultobj;
4475 fail:
4476 return NULL;
4477 }
4478
4479
4480 SWIGINTERN PyObject *_wrap_Size_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4481 PyObject *resultobj = 0;
4482 wxSize *arg1 = (wxSize *) 0 ;
4483 int result;
4484 void *argp1 = 0 ;
4485 int res1 = 0 ;
4486 PyObject *swig_obj[1] ;
4487
4488 if (!args) SWIG_fail;
4489 swig_obj[0] = args;
4490 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4491 if (!SWIG_IsOK(res1)) {
4492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_get" "', expected argument " "1"" of type '" "wxSize *""'");
4493 }
4494 arg1 = reinterpret_cast< wxSize * >(argp1);
4495 result = (int) ((arg1)->x);
4496 resultobj = SWIG_From_int(static_cast< int >(result));
4497 return resultobj;
4498 fail:
4499 return NULL;
4500 }
4501
4502
4503 SWIGINTERN PyObject *_wrap_Size_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4504 PyObject *resultobj = 0;
4505 wxSize *arg1 = (wxSize *) 0 ;
4506 int arg2 ;
4507 void *argp1 = 0 ;
4508 int res1 = 0 ;
4509 int val2 ;
4510 int ecode2 = 0 ;
4511 PyObject *swig_obj[2] ;
4512
4513 if (!SWIG_Python_UnpackTuple(args,"Size_height_set",2,2,swig_obj)) SWIG_fail;
4514 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4515 if (!SWIG_IsOK(res1)) {
4516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_set" "', expected argument " "1"" of type '" "wxSize *""'");
4517 }
4518 arg1 = reinterpret_cast< wxSize * >(argp1);
4519 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4520 if (!SWIG_IsOK(ecode2)) {
4521 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_height_set" "', expected argument " "2"" of type '" "int""'");
4522 }
4523 arg2 = static_cast< int >(val2);
4524 if (arg1) (arg1)->y = arg2;
4525
4526 resultobj = SWIG_Py_Void();
4527 return resultobj;
4528 fail:
4529 return NULL;
4530 }
4531
4532
4533 SWIGINTERN PyObject *_wrap_Size_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4534 PyObject *resultobj = 0;
4535 wxSize *arg1 = (wxSize *) 0 ;
4536 int result;
4537 void *argp1 = 0 ;
4538 int res1 = 0 ;
4539 PyObject *swig_obj[1] ;
4540
4541 if (!args) SWIG_fail;
4542 swig_obj[0] = args;
4543 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4544 if (!SWIG_IsOK(res1)) {
4545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_get" "', expected argument " "1"" of type '" "wxSize *""'");
4546 }
4547 arg1 = reinterpret_cast< wxSize * >(argp1);
4548 result = (int) ((arg1)->y);
4549 resultobj = SWIG_From_int(static_cast< int >(result));
4550 return resultobj;
4551 fail:
4552 return NULL;
4553 }
4554
4555
4556 SWIGINTERN PyObject *_wrap_new_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4557 PyObject *resultobj = 0;
4558 int arg1 = (int) 0 ;
4559 int arg2 = (int) 0 ;
4560 wxSize *result = 0 ;
4561 int val1 ;
4562 int ecode1 = 0 ;
4563 int val2 ;
4564 int ecode2 = 0 ;
4565 PyObject * obj0 = 0 ;
4566 PyObject * obj1 = 0 ;
4567 char * kwnames[] = {
4568 (char *) "w",(char *) "h", NULL
4569 };
4570
4571 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) SWIG_fail;
4572 if (obj0) {
4573 ecode1 = SWIG_AsVal_int(obj0, &val1);
4574 if (!SWIG_IsOK(ecode1)) {
4575 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Size" "', expected argument " "1"" of type '" "int""'");
4576 }
4577 arg1 = static_cast< int >(val1);
4578 }
4579 if (obj1) {
4580 ecode2 = SWIG_AsVal_int(obj1, &val2);
4581 if (!SWIG_IsOK(ecode2)) {
4582 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Size" "', expected argument " "2"" of type '" "int""'");
4583 }
4584 arg2 = static_cast< int >(val2);
4585 }
4586 {
4587 PyThreadState* __tstate = wxPyBeginAllowThreads();
4588 result = (wxSize *)new wxSize(arg1,arg2);
4589 wxPyEndAllowThreads(__tstate);
4590 if (PyErr_Occurred()) SWIG_fail;
4591 }
4592 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, SWIG_POINTER_NEW | 0 );
4593 return resultobj;
4594 fail:
4595 return NULL;
4596 }
4597
4598
4599 SWIGINTERN PyObject *_wrap_delete_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4600 PyObject *resultobj = 0;
4601 wxSize *arg1 = (wxSize *) 0 ;
4602 void *argp1 = 0 ;
4603 int res1 = 0 ;
4604 PyObject *swig_obj[1] ;
4605
4606 if (!args) SWIG_fail;
4607 swig_obj[0] = args;
4608 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, SWIG_POINTER_DISOWN | 0 );
4609 if (!SWIG_IsOK(res1)) {
4610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Size" "', expected argument " "1"" of type '" "wxSize *""'");
4611 }
4612 arg1 = reinterpret_cast< wxSize * >(argp1);
4613 {
4614 PyThreadState* __tstate = wxPyBeginAllowThreads();
4615 delete arg1;
4616
4617 wxPyEndAllowThreads(__tstate);
4618 if (PyErr_Occurred()) SWIG_fail;
4619 }
4620 resultobj = SWIG_Py_Void();
4621 return resultobj;
4622 fail:
4623 return NULL;
4624 }
4625
4626
4627 SWIGINTERN PyObject *_wrap_Size___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4628 PyObject *resultobj = 0;
4629 wxSize *arg1 = (wxSize *) 0 ;
4630 PyObject *arg2 = (PyObject *) 0 ;
4631 bool result;
4632 void *argp1 = 0 ;
4633 int res1 = 0 ;
4634 PyObject * obj0 = 0 ;
4635 PyObject * obj1 = 0 ;
4636 char * kwnames[] = {
4637 (char *) "self",(char *) "other", NULL
4638 };
4639
4640 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
4641 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4642 if (!SWIG_IsOK(res1)) {
4643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___eq__" "', expected argument " "1"" of type '" "wxSize *""'");
4644 }
4645 arg1 = reinterpret_cast< wxSize * >(argp1);
4646 arg2 = obj1;
4647 {
4648 result = (bool)wxSize___eq__(arg1,arg2);
4649 if (PyErr_Occurred()) SWIG_fail;
4650 }
4651 {
4652 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4653 }
4654 return resultobj;
4655 fail:
4656 return NULL;
4657 }
4658
4659
4660 SWIGINTERN PyObject *_wrap_Size___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4661 PyObject *resultobj = 0;
4662 wxSize *arg1 = (wxSize *) 0 ;
4663 PyObject *arg2 = (PyObject *) 0 ;
4664 bool result;
4665 void *argp1 = 0 ;
4666 int res1 = 0 ;
4667 PyObject * obj0 = 0 ;
4668 PyObject * obj1 = 0 ;
4669 char * kwnames[] = {
4670 (char *) "self",(char *) "other", NULL
4671 };
4672
4673 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
4674 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4675 if (!SWIG_IsOK(res1)) {
4676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___ne__" "', expected argument " "1"" of type '" "wxSize *""'");
4677 }
4678 arg1 = reinterpret_cast< wxSize * >(argp1);
4679 arg2 = obj1;
4680 {
4681 result = (bool)wxSize___ne__(arg1,arg2);
4682 if (PyErr_Occurred()) SWIG_fail;
4683 }
4684 {
4685 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4686 }
4687 return resultobj;
4688 fail:
4689 return NULL;
4690 }
4691
4692
4693 SWIGINTERN PyObject *_wrap_Size___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4694 PyObject *resultobj = 0;
4695 wxSize *arg1 = (wxSize *) 0 ;
4696 wxSize *arg2 = 0 ;
4697 wxSize result;
4698 void *argp1 = 0 ;
4699 int res1 = 0 ;
4700 wxSize temp2 ;
4701 PyObject * obj0 = 0 ;
4702 PyObject * obj1 = 0 ;
4703 char * kwnames[] = {
4704 (char *) "self",(char *) "sz", NULL
4705 };
4706
4707 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) SWIG_fail;
4708 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4709 if (!SWIG_IsOK(res1)) {
4710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___add__" "', expected argument " "1"" of type '" "wxSize *""'");
4711 }
4712 arg1 = reinterpret_cast< wxSize * >(argp1);
4713 {
4714 arg2 = &temp2;
4715 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4716 }
4717 {
4718 PyThreadState* __tstate = wxPyBeginAllowThreads();
4719 result = (arg1)->operator +((wxSize const &)*arg2);
4720 wxPyEndAllowThreads(__tstate);
4721 if (PyErr_Occurred()) SWIG_fail;
4722 }
4723 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4724 return resultobj;
4725 fail:
4726 return NULL;
4727 }
4728
4729
4730 SWIGINTERN PyObject *_wrap_Size___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4731 PyObject *resultobj = 0;
4732 wxSize *arg1 = (wxSize *) 0 ;
4733 wxSize *arg2 = 0 ;
4734 wxSize result;
4735 void *argp1 = 0 ;
4736 int res1 = 0 ;
4737 wxSize temp2 ;
4738 PyObject * obj0 = 0 ;
4739 PyObject * obj1 = 0 ;
4740 char * kwnames[] = {
4741 (char *) "self",(char *) "sz", NULL
4742 };
4743
4744 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
4745 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4746 if (!SWIG_IsOK(res1)) {
4747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___sub__" "', expected argument " "1"" of type '" "wxSize *""'");
4748 }
4749 arg1 = reinterpret_cast< wxSize * >(argp1);
4750 {
4751 arg2 = &temp2;
4752 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4753 }
4754 {
4755 PyThreadState* __tstate = wxPyBeginAllowThreads();
4756 result = (arg1)->operator -((wxSize const &)*arg2);
4757 wxPyEndAllowThreads(__tstate);
4758 if (PyErr_Occurred()) SWIG_fail;
4759 }
4760 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4761 return resultobj;
4762 fail:
4763 return NULL;
4764 }
4765
4766
4767 SWIGINTERN PyObject *_wrap_Size_IncTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4768 PyObject *resultobj = 0;
4769 wxSize *arg1 = (wxSize *) 0 ;
4770 wxSize *arg2 = 0 ;
4771 void *argp1 = 0 ;
4772 int res1 = 0 ;
4773 wxSize temp2 ;
4774 PyObject * obj0 = 0 ;
4775 PyObject * obj1 = 0 ;
4776 char * kwnames[] = {
4777 (char *) "self",(char *) "sz", NULL
4778 };
4779
4780 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) SWIG_fail;
4781 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4782 if (!SWIG_IsOK(res1)) {
4783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncTo" "', expected argument " "1"" of type '" "wxSize *""'");
4784 }
4785 arg1 = reinterpret_cast< wxSize * >(argp1);
4786 {
4787 arg2 = &temp2;
4788 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4789 }
4790 {
4791 PyThreadState* __tstate = wxPyBeginAllowThreads();
4792 (arg1)->IncTo((wxSize const &)*arg2);
4793 wxPyEndAllowThreads(__tstate);
4794 if (PyErr_Occurred()) SWIG_fail;
4795 }
4796 resultobj = SWIG_Py_Void();
4797 return resultobj;
4798 fail:
4799 return NULL;
4800 }
4801
4802
4803 SWIGINTERN PyObject *_wrap_Size_DecTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4804 PyObject *resultobj = 0;
4805 wxSize *arg1 = (wxSize *) 0 ;
4806 wxSize *arg2 = 0 ;
4807 void *argp1 = 0 ;
4808 int res1 = 0 ;
4809 wxSize temp2 ;
4810 PyObject * obj0 = 0 ;
4811 PyObject * obj1 = 0 ;
4812 char * kwnames[] = {
4813 (char *) "self",(char *) "sz", NULL
4814 };
4815
4816 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) SWIG_fail;
4817 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4818 if (!SWIG_IsOK(res1)) {
4819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecTo" "', expected argument " "1"" of type '" "wxSize *""'");
4820 }
4821 arg1 = reinterpret_cast< wxSize * >(argp1);
4822 {
4823 arg2 = &temp2;
4824 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4825 }
4826 {
4827 PyThreadState* __tstate = wxPyBeginAllowThreads();
4828 (arg1)->DecTo((wxSize const &)*arg2);
4829 wxPyEndAllowThreads(__tstate);
4830 if (PyErr_Occurred()) SWIG_fail;
4831 }
4832 resultobj = SWIG_Py_Void();
4833 return resultobj;
4834 fail:
4835 return NULL;
4836 }
4837
4838
4839 SWIGINTERN PyObject *_wrap_Size_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4840 PyObject *resultobj = 0;
4841 wxSize *arg1 = (wxSize *) 0 ;
4842 int arg2 ;
4843 int arg3 ;
4844 void *argp1 = 0 ;
4845 int res1 = 0 ;
4846 int val2 ;
4847 int ecode2 = 0 ;
4848 int val3 ;
4849 int ecode3 = 0 ;
4850 PyObject * obj0 = 0 ;
4851 PyObject * obj1 = 0 ;
4852 PyObject * obj2 = 0 ;
4853 char * kwnames[] = {
4854 (char *) "self",(char *) "w",(char *) "h", NULL
4855 };
4856
4857 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4858 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4859 if (!SWIG_IsOK(res1)) {
4860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Set" "', expected argument " "1"" of type '" "wxSize *""'");
4861 }
4862 arg1 = reinterpret_cast< wxSize * >(argp1);
4863 ecode2 = SWIG_AsVal_int(obj1, &val2);
4864 if (!SWIG_IsOK(ecode2)) {
4865 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Set" "', expected argument " "2"" of type '" "int""'");
4866 }
4867 arg2 = static_cast< int >(val2);
4868 ecode3 = SWIG_AsVal_int(obj2, &val3);
4869 if (!SWIG_IsOK(ecode3)) {
4870 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Set" "', expected argument " "3"" of type '" "int""'");
4871 }
4872 arg3 = static_cast< int >(val3);
4873 {
4874 PyThreadState* __tstate = wxPyBeginAllowThreads();
4875 (arg1)->Set(arg2,arg3);
4876 wxPyEndAllowThreads(__tstate);
4877 if (PyErr_Occurred()) SWIG_fail;
4878 }
4879 resultobj = SWIG_Py_Void();
4880 return resultobj;
4881 fail:
4882 return NULL;
4883 }
4884
4885
4886 SWIGINTERN PyObject *_wrap_Size_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4887 PyObject *resultobj = 0;
4888 wxSize *arg1 = (wxSize *) 0 ;
4889 int arg2 ;
4890 void *argp1 = 0 ;
4891 int res1 = 0 ;
4892 int val2 ;
4893 int ecode2 = 0 ;
4894 PyObject * obj0 = 0 ;
4895 PyObject * obj1 = 0 ;
4896 char * kwnames[] = {
4897 (char *) "self",(char *) "w", NULL
4898 };
4899
4900 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
4901 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4902 if (!SWIG_IsOK(res1)) {
4903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetWidth" "', expected argument " "1"" of type '" "wxSize *""'");
4904 }
4905 arg1 = reinterpret_cast< wxSize * >(argp1);
4906 ecode2 = SWIG_AsVal_int(obj1, &val2);
4907 if (!SWIG_IsOK(ecode2)) {
4908 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetWidth" "', expected argument " "2"" of type '" "int""'");
4909 }
4910 arg2 = static_cast< int >(val2);
4911 {
4912 PyThreadState* __tstate = wxPyBeginAllowThreads();
4913 (arg1)->SetWidth(arg2);
4914 wxPyEndAllowThreads(__tstate);
4915 if (PyErr_Occurred()) SWIG_fail;
4916 }
4917 resultobj = SWIG_Py_Void();
4918 return resultobj;
4919 fail:
4920 return NULL;
4921 }
4922
4923
4924 SWIGINTERN PyObject *_wrap_Size_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4925 PyObject *resultobj = 0;
4926 wxSize *arg1 = (wxSize *) 0 ;
4927 int arg2 ;
4928 void *argp1 = 0 ;
4929 int res1 = 0 ;
4930 int val2 ;
4931 int ecode2 = 0 ;
4932 PyObject * obj0 = 0 ;
4933 PyObject * obj1 = 0 ;
4934 char * kwnames[] = {
4935 (char *) "self",(char *) "h", NULL
4936 };
4937
4938 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
4939 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4940 if (!SWIG_IsOK(res1)) {
4941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetHeight" "', expected argument " "1"" of type '" "wxSize *""'");
4942 }
4943 arg1 = reinterpret_cast< wxSize * >(argp1);
4944 ecode2 = SWIG_AsVal_int(obj1, &val2);
4945 if (!SWIG_IsOK(ecode2)) {
4946 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetHeight" "', expected argument " "2"" of type '" "int""'");
4947 }
4948 arg2 = static_cast< int >(val2);
4949 {
4950 PyThreadState* __tstate = wxPyBeginAllowThreads();
4951 (arg1)->SetHeight(arg2);
4952 wxPyEndAllowThreads(__tstate);
4953 if (PyErr_Occurred()) SWIG_fail;
4954 }
4955 resultobj = SWIG_Py_Void();
4956 return resultobj;
4957 fail:
4958 return NULL;
4959 }
4960
4961
4962 SWIGINTERN PyObject *_wrap_Size_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4963 PyObject *resultobj = 0;
4964 wxSize *arg1 = (wxSize *) 0 ;
4965 int result;
4966 void *argp1 = 0 ;
4967 int res1 = 0 ;
4968 PyObject *swig_obj[1] ;
4969
4970 if (!args) SWIG_fail;
4971 swig_obj[0] = args;
4972 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4973 if (!SWIG_IsOK(res1)) {
4974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetWidth" "', expected argument " "1"" of type '" "wxSize const *""'");
4975 }
4976 arg1 = reinterpret_cast< wxSize * >(argp1);
4977 {
4978 PyThreadState* __tstate = wxPyBeginAllowThreads();
4979 result = (int)((wxSize const *)arg1)->GetWidth();
4980 wxPyEndAllowThreads(__tstate);
4981 if (PyErr_Occurred()) SWIG_fail;
4982 }
4983 resultobj = SWIG_From_int(static_cast< int >(result));
4984 return resultobj;
4985 fail:
4986 return NULL;
4987 }
4988
4989
4990 SWIGINTERN PyObject *_wrap_Size_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4991 PyObject *resultobj = 0;
4992 wxSize *arg1 = (wxSize *) 0 ;
4993 int result;
4994 void *argp1 = 0 ;
4995 int res1 = 0 ;
4996 PyObject *swig_obj[1] ;
4997
4998 if (!args) SWIG_fail;
4999 swig_obj[0] = args;
5000 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5001 if (!SWIG_IsOK(res1)) {
5002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetHeight" "', expected argument " "1"" of type '" "wxSize const *""'");
5003 }
5004 arg1 = reinterpret_cast< wxSize * >(argp1);
5005 {
5006 PyThreadState* __tstate = wxPyBeginAllowThreads();
5007 result = (int)((wxSize const *)arg1)->GetHeight();
5008 wxPyEndAllowThreads(__tstate);
5009 if (PyErr_Occurred()) SWIG_fail;
5010 }
5011 resultobj = SWIG_From_int(static_cast< int >(result));
5012 return resultobj;
5013 fail:
5014 return NULL;
5015 }
5016
5017
5018 SWIGINTERN PyObject *_wrap_Size_IsFullySpecified(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5019 PyObject *resultobj = 0;
5020 wxSize *arg1 = (wxSize *) 0 ;
5021 bool result;
5022 void *argp1 = 0 ;
5023 int res1 = 0 ;
5024 PyObject *swig_obj[1] ;
5025
5026 if (!args) SWIG_fail;
5027 swig_obj[0] = args;
5028 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5029 if (!SWIG_IsOK(res1)) {
5030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IsFullySpecified" "', expected argument " "1"" of type '" "wxSize const *""'");
5031 }
5032 arg1 = reinterpret_cast< wxSize * >(argp1);
5033 {
5034 PyThreadState* __tstate = wxPyBeginAllowThreads();
5035 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
5036 wxPyEndAllowThreads(__tstate);
5037 if (PyErr_Occurred()) SWIG_fail;
5038 }
5039 {
5040 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5041 }
5042 return resultobj;
5043 fail:
5044 return NULL;
5045 }
5046
5047
5048 SWIGINTERN PyObject *_wrap_Size_SetDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5049 PyObject *resultobj = 0;
5050 wxSize *arg1 = (wxSize *) 0 ;
5051 wxSize *arg2 = 0 ;
5052 void *argp1 = 0 ;
5053 int res1 = 0 ;
5054 wxSize temp2 ;
5055 PyObject * obj0 = 0 ;
5056 PyObject * obj1 = 0 ;
5057 char * kwnames[] = {
5058 (char *) "self",(char *) "size", NULL
5059 };
5060
5061 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
5062 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5063 if (!SWIG_IsOK(res1)) {
5064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetDefaults" "', expected argument " "1"" of type '" "wxSize *""'");
5065 }
5066 arg1 = reinterpret_cast< wxSize * >(argp1);
5067 {
5068 arg2 = &temp2;
5069 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5070 }
5071 {
5072 PyThreadState* __tstate = wxPyBeginAllowThreads();
5073 (arg1)->SetDefaults((wxSize const &)*arg2);
5074 wxPyEndAllowThreads(__tstate);
5075 if (PyErr_Occurred()) SWIG_fail;
5076 }
5077 resultobj = SWIG_Py_Void();
5078 return resultobj;
5079 fail:
5080 return NULL;
5081 }
5082
5083
5084 SWIGINTERN PyObject *_wrap_Size_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5085 PyObject *resultobj = 0;
5086 wxSize *arg1 = (wxSize *) 0 ;
5087 PyObject *result = 0 ;
5088 void *argp1 = 0 ;
5089 int res1 = 0 ;
5090 PyObject *swig_obj[1] ;
5091
5092 if (!args) SWIG_fail;
5093 swig_obj[0] = args;
5094 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5095 if (!SWIG_IsOK(res1)) {
5096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Get" "', expected argument " "1"" of type '" "wxSize *""'");
5097 }
5098 arg1 = reinterpret_cast< wxSize * >(argp1);
5099 {
5100 PyThreadState* __tstate = wxPyBeginAllowThreads();
5101 result = (PyObject *)wxSize_Get(arg1);
5102 wxPyEndAllowThreads(__tstate);
5103 if (PyErr_Occurred()) SWIG_fail;
5104 }
5105 resultobj = result;
5106 return resultobj;
5107 fail:
5108 return NULL;
5109 }
5110
5111
5112 SWIGINTERN PyObject *Size_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5113 PyObject *obj;
5114 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5115 SWIG_TypeNewClientData(SWIGTYPE_p_wxSize, SWIG_NewClientData(obj));
5116 return SWIG_Py_Void();
5117 }
5118
5119 SWIGINTERN PyObject *Size_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5120 return SWIG_Python_InitShadowInstance(args);
5121 }
5122
5123 SWIGINTERN PyObject *_wrap_RealPoint_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5124 PyObject *resultobj = 0;
5125 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5126 double arg2 ;
5127 void *argp1 = 0 ;
5128 int res1 = 0 ;
5129 double val2 ;
5130 int ecode2 = 0 ;
5131 PyObject *swig_obj[2] ;
5132
5133 if (!SWIG_Python_UnpackTuple(args,"RealPoint_x_set",2,2,swig_obj)) SWIG_fail;
5134 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5135 if (!SWIG_IsOK(res1)) {
5136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5137 }
5138 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5139 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5140 if (!SWIG_IsOK(ecode2)) {
5141 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_x_set" "', expected argument " "2"" of type '" "double""'");
5142 }
5143 arg2 = static_cast< double >(val2);
5144 if (arg1) (arg1)->x = arg2;
5145
5146 resultobj = SWIG_Py_Void();
5147 return resultobj;
5148 fail:
5149 return NULL;
5150 }
5151
5152
5153 SWIGINTERN PyObject *_wrap_RealPoint_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5154 PyObject *resultobj = 0;
5155 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5156 double result;
5157 void *argp1 = 0 ;
5158 int res1 = 0 ;
5159 PyObject *swig_obj[1] ;
5160
5161 if (!args) SWIG_fail;
5162 swig_obj[0] = args;
5163 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5164 if (!SWIG_IsOK(res1)) {
5165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5166 }
5167 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5168 result = (double) ((arg1)->x);
5169 resultobj = SWIG_From_double(static_cast< double >(result));
5170 return resultobj;
5171 fail:
5172 return NULL;
5173 }
5174
5175
5176 SWIGINTERN PyObject *_wrap_RealPoint_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5177 PyObject *resultobj = 0;
5178 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5179 double arg2 ;
5180 void *argp1 = 0 ;
5181 int res1 = 0 ;
5182 double val2 ;
5183 int ecode2 = 0 ;
5184 PyObject *swig_obj[2] ;
5185
5186 if (!SWIG_Python_UnpackTuple(args,"RealPoint_y_set",2,2,swig_obj)) SWIG_fail;
5187 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5188 if (!SWIG_IsOK(res1)) {
5189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5190 }
5191 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5192 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5193 if (!SWIG_IsOK(ecode2)) {
5194 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_y_set" "', expected argument " "2"" of type '" "double""'");
5195 }
5196 arg2 = static_cast< double >(val2);
5197 if (arg1) (arg1)->y = arg2;
5198
5199 resultobj = SWIG_Py_Void();
5200 return resultobj;
5201 fail:
5202 return NULL;
5203 }
5204
5205
5206 SWIGINTERN PyObject *_wrap_RealPoint_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5207 PyObject *resultobj = 0;
5208 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5209 double result;
5210 void *argp1 = 0 ;
5211 int res1 = 0 ;
5212 PyObject *swig_obj[1] ;
5213
5214 if (!args) SWIG_fail;
5215 swig_obj[0] = args;
5216 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5217 if (!SWIG_IsOK(res1)) {
5218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5219 }
5220 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5221 result = (double) ((arg1)->y);
5222 resultobj = SWIG_From_double(static_cast< double >(result));
5223 return resultobj;
5224 fail:
5225 return NULL;
5226 }
5227
5228
5229 SWIGINTERN PyObject *_wrap_new_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5230 PyObject *resultobj = 0;
5231 double arg1 = (double) 0.0 ;
5232 double arg2 = (double) 0.0 ;
5233 wxRealPoint *result = 0 ;
5234 double val1 ;
5235 int ecode1 = 0 ;
5236 double val2 ;
5237 int ecode2 = 0 ;
5238 PyObject * obj0 = 0 ;
5239 PyObject * obj1 = 0 ;
5240 char * kwnames[] = {
5241 (char *) "x",(char *) "y", NULL
5242 };
5243
5244 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) SWIG_fail;
5245 if (obj0) {
5246 ecode1 = SWIG_AsVal_double(obj0, &val1);
5247 if (!SWIG_IsOK(ecode1)) {
5248 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RealPoint" "', expected argument " "1"" of type '" "double""'");
5249 }
5250 arg1 = static_cast< double >(val1);
5251 }
5252 if (obj1) {
5253 ecode2 = SWIG_AsVal_double(obj1, &val2);
5254 if (!SWIG_IsOK(ecode2)) {
5255 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RealPoint" "', expected argument " "2"" of type '" "double""'");
5256 }
5257 arg2 = static_cast< double >(val2);
5258 }
5259 {
5260 PyThreadState* __tstate = wxPyBeginAllowThreads();
5261 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
5262 wxPyEndAllowThreads(__tstate);
5263 if (PyErr_Occurred()) SWIG_fail;
5264 }
5265 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_NEW | 0 );
5266 return resultobj;
5267 fail:
5268 return NULL;
5269 }
5270
5271
5272 SWIGINTERN PyObject *_wrap_delete_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5273 PyObject *resultobj = 0;
5274 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5275 void *argp1 = 0 ;
5276 int res1 = 0 ;
5277 PyObject *swig_obj[1] ;
5278
5279 if (!args) SWIG_fail;
5280 swig_obj[0] = args;
5281 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, SWIG_POINTER_DISOWN | 0 );
5282 if (!SWIG_IsOK(res1)) {
5283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RealPoint" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5284 }
5285 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5286 {
5287 PyThreadState* __tstate = wxPyBeginAllowThreads();
5288 delete arg1;
5289
5290 wxPyEndAllowThreads(__tstate);
5291 if (PyErr_Occurred()) SWIG_fail;
5292 }
5293 resultobj = SWIG_Py_Void();
5294 return resultobj;
5295 fail:
5296 return NULL;
5297 }
5298
5299
5300 SWIGINTERN PyObject *_wrap_RealPoint___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5301 PyObject *resultobj = 0;
5302 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5303 PyObject *arg2 = (PyObject *) 0 ;
5304 bool result;
5305 void *argp1 = 0 ;
5306 int res1 = 0 ;
5307 PyObject * obj0 = 0 ;
5308 PyObject * obj1 = 0 ;
5309 char * kwnames[] = {
5310 (char *) "self",(char *) "other", NULL
5311 };
5312
5313 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5314 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5315 if (!SWIG_IsOK(res1)) {
5316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___eq__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5317 }
5318 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5319 arg2 = obj1;
5320 {
5321 result = (bool)wxRealPoint___eq__(arg1,arg2);
5322 if (PyErr_Occurred()) SWIG_fail;
5323 }
5324 {
5325 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5326 }
5327 return resultobj;
5328 fail:
5329 return NULL;
5330 }
5331
5332
5333 SWIGINTERN PyObject *_wrap_RealPoint___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5334 PyObject *resultobj = 0;
5335 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5336 PyObject *arg2 = (PyObject *) 0 ;
5337 bool result;
5338 void *argp1 = 0 ;
5339 int res1 = 0 ;
5340 PyObject * obj0 = 0 ;
5341 PyObject * obj1 = 0 ;
5342 char * kwnames[] = {
5343 (char *) "self",(char *) "other", NULL
5344 };
5345
5346 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5347 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5348 if (!SWIG_IsOK(res1)) {
5349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___ne__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5350 }
5351 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5352 arg2 = obj1;
5353 {
5354 result = (bool)wxRealPoint___ne__(arg1,arg2);
5355 if (PyErr_Occurred()) SWIG_fail;
5356 }
5357 {
5358 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5359 }
5360 return resultobj;
5361 fail:
5362 return NULL;
5363 }
5364
5365
5366 SWIGINTERN PyObject *_wrap_RealPoint___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5367 PyObject *resultobj = 0;
5368 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5369 wxRealPoint *arg2 = 0 ;
5370 wxRealPoint result;
5371 void *argp1 = 0 ;
5372 int res1 = 0 ;
5373 wxRealPoint temp2 ;
5374 PyObject * obj0 = 0 ;
5375 PyObject * obj1 = 0 ;
5376 char * kwnames[] = {
5377 (char *) "self",(char *) "pt", NULL
5378 };
5379
5380 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5381 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5382 if (!SWIG_IsOK(res1)) {
5383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___add__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5384 }
5385 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5386 {
5387 arg2 = &temp2;
5388 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5389 }
5390 {
5391 PyThreadState* __tstate = wxPyBeginAllowThreads();
5392 result = (arg1)->operator +((wxRealPoint const &)*arg2);
5393 wxPyEndAllowThreads(__tstate);
5394 if (PyErr_Occurred()) SWIG_fail;
5395 }
5396 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5397 return resultobj;
5398 fail:
5399 return NULL;
5400 }
5401
5402
5403 SWIGINTERN PyObject *_wrap_RealPoint___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5404 PyObject *resultobj = 0;
5405 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5406 wxRealPoint *arg2 = 0 ;
5407 wxRealPoint result;
5408 void *argp1 = 0 ;
5409 int res1 = 0 ;
5410 wxRealPoint temp2 ;
5411 PyObject * obj0 = 0 ;
5412 PyObject * obj1 = 0 ;
5413 char * kwnames[] = {
5414 (char *) "self",(char *) "pt", NULL
5415 };
5416
5417 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5418 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5419 if (!SWIG_IsOK(res1)) {
5420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___sub__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5421 }
5422 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5423 {
5424 arg2 = &temp2;
5425 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5426 }
5427 {
5428 PyThreadState* __tstate = wxPyBeginAllowThreads();
5429 result = (arg1)->operator -((wxRealPoint const &)*arg2);
5430 wxPyEndAllowThreads(__tstate);
5431 if (PyErr_Occurred()) SWIG_fail;
5432 }
5433 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5434 return resultobj;
5435 fail:
5436 return NULL;
5437 }
5438
5439
5440 SWIGINTERN PyObject *_wrap_RealPoint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5441 PyObject *resultobj = 0;
5442 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5443 double arg2 ;
5444 double arg3 ;
5445 void *argp1 = 0 ;
5446 int res1 = 0 ;
5447 double val2 ;
5448 int ecode2 = 0 ;
5449 double val3 ;
5450 int ecode3 = 0 ;
5451 PyObject * obj0 = 0 ;
5452 PyObject * obj1 = 0 ;
5453 PyObject * obj2 = 0 ;
5454 char * kwnames[] = {
5455 (char *) "self",(char *) "x",(char *) "y", NULL
5456 };
5457
5458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5459 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5460 if (!SWIG_IsOK(res1)) {
5461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5462 }
5463 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5464 ecode2 = SWIG_AsVal_double(obj1, &val2);
5465 if (!SWIG_IsOK(ecode2)) {
5466 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_Set" "', expected argument " "2"" of type '" "double""'");
5467 }
5468 arg2 = static_cast< double >(val2);
5469 ecode3 = SWIG_AsVal_double(obj2, &val3);
5470 if (!SWIG_IsOK(ecode3)) {
5471 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RealPoint_Set" "', expected argument " "3"" of type '" "double""'");
5472 }
5473 arg3 = static_cast< double >(val3);
5474 {
5475 PyThreadState* __tstate = wxPyBeginAllowThreads();
5476 wxRealPoint_Set(arg1,arg2,arg3);
5477 wxPyEndAllowThreads(__tstate);
5478 if (PyErr_Occurred()) SWIG_fail;
5479 }
5480 resultobj = SWIG_Py_Void();
5481 return resultobj;
5482 fail:
5483 return NULL;
5484 }
5485
5486
5487 SWIGINTERN PyObject *_wrap_RealPoint_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5488 PyObject *resultobj = 0;
5489 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5490 PyObject *result = 0 ;
5491 void *argp1 = 0 ;
5492 int res1 = 0 ;
5493 PyObject *swig_obj[1] ;
5494
5495 if (!args) SWIG_fail;
5496 swig_obj[0] = args;
5497 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5498 if (!SWIG_IsOK(res1)) {
5499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5500 }
5501 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5502 {
5503 PyThreadState* __tstate = wxPyBeginAllowThreads();
5504 result = (PyObject *)wxRealPoint_Get(arg1);
5505 wxPyEndAllowThreads(__tstate);
5506 if (PyErr_Occurred()) SWIG_fail;
5507 }
5508 resultobj = result;
5509 return resultobj;
5510 fail:
5511 return NULL;
5512 }
5513
5514
5515 SWIGINTERN PyObject *RealPoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5516 PyObject *obj;
5517 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5518 SWIG_TypeNewClientData(SWIGTYPE_p_wxRealPoint, SWIG_NewClientData(obj));
5519 return SWIG_Py_Void();
5520 }
5521
5522 SWIGINTERN PyObject *RealPoint_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5523 return SWIG_Python_InitShadowInstance(args);
5524 }
5525
5526 SWIGINTERN PyObject *_wrap_Point_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5527 PyObject *resultobj = 0;
5528 wxPoint *arg1 = (wxPoint *) 0 ;
5529 int arg2 ;
5530 void *argp1 = 0 ;
5531 int res1 = 0 ;
5532 int val2 ;
5533 int ecode2 = 0 ;
5534 PyObject *swig_obj[2] ;
5535
5536 if (!SWIG_Python_UnpackTuple(args,"Point_x_set",2,2,swig_obj)) SWIG_fail;
5537 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5538 if (!SWIG_IsOK(res1)) {
5539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5540 }
5541 arg1 = reinterpret_cast< wxPoint * >(argp1);
5542 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5543 if (!SWIG_IsOK(ecode2)) {
5544 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_x_set" "', expected argument " "2"" of type '" "int""'");
5545 }
5546 arg2 = static_cast< int >(val2);
5547 if (arg1) (arg1)->x = arg2;
5548
5549 resultobj = SWIG_Py_Void();
5550 return resultobj;
5551 fail:
5552 return NULL;
5553 }
5554
5555
5556 SWIGINTERN PyObject *_wrap_Point_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5557 PyObject *resultobj = 0;
5558 wxPoint *arg1 = (wxPoint *) 0 ;
5559 int result;
5560 void *argp1 = 0 ;
5561 int res1 = 0 ;
5562 PyObject *swig_obj[1] ;
5563
5564 if (!args) SWIG_fail;
5565 swig_obj[0] = args;
5566 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5567 if (!SWIG_IsOK(res1)) {
5568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5569 }
5570 arg1 = reinterpret_cast< wxPoint * >(argp1);
5571 result = (int) ((arg1)->x);
5572 resultobj = SWIG_From_int(static_cast< int >(result));
5573 return resultobj;
5574 fail:
5575 return NULL;
5576 }
5577
5578
5579 SWIGINTERN PyObject *_wrap_Point_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5580 PyObject *resultobj = 0;
5581 wxPoint *arg1 = (wxPoint *) 0 ;
5582 int arg2 ;
5583 void *argp1 = 0 ;
5584 int res1 = 0 ;
5585 int val2 ;
5586 int ecode2 = 0 ;
5587 PyObject *swig_obj[2] ;
5588
5589 if (!SWIG_Python_UnpackTuple(args,"Point_y_set",2,2,swig_obj)) SWIG_fail;
5590 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5591 if (!SWIG_IsOK(res1)) {
5592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5593 }
5594 arg1 = reinterpret_cast< wxPoint * >(argp1);
5595 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5596 if (!SWIG_IsOK(ecode2)) {
5597 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_y_set" "', expected argument " "2"" of type '" "int""'");
5598 }
5599 arg2 = static_cast< int >(val2);
5600 if (arg1) (arg1)->y = arg2;
5601
5602 resultobj = SWIG_Py_Void();
5603 return resultobj;
5604 fail:
5605 return NULL;
5606 }
5607
5608
5609 SWIGINTERN PyObject *_wrap_Point_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5610 PyObject *resultobj = 0;
5611 wxPoint *arg1 = (wxPoint *) 0 ;
5612 int result;
5613 void *argp1 = 0 ;
5614 int res1 = 0 ;
5615 PyObject *swig_obj[1] ;
5616
5617 if (!args) SWIG_fail;
5618 swig_obj[0] = args;
5619 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5620 if (!SWIG_IsOK(res1)) {
5621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5622 }
5623 arg1 = reinterpret_cast< wxPoint * >(argp1);
5624 result = (int) ((arg1)->y);
5625 resultobj = SWIG_From_int(static_cast< int >(result));
5626 return resultobj;
5627 fail:
5628 return NULL;
5629 }
5630
5631
5632 SWIGINTERN PyObject *_wrap_new_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5633 PyObject *resultobj = 0;
5634 int arg1 = (int) 0 ;
5635 int arg2 = (int) 0 ;
5636 wxPoint *result = 0 ;
5637 int val1 ;
5638 int ecode1 = 0 ;
5639 int val2 ;
5640 int ecode2 = 0 ;
5641 PyObject * obj0 = 0 ;
5642 PyObject * obj1 = 0 ;
5643 char * kwnames[] = {
5644 (char *) "x",(char *) "y", NULL
5645 };
5646
5647 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) SWIG_fail;
5648 if (obj0) {
5649 ecode1 = SWIG_AsVal_int(obj0, &val1);
5650 if (!SWIG_IsOK(ecode1)) {
5651 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point" "', expected argument " "1"" of type '" "int""'");
5652 }
5653 arg1 = static_cast< int >(val1);
5654 }
5655 if (obj1) {
5656 ecode2 = SWIG_AsVal_int(obj1, &val2);
5657 if (!SWIG_IsOK(ecode2)) {
5658 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point" "', expected argument " "2"" of type '" "int""'");
5659 }
5660 arg2 = static_cast< int >(val2);
5661 }
5662 {
5663 PyThreadState* __tstate = wxPyBeginAllowThreads();
5664 result = (wxPoint *)new wxPoint(arg1,arg2);
5665 wxPyEndAllowThreads(__tstate);
5666 if (PyErr_Occurred()) SWIG_fail;
5667 }
5668 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_NEW | 0 );
5669 return resultobj;
5670 fail:
5671 return NULL;
5672 }
5673
5674
5675 SWIGINTERN PyObject *_wrap_delete_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5676 PyObject *resultobj = 0;
5677 wxPoint *arg1 = (wxPoint *) 0 ;
5678 void *argp1 = 0 ;
5679 int res1 = 0 ;
5680 PyObject *swig_obj[1] ;
5681
5682 if (!args) SWIG_fail;
5683 swig_obj[0] = args;
5684 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5685 if (!SWIG_IsOK(res1)) {
5686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point" "', expected argument " "1"" of type '" "wxPoint *""'");
5687 }
5688 arg1 = reinterpret_cast< wxPoint * >(argp1);
5689 {
5690 PyThreadState* __tstate = wxPyBeginAllowThreads();
5691 delete arg1;
5692
5693 wxPyEndAllowThreads(__tstate);
5694 if (PyErr_Occurred()) SWIG_fail;
5695 }
5696 resultobj = SWIG_Py_Void();
5697 return resultobj;
5698 fail:
5699 return NULL;
5700 }
5701
5702
5703 SWIGINTERN PyObject *_wrap_Point___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5704 PyObject *resultobj = 0;
5705 wxPoint *arg1 = (wxPoint *) 0 ;
5706 PyObject *arg2 = (PyObject *) 0 ;
5707 bool result;
5708 void *argp1 = 0 ;
5709 int res1 = 0 ;
5710 PyObject * obj0 = 0 ;
5711 PyObject * obj1 = 0 ;
5712 char * kwnames[] = {
5713 (char *) "self",(char *) "other", NULL
5714 };
5715
5716 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5717 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5718 if (!SWIG_IsOK(res1)) {
5719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___eq__" "', expected argument " "1"" of type '" "wxPoint *""'");
5720 }
5721 arg1 = reinterpret_cast< wxPoint * >(argp1);
5722 arg2 = obj1;
5723 {
5724 result = (bool)wxPoint___eq__(arg1,arg2);
5725 if (PyErr_Occurred()) SWIG_fail;
5726 }
5727 {
5728 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5729 }
5730 return resultobj;
5731 fail:
5732 return NULL;
5733 }
5734
5735
5736 SWIGINTERN PyObject *_wrap_Point___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5737 PyObject *resultobj = 0;
5738 wxPoint *arg1 = (wxPoint *) 0 ;
5739 PyObject *arg2 = (PyObject *) 0 ;
5740 bool result;
5741 void *argp1 = 0 ;
5742 int res1 = 0 ;
5743 PyObject * obj0 = 0 ;
5744 PyObject * obj1 = 0 ;
5745 char * kwnames[] = {
5746 (char *) "self",(char *) "other", NULL
5747 };
5748
5749 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5750 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5751 if (!SWIG_IsOK(res1)) {
5752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___ne__" "', expected argument " "1"" of type '" "wxPoint *""'");
5753 }
5754 arg1 = reinterpret_cast< wxPoint * >(argp1);
5755 arg2 = obj1;
5756 {
5757 result = (bool)wxPoint___ne__(arg1,arg2);
5758 if (PyErr_Occurred()) SWIG_fail;
5759 }
5760 {
5761 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5762 }
5763 return resultobj;
5764 fail:
5765 return NULL;
5766 }
5767
5768
5769 SWIGINTERN PyObject *_wrap_Point___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5770 PyObject *resultobj = 0;
5771 wxPoint *arg1 = (wxPoint *) 0 ;
5772 wxPoint *arg2 = 0 ;
5773 wxPoint result;
5774 void *argp1 = 0 ;
5775 int res1 = 0 ;
5776 wxPoint temp2 ;
5777 PyObject * obj0 = 0 ;
5778 PyObject * obj1 = 0 ;
5779 char * kwnames[] = {
5780 (char *) "self",(char *) "pt", NULL
5781 };
5782
5783 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5784 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5785 if (!SWIG_IsOK(res1)) {
5786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___add__" "', expected argument " "1"" of type '" "wxPoint *""'");
5787 }
5788 arg1 = reinterpret_cast< wxPoint * >(argp1);
5789 {
5790 arg2 = &temp2;
5791 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5792 }
5793 {
5794 PyThreadState* __tstate = wxPyBeginAllowThreads();
5795 result = (arg1)->operator +((wxPoint const &)*arg2);
5796 wxPyEndAllowThreads(__tstate);
5797 if (PyErr_Occurred()) SWIG_fail;
5798 }
5799 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5800 return resultobj;
5801 fail:
5802 return NULL;
5803 }
5804
5805
5806 SWIGINTERN PyObject *_wrap_Point___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5807 PyObject *resultobj = 0;
5808 wxPoint *arg1 = (wxPoint *) 0 ;
5809 wxPoint *arg2 = 0 ;
5810 wxPoint result;
5811 void *argp1 = 0 ;
5812 int res1 = 0 ;
5813 wxPoint temp2 ;
5814 PyObject * obj0 = 0 ;
5815 PyObject * obj1 = 0 ;
5816 char * kwnames[] = {
5817 (char *) "self",(char *) "pt", NULL
5818 };
5819
5820 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5821 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5822 if (!SWIG_IsOK(res1)) {
5823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___sub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5824 }
5825 arg1 = reinterpret_cast< wxPoint * >(argp1);
5826 {
5827 arg2 = &temp2;
5828 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5829 }
5830 {
5831 PyThreadState* __tstate = wxPyBeginAllowThreads();
5832 result = (arg1)->operator -((wxPoint const &)*arg2);
5833 wxPyEndAllowThreads(__tstate);
5834 if (PyErr_Occurred()) SWIG_fail;
5835 }
5836 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5837 return resultobj;
5838 fail:
5839 return NULL;
5840 }
5841
5842
5843 SWIGINTERN PyObject *_wrap_Point___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5844 PyObject *resultobj = 0;
5845 wxPoint *arg1 = (wxPoint *) 0 ;
5846 wxPoint *arg2 = 0 ;
5847 wxPoint *result = 0 ;
5848 void *argp1 = 0 ;
5849 int res1 = 0 ;
5850 wxPoint temp2 ;
5851 PyObject * obj0 = 0 ;
5852 PyObject * obj1 = 0 ;
5853 char * kwnames[] = {
5854 (char *) "self",(char *) "pt", NULL
5855 };
5856
5857 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
5858 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5859 if (!SWIG_IsOK(res1)) {
5860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___iadd__" "', expected argument " "1"" of type '" "wxPoint *""'");
5861 }
5862 arg1 = reinterpret_cast< wxPoint * >(argp1);
5863 {
5864 arg2 = &temp2;
5865 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5866 }
5867 {
5868 PyThreadState* __tstate = wxPyBeginAllowThreads();
5869 {
5870 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
5871 result = (wxPoint *) &_result_ref;
5872 }
5873 wxPyEndAllowThreads(__tstate);
5874 if (PyErr_Occurred()) SWIG_fail;
5875 }
5876 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5877 return resultobj;
5878 fail:
5879 return NULL;
5880 }
5881
5882
5883 SWIGINTERN PyObject *_wrap_Point___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5884 PyObject *resultobj = 0;
5885 wxPoint *arg1 = (wxPoint *) 0 ;
5886 wxPoint *arg2 = 0 ;
5887 wxPoint *result = 0 ;
5888 void *argp1 = 0 ;
5889 int res1 = 0 ;
5890 wxPoint temp2 ;
5891 PyObject * obj0 = 0 ;
5892 PyObject * obj1 = 0 ;
5893 char * kwnames[] = {
5894 (char *) "self",(char *) "pt", NULL
5895 };
5896
5897 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
5898 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5899 if (!SWIG_IsOK(res1)) {
5900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___isub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5901 }
5902 arg1 = reinterpret_cast< wxPoint * >(argp1);
5903 {
5904 arg2 = &temp2;
5905 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5906 }
5907 {
5908 PyThreadState* __tstate = wxPyBeginAllowThreads();
5909 {
5910 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
5911 result = (wxPoint *) &_result_ref;
5912 }
5913 wxPyEndAllowThreads(__tstate);
5914 if (PyErr_Occurred()) SWIG_fail;
5915 }
5916 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5917 return resultobj;
5918 fail:
5919 return NULL;
5920 }
5921
5922
5923 SWIGINTERN PyObject *_wrap_Point_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5924 PyObject *resultobj = 0;
5925 wxPoint *arg1 = (wxPoint *) 0 ;
5926 long arg2 ;
5927 long arg3 ;
5928 void *argp1 = 0 ;
5929 int res1 = 0 ;
5930 long val2 ;
5931 int ecode2 = 0 ;
5932 long val3 ;
5933 int ecode3 = 0 ;
5934 PyObject * obj0 = 0 ;
5935 PyObject * obj1 = 0 ;
5936 PyObject * obj2 = 0 ;
5937 char * kwnames[] = {
5938 (char *) "self",(char *) "x",(char *) "y", NULL
5939 };
5940
5941 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5942 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5943 if (!SWIG_IsOK(res1)) {
5944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Set" "', expected argument " "1"" of type '" "wxPoint *""'");
5945 }
5946 arg1 = reinterpret_cast< wxPoint * >(argp1);
5947 ecode2 = SWIG_AsVal_long(obj1, &val2);
5948 if (!SWIG_IsOK(ecode2)) {
5949 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_Set" "', expected argument " "2"" of type '" "long""'");
5950 }
5951 arg2 = static_cast< long >(val2);
5952 ecode3 = SWIG_AsVal_long(obj2, &val3);
5953 if (!SWIG_IsOK(ecode3)) {
5954 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point_Set" "', expected argument " "3"" of type '" "long""'");
5955 }
5956 arg3 = static_cast< long >(val3);
5957 {
5958 PyThreadState* __tstate = wxPyBeginAllowThreads();
5959 wxPoint_Set(arg1,arg2,arg3);
5960 wxPyEndAllowThreads(__tstate);
5961 if (PyErr_Occurred()) SWIG_fail;
5962 }
5963 resultobj = SWIG_Py_Void();
5964 return resultobj;
5965 fail:
5966 return NULL;
5967 }
5968
5969
5970 SWIGINTERN PyObject *_wrap_Point_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5971 PyObject *resultobj = 0;
5972 wxPoint *arg1 = (wxPoint *) 0 ;
5973 PyObject *result = 0 ;
5974 void *argp1 = 0 ;
5975 int res1 = 0 ;
5976 PyObject *swig_obj[1] ;
5977
5978 if (!args) SWIG_fail;
5979 swig_obj[0] = args;
5980 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5981 if (!SWIG_IsOK(res1)) {
5982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Get" "', expected argument " "1"" of type '" "wxPoint *""'");
5983 }
5984 arg1 = reinterpret_cast< wxPoint * >(argp1);
5985 {
5986 PyThreadState* __tstate = wxPyBeginAllowThreads();
5987 result = (PyObject *)wxPoint_Get(arg1);
5988 wxPyEndAllowThreads(__tstate);
5989 if (PyErr_Occurred()) SWIG_fail;
5990 }
5991 resultobj = result;
5992 return resultobj;
5993 fail:
5994 return NULL;
5995 }
5996
5997
5998 SWIGINTERN PyObject *Point_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5999 PyObject *obj;
6000 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
6001 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint, SWIG_NewClientData(obj));
6002 return SWIG_Py_Void();
6003 }
6004
6005 SWIGINTERN PyObject *Point_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6006 return SWIG_Python_InitShadowInstance(args);
6007 }
6008
6009 SWIGINTERN PyObject *_wrap_new_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6010 PyObject *resultobj = 0;
6011 int arg1 = (int) 0 ;
6012 int arg2 = (int) 0 ;
6013 int arg3 = (int) 0 ;
6014 int arg4 = (int) 0 ;
6015 wxRect *result = 0 ;
6016 int val1 ;
6017 int ecode1 = 0 ;
6018 int val2 ;
6019 int ecode2 = 0 ;
6020 int val3 ;
6021 int ecode3 = 0 ;
6022 int val4 ;
6023 int ecode4 = 0 ;
6024 PyObject * obj0 = 0 ;
6025 PyObject * obj1 = 0 ;
6026 PyObject * obj2 = 0 ;
6027 PyObject * obj3 = 0 ;
6028 char * kwnames[] = {
6029 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6030 };
6031
6032 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6033 if (obj0) {
6034 ecode1 = SWIG_AsVal_int(obj0, &val1);
6035 if (!SWIG_IsOK(ecode1)) {
6036 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Rect" "', expected argument " "1"" of type '" "int""'");
6037 }
6038 arg1 = static_cast< int >(val1);
6039 }
6040 if (obj1) {
6041 ecode2 = SWIG_AsVal_int(obj1, &val2);
6042 if (!SWIG_IsOK(ecode2)) {
6043 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Rect" "', expected argument " "2"" of type '" "int""'");
6044 }
6045 arg2 = static_cast< int >(val2);
6046 }
6047 if (obj2) {
6048 ecode3 = SWIG_AsVal_int(obj2, &val3);
6049 if (!SWIG_IsOK(ecode3)) {
6050 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Rect" "', expected argument " "3"" of type '" "int""'");
6051 }
6052 arg3 = static_cast< int >(val3);
6053 }
6054 if (obj3) {
6055 ecode4 = SWIG_AsVal_int(obj3, &val4);
6056 if (!SWIG_IsOK(ecode4)) {
6057 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Rect" "', expected argument " "4"" of type '" "int""'");
6058 }
6059 arg4 = static_cast< int >(val4);
6060 }
6061 {
6062 PyThreadState* __tstate = wxPyBeginAllowThreads();
6063 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
6064 wxPyEndAllowThreads(__tstate);
6065 if (PyErr_Occurred()) SWIG_fail;
6066 }
6067 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_NEW | 0 );
6068 return resultobj;
6069 fail:
6070 return NULL;
6071 }
6072
6073
6074 SWIGINTERN PyObject *_wrap_new_RectPP(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6075 PyObject *resultobj = 0;
6076 wxPoint *arg1 = 0 ;
6077 wxPoint *arg2 = 0 ;
6078 wxRect *result = 0 ;
6079 wxPoint temp1 ;
6080 wxPoint temp2 ;
6081 PyObject * obj0 = 0 ;
6082 PyObject * obj1 = 0 ;
6083 char * kwnames[] = {
6084 (char *) "topLeft",(char *) "bottomRight", NULL
6085 };
6086
6087 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) SWIG_fail;
6088 {
6089 arg1 = &temp1;
6090 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6091 }
6092 {
6093 arg2 = &temp2;
6094 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6095 }
6096 {
6097 PyThreadState* __tstate = wxPyBeginAllowThreads();
6098 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
6099 wxPyEndAllowThreads(__tstate);
6100 if (PyErr_Occurred()) SWIG_fail;
6101 }
6102 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6103 return resultobj;
6104 fail:
6105 return NULL;
6106 }
6107
6108
6109 SWIGINTERN PyObject *_wrap_new_RectPS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6110 PyObject *resultobj = 0;
6111 wxPoint *arg1 = 0 ;
6112 wxSize *arg2 = 0 ;
6113 wxRect *result = 0 ;
6114 wxPoint temp1 ;
6115 wxSize temp2 ;
6116 PyObject * obj0 = 0 ;
6117 PyObject * obj1 = 0 ;
6118 char * kwnames[] = {
6119 (char *) "pos",(char *) "size", NULL
6120 };
6121
6122 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) SWIG_fail;
6123 {
6124 arg1 = &temp1;
6125 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6126 }
6127 {
6128 arg2 = &temp2;
6129 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6130 }
6131 {
6132 PyThreadState* __tstate = wxPyBeginAllowThreads();
6133 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
6134 wxPyEndAllowThreads(__tstate);
6135 if (PyErr_Occurred()) SWIG_fail;
6136 }
6137 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6138 return resultobj;
6139 fail:
6140 return NULL;
6141 }
6142
6143
6144 SWIGINTERN PyObject *_wrap_new_RectS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6145 PyObject *resultobj = 0;
6146 wxSize *arg1 = 0 ;
6147 wxRect *result = 0 ;
6148 wxSize temp1 ;
6149 PyObject * obj0 = 0 ;
6150 char * kwnames[] = {
6151 (char *) "size", NULL
6152 };
6153
6154 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) SWIG_fail;
6155 {
6156 arg1 = &temp1;
6157 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
6158 }
6159 {
6160 PyThreadState* __tstate = wxPyBeginAllowThreads();
6161 result = (wxRect *)new wxRect((wxSize const &)*arg1);
6162 wxPyEndAllowThreads(__tstate);
6163 if (PyErr_Occurred()) SWIG_fail;
6164 }
6165 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6166 return resultobj;
6167 fail:
6168 return NULL;
6169 }
6170
6171
6172 SWIGINTERN PyObject *_wrap_delete_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6173 PyObject *resultobj = 0;
6174 wxRect *arg1 = (wxRect *) 0 ;
6175 void *argp1 = 0 ;
6176 int res1 = 0 ;
6177 PyObject *swig_obj[1] ;
6178
6179 if (!args) SWIG_fail;
6180 swig_obj[0] = args;
6181 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
6182 if (!SWIG_IsOK(res1)) {
6183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect" "', expected argument " "1"" of type '" "wxRect *""'");
6184 }
6185 arg1 = reinterpret_cast< wxRect * >(argp1);
6186 {
6187 PyThreadState* __tstate = wxPyBeginAllowThreads();
6188 delete arg1;
6189
6190 wxPyEndAllowThreads(__tstate);
6191 if (PyErr_Occurred()) SWIG_fail;
6192 }
6193 resultobj = SWIG_Py_Void();
6194 return resultobj;
6195 fail:
6196 return NULL;
6197 }
6198
6199
6200 SWIGINTERN PyObject *_wrap_Rect_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6201 PyObject *resultobj = 0;
6202 wxRect *arg1 = (wxRect *) 0 ;
6203 int result;
6204 void *argp1 = 0 ;
6205 int res1 = 0 ;
6206 PyObject *swig_obj[1] ;
6207
6208 if (!args) SWIG_fail;
6209 swig_obj[0] = args;
6210 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6211 if (!SWIG_IsOK(res1)) {
6212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetX" "', expected argument " "1"" of type '" "wxRect const *""'");
6213 }
6214 arg1 = reinterpret_cast< wxRect * >(argp1);
6215 {
6216 PyThreadState* __tstate = wxPyBeginAllowThreads();
6217 result = (int)((wxRect const *)arg1)->GetX();
6218 wxPyEndAllowThreads(__tstate);
6219 if (PyErr_Occurred()) SWIG_fail;
6220 }
6221 resultobj = SWIG_From_int(static_cast< int >(result));
6222 return resultobj;
6223 fail:
6224 return NULL;
6225 }
6226
6227
6228 SWIGINTERN PyObject *_wrap_Rect_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6229 PyObject *resultobj = 0;
6230 wxRect *arg1 = (wxRect *) 0 ;
6231 int arg2 ;
6232 void *argp1 = 0 ;
6233 int res1 = 0 ;
6234 int val2 ;
6235 int ecode2 = 0 ;
6236 PyObject * obj0 = 0 ;
6237 PyObject * obj1 = 0 ;
6238 char * kwnames[] = {
6239 (char *) "self",(char *) "x", NULL
6240 };
6241
6242 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
6243 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6244 if (!SWIG_IsOK(res1)) {
6245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetX" "', expected argument " "1"" of type '" "wxRect *""'");
6246 }
6247 arg1 = reinterpret_cast< wxRect * >(argp1);
6248 ecode2 = SWIG_AsVal_int(obj1, &val2);
6249 if (!SWIG_IsOK(ecode2)) {
6250 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetX" "', expected argument " "2"" of type '" "int""'");
6251 }
6252 arg2 = static_cast< int >(val2);
6253 {
6254 PyThreadState* __tstate = wxPyBeginAllowThreads();
6255 (arg1)->SetX(arg2);
6256 wxPyEndAllowThreads(__tstate);
6257 if (PyErr_Occurred()) SWIG_fail;
6258 }
6259 resultobj = SWIG_Py_Void();
6260 return resultobj;
6261 fail:
6262 return NULL;
6263 }
6264
6265
6266 SWIGINTERN PyObject *_wrap_Rect_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6267 PyObject *resultobj = 0;
6268 wxRect *arg1 = (wxRect *) 0 ;
6269 int result;
6270 void *argp1 = 0 ;
6271 int res1 = 0 ;
6272 PyObject *swig_obj[1] ;
6273
6274 if (!args) SWIG_fail;
6275 swig_obj[0] = args;
6276 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6277 if (!SWIG_IsOK(res1)) {
6278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetY" "', expected argument " "1"" of type '" "wxRect *""'");
6279 }
6280 arg1 = reinterpret_cast< wxRect * >(argp1);
6281 {
6282 PyThreadState* __tstate = wxPyBeginAllowThreads();
6283 result = (int)(arg1)->GetY();
6284 wxPyEndAllowThreads(__tstate);
6285 if (PyErr_Occurred()) SWIG_fail;
6286 }
6287 resultobj = SWIG_From_int(static_cast< int >(result));
6288 return resultobj;
6289 fail:
6290 return NULL;
6291 }
6292
6293
6294 SWIGINTERN PyObject *_wrap_Rect_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6295 PyObject *resultobj = 0;
6296 wxRect *arg1 = (wxRect *) 0 ;
6297 int arg2 ;
6298 void *argp1 = 0 ;
6299 int res1 = 0 ;
6300 int val2 ;
6301 int ecode2 = 0 ;
6302 PyObject * obj0 = 0 ;
6303 PyObject * obj1 = 0 ;
6304 char * kwnames[] = {
6305 (char *) "self",(char *) "y", NULL
6306 };
6307
6308 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
6309 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6310 if (!SWIG_IsOK(res1)) {
6311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetY" "', expected argument " "1"" of type '" "wxRect *""'");
6312 }
6313 arg1 = reinterpret_cast< wxRect * >(argp1);
6314 ecode2 = SWIG_AsVal_int(obj1, &val2);
6315 if (!SWIG_IsOK(ecode2)) {
6316 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetY" "', expected argument " "2"" of type '" "int""'");
6317 }
6318 arg2 = static_cast< int >(val2);
6319 {
6320 PyThreadState* __tstate = wxPyBeginAllowThreads();
6321 (arg1)->SetY(arg2);
6322 wxPyEndAllowThreads(__tstate);
6323 if (PyErr_Occurred()) SWIG_fail;
6324 }
6325 resultobj = SWIG_Py_Void();
6326 return resultobj;
6327 fail:
6328 return NULL;
6329 }
6330
6331
6332 SWIGINTERN PyObject *_wrap_Rect_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6333 PyObject *resultobj = 0;
6334 wxRect *arg1 = (wxRect *) 0 ;
6335 int result;
6336 void *argp1 = 0 ;
6337 int res1 = 0 ;
6338 PyObject *swig_obj[1] ;
6339
6340 if (!args) SWIG_fail;
6341 swig_obj[0] = args;
6342 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6343 if (!SWIG_IsOK(res1)) {
6344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetWidth" "', expected argument " "1"" of type '" "wxRect const *""'");
6345 }
6346 arg1 = reinterpret_cast< wxRect * >(argp1);
6347 {
6348 PyThreadState* __tstate = wxPyBeginAllowThreads();
6349 result = (int)((wxRect const *)arg1)->GetWidth();
6350 wxPyEndAllowThreads(__tstate);
6351 if (PyErr_Occurred()) SWIG_fail;
6352 }
6353 resultobj = SWIG_From_int(static_cast< int >(result));
6354 return resultobj;
6355 fail:
6356 return NULL;
6357 }
6358
6359
6360 SWIGINTERN PyObject *_wrap_Rect_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6361 PyObject *resultobj = 0;
6362 wxRect *arg1 = (wxRect *) 0 ;
6363 int arg2 ;
6364 void *argp1 = 0 ;
6365 int res1 = 0 ;
6366 int val2 ;
6367 int ecode2 = 0 ;
6368 PyObject * obj0 = 0 ;
6369 PyObject * obj1 = 0 ;
6370 char * kwnames[] = {
6371 (char *) "self",(char *) "w", NULL
6372 };
6373
6374 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
6375 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6376 if (!SWIG_IsOK(res1)) {
6377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetWidth" "', expected argument " "1"" of type '" "wxRect *""'");
6378 }
6379 arg1 = reinterpret_cast< wxRect * >(argp1);
6380 ecode2 = SWIG_AsVal_int(obj1, &val2);
6381 if (!SWIG_IsOK(ecode2)) {
6382 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetWidth" "', expected argument " "2"" of type '" "int""'");
6383 }
6384 arg2 = static_cast< int >(val2);
6385 {
6386 PyThreadState* __tstate = wxPyBeginAllowThreads();
6387 (arg1)->SetWidth(arg2);
6388 wxPyEndAllowThreads(__tstate);
6389 if (PyErr_Occurred()) SWIG_fail;
6390 }
6391 resultobj = SWIG_Py_Void();
6392 return resultobj;
6393 fail:
6394 return NULL;
6395 }
6396
6397
6398 SWIGINTERN PyObject *_wrap_Rect_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6399 PyObject *resultobj = 0;
6400 wxRect *arg1 = (wxRect *) 0 ;
6401 int result;
6402 void *argp1 = 0 ;
6403 int res1 = 0 ;
6404 PyObject *swig_obj[1] ;
6405
6406 if (!args) SWIG_fail;
6407 swig_obj[0] = args;
6408 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6409 if (!SWIG_IsOK(res1)) {
6410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetHeight" "', expected argument " "1"" of type '" "wxRect const *""'");
6411 }
6412 arg1 = reinterpret_cast< wxRect * >(argp1);
6413 {
6414 PyThreadState* __tstate = wxPyBeginAllowThreads();
6415 result = (int)((wxRect const *)arg1)->GetHeight();
6416 wxPyEndAllowThreads(__tstate);
6417 if (PyErr_Occurred()) SWIG_fail;
6418 }
6419 resultobj = SWIG_From_int(static_cast< int >(result));
6420 return resultobj;
6421 fail:
6422 return NULL;
6423 }
6424
6425
6426 SWIGINTERN PyObject *_wrap_Rect_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6427 PyObject *resultobj = 0;
6428 wxRect *arg1 = (wxRect *) 0 ;
6429 int arg2 ;
6430 void *argp1 = 0 ;
6431 int res1 = 0 ;
6432 int val2 ;
6433 int ecode2 = 0 ;
6434 PyObject * obj0 = 0 ;
6435 PyObject * obj1 = 0 ;
6436 char * kwnames[] = {
6437 (char *) "self",(char *) "h", NULL
6438 };
6439
6440 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
6441 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6442 if (!SWIG_IsOK(res1)) {
6443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetHeight" "', expected argument " "1"" of type '" "wxRect *""'");
6444 }
6445 arg1 = reinterpret_cast< wxRect * >(argp1);
6446 ecode2 = SWIG_AsVal_int(obj1, &val2);
6447 if (!SWIG_IsOK(ecode2)) {
6448 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetHeight" "', expected argument " "2"" of type '" "int""'");
6449 }
6450 arg2 = static_cast< int >(val2);
6451 {
6452 PyThreadState* __tstate = wxPyBeginAllowThreads();
6453 (arg1)->SetHeight(arg2);
6454 wxPyEndAllowThreads(__tstate);
6455 if (PyErr_Occurred()) SWIG_fail;
6456 }
6457 resultobj = SWIG_Py_Void();
6458 return resultobj;
6459 fail:
6460 return NULL;
6461 }
6462
6463
6464 SWIGINTERN PyObject *_wrap_Rect_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6465 PyObject *resultobj = 0;
6466 wxRect *arg1 = (wxRect *) 0 ;
6467 wxPoint result;
6468 void *argp1 = 0 ;
6469 int res1 = 0 ;
6470 PyObject *swig_obj[1] ;
6471
6472 if (!args) SWIG_fail;
6473 swig_obj[0] = args;
6474 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6475 if (!SWIG_IsOK(res1)) {
6476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetPosition" "', expected argument " "1"" of type '" "wxRect const *""'");
6477 }
6478 arg1 = reinterpret_cast< wxRect * >(argp1);
6479 {
6480 PyThreadState* __tstate = wxPyBeginAllowThreads();
6481 result = ((wxRect const *)arg1)->GetPosition();
6482 wxPyEndAllowThreads(__tstate);
6483 if (PyErr_Occurred()) SWIG_fail;
6484 }
6485 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6486 return resultobj;
6487 fail:
6488 return NULL;
6489 }
6490
6491
6492 SWIGINTERN PyObject *_wrap_Rect_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6493 PyObject *resultobj = 0;
6494 wxRect *arg1 = (wxRect *) 0 ;
6495 wxPoint *arg2 = 0 ;
6496 void *argp1 = 0 ;
6497 int res1 = 0 ;
6498 wxPoint temp2 ;
6499 PyObject * obj0 = 0 ;
6500 PyObject * obj1 = 0 ;
6501 char * kwnames[] = {
6502 (char *) "self",(char *) "p", NULL
6503 };
6504
6505 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
6506 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6507 if (!SWIG_IsOK(res1)) {
6508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetPosition" "', expected argument " "1"" of type '" "wxRect *""'");
6509 }
6510 arg1 = reinterpret_cast< wxRect * >(argp1);
6511 {
6512 arg2 = &temp2;
6513 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6514 }
6515 {
6516 PyThreadState* __tstate = wxPyBeginAllowThreads();
6517 (arg1)->SetPosition((wxPoint const &)*arg2);
6518 wxPyEndAllowThreads(__tstate);
6519 if (PyErr_Occurred()) SWIG_fail;
6520 }
6521 resultobj = SWIG_Py_Void();
6522 return resultobj;
6523 fail:
6524 return NULL;
6525 }
6526
6527
6528 SWIGINTERN PyObject *_wrap_Rect_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6529 PyObject *resultobj = 0;
6530 wxRect *arg1 = (wxRect *) 0 ;
6531 wxSize result;
6532 void *argp1 = 0 ;
6533 int res1 = 0 ;
6534 PyObject *swig_obj[1] ;
6535
6536 if (!args) SWIG_fail;
6537 swig_obj[0] = args;
6538 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6539 if (!SWIG_IsOK(res1)) {
6540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetSize" "', expected argument " "1"" of type '" "wxRect const *""'");
6541 }
6542 arg1 = reinterpret_cast< wxRect * >(argp1);
6543 {
6544 PyThreadState* __tstate = wxPyBeginAllowThreads();
6545 result = ((wxRect const *)arg1)->GetSize();
6546 wxPyEndAllowThreads(__tstate);
6547 if (PyErr_Occurred()) SWIG_fail;
6548 }
6549 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6550 return resultobj;
6551 fail:
6552 return NULL;
6553 }
6554
6555
6556 SWIGINTERN PyObject *_wrap_Rect_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6557 PyObject *resultobj = 0;
6558 wxRect *arg1 = (wxRect *) 0 ;
6559 wxSize *arg2 = 0 ;
6560 void *argp1 = 0 ;
6561 int res1 = 0 ;
6562 wxSize temp2 ;
6563 PyObject * obj0 = 0 ;
6564 PyObject * obj1 = 0 ;
6565 char * kwnames[] = {
6566 (char *) "self",(char *) "s", NULL
6567 };
6568
6569 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
6570 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6571 if (!SWIG_IsOK(res1)) {
6572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetSize" "', expected argument " "1"" of type '" "wxRect *""'");
6573 }
6574 arg1 = reinterpret_cast< wxRect * >(argp1);
6575 {
6576 arg2 = &temp2;
6577 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6578 }
6579 {
6580 PyThreadState* __tstate = wxPyBeginAllowThreads();
6581 (arg1)->SetSize((wxSize const &)*arg2);
6582 wxPyEndAllowThreads(__tstate);
6583 if (PyErr_Occurred()) SWIG_fail;
6584 }
6585 resultobj = SWIG_Py_Void();
6586 return resultobj;
6587 fail:
6588 return NULL;
6589 }
6590
6591
6592 SWIGINTERN PyObject *_wrap_Rect_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6593 PyObject *resultobj = 0;
6594 wxRect *arg1 = (wxRect *) 0 ;
6595 bool result;
6596 void *argp1 = 0 ;
6597 int res1 = 0 ;
6598 PyObject *swig_obj[1] ;
6599
6600 if (!args) SWIG_fail;
6601 swig_obj[0] = args;
6602 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6603 if (!SWIG_IsOK(res1)) {
6604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_IsEmpty" "', expected argument " "1"" of type '" "wxRect const *""'");
6605 }
6606 arg1 = reinterpret_cast< wxRect * >(argp1);
6607 {
6608 PyThreadState* __tstate = wxPyBeginAllowThreads();
6609 result = (bool)((wxRect const *)arg1)->IsEmpty();
6610 wxPyEndAllowThreads(__tstate);
6611 if (PyErr_Occurred()) SWIG_fail;
6612 }
6613 {
6614 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6615 }
6616 return resultobj;
6617 fail:
6618 return NULL;
6619 }
6620
6621
6622 SWIGINTERN PyObject *_wrap_Rect_GetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6623 PyObject *resultobj = 0;
6624 wxRect *arg1 = (wxRect *) 0 ;
6625 wxPoint result;
6626 void *argp1 = 0 ;
6627 int res1 = 0 ;
6628 PyObject *swig_obj[1] ;
6629
6630 if (!args) SWIG_fail;
6631 swig_obj[0] = args;
6632 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6633 if (!SWIG_IsOK(res1)) {
6634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6635 }
6636 arg1 = reinterpret_cast< wxRect * >(argp1);
6637 {
6638 PyThreadState* __tstate = wxPyBeginAllowThreads();
6639 result = ((wxRect const *)arg1)->GetTopLeft();
6640 wxPyEndAllowThreads(__tstate);
6641 if (PyErr_Occurred()) SWIG_fail;
6642 }
6643 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6644 return resultobj;
6645 fail:
6646 return NULL;
6647 }
6648
6649
6650 SWIGINTERN PyObject *_wrap_Rect_SetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6651 PyObject *resultobj = 0;
6652 wxRect *arg1 = (wxRect *) 0 ;
6653 wxPoint *arg2 = 0 ;
6654 void *argp1 = 0 ;
6655 int res1 = 0 ;
6656 wxPoint temp2 ;
6657 PyObject * obj0 = 0 ;
6658 PyObject * obj1 = 0 ;
6659 char * kwnames[] = {
6660 (char *) "self",(char *) "p", NULL
6661 };
6662
6663 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6664 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6665 if (!SWIG_IsOK(res1)) {
6666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6667 }
6668 arg1 = reinterpret_cast< wxRect * >(argp1);
6669 {
6670 arg2 = &temp2;
6671 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6672 }
6673 {
6674 PyThreadState* __tstate = wxPyBeginAllowThreads();
6675 (arg1)->SetTopLeft((wxPoint const &)*arg2);
6676 wxPyEndAllowThreads(__tstate);
6677 if (PyErr_Occurred()) SWIG_fail;
6678 }
6679 resultobj = SWIG_Py_Void();
6680 return resultobj;
6681 fail:
6682 return NULL;
6683 }
6684
6685
6686 SWIGINTERN PyObject *_wrap_Rect_GetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6687 PyObject *resultobj = 0;
6688 wxRect *arg1 = (wxRect *) 0 ;
6689 wxPoint result;
6690 void *argp1 = 0 ;
6691 int res1 = 0 ;
6692 PyObject *swig_obj[1] ;
6693
6694 if (!args) SWIG_fail;
6695 swig_obj[0] = args;
6696 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6697 if (!SWIG_IsOK(res1)) {
6698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6699 }
6700 arg1 = reinterpret_cast< wxRect * >(argp1);
6701 {
6702 PyThreadState* __tstate = wxPyBeginAllowThreads();
6703 result = ((wxRect const *)arg1)->GetBottomRight();
6704 wxPyEndAllowThreads(__tstate);
6705 if (PyErr_Occurred()) SWIG_fail;
6706 }
6707 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6708 return resultobj;
6709 fail:
6710 return NULL;
6711 }
6712
6713
6714 SWIGINTERN PyObject *_wrap_Rect_SetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6715 PyObject *resultobj = 0;
6716 wxRect *arg1 = (wxRect *) 0 ;
6717 wxPoint *arg2 = 0 ;
6718 void *argp1 = 0 ;
6719 int res1 = 0 ;
6720 wxPoint temp2 ;
6721 PyObject * obj0 = 0 ;
6722 PyObject * obj1 = 0 ;
6723 char * kwnames[] = {
6724 (char *) "self",(char *) "p", NULL
6725 };
6726
6727 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) SWIG_fail;
6728 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6729 if (!SWIG_IsOK(res1)) {
6730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomRight" "', expected argument " "1"" of type '" "wxRect *""'");
6731 }
6732 arg1 = reinterpret_cast< wxRect * >(argp1);
6733 {
6734 arg2 = &temp2;
6735 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6736 }
6737 {
6738 PyThreadState* __tstate = wxPyBeginAllowThreads();
6739 (arg1)->SetBottomRight((wxPoint const &)*arg2);
6740 wxPyEndAllowThreads(__tstate);
6741 if (PyErr_Occurred()) SWIG_fail;
6742 }
6743 resultobj = SWIG_Py_Void();
6744 return resultobj;
6745 fail:
6746 return NULL;
6747 }
6748
6749
6750 SWIGINTERN PyObject *_wrap_Rect_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6751 PyObject *resultobj = 0;
6752 wxRect *arg1 = (wxRect *) 0 ;
6753 int result;
6754 void *argp1 = 0 ;
6755 int res1 = 0 ;
6756 PyObject *swig_obj[1] ;
6757
6758 if (!args) SWIG_fail;
6759 swig_obj[0] = args;
6760 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6761 if (!SWIG_IsOK(res1)) {
6762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6763 }
6764 arg1 = reinterpret_cast< wxRect * >(argp1);
6765 {
6766 PyThreadState* __tstate = wxPyBeginAllowThreads();
6767 result = (int)((wxRect const *)arg1)->GetLeft();
6768 wxPyEndAllowThreads(__tstate);
6769 if (PyErr_Occurred()) SWIG_fail;
6770 }
6771 resultobj = SWIG_From_int(static_cast< int >(result));
6772 return resultobj;
6773 fail:
6774 return NULL;
6775 }
6776
6777
6778 SWIGINTERN PyObject *_wrap_Rect_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6779 PyObject *resultobj = 0;
6780 wxRect *arg1 = (wxRect *) 0 ;
6781 int result;
6782 void *argp1 = 0 ;
6783 int res1 = 0 ;
6784 PyObject *swig_obj[1] ;
6785
6786 if (!args) SWIG_fail;
6787 swig_obj[0] = args;
6788 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6789 if (!SWIG_IsOK(res1)) {
6790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTop" "', expected argument " "1"" of type '" "wxRect const *""'");
6791 }
6792 arg1 = reinterpret_cast< wxRect * >(argp1);
6793 {
6794 PyThreadState* __tstate = wxPyBeginAllowThreads();
6795 result = (int)((wxRect const *)arg1)->GetTop();
6796 wxPyEndAllowThreads(__tstate);
6797 if (PyErr_Occurred()) SWIG_fail;
6798 }
6799 resultobj = SWIG_From_int(static_cast< int >(result));
6800 return resultobj;
6801 fail:
6802 return NULL;
6803 }
6804
6805
6806 SWIGINTERN PyObject *_wrap_Rect_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6807 PyObject *resultobj = 0;
6808 wxRect *arg1 = (wxRect *) 0 ;
6809 int result;
6810 void *argp1 = 0 ;
6811 int res1 = 0 ;
6812 PyObject *swig_obj[1] ;
6813
6814 if (!args) SWIG_fail;
6815 swig_obj[0] = args;
6816 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6817 if (!SWIG_IsOK(res1)) {
6818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottom" "', expected argument " "1"" of type '" "wxRect const *""'");
6819 }
6820 arg1 = reinterpret_cast< wxRect * >(argp1);
6821 {
6822 PyThreadState* __tstate = wxPyBeginAllowThreads();
6823 result = (int)((wxRect const *)arg1)->GetBottom();
6824 wxPyEndAllowThreads(__tstate);
6825 if (PyErr_Occurred()) SWIG_fail;
6826 }
6827 resultobj = SWIG_From_int(static_cast< int >(result));
6828 return resultobj;
6829 fail:
6830 return NULL;
6831 }
6832
6833
6834 SWIGINTERN PyObject *_wrap_Rect_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6835 PyObject *resultobj = 0;
6836 wxRect *arg1 = (wxRect *) 0 ;
6837 int result;
6838 void *argp1 = 0 ;
6839 int res1 = 0 ;
6840 PyObject *swig_obj[1] ;
6841
6842 if (!args) SWIG_fail;
6843 swig_obj[0] = args;
6844 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6845 if (!SWIG_IsOK(res1)) {
6846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6847 }
6848 arg1 = reinterpret_cast< wxRect * >(argp1);
6849 {
6850 PyThreadState* __tstate = wxPyBeginAllowThreads();
6851 result = (int)((wxRect const *)arg1)->GetRight();
6852 wxPyEndAllowThreads(__tstate);
6853 if (PyErr_Occurred()) SWIG_fail;
6854 }
6855 resultobj = SWIG_From_int(static_cast< int >(result));
6856 return resultobj;
6857 fail:
6858 return NULL;
6859 }
6860
6861
6862 SWIGINTERN PyObject *_wrap_Rect_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6863 PyObject *resultobj = 0;
6864 wxRect *arg1 = (wxRect *) 0 ;
6865 int arg2 ;
6866 void *argp1 = 0 ;
6867 int res1 = 0 ;
6868 int val2 ;
6869 int ecode2 = 0 ;
6870 PyObject * obj0 = 0 ;
6871 PyObject * obj1 = 0 ;
6872 char * kwnames[] = {
6873 (char *) "self",(char *) "left", NULL
6874 };
6875
6876 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6877 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6878 if (!SWIG_IsOK(res1)) {
6879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6880 }
6881 arg1 = reinterpret_cast< wxRect * >(argp1);
6882 ecode2 = SWIG_AsVal_int(obj1, &val2);
6883 if (!SWIG_IsOK(ecode2)) {
6884 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetLeft" "', expected argument " "2"" of type '" "int""'");
6885 }
6886 arg2 = static_cast< int >(val2);
6887 {
6888 PyThreadState* __tstate = wxPyBeginAllowThreads();
6889 (arg1)->SetLeft(arg2);
6890 wxPyEndAllowThreads(__tstate);
6891 if (PyErr_Occurred()) SWIG_fail;
6892 }
6893 resultobj = SWIG_Py_Void();
6894 return resultobj;
6895 fail:
6896 return NULL;
6897 }
6898
6899
6900 SWIGINTERN PyObject *_wrap_Rect_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6901 PyObject *resultobj = 0;
6902 wxRect *arg1 = (wxRect *) 0 ;
6903 int arg2 ;
6904 void *argp1 = 0 ;
6905 int res1 = 0 ;
6906 int val2 ;
6907 int ecode2 = 0 ;
6908 PyObject * obj0 = 0 ;
6909 PyObject * obj1 = 0 ;
6910 char * kwnames[] = {
6911 (char *) "self",(char *) "right", NULL
6912 };
6913
6914 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
6915 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6916 if (!SWIG_IsOK(res1)) {
6917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetRight" "', expected argument " "1"" of type '" "wxRect *""'");
6918 }
6919 arg1 = reinterpret_cast< wxRect * >(argp1);
6920 ecode2 = SWIG_AsVal_int(obj1, &val2);
6921 if (!SWIG_IsOK(ecode2)) {
6922 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetRight" "', expected argument " "2"" of type '" "int""'");
6923 }
6924 arg2 = static_cast< int >(val2);
6925 {
6926 PyThreadState* __tstate = wxPyBeginAllowThreads();
6927 (arg1)->SetRight(arg2);
6928 wxPyEndAllowThreads(__tstate);
6929 if (PyErr_Occurred()) SWIG_fail;
6930 }
6931 resultobj = SWIG_Py_Void();
6932 return resultobj;
6933 fail:
6934 return NULL;
6935 }
6936
6937
6938 SWIGINTERN PyObject *_wrap_Rect_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6939 PyObject *resultobj = 0;
6940 wxRect *arg1 = (wxRect *) 0 ;
6941 int arg2 ;
6942 void *argp1 = 0 ;
6943 int res1 = 0 ;
6944 int val2 ;
6945 int ecode2 = 0 ;
6946 PyObject * obj0 = 0 ;
6947 PyObject * obj1 = 0 ;
6948 char * kwnames[] = {
6949 (char *) "self",(char *) "top", NULL
6950 };
6951
6952 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
6953 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6954 if (!SWIG_IsOK(res1)) {
6955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTop" "', expected argument " "1"" of type '" "wxRect *""'");
6956 }
6957 arg1 = reinterpret_cast< wxRect * >(argp1);
6958 ecode2 = SWIG_AsVal_int(obj1, &val2);
6959 if (!SWIG_IsOK(ecode2)) {
6960 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetTop" "', expected argument " "2"" of type '" "int""'");
6961 }
6962 arg2 = static_cast< int >(val2);
6963 {
6964 PyThreadState* __tstate = wxPyBeginAllowThreads();
6965 (arg1)->SetTop(arg2);
6966 wxPyEndAllowThreads(__tstate);
6967 if (PyErr_Occurred()) SWIG_fail;
6968 }
6969 resultobj = SWIG_Py_Void();
6970 return resultobj;
6971 fail:
6972 return NULL;
6973 }
6974
6975
6976 SWIGINTERN PyObject *_wrap_Rect_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6977 PyObject *resultobj = 0;
6978 wxRect *arg1 = (wxRect *) 0 ;
6979 int arg2 ;
6980 void *argp1 = 0 ;
6981 int res1 = 0 ;
6982 int val2 ;
6983 int ecode2 = 0 ;
6984 PyObject * obj0 = 0 ;
6985 PyObject * obj1 = 0 ;
6986 char * kwnames[] = {
6987 (char *) "self",(char *) "bottom", NULL
6988 };
6989
6990 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
6991 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6992 if (!SWIG_IsOK(res1)) {
6993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottom" "', expected argument " "1"" of type '" "wxRect *""'");
6994 }
6995 arg1 = reinterpret_cast< wxRect * >(argp1);
6996 ecode2 = SWIG_AsVal_int(obj1, &val2);
6997 if (!SWIG_IsOK(ecode2)) {
6998 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetBottom" "', expected argument " "2"" of type '" "int""'");
6999 }
7000 arg2 = static_cast< int >(val2);
7001 {
7002 PyThreadState* __tstate = wxPyBeginAllowThreads();
7003 (arg1)->SetBottom(arg2);
7004 wxPyEndAllowThreads(__tstate);
7005 if (PyErr_Occurred()) SWIG_fail;
7006 }
7007 resultobj = SWIG_Py_Void();
7008 return resultobj;
7009 fail:
7010 return NULL;
7011 }
7012
7013
7014 SWIGINTERN PyObject *_wrap_Rect_Inflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7015 PyObject *resultobj = 0;
7016 wxRect *arg1 = (wxRect *) 0 ;
7017 int arg2 ;
7018 int arg3 ;
7019 wxRect *result = 0 ;
7020 void *argp1 = 0 ;
7021 int res1 = 0 ;
7022 int val2 ;
7023 int ecode2 = 0 ;
7024 int val3 ;
7025 int ecode3 = 0 ;
7026 PyObject * obj0 = 0 ;
7027 PyObject * obj1 = 0 ;
7028 PyObject * obj2 = 0 ;
7029 char * kwnames[] = {
7030 (char *) "self",(char *) "dx",(char *) "dy", NULL
7031 };
7032
7033 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7034 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7035 if (!SWIG_IsOK(res1)) {
7036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inflate" "', expected argument " "1"" of type '" "wxRect *""'");
7037 }
7038 arg1 = reinterpret_cast< wxRect * >(argp1);
7039 ecode2 = SWIG_AsVal_int(obj1, &val2);
7040 if (!SWIG_IsOK(ecode2)) {
7041 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Inflate" "', expected argument " "2"" of type '" "int""'");
7042 }
7043 arg2 = static_cast< int >(val2);
7044 ecode3 = SWIG_AsVal_int(obj2, &val3);
7045 if (!SWIG_IsOK(ecode3)) {
7046 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Inflate" "', expected argument " "3"" of type '" "int""'");
7047 }
7048 arg3 = static_cast< int >(val3);
7049 {
7050 PyThreadState* __tstate = wxPyBeginAllowThreads();
7051 {
7052 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
7053 result = (wxRect *) &_result_ref;
7054 }
7055 wxPyEndAllowThreads(__tstate);
7056 if (PyErr_Occurred()) SWIG_fail;
7057 }
7058 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7059 return resultobj;
7060 fail:
7061 return NULL;
7062 }
7063
7064
7065 SWIGINTERN PyObject *_wrap_Rect_Deflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7066 PyObject *resultobj = 0;
7067 wxRect *arg1 = (wxRect *) 0 ;
7068 int arg2 ;
7069 int arg3 ;
7070 wxRect *result = 0 ;
7071 void *argp1 = 0 ;
7072 int res1 = 0 ;
7073 int val2 ;
7074 int ecode2 = 0 ;
7075 int val3 ;
7076 int ecode3 = 0 ;
7077 PyObject * obj0 = 0 ;
7078 PyObject * obj1 = 0 ;
7079 PyObject * obj2 = 0 ;
7080 char * kwnames[] = {
7081 (char *) "self",(char *) "dx",(char *) "dy", NULL
7082 };
7083
7084 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7085 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7086 if (!SWIG_IsOK(res1)) {
7087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Deflate" "', expected argument " "1"" of type '" "wxRect *""'");
7088 }
7089 arg1 = reinterpret_cast< wxRect * >(argp1);
7090 ecode2 = SWIG_AsVal_int(obj1, &val2);
7091 if (!SWIG_IsOK(ecode2)) {
7092 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Deflate" "', expected argument " "2"" of type '" "int""'");
7093 }
7094 arg2 = static_cast< int >(val2);
7095 ecode3 = SWIG_AsVal_int(obj2, &val3);
7096 if (!SWIG_IsOK(ecode3)) {
7097 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Deflate" "', expected argument " "3"" of type '" "int""'");
7098 }
7099 arg3 = static_cast< int >(val3);
7100 {
7101 PyThreadState* __tstate = wxPyBeginAllowThreads();
7102 {
7103 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
7104 result = (wxRect *) &_result_ref;
7105 }
7106 wxPyEndAllowThreads(__tstate);
7107 if (PyErr_Occurred()) SWIG_fail;
7108 }
7109 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7110 return resultobj;
7111 fail:
7112 return NULL;
7113 }
7114
7115
7116 SWIGINTERN PyObject *_wrap_Rect_OffsetXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7117 PyObject *resultobj = 0;
7118 wxRect *arg1 = (wxRect *) 0 ;
7119 int arg2 ;
7120 int arg3 ;
7121 void *argp1 = 0 ;
7122 int res1 = 0 ;
7123 int val2 ;
7124 int ecode2 = 0 ;
7125 int val3 ;
7126 int ecode3 = 0 ;
7127 PyObject * obj0 = 0 ;
7128 PyObject * obj1 = 0 ;
7129 PyObject * obj2 = 0 ;
7130 char * kwnames[] = {
7131 (char *) "self",(char *) "dx",(char *) "dy", NULL
7132 };
7133
7134 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7135 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7136 if (!SWIG_IsOK(res1)) {
7137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_OffsetXY" "', expected argument " "1"" of type '" "wxRect *""'");
7138 }
7139 arg1 = reinterpret_cast< wxRect * >(argp1);
7140 ecode2 = SWIG_AsVal_int(obj1, &val2);
7141 if (!SWIG_IsOK(ecode2)) {
7142 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_OffsetXY" "', expected argument " "2"" of type '" "int""'");
7143 }
7144 arg2 = static_cast< int >(val2);
7145 ecode3 = SWIG_AsVal_int(obj2, &val3);
7146 if (!SWIG_IsOK(ecode3)) {
7147 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_OffsetXY" "', expected argument " "3"" of type '" "int""'");
7148 }
7149 arg3 = static_cast< int >(val3);
7150 {
7151 PyThreadState* __tstate = wxPyBeginAllowThreads();
7152 (arg1)->Offset(arg2,arg3);
7153 wxPyEndAllowThreads(__tstate);
7154 if (PyErr_Occurred()) SWIG_fail;
7155 }
7156 resultobj = SWIG_Py_Void();
7157 return resultobj;
7158 fail:
7159 return NULL;
7160 }
7161
7162
7163 SWIGINTERN PyObject *_wrap_Rect_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7164 PyObject *resultobj = 0;
7165 wxRect *arg1 = (wxRect *) 0 ;
7166 wxPoint *arg2 = 0 ;
7167 void *argp1 = 0 ;
7168 int res1 = 0 ;
7169 wxPoint temp2 ;
7170 PyObject * obj0 = 0 ;
7171 PyObject * obj1 = 0 ;
7172 char * kwnames[] = {
7173 (char *) "self",(char *) "pt", NULL
7174 };
7175
7176 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
7177 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7178 if (!SWIG_IsOK(res1)) {
7179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Offset" "', expected argument " "1"" of type '" "wxRect *""'");
7180 }
7181 arg1 = reinterpret_cast< wxRect * >(argp1);
7182 {
7183 arg2 = &temp2;
7184 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7185 }
7186 {
7187 PyThreadState* __tstate = wxPyBeginAllowThreads();
7188 (arg1)->Offset((wxPoint const &)*arg2);
7189 wxPyEndAllowThreads(__tstate);
7190 if (PyErr_Occurred()) SWIG_fail;
7191 }
7192 resultobj = SWIG_Py_Void();
7193 return resultobj;
7194 fail:
7195 return NULL;
7196 }
7197
7198
7199 SWIGINTERN PyObject *_wrap_Rect_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7200 PyObject *resultobj = 0;
7201 wxRect *arg1 = (wxRect *) 0 ;
7202 wxRect *arg2 = 0 ;
7203 wxRect result;
7204 void *argp1 = 0 ;
7205 int res1 = 0 ;
7206 wxRect temp2 ;
7207 PyObject * obj0 = 0 ;
7208 PyObject * obj1 = 0 ;
7209 char * kwnames[] = {
7210 (char *) "self",(char *) "rect", NULL
7211 };
7212
7213 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
7214 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7215 if (!SWIG_IsOK(res1)) {
7216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersect" "', expected argument " "1"" of type '" "wxRect *""'");
7217 }
7218 arg1 = reinterpret_cast< wxRect * >(argp1);
7219 {
7220 arg2 = &temp2;
7221 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7222 }
7223 {
7224 PyThreadState* __tstate = wxPyBeginAllowThreads();
7225 result = (arg1)->Intersect((wxRect const &)*arg2);
7226 wxPyEndAllowThreads(__tstate);
7227 if (PyErr_Occurred()) SWIG_fail;
7228 }
7229 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7230 return resultobj;
7231 fail:
7232 return NULL;
7233 }
7234
7235
7236 SWIGINTERN PyObject *_wrap_Rect_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7237 PyObject *resultobj = 0;
7238 wxRect *arg1 = (wxRect *) 0 ;
7239 wxRect *arg2 = 0 ;
7240 wxRect result;
7241 void *argp1 = 0 ;
7242 int res1 = 0 ;
7243 wxRect temp2 ;
7244 PyObject * obj0 = 0 ;
7245 PyObject * obj1 = 0 ;
7246 char * kwnames[] = {
7247 (char *) "self",(char *) "rect", NULL
7248 };
7249
7250 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) SWIG_fail;
7251 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7252 if (!SWIG_IsOK(res1)) {
7253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Union" "', expected argument " "1"" of type '" "wxRect *""'");
7254 }
7255 arg1 = reinterpret_cast< wxRect * >(argp1);
7256 {
7257 arg2 = &temp2;
7258 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7259 }
7260 {
7261 PyThreadState* __tstate = wxPyBeginAllowThreads();
7262 result = (arg1)->Union((wxRect const &)*arg2);
7263 wxPyEndAllowThreads(__tstate);
7264 if (PyErr_Occurred()) SWIG_fail;
7265 }
7266 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7267 return resultobj;
7268 fail:
7269 return NULL;
7270 }
7271
7272
7273 SWIGINTERN PyObject *_wrap_Rect___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7274 PyObject *resultobj = 0;
7275 wxRect *arg1 = (wxRect *) 0 ;
7276 wxRect *arg2 = 0 ;
7277 wxRect result;
7278 void *argp1 = 0 ;
7279 int res1 = 0 ;
7280 wxRect temp2 ;
7281 PyObject * obj0 = 0 ;
7282 PyObject * obj1 = 0 ;
7283 char * kwnames[] = {
7284 (char *) "self",(char *) "rect", NULL
7285 };
7286
7287 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) SWIG_fail;
7288 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7289 if (!SWIG_IsOK(res1)) {
7290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___add__" "', expected argument " "1"" of type '" "wxRect const *""'");
7291 }
7292 arg1 = reinterpret_cast< wxRect * >(argp1);
7293 {
7294 arg2 = &temp2;
7295 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7296 }
7297 {
7298 PyThreadState* __tstate = wxPyBeginAllowThreads();
7299 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
7300 wxPyEndAllowThreads(__tstate);
7301 if (PyErr_Occurred()) SWIG_fail;
7302 }
7303 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7304 return resultobj;
7305 fail:
7306 return NULL;
7307 }
7308
7309
7310 SWIGINTERN PyObject *_wrap_Rect___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7311 PyObject *resultobj = 0;
7312 wxRect *arg1 = (wxRect *) 0 ;
7313 wxRect *arg2 = 0 ;
7314 wxRect *result = 0 ;
7315 void *argp1 = 0 ;
7316 int res1 = 0 ;
7317 wxRect temp2 ;
7318 PyObject * obj0 = 0 ;
7319 PyObject * obj1 = 0 ;
7320 char * kwnames[] = {
7321 (char *) "self",(char *) "rect", NULL
7322 };
7323
7324 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
7325 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
7326 if (!SWIG_IsOK(res1)) {
7327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___iadd__" "', expected argument " "1"" of type '" "wxRect *""'");
7328 }
7329 arg1 = reinterpret_cast< wxRect * >(argp1);
7330 {
7331 arg2 = &temp2;
7332 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7333 }
7334 {
7335 PyThreadState* __tstate = wxPyBeginAllowThreads();
7336 {
7337 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
7338 result = (wxRect *) &_result_ref;
7339 }
7340 wxPyEndAllowThreads(__tstate);
7341 if (PyErr_Occurred()) SWIG_fail;
7342 }
7343 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7344 return resultobj;
7345 fail:
7346 return NULL;
7347 }
7348
7349
7350 SWIGINTERN PyObject *_wrap_Rect___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7351 PyObject *resultobj = 0;
7352 wxRect *arg1 = (wxRect *) 0 ;
7353 PyObject *arg2 = (PyObject *) 0 ;
7354 bool result;
7355 void *argp1 = 0 ;
7356 int res1 = 0 ;
7357 PyObject * obj0 = 0 ;
7358 PyObject * obj1 = 0 ;
7359 char * kwnames[] = {
7360 (char *) "self",(char *) "other", NULL
7361 };
7362
7363 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
7364 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7365 if (!SWIG_IsOK(res1)) {
7366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___eq__" "', expected argument " "1"" of type '" "wxRect *""'");
7367 }
7368 arg1 = reinterpret_cast< wxRect * >(argp1);
7369 arg2 = obj1;
7370 {
7371 result = (bool)wxRect___eq__(arg1,arg2);
7372 if (PyErr_Occurred()) SWIG_fail;
7373 }
7374 {
7375 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7376 }
7377 return resultobj;
7378 fail:
7379 return NULL;
7380 }
7381
7382
7383 SWIGINTERN PyObject *_wrap_Rect___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7384 PyObject *resultobj = 0;
7385 wxRect *arg1 = (wxRect *) 0 ;
7386 PyObject *arg2 = (PyObject *) 0 ;
7387 bool result;
7388 void *argp1 = 0 ;
7389 int res1 = 0 ;
7390 PyObject * obj0 = 0 ;
7391 PyObject * obj1 = 0 ;
7392 char * kwnames[] = {
7393 (char *) "self",(char *) "other", NULL
7394 };
7395
7396 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
7397 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7398 if (!SWIG_IsOK(res1)) {
7399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___ne__" "', expected argument " "1"" of type '" "wxRect *""'");
7400 }
7401 arg1 = reinterpret_cast< wxRect * >(argp1);
7402 arg2 = obj1;
7403 {
7404 result = (bool)wxRect___ne__(arg1,arg2);
7405 if (PyErr_Occurred()) SWIG_fail;
7406 }
7407 {
7408 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7409 }
7410 return resultobj;
7411 fail:
7412 return NULL;
7413 }
7414
7415
7416 SWIGINTERN PyObject *_wrap_Rect_InsideXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7417 PyObject *resultobj = 0;
7418 wxRect *arg1 = (wxRect *) 0 ;
7419 int arg2 ;
7420 int arg3 ;
7421 bool result;
7422 void *argp1 = 0 ;
7423 int res1 = 0 ;
7424 int val2 ;
7425 int ecode2 = 0 ;
7426 int val3 ;
7427 int ecode3 = 0 ;
7428 PyObject * obj0 = 0 ;
7429 PyObject * obj1 = 0 ;
7430 PyObject * obj2 = 0 ;
7431 char * kwnames[] = {
7432 (char *) "self",(char *) "x",(char *) "y", NULL
7433 };
7434
7435 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_InsideXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7436 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7437 if (!SWIG_IsOK(res1)) {
7438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_InsideXY" "', expected argument " "1"" of type '" "wxRect const *""'");
7439 }
7440 arg1 = reinterpret_cast< wxRect * >(argp1);
7441 ecode2 = SWIG_AsVal_int(obj1, &val2);
7442 if (!SWIG_IsOK(ecode2)) {
7443 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_InsideXY" "', expected argument " "2"" of type '" "int""'");
7444 }
7445 arg2 = static_cast< int >(val2);
7446 ecode3 = SWIG_AsVal_int(obj2, &val3);
7447 if (!SWIG_IsOK(ecode3)) {
7448 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_InsideXY" "', expected argument " "3"" of type '" "int""'");
7449 }
7450 arg3 = static_cast< int >(val3);
7451 {
7452 PyThreadState* __tstate = wxPyBeginAllowThreads();
7453 result = (bool)((wxRect const *)arg1)->Inside(arg2,arg3);
7454 wxPyEndAllowThreads(__tstate);
7455 if (PyErr_Occurred()) SWIG_fail;
7456 }
7457 {
7458 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7459 }
7460 return resultobj;
7461 fail:
7462 return NULL;
7463 }
7464
7465
7466 SWIGINTERN PyObject *_wrap_Rect_Inside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7467 PyObject *resultobj = 0;
7468 wxRect *arg1 = (wxRect *) 0 ;
7469 wxPoint *arg2 = 0 ;
7470 bool result;
7471 void *argp1 = 0 ;
7472 int res1 = 0 ;
7473 wxPoint temp2 ;
7474 PyObject * obj0 = 0 ;
7475 PyObject * obj1 = 0 ;
7476 char * kwnames[] = {
7477 (char *) "self",(char *) "pt", NULL
7478 };
7479
7480 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Inside",kwnames,&obj0,&obj1)) SWIG_fail;
7481 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7482 if (!SWIG_IsOK(res1)) {
7483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inside" "', expected argument " "1"" of type '" "wxRect const *""'");
7484 }
7485 arg1 = reinterpret_cast< wxRect * >(argp1);
7486 {
7487 arg2 = &temp2;
7488 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7489 }
7490 {
7491 PyThreadState* __tstate = wxPyBeginAllowThreads();
7492 result = (bool)((wxRect const *)arg1)->Inside((wxPoint const &)*arg2);
7493 wxPyEndAllowThreads(__tstate);
7494 if (PyErr_Occurred()) SWIG_fail;
7495 }
7496 {
7497 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7498 }
7499 return resultobj;
7500 fail:
7501 return NULL;
7502 }
7503
7504
7505 SWIGINTERN PyObject *_wrap_Rect_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7506 PyObject *resultobj = 0;
7507 wxRect *arg1 = (wxRect *) 0 ;
7508 wxRect *arg2 = 0 ;
7509 bool result;
7510 void *argp1 = 0 ;
7511 int res1 = 0 ;
7512 wxRect temp2 ;
7513 PyObject * obj0 = 0 ;
7514 PyObject * obj1 = 0 ;
7515 char * kwnames[] = {
7516 (char *) "self",(char *) "rect", NULL
7517 };
7518
7519 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
7520 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7521 if (!SWIG_IsOK(res1)) {
7522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersects" "', expected argument " "1"" of type '" "wxRect const *""'");
7523 }
7524 arg1 = reinterpret_cast< wxRect * >(argp1);
7525 {
7526 arg2 = &temp2;
7527 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7528 }
7529 {
7530 PyThreadState* __tstate = wxPyBeginAllowThreads();
7531 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
7532 wxPyEndAllowThreads(__tstate);
7533 if (PyErr_Occurred()) SWIG_fail;
7534 }
7535 {
7536 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7537 }
7538 return resultobj;
7539 fail:
7540 return NULL;
7541 }
7542
7543
7544 SWIGINTERN PyObject *_wrap_Rect_CenterIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7545 PyObject *resultobj = 0;
7546 wxRect *arg1 = (wxRect *) 0 ;
7547 wxRect *arg2 = 0 ;
7548 int arg3 = (int) wxBOTH ;
7549 wxRect result;
7550 void *argp1 = 0 ;
7551 int res1 = 0 ;
7552 wxRect temp2 ;
7553 int val3 ;
7554 int ecode3 = 0 ;
7555 PyObject * obj0 = 0 ;
7556 PyObject * obj1 = 0 ;
7557 PyObject * obj2 = 0 ;
7558 char * kwnames[] = {
7559 (char *) "self",(char *) "r",(char *) "dir", NULL
7560 };
7561
7562 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Rect_CenterIn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7563 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7564 if (!SWIG_IsOK(res1)) {
7565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_CenterIn" "', expected argument " "1"" of type '" "wxRect *""'");
7566 }
7567 arg1 = reinterpret_cast< wxRect * >(argp1);
7568 {
7569 arg2 = &temp2;
7570 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7571 }
7572 if (obj2) {
7573 ecode3 = SWIG_AsVal_int(obj2, &val3);
7574 if (!SWIG_IsOK(ecode3)) {
7575 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_CenterIn" "', expected argument " "3"" of type '" "int""'");
7576 }
7577 arg3 = static_cast< int >(val3);
7578 }
7579 {
7580 PyThreadState* __tstate = wxPyBeginAllowThreads();
7581 result = (arg1)->CenterIn((wxRect const &)*arg2,arg3);
7582 wxPyEndAllowThreads(__tstate);
7583 if (PyErr_Occurred()) SWIG_fail;
7584 }
7585 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7586 return resultobj;
7587 fail:
7588 return NULL;
7589 }
7590
7591
7592 SWIGINTERN PyObject *_wrap_Rect_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7593 PyObject *resultobj = 0;
7594 wxRect *arg1 = (wxRect *) 0 ;
7595 int arg2 ;
7596 void *argp1 = 0 ;
7597 int res1 = 0 ;
7598 int val2 ;
7599 int ecode2 = 0 ;
7600 PyObject *swig_obj[2] ;
7601
7602 if (!SWIG_Python_UnpackTuple(args,"Rect_x_set",2,2,swig_obj)) SWIG_fail;
7603 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7604 if (!SWIG_IsOK(res1)) {
7605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_set" "', expected argument " "1"" of type '" "wxRect *""'");
7606 }
7607 arg1 = reinterpret_cast< wxRect * >(argp1);
7608 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7609 if (!SWIG_IsOK(ecode2)) {
7610 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_x_set" "', expected argument " "2"" of type '" "int""'");
7611 }
7612 arg2 = static_cast< int >(val2);
7613 if (arg1) (arg1)->x = arg2;
7614
7615 resultobj = SWIG_Py_Void();
7616 return resultobj;
7617 fail:
7618 return NULL;
7619 }
7620
7621
7622 SWIGINTERN PyObject *_wrap_Rect_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7623 PyObject *resultobj = 0;
7624 wxRect *arg1 = (wxRect *) 0 ;
7625 int result;
7626 void *argp1 = 0 ;
7627 int res1 = 0 ;
7628 PyObject *swig_obj[1] ;
7629
7630 if (!args) SWIG_fail;
7631 swig_obj[0] = args;
7632 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7633 if (!SWIG_IsOK(res1)) {
7634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_get" "', expected argument " "1"" of type '" "wxRect *""'");
7635 }
7636 arg1 = reinterpret_cast< wxRect * >(argp1);
7637 result = (int) ((arg1)->x);
7638 resultobj = SWIG_From_int(static_cast< int >(result));
7639 return resultobj;
7640 fail:
7641 return NULL;
7642 }
7643
7644
7645 SWIGINTERN PyObject *_wrap_Rect_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7646 PyObject *resultobj = 0;
7647 wxRect *arg1 = (wxRect *) 0 ;
7648 int arg2 ;
7649 void *argp1 = 0 ;
7650 int res1 = 0 ;
7651 int val2 ;
7652 int ecode2 = 0 ;
7653 PyObject *swig_obj[2] ;
7654
7655 if (!SWIG_Python_UnpackTuple(args,"Rect_y_set",2,2,swig_obj)) SWIG_fail;
7656 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7657 if (!SWIG_IsOK(res1)) {
7658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_set" "', expected argument " "1"" of type '" "wxRect *""'");
7659 }
7660 arg1 = reinterpret_cast< wxRect * >(argp1);
7661 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7662 if (!SWIG_IsOK(ecode2)) {
7663 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_y_set" "', expected argument " "2"" of type '" "int""'");
7664 }
7665 arg2 = static_cast< int >(val2);
7666 if (arg1) (arg1)->y = arg2;
7667
7668 resultobj = SWIG_Py_Void();
7669 return resultobj;
7670 fail:
7671 return NULL;
7672 }
7673
7674
7675 SWIGINTERN PyObject *_wrap_Rect_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7676 PyObject *resultobj = 0;
7677 wxRect *arg1 = (wxRect *) 0 ;
7678 int result;
7679 void *argp1 = 0 ;
7680 int res1 = 0 ;
7681 PyObject *swig_obj[1] ;
7682
7683 if (!args) SWIG_fail;
7684 swig_obj[0] = args;
7685 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7686 if (!SWIG_IsOK(res1)) {
7687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_get" "', expected argument " "1"" of type '" "wxRect *""'");
7688 }
7689 arg1 = reinterpret_cast< wxRect * >(argp1);
7690 result = (int) ((arg1)->y);
7691 resultobj = SWIG_From_int(static_cast< int >(result));
7692 return resultobj;
7693 fail:
7694 return NULL;
7695 }
7696
7697
7698 SWIGINTERN PyObject *_wrap_Rect_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7699 PyObject *resultobj = 0;
7700 wxRect *arg1 = (wxRect *) 0 ;
7701 int arg2 ;
7702 void *argp1 = 0 ;
7703 int res1 = 0 ;
7704 int val2 ;
7705 int ecode2 = 0 ;
7706 PyObject *swig_obj[2] ;
7707
7708 if (!SWIG_Python_UnpackTuple(args,"Rect_width_set",2,2,swig_obj)) SWIG_fail;
7709 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7710 if (!SWIG_IsOK(res1)) {
7711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_set" "', expected argument " "1"" of type '" "wxRect *""'");
7712 }
7713 arg1 = reinterpret_cast< wxRect * >(argp1);
7714 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7715 if (!SWIG_IsOK(ecode2)) {
7716 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_width_set" "', expected argument " "2"" of type '" "int""'");
7717 }
7718 arg2 = static_cast< int >(val2);
7719 if (arg1) (arg1)->width = arg2;
7720
7721 resultobj = SWIG_Py_Void();
7722 return resultobj;
7723 fail:
7724 return NULL;
7725 }
7726
7727
7728 SWIGINTERN PyObject *_wrap_Rect_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7729 PyObject *resultobj = 0;
7730 wxRect *arg1 = (wxRect *) 0 ;
7731 int result;
7732 void *argp1 = 0 ;
7733 int res1 = 0 ;
7734 PyObject *swig_obj[1] ;
7735
7736 if (!args) SWIG_fail;
7737 swig_obj[0] = args;
7738 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7739 if (!SWIG_IsOK(res1)) {
7740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_get" "', expected argument " "1"" of type '" "wxRect *""'");
7741 }
7742 arg1 = reinterpret_cast< wxRect * >(argp1);
7743 result = (int) ((arg1)->width);
7744 resultobj = SWIG_From_int(static_cast< int >(result));
7745 return resultobj;
7746 fail:
7747 return NULL;
7748 }
7749
7750
7751 SWIGINTERN PyObject *_wrap_Rect_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7752 PyObject *resultobj = 0;
7753 wxRect *arg1 = (wxRect *) 0 ;
7754 int arg2 ;
7755 void *argp1 = 0 ;
7756 int res1 = 0 ;
7757 int val2 ;
7758 int ecode2 = 0 ;
7759 PyObject *swig_obj[2] ;
7760
7761 if (!SWIG_Python_UnpackTuple(args,"Rect_height_set",2,2,swig_obj)) SWIG_fail;
7762 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7763 if (!SWIG_IsOK(res1)) {
7764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_set" "', expected argument " "1"" of type '" "wxRect *""'");
7765 }
7766 arg1 = reinterpret_cast< wxRect * >(argp1);
7767 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7768 if (!SWIG_IsOK(ecode2)) {
7769 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_height_set" "', expected argument " "2"" of type '" "int""'");
7770 }
7771 arg2 = static_cast< int >(val2);
7772 if (arg1) (arg1)->height = arg2;
7773
7774 resultobj = SWIG_Py_Void();
7775 return resultobj;
7776 fail:
7777 return NULL;
7778 }
7779
7780
7781 SWIGINTERN PyObject *_wrap_Rect_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7782 PyObject *resultobj = 0;
7783 wxRect *arg1 = (wxRect *) 0 ;
7784 int result;
7785 void *argp1 = 0 ;
7786 int res1 = 0 ;
7787 PyObject *swig_obj[1] ;
7788
7789 if (!args) SWIG_fail;
7790 swig_obj[0] = args;
7791 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7792 if (!SWIG_IsOK(res1)) {
7793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_get" "', expected argument " "1"" of type '" "wxRect *""'");
7794 }
7795 arg1 = reinterpret_cast< wxRect * >(argp1);
7796 result = (int) ((arg1)->height);
7797 resultobj = SWIG_From_int(static_cast< int >(result));
7798 return resultobj;
7799 fail:
7800 return NULL;
7801 }
7802
7803
7804 SWIGINTERN PyObject *_wrap_Rect_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7805 PyObject *resultobj = 0;
7806 wxRect *arg1 = (wxRect *) 0 ;
7807 int arg2 = (int) 0 ;
7808 int arg3 = (int) 0 ;
7809 int arg4 = (int) 0 ;
7810 int arg5 = (int) 0 ;
7811 void *argp1 = 0 ;
7812 int res1 = 0 ;
7813 int val2 ;
7814 int ecode2 = 0 ;
7815 int val3 ;
7816 int ecode3 = 0 ;
7817 int val4 ;
7818 int ecode4 = 0 ;
7819 int val5 ;
7820 int ecode5 = 0 ;
7821 PyObject * obj0 = 0 ;
7822 PyObject * obj1 = 0 ;
7823 PyObject * obj2 = 0 ;
7824 PyObject * obj3 = 0 ;
7825 PyObject * obj4 = 0 ;
7826 char * kwnames[] = {
7827 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
7828 };
7829
7830 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
7831 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7832 if (!SWIG_IsOK(res1)) {
7833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Set" "', expected argument " "1"" of type '" "wxRect *""'");
7834 }
7835 arg1 = reinterpret_cast< wxRect * >(argp1);
7836 if (obj1) {
7837 ecode2 = SWIG_AsVal_int(obj1, &val2);
7838 if (!SWIG_IsOK(ecode2)) {
7839 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Set" "', expected argument " "2"" of type '" "int""'");
7840 }
7841 arg2 = static_cast< int >(val2);
7842 }
7843 if (obj2) {
7844 ecode3 = SWIG_AsVal_int(obj2, &val3);
7845 if (!SWIG_IsOK(ecode3)) {
7846 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Set" "', expected argument " "3"" of type '" "int""'");
7847 }
7848 arg3 = static_cast< int >(val3);
7849 }
7850 if (obj3) {
7851 ecode4 = SWIG_AsVal_int(obj3, &val4);
7852 if (!SWIG_IsOK(ecode4)) {
7853 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Rect_Set" "', expected argument " "4"" of type '" "int""'");
7854 }
7855 arg4 = static_cast< int >(val4);
7856 }
7857 if (obj4) {
7858 ecode5 = SWIG_AsVal_int(obj4, &val5);
7859 if (!SWIG_IsOK(ecode5)) {
7860 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Rect_Set" "', expected argument " "5"" of type '" "int""'");
7861 }
7862 arg5 = static_cast< int >(val5);
7863 }
7864 {
7865 PyThreadState* __tstate = wxPyBeginAllowThreads();
7866 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
7867 wxPyEndAllowThreads(__tstate);
7868 if (PyErr_Occurred()) SWIG_fail;
7869 }
7870 resultobj = SWIG_Py_Void();
7871 return resultobj;
7872 fail:
7873 return NULL;
7874 }
7875
7876
7877 SWIGINTERN PyObject *_wrap_Rect_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7878 PyObject *resultobj = 0;
7879 wxRect *arg1 = (wxRect *) 0 ;
7880 PyObject *result = 0 ;
7881 void *argp1 = 0 ;
7882 int res1 = 0 ;
7883 PyObject *swig_obj[1] ;
7884
7885 if (!args) SWIG_fail;
7886 swig_obj[0] = args;
7887 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7888 if (!SWIG_IsOK(res1)) {
7889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Get" "', expected argument " "1"" of type '" "wxRect *""'");
7890 }
7891 arg1 = reinterpret_cast< wxRect * >(argp1);
7892 {
7893 PyThreadState* __tstate = wxPyBeginAllowThreads();
7894 result = (PyObject *)wxRect_Get(arg1);
7895 wxPyEndAllowThreads(__tstate);
7896 if (PyErr_Occurred()) SWIG_fail;
7897 }
7898 resultobj = result;
7899 return resultobj;
7900 fail:
7901 return NULL;
7902 }
7903
7904
7905 SWIGINTERN PyObject *Rect_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7906 PyObject *obj;
7907 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7908 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect, SWIG_NewClientData(obj));
7909 return SWIG_Py_Void();
7910 }
7911
7912 SWIGINTERN PyObject *Rect_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7913 return SWIG_Python_InitShadowInstance(args);
7914 }
7915
7916 SWIGINTERN PyObject *_wrap_IntersectRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7917 PyObject *resultobj = 0;
7918 wxRect *arg1 = (wxRect *) 0 ;
7919 wxRect *arg2 = (wxRect *) 0 ;
7920 PyObject *result = 0 ;
7921 void *argp1 = 0 ;
7922 int res1 = 0 ;
7923 void *argp2 = 0 ;
7924 int res2 = 0 ;
7925 PyObject * obj0 = 0 ;
7926 PyObject * obj1 = 0 ;
7927 char * kwnames[] = {
7928 (char *) "r1",(char *) "r2", NULL
7929 };
7930
7931 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) SWIG_fail;
7932 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7933 if (!SWIG_IsOK(res1)) {
7934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntersectRect" "', expected argument " "1"" of type '" "wxRect *""'");
7935 }
7936 arg1 = reinterpret_cast< wxRect * >(argp1);
7937 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
7938 if (!SWIG_IsOK(res2)) {
7939 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntersectRect" "', expected argument " "2"" of type '" "wxRect *""'");
7940 }
7941 arg2 = reinterpret_cast< wxRect * >(argp2);
7942 {
7943 if (!wxPyCheckForApp()) SWIG_fail;
7944 PyThreadState* __tstate = wxPyBeginAllowThreads();
7945 result = (PyObject *)wxIntersectRect(arg1,arg2);
7946 wxPyEndAllowThreads(__tstate);
7947 if (PyErr_Occurred()) SWIG_fail;
7948 }
7949 resultobj = result;
7950 return resultobj;
7951 fail:
7952 return NULL;
7953 }
7954
7955
7956 SWIGINTERN PyObject *_wrap_new_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7957 PyObject *resultobj = 0;
7958 double arg1 = (double) 0.0 ;
7959 double arg2 = (double) 0.0 ;
7960 wxPoint2D *result = 0 ;
7961 double val1 ;
7962 int ecode1 = 0 ;
7963 double val2 ;
7964 int ecode2 = 0 ;
7965 PyObject * obj0 = 0 ;
7966 PyObject * obj1 = 0 ;
7967 char * kwnames[] = {
7968 (char *) "x",(char *) "y", NULL
7969 };
7970
7971 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) SWIG_fail;
7972 if (obj0) {
7973 ecode1 = SWIG_AsVal_double(obj0, &val1);
7974 if (!SWIG_IsOK(ecode1)) {
7975 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point2D" "', expected argument " "1"" of type '" "double""'");
7976 }
7977 arg1 = static_cast< double >(val1);
7978 }
7979 if (obj1) {
7980 ecode2 = SWIG_AsVal_double(obj1, &val2);
7981 if (!SWIG_IsOK(ecode2)) {
7982 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point2D" "', expected argument " "2"" of type '" "double""'");
7983 }
7984 arg2 = static_cast< double >(val2);
7985 }
7986 {
7987 PyThreadState* __tstate = wxPyBeginAllowThreads();
7988 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
7989 wxPyEndAllowThreads(__tstate);
7990 if (PyErr_Occurred()) SWIG_fail;
7991 }
7992 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_NEW | 0 );
7993 return resultobj;
7994 fail:
7995 return NULL;
7996 }
7997
7998
7999 SWIGINTERN PyObject *_wrap_new_Point2DCopy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8000 PyObject *resultobj = 0;
8001 wxPoint2D *arg1 = 0 ;
8002 wxPoint2D *result = 0 ;
8003 wxPoint2D temp1 ;
8004 PyObject * obj0 = 0 ;
8005 char * kwnames[] = {
8006 (char *) "pt", NULL
8007 };
8008
8009 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) SWIG_fail;
8010 {
8011 arg1 = &temp1;
8012 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
8013 }
8014 {
8015 PyThreadState* __tstate = wxPyBeginAllowThreads();
8016 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
8017 wxPyEndAllowThreads(__tstate);
8018 if (PyErr_Occurred()) SWIG_fail;
8019 }
8020 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8021 return resultobj;
8022 fail:
8023 return NULL;
8024 }
8025
8026
8027 SWIGINTERN PyObject *_wrap_new_Point2DFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8028 PyObject *resultobj = 0;
8029 wxPoint *arg1 = 0 ;
8030 wxPoint2D *result = 0 ;
8031 wxPoint temp1 ;
8032 PyObject * obj0 = 0 ;
8033 char * kwnames[] = {
8034 (char *) "pt", NULL
8035 };
8036
8037 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) SWIG_fail;
8038 {
8039 arg1 = &temp1;
8040 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
8041 }
8042 {
8043 PyThreadState* __tstate = wxPyBeginAllowThreads();
8044 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
8045 wxPyEndAllowThreads(__tstate);
8046 if (PyErr_Occurred()) SWIG_fail;
8047 }
8048 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8049 return resultobj;
8050 fail:
8051 return NULL;
8052 }
8053
8054
8055 SWIGINTERN PyObject *_wrap_Point2D_GetFloor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8056 PyObject *resultobj = 0;
8057 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8058 int *arg2 = (int *) 0 ;
8059 int *arg3 = (int *) 0 ;
8060 void *argp1 = 0 ;
8061 int res1 = 0 ;
8062 int temp2 ;
8063 int res2 = SWIG_TMPOBJ ;
8064 int temp3 ;
8065 int res3 = SWIG_TMPOBJ ;
8066 PyObject *swig_obj[1] ;
8067
8068 arg2 = &temp2;
8069 arg3 = &temp3;
8070 if (!args) SWIG_fail;
8071 swig_obj[0] = args;
8072 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8073 if (!SWIG_IsOK(res1)) {
8074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetFloor" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8075 }
8076 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8077 {
8078 PyThreadState* __tstate = wxPyBeginAllowThreads();
8079 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
8080 wxPyEndAllowThreads(__tstate);
8081 if (PyErr_Occurred()) SWIG_fail;
8082 }
8083 resultobj = SWIG_Py_Void();
8084 if (SWIG_IsTmpObj(res2)) {
8085 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8086 } else {
8087 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8088 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8089 }
8090 if (SWIG_IsTmpObj(res3)) {
8091 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8092 } else {
8093 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8094 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8095 }
8096 return resultobj;
8097 fail:
8098 return NULL;
8099 }
8100
8101
8102 SWIGINTERN PyObject *_wrap_Point2D_GetRounded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8103 PyObject *resultobj = 0;
8104 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8105 int *arg2 = (int *) 0 ;
8106 int *arg3 = (int *) 0 ;
8107 void *argp1 = 0 ;
8108 int res1 = 0 ;
8109 int temp2 ;
8110 int res2 = SWIG_TMPOBJ ;
8111 int temp3 ;
8112 int res3 = SWIG_TMPOBJ ;
8113 PyObject *swig_obj[1] ;
8114
8115 arg2 = &temp2;
8116 arg3 = &temp3;
8117 if (!args) SWIG_fail;
8118 swig_obj[0] = args;
8119 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8120 if (!SWIG_IsOK(res1)) {
8121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetRounded" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8122 }
8123 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8124 {
8125 PyThreadState* __tstate = wxPyBeginAllowThreads();
8126 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
8127 wxPyEndAllowThreads(__tstate);
8128 if (PyErr_Occurred()) SWIG_fail;
8129 }
8130 resultobj = SWIG_Py_Void();
8131 if (SWIG_IsTmpObj(res2)) {
8132 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8133 } else {
8134 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8135 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8136 }
8137 if (SWIG_IsTmpObj(res3)) {
8138 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8139 } else {
8140 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8141 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8142 }
8143 return resultobj;
8144 fail:
8145 return NULL;
8146 }
8147
8148
8149 SWIGINTERN PyObject *_wrap_Point2D_GetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8150 PyObject *resultobj = 0;
8151 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8152 double result;
8153 void *argp1 = 0 ;
8154 int res1 = 0 ;
8155 PyObject *swig_obj[1] ;
8156
8157 if (!args) SWIG_fail;
8158 swig_obj[0] = args;
8159 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8160 if (!SWIG_IsOK(res1)) {
8161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8162 }
8163 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8164 {
8165 PyThreadState* __tstate = wxPyBeginAllowThreads();
8166 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
8167 wxPyEndAllowThreads(__tstate);
8168 if (PyErr_Occurred()) SWIG_fail;
8169 }
8170 resultobj = SWIG_From_double(static_cast< double >(result));
8171 return resultobj;
8172 fail:
8173 return NULL;
8174 }
8175
8176
8177 SWIGINTERN PyObject *_wrap_Point2D_GetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8178 PyObject *resultobj = 0;
8179 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8180 double result;
8181 void *argp1 = 0 ;
8182 int res1 = 0 ;
8183 PyObject *swig_obj[1] ;
8184
8185 if (!args) SWIG_fail;
8186 swig_obj[0] = args;
8187 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8188 if (!SWIG_IsOK(res1)) {
8189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8190 }
8191 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8192 {
8193 PyThreadState* __tstate = wxPyBeginAllowThreads();
8194 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
8195 wxPyEndAllowThreads(__tstate);
8196 if (PyErr_Occurred()) SWIG_fail;
8197 }
8198 resultobj = SWIG_From_double(static_cast< double >(result));
8199 return resultobj;
8200 fail:
8201 return NULL;
8202 }
8203
8204
8205 SWIGINTERN PyObject *_wrap_Point2D_SetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8206 PyObject *resultobj = 0;
8207 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8208 double arg2 ;
8209 void *argp1 = 0 ;
8210 int res1 = 0 ;
8211 double val2 ;
8212 int ecode2 = 0 ;
8213 PyObject * obj0 = 0 ;
8214 PyObject * obj1 = 0 ;
8215 char * kwnames[] = {
8216 (char *) "self",(char *) "length", NULL
8217 };
8218
8219 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) SWIG_fail;
8220 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8221 if (!SWIG_IsOK(res1)) {
8222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8223 }
8224 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8225 ecode2 = SWIG_AsVal_double(obj1, &val2);
8226 if (!SWIG_IsOK(ecode2)) {
8227 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorLength" "', expected argument " "2"" of type '" "double""'");
8228 }
8229 arg2 = static_cast< double >(val2);
8230 {
8231 PyThreadState* __tstate = wxPyBeginAllowThreads();
8232 (arg1)->SetVectorLength(arg2);
8233 wxPyEndAllowThreads(__tstate);
8234 if (PyErr_Occurred()) SWIG_fail;
8235 }
8236 resultobj = SWIG_Py_Void();
8237 return resultobj;
8238 fail:
8239 return NULL;
8240 }
8241
8242
8243 SWIGINTERN PyObject *_wrap_Point2D_SetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8244 PyObject *resultobj = 0;
8245 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8246 double arg2 ;
8247 void *argp1 = 0 ;
8248 int res1 = 0 ;
8249 double val2 ;
8250 int ecode2 = 0 ;
8251 PyObject * obj0 = 0 ;
8252 PyObject * obj1 = 0 ;
8253 char * kwnames[] = {
8254 (char *) "self",(char *) "degrees", NULL
8255 };
8256
8257 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) SWIG_fail;
8258 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8259 if (!SWIG_IsOK(res1)) {
8260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8261 }
8262 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8263 ecode2 = SWIG_AsVal_double(obj1, &val2);
8264 if (!SWIG_IsOK(ecode2)) {
8265 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorAngle" "', expected argument " "2"" of type '" "double""'");
8266 }
8267 arg2 = static_cast< double >(val2);
8268 {
8269 PyThreadState* __tstate = wxPyBeginAllowThreads();
8270 (arg1)->SetVectorAngle(arg2);
8271 wxPyEndAllowThreads(__tstate);
8272 if (PyErr_Occurred()) SWIG_fail;
8273 }
8274 resultobj = SWIG_Py_Void();
8275 return resultobj;
8276 fail:
8277 return NULL;
8278 }
8279
8280
8281 SWIGINTERN PyObject *_wrap_Point2D_GetDistance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8282 PyObject *resultobj = 0;
8283 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8284 wxPoint2D *arg2 = 0 ;
8285 double result;
8286 void *argp1 = 0 ;
8287 int res1 = 0 ;
8288 wxPoint2D temp2 ;
8289 PyObject * obj0 = 0 ;
8290 PyObject * obj1 = 0 ;
8291 char * kwnames[] = {
8292 (char *) "self",(char *) "pt", NULL
8293 };
8294
8295 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) SWIG_fail;
8296 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8297 if (!SWIG_IsOK(res1)) {
8298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistance" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8299 }
8300 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8301 {
8302 arg2 = &temp2;
8303 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8304 }
8305 {
8306 PyThreadState* __tstate = wxPyBeginAllowThreads();
8307 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
8308 wxPyEndAllowThreads(__tstate);
8309 if (PyErr_Occurred()) SWIG_fail;
8310 }
8311 resultobj = SWIG_From_double(static_cast< double >(result));
8312 return resultobj;
8313 fail:
8314 return NULL;
8315 }
8316
8317
8318 SWIGINTERN PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8319 PyObject *resultobj = 0;
8320 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8321 wxPoint2D *arg2 = 0 ;
8322 double result;
8323 void *argp1 = 0 ;
8324 int res1 = 0 ;
8325 wxPoint2D temp2 ;
8326 PyObject * obj0 = 0 ;
8327 PyObject * obj1 = 0 ;
8328 char * kwnames[] = {
8329 (char *) "self",(char *) "pt", NULL
8330 };
8331
8332 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) SWIG_fail;
8333 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8334 if (!SWIG_IsOK(res1)) {
8335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistanceSquare" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8336 }
8337 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8338 {
8339 arg2 = &temp2;
8340 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8341 }
8342 {
8343 PyThreadState* __tstate = wxPyBeginAllowThreads();
8344 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
8345 wxPyEndAllowThreads(__tstate);
8346 if (PyErr_Occurred()) SWIG_fail;
8347 }
8348 resultobj = SWIG_From_double(static_cast< double >(result));
8349 return resultobj;
8350 fail:
8351 return NULL;
8352 }
8353
8354
8355 SWIGINTERN PyObject *_wrap_Point2D_GetDotProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8356 PyObject *resultobj = 0;
8357 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8358 wxPoint2D *arg2 = 0 ;
8359 double result;
8360 void *argp1 = 0 ;
8361 int res1 = 0 ;
8362 wxPoint2D temp2 ;
8363 PyObject * obj0 = 0 ;
8364 PyObject * obj1 = 0 ;
8365 char * kwnames[] = {
8366 (char *) "self",(char *) "vec", NULL
8367 };
8368
8369 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8370 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8371 if (!SWIG_IsOK(res1)) {
8372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDotProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8373 }
8374 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8375 {
8376 arg2 = &temp2;
8377 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8378 }
8379 {
8380 PyThreadState* __tstate = wxPyBeginAllowThreads();
8381 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
8382 wxPyEndAllowThreads(__tstate);
8383 if (PyErr_Occurred()) SWIG_fail;
8384 }
8385 resultobj = SWIG_From_double(static_cast< double >(result));
8386 return resultobj;
8387 fail:
8388 return NULL;
8389 }
8390
8391
8392 SWIGINTERN PyObject *_wrap_Point2D_GetCrossProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8393 PyObject *resultobj = 0;
8394 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8395 wxPoint2D *arg2 = 0 ;
8396 double result;
8397 void *argp1 = 0 ;
8398 int res1 = 0 ;
8399 wxPoint2D temp2 ;
8400 PyObject * obj0 = 0 ;
8401 PyObject * obj1 = 0 ;
8402 char * kwnames[] = {
8403 (char *) "self",(char *) "vec", NULL
8404 };
8405
8406 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8407 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8408 if (!SWIG_IsOK(res1)) {
8409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetCrossProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8410 }
8411 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8412 {
8413 arg2 = &temp2;
8414 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8415 }
8416 {
8417 PyThreadState* __tstate = wxPyBeginAllowThreads();
8418 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
8419 wxPyEndAllowThreads(__tstate);
8420 if (PyErr_Occurred()) SWIG_fail;
8421 }
8422 resultobj = SWIG_From_double(static_cast< double >(result));
8423 return resultobj;
8424 fail:
8425 return NULL;
8426 }
8427
8428
8429 SWIGINTERN PyObject *_wrap_Point2D___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8430 PyObject *resultobj = 0;
8431 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8432 wxPoint2D result;
8433 void *argp1 = 0 ;
8434 int res1 = 0 ;
8435 PyObject *swig_obj[1] ;
8436
8437 if (!args) SWIG_fail;
8438 swig_obj[0] = args;
8439 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8440 if (!SWIG_IsOK(res1)) {
8441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___neg__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8442 }
8443 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8444 {
8445 PyThreadState* __tstate = wxPyBeginAllowThreads();
8446 result = (arg1)->operator -();
8447 wxPyEndAllowThreads(__tstate);
8448 if (PyErr_Occurred()) SWIG_fail;
8449 }
8450 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8451 return resultobj;
8452 fail:
8453 return NULL;
8454 }
8455
8456
8457 SWIGINTERN PyObject *_wrap_Point2D___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8458 PyObject *resultobj = 0;
8459 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8460 wxPoint2D *arg2 = 0 ;
8461 wxPoint2D *result = 0 ;
8462 void *argp1 = 0 ;
8463 int res1 = 0 ;
8464 wxPoint2D temp2 ;
8465 PyObject * obj0 = 0 ;
8466 PyObject * obj1 = 0 ;
8467 char * kwnames[] = {
8468 (char *) "self",(char *) "pt", NULL
8469 };
8470
8471 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
8472 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8473 if (!SWIG_IsOK(res1)) {
8474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___iadd__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8475 }
8476 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8477 {
8478 arg2 = &temp2;
8479 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8480 }
8481 {
8482 PyThreadState* __tstate = wxPyBeginAllowThreads();
8483 {
8484 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
8485 result = (wxPoint2D *) &_result_ref;
8486 }
8487 wxPyEndAllowThreads(__tstate);
8488 if (PyErr_Occurred()) SWIG_fail;
8489 }
8490 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8491 return resultobj;
8492 fail:
8493 return NULL;
8494 }
8495
8496
8497 SWIGINTERN PyObject *_wrap_Point2D___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8498 PyObject *resultobj = 0;
8499 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8500 wxPoint2D *arg2 = 0 ;
8501 wxPoint2D *result = 0 ;
8502 void *argp1 = 0 ;
8503 int res1 = 0 ;
8504 wxPoint2D temp2 ;
8505 PyObject * obj0 = 0 ;
8506 PyObject * obj1 = 0 ;
8507 char * kwnames[] = {
8508 (char *) "self",(char *) "pt", NULL
8509 };
8510
8511 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
8512 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8513 if (!SWIG_IsOK(res1)) {
8514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___isub__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8515 }
8516 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8517 {
8518 arg2 = &temp2;
8519 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8520 }
8521 {
8522 PyThreadState* __tstate = wxPyBeginAllowThreads();
8523 {
8524 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
8525 result = (wxPoint2D *) &_result_ref;
8526 }
8527 wxPyEndAllowThreads(__tstate);
8528 if (PyErr_Occurred()) SWIG_fail;
8529 }
8530 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8531 return resultobj;
8532 fail:
8533 return NULL;
8534 }
8535
8536
8537 SWIGINTERN PyObject *_wrap_Point2D___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8538 PyObject *resultobj = 0;
8539 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8540 wxPoint2D *arg2 = 0 ;
8541 wxPoint2D *result = 0 ;
8542 void *argp1 = 0 ;
8543 int res1 = 0 ;
8544 wxPoint2D temp2 ;
8545 PyObject * obj0 = 0 ;
8546 PyObject * obj1 = 0 ;
8547 char * kwnames[] = {
8548 (char *) "self",(char *) "pt", NULL
8549 };
8550
8551 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
8552 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8553 if (!SWIG_IsOK(res1)) {
8554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___imul__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8555 }
8556 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8557 {
8558 arg2 = &temp2;
8559 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8560 }
8561 {
8562 PyThreadState* __tstate = wxPyBeginAllowThreads();
8563 {
8564 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
8565 result = (wxPoint2D *) &_result_ref;
8566 }
8567 wxPyEndAllowThreads(__tstate);
8568 if (PyErr_Occurred()) SWIG_fail;
8569 }
8570 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8571 return resultobj;
8572 fail:
8573 return NULL;
8574 }
8575
8576
8577 SWIGINTERN PyObject *_wrap_Point2D___idiv__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8578 PyObject *resultobj = 0;
8579 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8580 wxPoint2D *arg2 = 0 ;
8581 wxPoint2D *result = 0 ;
8582 void *argp1 = 0 ;
8583 int res1 = 0 ;
8584 wxPoint2D temp2 ;
8585 PyObject * obj0 = 0 ;
8586 PyObject * obj1 = 0 ;
8587 char * kwnames[] = {
8588 (char *) "self",(char *) "pt", NULL
8589 };
8590
8591 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) SWIG_fail;
8592 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8593 if (!SWIG_IsOK(res1)) {
8594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___idiv__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8595 }
8596 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8597 {
8598 arg2 = &temp2;
8599 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8600 }
8601 {
8602 PyThreadState* __tstate = wxPyBeginAllowThreads();
8603 {
8604 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
8605 result = (wxPoint2D *) &_result_ref;
8606 }
8607 wxPyEndAllowThreads(__tstate);
8608 if (PyErr_Occurred()) SWIG_fail;
8609 }
8610 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8611 return resultobj;
8612 fail:
8613 return NULL;
8614 }
8615
8616
8617 SWIGINTERN PyObject *_wrap_Point2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8618 PyObject *resultobj = 0;
8619 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8620 PyObject *arg2 = (PyObject *) 0 ;
8621 bool result;
8622 void *argp1 = 0 ;
8623 int res1 = 0 ;
8624 PyObject * obj0 = 0 ;
8625 PyObject * obj1 = 0 ;
8626 char * kwnames[] = {
8627 (char *) "self",(char *) "other", NULL
8628 };
8629
8630 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
8631 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8632 if (!SWIG_IsOK(res1)) {
8633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___eq__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8634 }
8635 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8636 arg2 = obj1;
8637 {
8638 result = (bool)wxPoint2D___eq__(arg1,arg2);
8639 if (PyErr_Occurred()) SWIG_fail;
8640 }
8641 {
8642 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8643 }
8644 return resultobj;
8645 fail:
8646 return NULL;
8647 }
8648
8649
8650 SWIGINTERN PyObject *_wrap_Point2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8651 PyObject *resultobj = 0;
8652 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8653 PyObject *arg2 = (PyObject *) 0 ;
8654 bool result;
8655 void *argp1 = 0 ;
8656 int res1 = 0 ;
8657 PyObject * obj0 = 0 ;
8658 PyObject * obj1 = 0 ;
8659 char * kwnames[] = {
8660 (char *) "self",(char *) "other", NULL
8661 };
8662
8663 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
8664 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8665 if (!SWIG_IsOK(res1)) {
8666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___ne__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8667 }
8668 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8669 arg2 = obj1;
8670 {
8671 result = (bool)wxPoint2D___ne__(arg1,arg2);
8672 if (PyErr_Occurred()) SWIG_fail;
8673 }
8674 {
8675 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8676 }
8677 return resultobj;
8678 fail:
8679 return NULL;
8680 }
8681
8682
8683 SWIGINTERN PyObject *_wrap_Point2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8684 PyObject *resultobj = 0;
8685 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8686 double arg2 ;
8687 void *argp1 = 0 ;
8688 int res1 = 0 ;
8689 double val2 ;
8690 int ecode2 = 0 ;
8691 PyObject *swig_obj[2] ;
8692
8693 if (!SWIG_Python_UnpackTuple(args,"Point2D_x_set",2,2,swig_obj)) SWIG_fail;
8694 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8695 if (!SWIG_IsOK(res1)) {
8696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8697 }
8698 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8699 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8700 if (!SWIG_IsOK(ecode2)) {
8701 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_x_set" "', expected argument " "2"" of type '" "double""'");
8702 }
8703 arg2 = static_cast< double >(val2);
8704 if (arg1) (arg1)->m_x = arg2;
8705
8706 resultobj = SWIG_Py_Void();
8707 return resultobj;
8708 fail:
8709 return NULL;
8710 }
8711
8712
8713 SWIGINTERN PyObject *_wrap_Point2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8714 PyObject *resultobj = 0;
8715 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8716 double result;
8717 void *argp1 = 0 ;
8718 int res1 = 0 ;
8719 PyObject *swig_obj[1] ;
8720
8721 if (!args) SWIG_fail;
8722 swig_obj[0] = args;
8723 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8724 if (!SWIG_IsOK(res1)) {
8725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8726 }
8727 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8728 result = (double) ((arg1)->m_x);
8729 resultobj = SWIG_From_double(static_cast< double >(result));
8730 return resultobj;
8731 fail:
8732 return NULL;
8733 }
8734
8735
8736 SWIGINTERN PyObject *_wrap_Point2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8737 PyObject *resultobj = 0;
8738 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8739 double arg2 ;
8740 void *argp1 = 0 ;
8741 int res1 = 0 ;
8742 double val2 ;
8743 int ecode2 = 0 ;
8744 PyObject *swig_obj[2] ;
8745
8746 if (!SWIG_Python_UnpackTuple(args,"Point2D_y_set",2,2,swig_obj)) SWIG_fail;
8747 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8748 if (!SWIG_IsOK(res1)) {
8749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8750 }
8751 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8752 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8753 if (!SWIG_IsOK(ecode2)) {
8754 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_y_set" "', expected argument " "2"" of type '" "double""'");
8755 }
8756 arg2 = static_cast< double >(val2);
8757 if (arg1) (arg1)->m_y = arg2;
8758
8759 resultobj = SWIG_Py_Void();
8760 return resultobj;
8761 fail:
8762 return NULL;
8763 }
8764
8765
8766 SWIGINTERN PyObject *_wrap_Point2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8767 PyObject *resultobj = 0;
8768 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8769 double result;
8770 void *argp1 = 0 ;
8771 int res1 = 0 ;
8772 PyObject *swig_obj[1] ;
8773
8774 if (!args) SWIG_fail;
8775 swig_obj[0] = args;
8776 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8777 if (!SWIG_IsOK(res1)) {
8778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8779 }
8780 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8781 result = (double) ((arg1)->m_y);
8782 resultobj = SWIG_From_double(static_cast< double >(result));
8783 return resultobj;
8784 fail:
8785 return NULL;
8786 }
8787
8788
8789 SWIGINTERN PyObject *_wrap_Point2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8790 PyObject *resultobj = 0;
8791 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8792 double arg2 = (double) 0 ;
8793 double arg3 = (double) 0 ;
8794 void *argp1 = 0 ;
8795 int res1 = 0 ;
8796 double val2 ;
8797 int ecode2 = 0 ;
8798 double val3 ;
8799 int ecode3 = 0 ;
8800 PyObject * obj0 = 0 ;
8801 PyObject * obj1 = 0 ;
8802 PyObject * obj2 = 0 ;
8803 char * kwnames[] = {
8804 (char *) "self",(char *) "x",(char *) "y", NULL
8805 };
8806
8807 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8808 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8809 if (!SWIG_IsOK(res1)) {
8810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8811 }
8812 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8813 if (obj1) {
8814 ecode2 = SWIG_AsVal_double(obj1, &val2);
8815 if (!SWIG_IsOK(ecode2)) {
8816 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_Set" "', expected argument " "2"" of type '" "double""'");
8817 }
8818 arg2 = static_cast< double >(val2);
8819 }
8820 if (obj2) {
8821 ecode3 = SWIG_AsVal_double(obj2, &val3);
8822 if (!SWIG_IsOK(ecode3)) {
8823 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point2D_Set" "', expected argument " "3"" of type '" "double""'");
8824 }
8825 arg3 = static_cast< double >(val3);
8826 }
8827 {
8828 PyThreadState* __tstate = wxPyBeginAllowThreads();
8829 wxPoint2D_Set(arg1,arg2,arg3);
8830 wxPyEndAllowThreads(__tstate);
8831 if (PyErr_Occurred()) SWIG_fail;
8832 }
8833 resultobj = SWIG_Py_Void();
8834 return resultobj;
8835 fail:
8836 return NULL;
8837 }
8838
8839
8840 SWIGINTERN PyObject *_wrap_Point2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8841 PyObject *resultobj = 0;
8842 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8843 PyObject *result = 0 ;
8844 void *argp1 = 0 ;
8845 int res1 = 0 ;
8846 PyObject *swig_obj[1] ;
8847
8848 if (!args) SWIG_fail;
8849 swig_obj[0] = args;
8850 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8851 if (!SWIG_IsOK(res1)) {
8852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8853 }
8854 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8855 {
8856 PyThreadState* __tstate = wxPyBeginAllowThreads();
8857 result = (PyObject *)wxPoint2D_Get(arg1);
8858 wxPyEndAllowThreads(__tstate);
8859 if (PyErr_Occurred()) SWIG_fail;
8860 }
8861 resultobj = result;
8862 return resultobj;
8863 fail:
8864 return NULL;
8865 }
8866
8867
8868 SWIGINTERN PyObject *Point2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8869 PyObject *obj;
8870 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8871 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint2D, SWIG_NewClientData(obj));
8872 return SWIG_Py_Void();
8873 }
8874
8875 SWIGINTERN PyObject *Point2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8876 return SWIG_Python_InitShadowInstance(args);
8877 }
8878
8879 SWIGINTERN int DefaultPosition_set(PyObject *) {
8880 SWIG_Error(SWIG_AttributeError,"Variable DefaultPosition is read-only.");
8881 return 1;
8882 }
8883
8884
8885 SWIGINTERN PyObject *DefaultPosition_get(void) {
8886 PyObject *pyobj = 0;
8887
8888 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0 );
8889 return pyobj;
8890 }
8891
8892
8893 SWIGINTERN int DefaultSize_set(PyObject *) {
8894 SWIG_Error(SWIG_AttributeError,"Variable DefaultSize is read-only.");
8895 return 1;
8896 }
8897
8898
8899 SWIGINTERN PyObject *DefaultSize_get(void) {
8900 PyObject *pyobj = 0;
8901
8902 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSize), SWIGTYPE_p_wxSize, 0 );
8903 return pyobj;
8904 }
8905
8906
8907 SWIGINTERN PyObject *_wrap_new_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8908 PyObject *resultobj = 0;
8909 PyObject *arg1 = (PyObject *) 0 ;
8910 wxPyInputStream *result = 0 ;
8911 PyObject * obj0 = 0 ;
8912 char * kwnames[] = {
8913 (char *) "p", NULL
8914 };
8915
8916 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) SWIG_fail;
8917 arg1 = obj0;
8918 {
8919 PyThreadState* __tstate = wxPyBeginAllowThreads();
8920 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
8921 wxPyEndAllowThreads(__tstate);
8922 if (PyErr_Occurred()) SWIG_fail;
8923 }
8924 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_NEW | 0 );
8925 return resultobj;
8926 fail:
8927 return NULL;
8928 }
8929
8930
8931 SWIGINTERN PyObject *_wrap_delete_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8932 PyObject *resultobj = 0;
8933 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8934 void *argp1 = 0 ;
8935 int res1 = 0 ;
8936 PyObject *swig_obj[1] ;
8937
8938 if (!args) SWIG_fail;
8939 swig_obj[0] = args;
8940 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_DISOWN | 0 );
8941 if (!SWIG_IsOK(res1)) {
8942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InputStream" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
8943 }
8944 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
8945 {
8946 PyThreadState* __tstate = wxPyBeginAllowThreads();
8947 delete arg1;
8948
8949 wxPyEndAllowThreads(__tstate);
8950 if (PyErr_Occurred()) SWIG_fail;
8951 }
8952 resultobj = SWIG_Py_Void();
8953 return resultobj;
8954 fail:
8955 return NULL;
8956 }
8957
8958
8959 SWIGINTERN PyObject *_wrap_InputStream_close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8960 PyObject *resultobj = 0;
8961 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8962 void *argp1 = 0 ;
8963 int res1 = 0 ;
8964 PyObject *swig_obj[1] ;
8965
8966 if (!args) SWIG_fail;
8967 swig_obj[0] = args;
8968 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
8969 if (!SWIG_IsOK(res1)) {
8970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_close" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
8971 }
8972 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
8973 {
8974 PyThreadState* __tstate = wxPyBeginAllowThreads();
8975 (arg1)->close();
8976 wxPyEndAllowThreads(__tstate);
8977 if (PyErr_Occurred()) SWIG_fail;
8978 }
8979 resultobj = SWIG_Py_Void();
8980 return resultobj;
8981 fail:
8982 return NULL;
8983 }
8984
8985
8986 SWIGINTERN PyObject *_wrap_InputStream_flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8987 PyObject *resultobj = 0;
8988 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8989 void *argp1 = 0 ;
8990 int res1 = 0 ;
8991 PyObject *swig_obj[1] ;
8992
8993 if (!args) SWIG_fail;
8994 swig_obj[0] = args;
8995 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
8996 if (!SWIG_IsOK(res1)) {
8997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_flush" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
8998 }
8999 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9000 {
9001 PyThreadState* __tstate = wxPyBeginAllowThreads();
9002 (arg1)->flush();
9003 wxPyEndAllowThreads(__tstate);
9004 if (PyErr_Occurred()) SWIG_fail;
9005 }
9006 resultobj = SWIG_Py_Void();
9007 return resultobj;
9008 fail:
9009 return NULL;
9010 }
9011
9012
9013 SWIGINTERN PyObject *_wrap_InputStream_eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9014 PyObject *resultobj = 0;
9015 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9016 bool result;
9017 void *argp1 = 0 ;
9018 int res1 = 0 ;
9019 PyObject *swig_obj[1] ;
9020
9021 if (!args) SWIG_fail;
9022 swig_obj[0] = args;
9023 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9024 if (!SWIG_IsOK(res1)) {
9025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9026 }
9027 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9028 {
9029 PyThreadState* __tstate = wxPyBeginAllowThreads();
9030 result = (bool)(arg1)->eof();
9031 wxPyEndAllowThreads(__tstate);
9032 if (PyErr_Occurred()) SWIG_fail;
9033 }
9034 {
9035 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9036 }
9037 return resultobj;
9038 fail:
9039 return NULL;
9040 }
9041
9042
9043 SWIGINTERN PyObject *_wrap_InputStream_read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9044 PyObject *resultobj = 0;
9045 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9046 int arg2 = (int) -1 ;
9047 PyObject *result = 0 ;
9048 void *argp1 = 0 ;
9049 int res1 = 0 ;
9050 int val2 ;
9051 int ecode2 = 0 ;
9052 PyObject * obj0 = 0 ;
9053 PyObject * obj1 = 0 ;
9054 char * kwnames[] = {
9055 (char *) "self",(char *) "size", NULL
9056 };
9057
9058 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) SWIG_fail;
9059 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9060 if (!SWIG_IsOK(res1)) {
9061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_read" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9062 }
9063 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9064 if (obj1) {
9065 ecode2 = SWIG_AsVal_int(obj1, &val2);
9066 if (!SWIG_IsOK(ecode2)) {
9067 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_read" "', expected argument " "2"" of type '" "int""'");
9068 }
9069 arg2 = static_cast< int >(val2);
9070 }
9071 {
9072 PyThreadState* __tstate = wxPyBeginAllowThreads();
9073 result = (PyObject *)(arg1)->read(arg2);
9074 wxPyEndAllowThreads(__tstate);
9075 if (PyErr_Occurred()) SWIG_fail;
9076 }
9077 resultobj = result;
9078 return resultobj;
9079 fail:
9080 return NULL;
9081 }
9082
9083
9084 SWIGINTERN PyObject *_wrap_InputStream_readline(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9085 PyObject *resultobj = 0;
9086 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9087 int arg2 = (int) -1 ;
9088 PyObject *result = 0 ;
9089 void *argp1 = 0 ;
9090 int res1 = 0 ;
9091 int val2 ;
9092 int ecode2 = 0 ;
9093 PyObject * obj0 = 0 ;
9094 PyObject * obj1 = 0 ;
9095 char * kwnames[] = {
9096 (char *) "self",(char *) "size", NULL
9097 };
9098
9099 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) SWIG_fail;
9100 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9101 if (!SWIG_IsOK(res1)) {
9102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readline" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9103 }
9104 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9105 if (obj1) {
9106 ecode2 = SWIG_AsVal_int(obj1, &val2);
9107 if (!SWIG_IsOK(ecode2)) {
9108 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readline" "', expected argument " "2"" of type '" "int""'");
9109 }
9110 arg2 = static_cast< int >(val2);
9111 }
9112 {
9113 PyThreadState* __tstate = wxPyBeginAllowThreads();
9114 result = (PyObject *)(arg1)->readline(arg2);
9115 wxPyEndAllowThreads(__tstate);
9116 if (PyErr_Occurred()) SWIG_fail;
9117 }
9118 resultobj = result;
9119 return resultobj;
9120 fail:
9121 return NULL;
9122 }
9123
9124
9125 SWIGINTERN PyObject *_wrap_InputStream_readlines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9126 PyObject *resultobj = 0;
9127 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9128 int arg2 = (int) -1 ;
9129 PyObject *result = 0 ;
9130 void *argp1 = 0 ;
9131 int res1 = 0 ;
9132 int val2 ;
9133 int ecode2 = 0 ;
9134 PyObject * obj0 = 0 ;
9135 PyObject * obj1 = 0 ;
9136 char * kwnames[] = {
9137 (char *) "self",(char *) "sizehint", NULL
9138 };
9139
9140 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) SWIG_fail;
9141 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9142 if (!SWIG_IsOK(res1)) {
9143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readlines" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9144 }
9145 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9146 if (obj1) {
9147 ecode2 = SWIG_AsVal_int(obj1, &val2);
9148 if (!SWIG_IsOK(ecode2)) {
9149 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readlines" "', expected argument " "2"" of type '" "int""'");
9150 }
9151 arg2 = static_cast< int >(val2);
9152 }
9153 {
9154 PyThreadState* __tstate = wxPyBeginAllowThreads();
9155 result = (PyObject *)(arg1)->readlines(arg2);
9156 wxPyEndAllowThreads(__tstate);
9157 if (PyErr_Occurred()) SWIG_fail;
9158 }
9159 resultobj = result;
9160 return resultobj;
9161 fail:
9162 return NULL;
9163 }
9164
9165
9166 SWIGINTERN PyObject *_wrap_InputStream_seek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9167 PyObject *resultobj = 0;
9168 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9169 int arg2 ;
9170 int arg3 = (int) 0 ;
9171 void *argp1 = 0 ;
9172 int res1 = 0 ;
9173 int val2 ;
9174 int ecode2 = 0 ;
9175 int val3 ;
9176 int ecode3 = 0 ;
9177 PyObject * obj0 = 0 ;
9178 PyObject * obj1 = 0 ;
9179 PyObject * obj2 = 0 ;
9180 char * kwnames[] = {
9181 (char *) "self",(char *) "offset",(char *) "whence", NULL
9182 };
9183
9184 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9185 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9186 if (!SWIG_IsOK(res1)) {
9187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_seek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9188 }
9189 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9190 ecode2 = SWIG_AsVal_int(obj1, &val2);
9191 if (!SWIG_IsOK(ecode2)) {
9192 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_seek" "', expected argument " "2"" of type '" "int""'");
9193 }
9194 arg2 = static_cast< int >(val2);
9195 if (obj2) {
9196 ecode3 = SWIG_AsVal_int(obj2, &val3);
9197 if (!SWIG_IsOK(ecode3)) {
9198 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_seek" "', expected argument " "3"" of type '" "int""'");
9199 }
9200 arg3 = static_cast< int >(val3);
9201 }
9202 {
9203 PyThreadState* __tstate = wxPyBeginAllowThreads();
9204 (arg1)->seek(arg2,arg3);
9205 wxPyEndAllowThreads(__tstate);
9206 if (PyErr_Occurred()) SWIG_fail;
9207 }
9208 resultobj = SWIG_Py_Void();
9209 return resultobj;
9210 fail:
9211 return NULL;
9212 }
9213
9214
9215 SWIGINTERN PyObject *_wrap_InputStream_tell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9216 PyObject *resultobj = 0;
9217 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9218 int result;
9219 void *argp1 = 0 ;
9220 int res1 = 0 ;
9221 PyObject *swig_obj[1] ;
9222
9223 if (!args) SWIG_fail;
9224 swig_obj[0] = args;
9225 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9226 if (!SWIG_IsOK(res1)) {
9227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_tell" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9228 }
9229 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9230 {
9231 PyThreadState* __tstate = wxPyBeginAllowThreads();
9232 result = (int)(arg1)->tell();
9233 wxPyEndAllowThreads(__tstate);
9234 if (PyErr_Occurred()) SWIG_fail;
9235 }
9236 resultobj = SWIG_From_int(static_cast< int >(result));
9237 return resultobj;
9238 fail:
9239 return NULL;
9240 }
9241
9242
9243 SWIGINTERN PyObject *_wrap_InputStream_Peek(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9244 PyObject *resultobj = 0;
9245 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9246 char result;
9247 void *argp1 = 0 ;
9248 int res1 = 0 ;
9249 PyObject *swig_obj[1] ;
9250
9251 if (!args) SWIG_fail;
9252 swig_obj[0] = args;
9253 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9254 if (!SWIG_IsOK(res1)) {
9255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Peek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9256 }
9257 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9258 {
9259 PyThreadState* __tstate = wxPyBeginAllowThreads();
9260 result = (char)(arg1)->Peek();
9261 wxPyEndAllowThreads(__tstate);
9262 if (PyErr_Occurred()) SWIG_fail;
9263 }
9264 resultobj = SWIG_From_char(static_cast< char >(result));
9265 return resultobj;
9266 fail:
9267 return NULL;
9268 }
9269
9270
9271 SWIGINTERN PyObject *_wrap_InputStream_GetC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9272 PyObject *resultobj = 0;
9273 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9274 char result;
9275 void *argp1 = 0 ;
9276 int res1 = 0 ;
9277 PyObject *swig_obj[1] ;
9278
9279 if (!args) SWIG_fail;
9280 swig_obj[0] = args;
9281 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9282 if (!SWIG_IsOK(res1)) {
9283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_GetC" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9284 }
9285 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9286 {
9287 PyThreadState* __tstate = wxPyBeginAllowThreads();
9288 result = (char)(arg1)->GetC();
9289 wxPyEndAllowThreads(__tstate);
9290 if (PyErr_Occurred()) SWIG_fail;
9291 }
9292 resultobj = SWIG_From_char(static_cast< char >(result));
9293 return resultobj;
9294 fail:
9295 return NULL;
9296 }
9297
9298
9299 SWIGINTERN PyObject *_wrap_InputStream_LastRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9300 PyObject *resultobj = 0;
9301 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9302 size_t result;
9303 void *argp1 = 0 ;
9304 int res1 = 0 ;
9305 PyObject *swig_obj[1] ;
9306
9307 if (!args) SWIG_fail;
9308 swig_obj[0] = args;
9309 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9310 if (!SWIG_IsOK(res1)) {
9311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_LastRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9312 }
9313 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9314 {
9315 PyThreadState* __tstate = wxPyBeginAllowThreads();
9316 result = (size_t)(arg1)->LastRead();
9317 wxPyEndAllowThreads(__tstate);
9318 if (PyErr_Occurred()) SWIG_fail;
9319 }
9320 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9321 return resultobj;
9322 fail:
9323 return NULL;
9324 }
9325
9326
9327 SWIGINTERN PyObject *_wrap_InputStream_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9328 PyObject *resultobj = 0;
9329 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9330 bool result;
9331 void *argp1 = 0 ;
9332 int res1 = 0 ;
9333 PyObject *swig_obj[1] ;
9334
9335 if (!args) SWIG_fail;
9336 swig_obj[0] = args;
9337 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9338 if (!SWIG_IsOK(res1)) {
9339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_CanRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9340 }
9341 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9342 {
9343 PyThreadState* __tstate = wxPyBeginAllowThreads();
9344 result = (bool)(arg1)->CanRead();
9345 wxPyEndAllowThreads(__tstate);
9346 if (PyErr_Occurred()) SWIG_fail;
9347 }
9348 {
9349 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9350 }
9351 return resultobj;
9352 fail:
9353 return NULL;
9354 }
9355
9356
9357 SWIGINTERN PyObject *_wrap_InputStream_Eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9358 PyObject *resultobj = 0;
9359 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9360 bool result;
9361 void *argp1 = 0 ;
9362 int res1 = 0 ;
9363 PyObject *swig_obj[1] ;
9364
9365 if (!args) SWIG_fail;
9366 swig_obj[0] = args;
9367 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9368 if (!SWIG_IsOK(res1)) {
9369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9370 }
9371 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9372 {
9373 PyThreadState* __tstate = wxPyBeginAllowThreads();
9374 result = (bool)(arg1)->Eof();
9375 wxPyEndAllowThreads(__tstate);
9376 if (PyErr_Occurred()) SWIG_fail;
9377 }
9378 {
9379 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9380 }
9381 return resultobj;
9382 fail:
9383 return NULL;
9384 }
9385
9386
9387 SWIGINTERN PyObject *_wrap_InputStream_Ungetch(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9388 PyObject *resultobj = 0;
9389 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9390 char arg2 ;
9391 bool result;
9392 void *argp1 = 0 ;
9393 int res1 = 0 ;
9394 char val2 ;
9395 int ecode2 = 0 ;
9396 PyObject * obj0 = 0 ;
9397 PyObject * obj1 = 0 ;
9398 char * kwnames[] = {
9399 (char *) "self",(char *) "c", NULL
9400 };
9401
9402 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) SWIG_fail;
9403 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9404 if (!SWIG_IsOK(res1)) {
9405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Ungetch" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9406 }
9407 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9408 ecode2 = SWIG_AsVal_char(obj1, &val2);
9409 if (!SWIG_IsOK(ecode2)) {
9410 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_Ungetch" "', expected argument " "2"" of type '" "char""'");
9411 }
9412 arg2 = static_cast< char >(val2);
9413 {
9414 PyThreadState* __tstate = wxPyBeginAllowThreads();
9415 result = (bool)(arg1)->Ungetch(arg2);
9416 wxPyEndAllowThreads(__tstate);
9417 if (PyErr_Occurred()) SWIG_fail;
9418 }
9419 {
9420 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9421 }
9422 return resultobj;
9423 fail:
9424 return NULL;
9425 }
9426
9427
9428 SWIGINTERN PyObject *_wrap_InputStream_SeekI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9429 PyObject *resultobj = 0;
9430 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9431 long arg2 ;
9432 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
9433 long result;
9434 void *argp1 = 0 ;
9435 int res1 = 0 ;
9436 long val2 ;
9437 int ecode2 = 0 ;
9438 int val3 ;
9439 int ecode3 = 0 ;
9440 PyObject * obj0 = 0 ;
9441 PyObject * obj1 = 0 ;
9442 PyObject * obj2 = 0 ;
9443 char * kwnames[] = {
9444 (char *) "self",(char *) "pos",(char *) "mode", NULL
9445 };
9446
9447 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9448 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9449 if (!SWIG_IsOK(res1)) {
9450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_SeekI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9451 }
9452 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9453 ecode2 = SWIG_AsVal_long(obj1, &val2);
9454 if (!SWIG_IsOK(ecode2)) {
9455 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_SeekI" "', expected argument " "2"" of type '" "long""'");
9456 }
9457 arg2 = static_cast< long >(val2);
9458 if (obj2) {
9459 ecode3 = SWIG_AsVal_int(obj2, &val3);
9460 if (!SWIG_IsOK(ecode3)) {
9461 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_SeekI" "', expected argument " "3"" of type '" "wxSeekMode""'");
9462 }
9463 arg3 = static_cast< wxSeekMode >(val3);
9464 }
9465 {
9466 PyThreadState* __tstate = wxPyBeginAllowThreads();
9467 result = (long)(arg1)->SeekI(arg2,arg3);
9468 wxPyEndAllowThreads(__tstate);
9469 if (PyErr_Occurred()) SWIG_fail;
9470 }
9471 resultobj = SWIG_From_long(static_cast< long >(result));
9472 return resultobj;
9473 fail:
9474 return NULL;
9475 }
9476
9477
9478 SWIGINTERN PyObject *_wrap_InputStream_TellI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9479 PyObject *resultobj = 0;
9480 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9481 long result;
9482 void *argp1 = 0 ;
9483 int res1 = 0 ;
9484 PyObject *swig_obj[1] ;
9485
9486 if (!args) SWIG_fail;
9487 swig_obj[0] = args;
9488 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9489 if (!SWIG_IsOK(res1)) {
9490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_TellI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9491 }
9492 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9493 {
9494 PyThreadState* __tstate = wxPyBeginAllowThreads();
9495 result = (long)(arg1)->TellI();
9496 wxPyEndAllowThreads(__tstate);
9497 if (PyErr_Occurred()) SWIG_fail;
9498 }
9499 resultobj = SWIG_From_long(static_cast< long >(result));
9500 return resultobj;
9501 fail:
9502 return NULL;
9503 }
9504
9505
9506 SWIGINTERN PyObject *InputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9507 PyObject *obj;
9508 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9509 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyInputStream, SWIG_NewClientData(obj));
9510 return SWIG_Py_Void();
9511 }
9512
9513 SWIGINTERN PyObject *InputStream_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9514 return SWIG_Python_InitShadowInstance(args);
9515 }
9516
9517 SWIGINTERN PyObject *_wrap_OutputStream_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9518 PyObject *resultobj = 0;
9519 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9520 PyObject *arg2 = (PyObject *) 0 ;
9521 void *argp1 = 0 ;
9522 int res1 = 0 ;
9523 PyObject * obj0 = 0 ;
9524 PyObject * obj1 = 0 ;
9525 char * kwnames[] = {
9526 (char *) "self",(char *) "obj", NULL
9527 };
9528
9529 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) SWIG_fail;
9530 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9531 if (!SWIG_IsOK(res1)) {
9532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_write" "', expected argument " "1"" of type '" "wxOutputStream *""'");
9533 }
9534 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9535 arg2 = obj1;
9536 {
9537 PyThreadState* __tstate = wxPyBeginAllowThreads();
9538 wxOutputStream_write(arg1,arg2);
9539 wxPyEndAllowThreads(__tstate);
9540 if (PyErr_Occurred()) SWIG_fail;
9541 }
9542 resultobj = SWIG_Py_Void();
9543 return resultobj;
9544 fail:
9545 return NULL;
9546 }
9547
9548
9549 SWIGINTERN PyObject *_wrap_OutputStream_LastWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9550 PyObject *resultobj = 0;
9551 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9552 size_t result;
9553 void *argp1 = 0 ;
9554 int res1 = 0 ;
9555 PyObject *swig_obj[1] ;
9556
9557 if (!args) SWIG_fail;
9558 swig_obj[0] = args;
9559 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9560 if (!SWIG_IsOK(res1)) {
9561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_LastWrite" "', expected argument " "1"" of type '" "wxOutputStream const *""'");
9562 }
9563 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9564 {
9565 PyThreadState* __tstate = wxPyBeginAllowThreads();
9566 result = (size_t)((wxOutputStream const *)arg1)->LastWrite();
9567 wxPyEndAllowThreads(__tstate);
9568 if (PyErr_Occurred()) SWIG_fail;
9569 }
9570 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9571 return resultobj;
9572 fail:
9573 return NULL;
9574 }
9575
9576
9577 SWIGINTERN PyObject *OutputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9578 PyObject *obj;
9579 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9580 SWIG_TypeNewClientData(SWIGTYPE_p_wxOutputStream, SWIG_NewClientData(obj));
9581 return SWIG_Py_Void();
9582 }
9583
9584 SWIGINTERN PyObject *_wrap_new_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9585 PyObject *resultobj = 0;
9586 wxInputStream *arg1 = (wxInputStream *) 0 ;
9587 wxString *arg2 = 0 ;
9588 wxString *arg3 = 0 ;
9589 wxString *arg4 = 0 ;
9590 wxDateTime arg5 ;
9591 wxFSFile *result = 0 ;
9592 wxPyInputStream *temp1 ;
9593 bool temp2 = false ;
9594 bool temp3 = false ;
9595 bool temp4 = false ;
9596 void *argp5 ;
9597 int res5 = 0 ;
9598 PyObject * obj0 = 0 ;
9599 PyObject * obj1 = 0 ;
9600 PyObject * obj2 = 0 ;
9601 PyObject * obj3 = 0 ;
9602 PyObject * obj4 = 0 ;
9603 char * kwnames[] = {
9604 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
9605 };
9606
9607 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9608 {
9609 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
9610 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
9611 } else {
9612 PyErr_Clear(); // clear the failure of the wxPyConvert above
9613 arg1 = wxPyCBInputStream_create(obj0, true);
9614 if (arg1 == NULL) {
9615 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
9616 SWIG_fail;
9617 }
9618 }
9619 }
9620 {
9621 arg2 = wxString_in_helper(obj1);
9622 if (arg2 == NULL) SWIG_fail;
9623 temp2 = true;
9624 }
9625 {
9626 arg3 = wxString_in_helper(obj2);
9627 if (arg3 == NULL) SWIG_fail;
9628 temp3 = true;
9629 }
9630 {
9631 arg4 = wxString_in_helper(obj3);
9632 if (arg4 == NULL) SWIG_fail;
9633 temp4 = true;
9634 }
9635 {
9636 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDateTime, 0 | 0);
9637 if (!SWIG_IsOK(res5)) {
9638 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9639 }
9640 if (!argp5) {
9641 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9642 } else {
9643 wxDateTime * temp = reinterpret_cast< wxDateTime * >(argp5);
9644 arg5 = *temp;
9645 if (SWIG_IsNewObj(res5)) delete temp;
9646 }
9647 }
9648 {
9649 PyThreadState* __tstate = wxPyBeginAllowThreads();
9650 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
9651 wxPyEndAllowThreads(__tstate);
9652 if (PyErr_Occurred()) SWIG_fail;
9653 }
9654 {
9655 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
9656 }
9657 {
9658 if (temp2)
9659 delete arg2;
9660 }
9661 {
9662 if (temp3)
9663 delete arg3;
9664 }
9665 {
9666 if (temp4)
9667 delete arg4;
9668 }
9669 return resultobj;
9670 fail:
9671 {
9672 if (temp2)
9673 delete arg2;
9674 }
9675 {
9676 if (temp3)
9677 delete arg3;
9678 }
9679 {
9680 if (temp4)
9681 delete arg4;
9682 }
9683 return NULL;
9684 }
9685
9686
9687 SWIGINTERN PyObject *_wrap_delete_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9688 PyObject *resultobj = 0;
9689 wxFSFile *arg1 = (wxFSFile *) 0 ;
9690 void *argp1 = 0 ;
9691 int res1 = 0 ;
9692 PyObject *swig_obj[1] ;
9693
9694 if (!args) SWIG_fail;
9695 swig_obj[0] = args;
9696 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, SWIG_POINTER_DISOWN | 0 );
9697 if (!SWIG_IsOK(res1)) {
9698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FSFile" "', expected argument " "1"" of type '" "wxFSFile *""'");
9699 }
9700 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9701 {
9702 PyThreadState* __tstate = wxPyBeginAllowThreads();
9703 delete arg1;
9704
9705 wxPyEndAllowThreads(__tstate);
9706 if (PyErr_Occurred()) SWIG_fail;
9707 }
9708 resultobj = SWIG_Py_Void();
9709 return resultobj;
9710 fail:
9711 return NULL;
9712 }
9713
9714
9715 SWIGINTERN PyObject *_wrap_FSFile_GetStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9716 PyObject *resultobj = 0;
9717 wxFSFile *arg1 = (wxFSFile *) 0 ;
9718 wxInputStream *result = 0 ;
9719 void *argp1 = 0 ;
9720 int res1 = 0 ;
9721 PyObject *swig_obj[1] ;
9722
9723 if (!args) SWIG_fail;
9724 swig_obj[0] = args;
9725 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9726 if (!SWIG_IsOK(res1)) {
9727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
9728 }
9729 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9730 {
9731 PyThreadState* __tstate = wxPyBeginAllowThreads();
9732 result = (wxInputStream *)(arg1)->GetStream();
9733 wxPyEndAllowThreads(__tstate);
9734 if (PyErr_Occurred()) SWIG_fail;
9735 }
9736 {
9737 wxPyInputStream * _ptr = NULL;
9738
9739 if (result) {
9740 _ptr = new wxPyInputStream(result);
9741 }
9742 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
9743 }
9744 return resultobj;
9745 fail:
9746 return NULL;
9747 }
9748
9749
9750 SWIGINTERN PyObject *_wrap_FSFile_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9751 PyObject *resultobj = 0;
9752 wxFSFile *arg1 = (wxFSFile *) 0 ;
9753 wxString *result = 0 ;
9754 void *argp1 = 0 ;
9755 int res1 = 0 ;
9756 PyObject *swig_obj[1] ;
9757
9758 if (!args) SWIG_fail;
9759 swig_obj[0] = args;
9760 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9761 if (!SWIG_IsOK(res1)) {
9762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetMimeType" "', expected argument " "1"" of type '" "wxFSFile *""'");
9763 }
9764 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9765 {
9766 PyThreadState* __tstate = wxPyBeginAllowThreads();
9767 {
9768 wxString const &_result_ref = (arg1)->GetMimeType();
9769 result = (wxString *) &_result_ref;
9770 }
9771 wxPyEndAllowThreads(__tstate);
9772 if (PyErr_Occurred()) SWIG_fail;
9773 }
9774 {
9775 #if wxUSE_UNICODE
9776 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9777 #else
9778 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9779 #endif
9780 }
9781 return resultobj;
9782 fail:
9783 return NULL;
9784 }
9785
9786
9787 SWIGINTERN PyObject *_wrap_FSFile_GetLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9788 PyObject *resultobj = 0;
9789 wxFSFile *arg1 = (wxFSFile *) 0 ;
9790 wxString *result = 0 ;
9791 void *argp1 = 0 ;
9792 int res1 = 0 ;
9793 PyObject *swig_obj[1] ;
9794
9795 if (!args) SWIG_fail;
9796 swig_obj[0] = args;
9797 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9798 if (!SWIG_IsOK(res1)) {
9799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetLocation" "', expected argument " "1"" of type '" "wxFSFile *""'");
9800 }
9801 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9802 {
9803 PyThreadState* __tstate = wxPyBeginAllowThreads();
9804 {
9805 wxString const &_result_ref = (arg1)->GetLocation();
9806 result = (wxString *) &_result_ref;
9807 }
9808 wxPyEndAllowThreads(__tstate);
9809 if (PyErr_Occurred()) SWIG_fail;
9810 }
9811 {
9812 #if wxUSE_UNICODE
9813 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9814 #else
9815 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9816 #endif
9817 }
9818 return resultobj;
9819 fail:
9820 return NULL;
9821 }
9822
9823
9824 SWIGINTERN PyObject *_wrap_FSFile_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9825 PyObject *resultobj = 0;
9826 wxFSFile *arg1 = (wxFSFile *) 0 ;
9827 wxString *result = 0 ;
9828 void *argp1 = 0 ;
9829 int res1 = 0 ;
9830 PyObject *swig_obj[1] ;
9831
9832 if (!args) SWIG_fail;
9833 swig_obj[0] = args;
9834 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9835 if (!SWIG_IsOK(res1)) {
9836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetAnchor" "', expected argument " "1"" of type '" "wxFSFile *""'");
9837 }
9838 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9839 {
9840 PyThreadState* __tstate = wxPyBeginAllowThreads();
9841 {
9842 wxString const &_result_ref = (arg1)->GetAnchor();
9843 result = (wxString *) &_result_ref;
9844 }
9845 wxPyEndAllowThreads(__tstate);
9846 if (PyErr_Occurred()) SWIG_fail;
9847 }
9848 {
9849 #if wxUSE_UNICODE
9850 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9851 #else
9852 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9853 #endif
9854 }
9855 return resultobj;
9856 fail:
9857 return NULL;
9858 }
9859
9860
9861 SWIGINTERN PyObject *_wrap_FSFile_GetModificationTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9862 PyObject *resultobj = 0;
9863 wxFSFile *arg1 = (wxFSFile *) 0 ;
9864 wxDateTime result;
9865 void *argp1 = 0 ;
9866 int res1 = 0 ;
9867 PyObject *swig_obj[1] ;
9868
9869 if (!args) SWIG_fail;
9870 swig_obj[0] = args;
9871 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9872 if (!SWIG_IsOK(res1)) {
9873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetModificationTime" "', expected argument " "1"" of type '" "wxFSFile *""'");
9874 }
9875 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9876 {
9877 PyThreadState* __tstate = wxPyBeginAllowThreads();
9878 result = (arg1)->GetModificationTime();
9879 wxPyEndAllowThreads(__tstate);
9880 if (PyErr_Occurred()) SWIG_fail;
9881 }
9882 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
9883 return resultobj;
9884 fail:
9885 return NULL;
9886 }
9887
9888
9889 SWIGINTERN PyObject *FSFile_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9890 PyObject *obj;
9891 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9892 SWIG_TypeNewClientData(SWIGTYPE_p_wxFSFile, SWIG_NewClientData(obj));
9893 return SWIG_Py_Void();
9894 }
9895
9896 SWIGINTERN PyObject *FSFile_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9897 return SWIG_Python_InitShadowInstance(args);
9898 }
9899
9900 SWIGINTERN PyObject *_wrap_delete_CPPFileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9901 PyObject *resultobj = 0;
9902 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
9903 void *argp1 = 0 ;
9904 int res1 = 0 ;
9905 PyObject *swig_obj[1] ;
9906
9907 if (!args) SWIG_fail;
9908 swig_obj[0] = args;
9909 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
9910 if (!SWIG_IsOK(res1)) {
9911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CPPFileSystemHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
9912 }
9913 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
9914 {
9915 PyThreadState* __tstate = wxPyBeginAllowThreads();
9916 delete arg1;
9917
9918 wxPyEndAllowThreads(__tstate);
9919 if (PyErr_Occurred()) SWIG_fail;
9920 }
9921 resultobj = SWIG_Py_Void();
9922 return resultobj;
9923 fail:
9924 return NULL;
9925 }
9926
9927
9928 SWIGINTERN PyObject *CPPFileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9929 PyObject *obj;
9930 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9931 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystemHandler, SWIG_NewClientData(obj));
9932 return SWIG_Py_Void();
9933 }
9934
9935 SWIGINTERN PyObject *_wrap_new_FileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9936 PyObject *resultobj = 0;
9937 wxPyFileSystemHandler *result = 0 ;
9938
9939 if (!SWIG_Python_UnpackTuple(args,"new_FileSystemHandler",0,0,0)) SWIG_fail;
9940 {
9941 PyThreadState* __tstate = wxPyBeginAllowThreads();
9942 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
9943 wxPyEndAllowThreads(__tstate);
9944 if (PyErr_Occurred()) SWIG_fail;
9945 }
9946 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_NEW | 0 );
9947 return resultobj;
9948 fail:
9949 return NULL;
9950 }
9951
9952
9953 SWIGINTERN PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9954 PyObject *resultobj = 0;
9955 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
9956 PyObject *arg2 = (PyObject *) 0 ;
9957 PyObject *arg3 = (PyObject *) 0 ;
9958 void *argp1 = 0 ;
9959 int res1 = 0 ;
9960 PyObject * obj0 = 0 ;
9961 PyObject * obj1 = 0 ;
9962 PyObject * obj2 = 0 ;
9963 char * kwnames[] = {
9964 (char *) "self",(char *) "self",(char *) "_class", NULL
9965 };
9966
9967 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9968 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
9969 if (!SWIG_IsOK(res1)) {
9970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
9971 }
9972 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
9973 arg2 = obj1;
9974 arg3 = obj2;
9975 {
9976 PyThreadState* __tstate = wxPyBeginAllowThreads();
9977 (arg1)->_setCallbackInfo(arg2,arg3);
9978 wxPyEndAllowThreads(__tstate);
9979 if (PyErr_Occurred()) SWIG_fail;
9980 }
9981 resultobj = SWIG_Py_Void();
9982 return resultobj;
9983 fail:
9984 return NULL;
9985 }
9986
9987
9988 SWIGINTERN PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9989 PyObject *resultobj = 0;
9990 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
9991 wxString *arg2 = 0 ;
9992 bool result;
9993 void *argp1 = 0 ;
9994 int res1 = 0 ;
9995 bool temp2 = false ;
9996 PyObject * obj0 = 0 ;
9997 PyObject * obj1 = 0 ;
9998 char * kwnames[] = {
9999 (char *) "self",(char *) "location", NULL
10000 };
10001
10002 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
10003 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10004 if (!SWIG_IsOK(res1)) {
10005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_CanOpen" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10006 }
10007 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10008 {
10009 arg2 = wxString_in_helper(obj1);
10010 if (arg2 == NULL) SWIG_fail;
10011 temp2 = true;
10012 }
10013 {
10014 PyThreadState* __tstate = wxPyBeginAllowThreads();
10015 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
10016 wxPyEndAllowThreads(__tstate);
10017 if (PyErr_Occurred()) SWIG_fail;
10018 }
10019 {
10020 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10021 }
10022 {
10023 if (temp2)
10024 delete arg2;
10025 }
10026 return resultobj;
10027 fail:
10028 {
10029 if (temp2)
10030 delete arg2;
10031 }
10032 return NULL;
10033 }
10034
10035
10036 SWIGINTERN PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10037 PyObject *resultobj = 0;
10038 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10039 wxFileSystem *arg2 = 0 ;
10040 wxString *arg3 = 0 ;
10041 wxFSFile *result = 0 ;
10042 void *argp1 = 0 ;
10043 int res1 = 0 ;
10044 void *argp2 = 0 ;
10045 int res2 = 0 ;
10046 bool temp3 = false ;
10047 PyObject * obj0 = 0 ;
10048 PyObject * obj1 = 0 ;
10049 PyObject * obj2 = 0 ;
10050 char * kwnames[] = {
10051 (char *) "self",(char *) "fs",(char *) "location", NULL
10052 };
10053
10054 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10055 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10056 if (!SWIG_IsOK(res1)) {
10057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10058 }
10059 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10060 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
10061 if (!SWIG_IsOK(res2)) {
10062 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10063 }
10064 if (!argp2) {
10065 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10066 }
10067 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
10068 {
10069 arg3 = wxString_in_helper(obj2);
10070 if (arg3 == NULL) SWIG_fail;
10071 temp3 = true;
10072 }
10073 {
10074 PyThreadState* __tstate = wxPyBeginAllowThreads();
10075 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
10076 wxPyEndAllowThreads(__tstate);
10077 if (PyErr_Occurred()) SWIG_fail;
10078 }
10079 {
10080 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
10081 }
10082 {
10083 if (temp3)
10084 delete arg3;
10085 }
10086 return resultobj;
10087 fail:
10088 {
10089 if (temp3)
10090 delete arg3;
10091 }
10092 return NULL;
10093 }
10094
10095
10096 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10097 PyObject *resultobj = 0;
10098 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10099 wxString *arg2 = 0 ;
10100 int arg3 = (int) 0 ;
10101 wxString result;
10102 void *argp1 = 0 ;
10103 int res1 = 0 ;
10104 bool temp2 = false ;
10105 int val3 ;
10106 int ecode3 = 0 ;
10107 PyObject * obj0 = 0 ;
10108 PyObject * obj1 = 0 ;
10109 PyObject * obj2 = 0 ;
10110 char * kwnames[] = {
10111 (char *) "self",(char *) "spec",(char *) "flags", NULL
10112 };
10113
10114 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10115 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10116 if (!SWIG_IsOK(res1)) {
10117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10118 }
10119 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10120 {
10121 arg2 = wxString_in_helper(obj1);
10122 if (arg2 == NULL) SWIG_fail;
10123 temp2 = true;
10124 }
10125 if (obj2) {
10126 ecode3 = SWIG_AsVal_int(obj2, &val3);
10127 if (!SWIG_IsOK(ecode3)) {
10128 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
10129 }
10130 arg3 = static_cast< int >(val3);
10131 }
10132 {
10133 PyThreadState* __tstate = wxPyBeginAllowThreads();
10134 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10135 wxPyEndAllowThreads(__tstate);
10136 if (PyErr_Occurred()) SWIG_fail;
10137 }
10138 {
10139 #if wxUSE_UNICODE
10140 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10141 #else
10142 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10143 #endif
10144 }
10145 {
10146 if (temp2)
10147 delete arg2;
10148 }
10149 return resultobj;
10150 fail:
10151 {
10152 if (temp2)
10153 delete arg2;
10154 }
10155 return NULL;
10156 }
10157
10158
10159 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10160 PyObject *resultobj = 0;
10161 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10162 wxString result;
10163 void *argp1 = 0 ;
10164 int res1 = 0 ;
10165 PyObject *swig_obj[1] ;
10166
10167 if (!args) SWIG_fail;
10168 swig_obj[0] = args;
10169 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10170 if (!SWIG_IsOK(res1)) {
10171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindNext" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10172 }
10173 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10174 {
10175 PyThreadState* __tstate = wxPyBeginAllowThreads();
10176 result = (arg1)->FindNext();
10177 wxPyEndAllowThreads(__tstate);
10178 if (PyErr_Occurred()) SWIG_fail;
10179 }
10180 {
10181 #if wxUSE_UNICODE
10182 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10183 #else
10184 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10185 #endif
10186 }
10187 return resultobj;
10188 fail:
10189 return NULL;
10190 }
10191
10192
10193 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10194 PyObject *resultobj = 0;
10195 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10196 wxString *arg2 = 0 ;
10197 wxString result;
10198 void *argp1 = 0 ;
10199 int res1 = 0 ;
10200 bool temp2 = false ;
10201 PyObject * obj0 = 0 ;
10202 PyObject * obj1 = 0 ;
10203 char * kwnames[] = {
10204 (char *) "self",(char *) "location", NULL
10205 };
10206
10207 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) SWIG_fail;
10208 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10209 if (!SWIG_IsOK(res1)) {
10210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetProtocol" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10211 }
10212 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10213 {
10214 arg2 = wxString_in_helper(obj1);
10215 if (arg2 == NULL) SWIG_fail;
10216 temp2 = true;
10217 }
10218 {
10219 PyThreadState* __tstate = wxPyBeginAllowThreads();
10220 result = (arg1)->GetProtocol((wxString const &)*arg2);
10221 wxPyEndAllowThreads(__tstate);
10222 if (PyErr_Occurred()) SWIG_fail;
10223 }
10224 {
10225 #if wxUSE_UNICODE
10226 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10227 #else
10228 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10229 #endif
10230 }
10231 {
10232 if (temp2)
10233 delete arg2;
10234 }
10235 return resultobj;
10236 fail:
10237 {
10238 if (temp2)
10239 delete arg2;
10240 }
10241 return NULL;
10242 }
10243
10244
10245 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10246 PyObject *resultobj = 0;
10247 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10248 wxString *arg2 = 0 ;
10249 wxString result;
10250 void *argp1 = 0 ;
10251 int res1 = 0 ;
10252 bool temp2 = false ;
10253 PyObject * obj0 = 0 ;
10254 PyObject * obj1 = 0 ;
10255 char * kwnames[] = {
10256 (char *) "self",(char *) "location", NULL
10257 };
10258
10259 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10260 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10261 if (!SWIG_IsOK(res1)) {
10262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetLeftLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10263 }
10264 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10265 {
10266 arg2 = wxString_in_helper(obj1);
10267 if (arg2 == NULL) SWIG_fail;
10268 temp2 = true;
10269 }
10270 {
10271 PyThreadState* __tstate = wxPyBeginAllowThreads();
10272 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
10273 wxPyEndAllowThreads(__tstate);
10274 if (PyErr_Occurred()) SWIG_fail;
10275 }
10276 {
10277 #if wxUSE_UNICODE
10278 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10279 #else
10280 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10281 #endif
10282 }
10283 {
10284 if (temp2)
10285 delete arg2;
10286 }
10287 return resultobj;
10288 fail:
10289 {
10290 if (temp2)
10291 delete arg2;
10292 }
10293 return NULL;
10294 }
10295
10296
10297 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10298 PyObject *resultobj = 0;
10299 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10300 wxString *arg2 = 0 ;
10301 wxString result;
10302 void *argp1 = 0 ;
10303 int res1 = 0 ;
10304 bool temp2 = false ;
10305 PyObject * obj0 = 0 ;
10306 PyObject * obj1 = 0 ;
10307 char * kwnames[] = {
10308 (char *) "self",(char *) "location", NULL
10309 };
10310
10311 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) SWIG_fail;
10312 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10313 if (!SWIG_IsOK(res1)) {
10314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetAnchor" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10315 }
10316 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10317 {
10318 arg2 = wxString_in_helper(obj1);
10319 if (arg2 == NULL) SWIG_fail;
10320 temp2 = true;
10321 }
10322 {
10323 PyThreadState* __tstate = wxPyBeginAllowThreads();
10324 result = (arg1)->GetAnchor((wxString const &)*arg2);
10325 wxPyEndAllowThreads(__tstate);
10326 if (PyErr_Occurred()) SWIG_fail;
10327 }
10328 {
10329 #if wxUSE_UNICODE
10330 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10331 #else
10332 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10333 #endif
10334 }
10335 {
10336 if (temp2)
10337 delete arg2;
10338 }
10339 return resultobj;
10340 fail:
10341 {
10342 if (temp2)
10343 delete arg2;
10344 }
10345 return NULL;
10346 }
10347
10348
10349 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10350 PyObject *resultobj = 0;
10351 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10352 wxString *arg2 = 0 ;
10353 wxString result;
10354 void *argp1 = 0 ;
10355 int res1 = 0 ;
10356 bool temp2 = false ;
10357 PyObject * obj0 = 0 ;
10358 PyObject * obj1 = 0 ;
10359 char * kwnames[] = {
10360 (char *) "self",(char *) "location", NULL
10361 };
10362
10363 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10364 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10365 if (!SWIG_IsOK(res1)) {
10366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetRightLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10367 }
10368 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10369 {
10370 arg2 = wxString_in_helper(obj1);
10371 if (arg2 == NULL) SWIG_fail;
10372 temp2 = true;
10373 }
10374 {
10375 PyThreadState* __tstate = wxPyBeginAllowThreads();
10376 result = (arg1)->GetRightLocation((wxString const &)*arg2);
10377 wxPyEndAllowThreads(__tstate);
10378 if (PyErr_Occurred()) SWIG_fail;
10379 }
10380 {
10381 #if wxUSE_UNICODE
10382 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10383 #else
10384 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10385 #endif
10386 }
10387 {
10388 if (temp2)
10389 delete arg2;
10390 }
10391 return resultobj;
10392 fail:
10393 {
10394 if (temp2)
10395 delete arg2;
10396 }
10397 return NULL;
10398 }
10399
10400
10401 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10402 PyObject *resultobj = 0;
10403 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10404 wxString *arg2 = 0 ;
10405 wxString result;
10406 void *argp1 = 0 ;
10407 int res1 = 0 ;
10408 bool temp2 = false ;
10409 PyObject * obj0 = 0 ;
10410 PyObject * obj1 = 0 ;
10411 char * kwnames[] = {
10412 (char *) "self",(char *) "location", NULL
10413 };
10414
10415 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) SWIG_fail;
10416 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10417 if (!SWIG_IsOK(res1)) {
10418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetMimeTypeFromExt" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10419 }
10420 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10421 {
10422 arg2 = wxString_in_helper(obj1);
10423 if (arg2 == NULL) SWIG_fail;
10424 temp2 = true;
10425 }
10426 {
10427 PyThreadState* __tstate = wxPyBeginAllowThreads();
10428 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
10429 wxPyEndAllowThreads(__tstate);
10430 if (PyErr_Occurred()) SWIG_fail;
10431 }
10432 {
10433 #if wxUSE_UNICODE
10434 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10435 #else
10436 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10437 #endif
10438 }
10439 {
10440 if (temp2)
10441 delete arg2;
10442 }
10443 return resultobj;
10444 fail:
10445 {
10446 if (temp2)
10447 delete arg2;
10448 }
10449 return NULL;
10450 }
10451
10452
10453 SWIGINTERN PyObject *FileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10454 PyObject *obj;
10455 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10456 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileSystemHandler, SWIG_NewClientData(obj));
10457 return SWIG_Py_Void();
10458 }
10459
10460 SWIGINTERN PyObject *FileSystemHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10461 return SWIG_Python_InitShadowInstance(args);
10462 }
10463
10464 SWIGINTERN PyObject *_wrap_new_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10465 PyObject *resultobj = 0;
10466 wxFileSystem *result = 0 ;
10467
10468 if (!SWIG_Python_UnpackTuple(args,"new_FileSystem",0,0,0)) SWIG_fail;
10469 {
10470 PyThreadState* __tstate = wxPyBeginAllowThreads();
10471 result = (wxFileSystem *)new wxFileSystem();
10472 wxPyEndAllowThreads(__tstate);
10473 if (PyErr_Occurred()) SWIG_fail;
10474 }
10475 {
10476 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
10477 }
10478 return resultobj;
10479 fail:
10480 return NULL;
10481 }
10482
10483
10484 SWIGINTERN PyObject *_wrap_delete_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10485 PyObject *resultobj = 0;
10486 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10487 void *argp1 = 0 ;
10488 int res1 = 0 ;
10489 PyObject *swig_obj[1] ;
10490
10491 if (!args) SWIG_fail;
10492 swig_obj[0] = args;
10493 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, SWIG_POINTER_DISOWN | 0 );
10494 if (!SWIG_IsOK(res1)) {
10495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileSystem" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10496 }
10497 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10498 {
10499 PyThreadState* __tstate = wxPyBeginAllowThreads();
10500 delete arg1;
10501
10502 wxPyEndAllowThreads(__tstate);
10503 if (PyErr_Occurred()) SWIG_fail;
10504 }
10505 resultobj = SWIG_Py_Void();
10506 return resultobj;
10507 fail:
10508 return NULL;
10509 }
10510
10511
10512 SWIGINTERN PyObject *_wrap_FileSystem_ChangePathTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10513 PyObject *resultobj = 0;
10514 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10515 wxString *arg2 = 0 ;
10516 bool arg3 = (bool) false ;
10517 void *argp1 = 0 ;
10518 int res1 = 0 ;
10519 bool temp2 = false ;
10520 bool val3 ;
10521 int ecode3 = 0 ;
10522 PyObject * obj0 = 0 ;
10523 PyObject * obj1 = 0 ;
10524 PyObject * obj2 = 0 ;
10525 char * kwnames[] = {
10526 (char *) "self",(char *) "location",(char *) "is_dir", NULL
10527 };
10528
10529 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10530 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10531 if (!SWIG_IsOK(res1)) {
10532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_ChangePathTo" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10533 }
10534 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10535 {
10536 arg2 = wxString_in_helper(obj1);
10537 if (arg2 == NULL) SWIG_fail;
10538 temp2 = true;
10539 }
10540 if (obj2) {
10541 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10542 if (!SWIG_IsOK(ecode3)) {
10543 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_ChangePathTo" "', expected argument " "3"" of type '" "bool""'");
10544 }
10545 arg3 = static_cast< bool >(val3);
10546 }
10547 {
10548 PyThreadState* __tstate = wxPyBeginAllowThreads();
10549 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
10550 wxPyEndAllowThreads(__tstate);
10551 if (PyErr_Occurred()) SWIG_fail;
10552 }
10553 resultobj = SWIG_Py_Void();
10554 {
10555 if (temp2)
10556 delete arg2;
10557 }
10558 return resultobj;
10559 fail:
10560 {
10561 if (temp2)
10562 delete arg2;
10563 }
10564 return NULL;
10565 }
10566
10567
10568 SWIGINTERN PyObject *_wrap_FileSystem_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10569 PyObject *resultobj = 0;
10570 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10571 wxString result;
10572 void *argp1 = 0 ;
10573 int res1 = 0 ;
10574 PyObject *swig_obj[1] ;
10575
10576 if (!args) SWIG_fail;
10577 swig_obj[0] = args;
10578 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10579 if (!SWIG_IsOK(res1)) {
10580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_GetPath" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10581 }
10582 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10583 {
10584 PyThreadState* __tstate = wxPyBeginAllowThreads();
10585 result = (arg1)->GetPath();
10586 wxPyEndAllowThreads(__tstate);
10587 if (PyErr_Occurred()) SWIG_fail;
10588 }
10589 {
10590 #if wxUSE_UNICODE
10591 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10592 #else
10593 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10594 #endif
10595 }
10596 return resultobj;
10597 fail:
10598 return NULL;
10599 }
10600
10601
10602 SWIGINTERN PyObject *_wrap_FileSystem_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10603 PyObject *resultobj = 0;
10604 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10605 wxString *arg2 = 0 ;
10606 wxFSFile *result = 0 ;
10607 void *argp1 = 0 ;
10608 int res1 = 0 ;
10609 bool temp2 = false ;
10610 PyObject * obj0 = 0 ;
10611 PyObject * obj1 = 0 ;
10612 char * kwnames[] = {
10613 (char *) "self",(char *) "location", NULL
10614 };
10615
10616 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) SWIG_fail;
10617 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10618 if (!SWIG_IsOK(res1)) {
10619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_OpenFile" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10620 }
10621 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10622 {
10623 arg2 = wxString_in_helper(obj1);
10624 if (arg2 == NULL) SWIG_fail;
10625 temp2 = true;
10626 }
10627 {
10628 PyThreadState* __tstate = wxPyBeginAllowThreads();
10629 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
10630 wxPyEndAllowThreads(__tstate);
10631 if (PyErr_Occurred()) SWIG_fail;
10632 }
10633 {
10634 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
10635 }
10636 {
10637 if (temp2)
10638 delete arg2;
10639 }
10640 return resultobj;
10641 fail:
10642 {
10643 if (temp2)
10644 delete arg2;
10645 }
10646 return NULL;
10647 }
10648
10649
10650 SWIGINTERN PyObject *_wrap_FileSystem_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10651 PyObject *resultobj = 0;
10652 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10653 wxString *arg2 = 0 ;
10654 int arg3 = (int) 0 ;
10655 wxString result;
10656 void *argp1 = 0 ;
10657 int res1 = 0 ;
10658 bool temp2 = false ;
10659 int val3 ;
10660 int ecode3 = 0 ;
10661 PyObject * obj0 = 0 ;
10662 PyObject * obj1 = 0 ;
10663 PyObject * obj2 = 0 ;
10664 char * kwnames[] = {
10665 (char *) "self",(char *) "spec",(char *) "flags", NULL
10666 };
10667
10668 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10669 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10670 if (!SWIG_IsOK(res1)) {
10671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindFirst" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10672 }
10673 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10674 {
10675 arg2 = wxString_in_helper(obj1);
10676 if (arg2 == NULL) SWIG_fail;
10677 temp2 = true;
10678 }
10679 if (obj2) {
10680 ecode3 = SWIG_AsVal_int(obj2, &val3);
10681 if (!SWIG_IsOK(ecode3)) {
10682 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_FindFirst" "', expected argument " "3"" of type '" "int""'");
10683 }
10684 arg3 = static_cast< int >(val3);
10685 }
10686 {
10687 PyThreadState* __tstate = wxPyBeginAllowThreads();
10688 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10689 wxPyEndAllowThreads(__tstate);
10690 if (PyErr_Occurred()) SWIG_fail;
10691 }
10692 {
10693 #if wxUSE_UNICODE
10694 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10695 #else
10696 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10697 #endif
10698 }
10699 {
10700 if (temp2)
10701 delete arg2;
10702 }
10703 return resultobj;
10704 fail:
10705 {
10706 if (temp2)
10707 delete arg2;
10708 }
10709 return NULL;
10710 }
10711
10712
10713 SWIGINTERN PyObject *_wrap_FileSystem_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10714 PyObject *resultobj = 0;
10715 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10716 wxString result;
10717 void *argp1 = 0 ;
10718 int res1 = 0 ;
10719 PyObject *swig_obj[1] ;
10720
10721 if (!args) SWIG_fail;
10722 swig_obj[0] = args;
10723 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10724 if (!SWIG_IsOK(res1)) {
10725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindNext" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10726 }
10727 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10728 {
10729 PyThreadState* __tstate = wxPyBeginAllowThreads();
10730 result = (arg1)->FindNext();
10731 wxPyEndAllowThreads(__tstate);
10732 if (PyErr_Occurred()) SWIG_fail;
10733 }
10734 {
10735 #if wxUSE_UNICODE
10736 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10737 #else
10738 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10739 #endif
10740 }
10741 return resultobj;
10742 fail:
10743 return NULL;
10744 }
10745
10746
10747 SWIGINTERN PyObject *_wrap_FileSystem_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10748 PyObject *resultobj = 0;
10749 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
10750 int res1 = 0 ;
10751 PyObject * obj0 = 0 ;
10752 char * kwnames[] = {
10753 (char *) "handler", NULL
10754 };
10755
10756 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) SWIG_fail;
10757 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
10758 if (!SWIG_IsOK(res1)) {
10759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_AddHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
10760 }
10761 {
10762 PyThreadState* __tstate = wxPyBeginAllowThreads();
10763 wxFileSystem::AddHandler(arg1);
10764 wxPyEndAllowThreads(__tstate);
10765 if (PyErr_Occurred()) SWIG_fail;
10766 }
10767 resultobj = SWIG_Py_Void();
10768 return resultobj;
10769 fail:
10770 return NULL;
10771 }
10772
10773
10774 SWIGINTERN PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10775 PyObject *resultobj = 0;
10776
10777 if (!SWIG_Python_UnpackTuple(args,"FileSystem_CleanUpHandlers",0,0,0)) SWIG_fail;
10778 {
10779 PyThreadState* __tstate = wxPyBeginAllowThreads();
10780 wxFileSystem::CleanUpHandlers();
10781 wxPyEndAllowThreads(__tstate);
10782 if (PyErr_Occurred()) SWIG_fail;
10783 }
10784 resultobj = SWIG_Py_Void();
10785 return resultobj;
10786 fail:
10787 return NULL;
10788 }
10789
10790
10791 SWIGINTERN PyObject *_wrap_FileSystem_FileNameToURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10792 PyObject *resultobj = 0;
10793 wxString *arg1 = 0 ;
10794 wxString result;
10795 bool temp1 = false ;
10796 PyObject * obj0 = 0 ;
10797 char * kwnames[] = {
10798 (char *) "filename", NULL
10799 };
10800
10801 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) SWIG_fail;
10802 {
10803 arg1 = wxString_in_helper(obj0);
10804 if (arg1 == NULL) SWIG_fail;
10805 temp1 = true;
10806 }
10807 {
10808 PyThreadState* __tstate = wxPyBeginAllowThreads();
10809 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
10810 wxPyEndAllowThreads(__tstate);
10811 if (PyErr_Occurred()) SWIG_fail;
10812 }
10813 {
10814 #if wxUSE_UNICODE
10815 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10816 #else
10817 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10818 #endif
10819 }
10820 {
10821 if (temp1)
10822 delete arg1;
10823 }
10824 return resultobj;
10825 fail:
10826 {
10827 if (temp1)
10828 delete arg1;
10829 }
10830 return NULL;
10831 }
10832
10833
10834 SWIGINTERN PyObject *_wrap_FileSystem_URLToFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10835 PyObject *resultobj = 0;
10836 wxString *arg1 = 0 ;
10837 wxString result;
10838 bool temp1 = false ;
10839 PyObject * obj0 = 0 ;
10840 char * kwnames[] = {
10841 (char *) "url", NULL
10842 };
10843
10844 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) SWIG_fail;
10845 {
10846 arg1 = wxString_in_helper(obj0);
10847 if (arg1 == NULL) SWIG_fail;
10848 temp1 = true;
10849 }
10850 {
10851 PyThreadState* __tstate = wxPyBeginAllowThreads();
10852 result = wxFileSystem_URLToFileName((wxString const &)*arg1);
10853 wxPyEndAllowThreads(__tstate);
10854 if (PyErr_Occurred()) SWIG_fail;
10855 }
10856 {
10857 #if wxUSE_UNICODE
10858 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10859 #else
10860 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10861 #endif
10862 }
10863 {
10864 if (temp1)
10865 delete arg1;
10866 }
10867 return resultobj;
10868 fail:
10869 {
10870 if (temp1)
10871 delete arg1;
10872 }
10873 return NULL;
10874 }
10875
10876
10877 SWIGINTERN PyObject *FileSystem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10878 PyObject *obj;
10879 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10880 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystem, SWIG_NewClientData(obj));
10881 return SWIG_Py_Void();
10882 }
10883
10884 SWIGINTERN PyObject *FileSystem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10885 return SWIG_Python_InitShadowInstance(args);
10886 }
10887
10888 SWIGINTERN PyObject *_wrap_new_InternetFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10889 PyObject *resultobj = 0;
10890 wxInternetFSHandler *result = 0 ;
10891
10892 if (!SWIG_Python_UnpackTuple(args,"new_InternetFSHandler",0,0,0)) SWIG_fail;
10893 {
10894 PyThreadState* __tstate = wxPyBeginAllowThreads();
10895 result = (wxInternetFSHandler *)new wxInternetFSHandler();
10896 wxPyEndAllowThreads(__tstate);
10897 if (PyErr_Occurred()) SWIG_fail;
10898 }
10899 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_NEW | 0 );
10900 return resultobj;
10901 fail:
10902 return NULL;
10903 }
10904
10905
10906 SWIGINTERN PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10907 PyObject *resultobj = 0;
10908 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
10909 wxString *arg2 = 0 ;
10910 bool result;
10911 void *argp1 = 0 ;
10912 int res1 = 0 ;
10913 bool temp2 = false ;
10914 PyObject * obj0 = 0 ;
10915 PyObject * obj1 = 0 ;
10916 char * kwnames[] = {
10917 (char *) "self",(char *) "location", NULL
10918 };
10919
10920 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
10921 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
10922 if (!SWIG_IsOK(res1)) {
10923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
10924 }
10925 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
10926 {
10927 arg2 = wxString_in_helper(obj1);
10928 if (arg2 == NULL) SWIG_fail;
10929 temp2 = true;
10930 }
10931 {
10932 PyThreadState* __tstate = wxPyBeginAllowThreads();
10933 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
10934 wxPyEndAllowThreads(__tstate);
10935 if (PyErr_Occurred()) SWIG_fail;
10936 }
10937 {
10938 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10939 }
10940 {
10941 if (temp2)
10942 delete arg2;
10943 }
10944 return resultobj;
10945 fail:
10946 {
10947 if (temp2)
10948 delete arg2;
10949 }
10950 return NULL;
10951 }
10952
10953
10954 SWIGINTERN PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10955 PyObject *resultobj = 0;
10956 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
10957 wxFileSystem *arg2 = 0 ;
10958 wxString *arg3 = 0 ;
10959 wxFSFile *result = 0 ;
10960 void *argp1 = 0 ;
10961 int res1 = 0 ;
10962 void *argp2 = 0 ;
10963 int res2 = 0 ;
10964 bool temp3 = false ;
10965 PyObject * obj0 = 0 ;
10966 PyObject * obj1 = 0 ;
10967 PyObject * obj2 = 0 ;
10968 char * kwnames[] = {
10969 (char *) "self",(char *) "fs",(char *) "location", NULL
10970 };
10971
10972 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10973 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
10974 if (!SWIG_IsOK(res1)) {
10975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
10976 }
10977 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
10978 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
10979 if (!SWIG_IsOK(res2)) {
10980 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10981 }
10982 if (!argp2) {
10983 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10984 }
10985 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
10986 {
10987 arg3 = wxString_in_helper(obj2);
10988 if (arg3 == NULL) SWIG_fail;
10989 temp3 = true;
10990 }
10991 {
10992 PyThreadState* __tstate = wxPyBeginAllowThreads();
10993 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
10994 wxPyEndAllowThreads(__tstate);
10995 if (PyErr_Occurred()) SWIG_fail;
10996 }
10997 {
10998 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
10999 }
11000 {
11001 if (temp3)
11002 delete arg3;
11003 }
11004 return resultobj;
11005 fail:
11006 {
11007 if (temp3)
11008 delete arg3;
11009 }
11010 return NULL;
11011 }
11012
11013
11014 SWIGINTERN PyObject *InternetFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11015 PyObject *obj;
11016 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11017 SWIG_TypeNewClientData(SWIGTYPE_p_wxInternetFSHandler, SWIG_NewClientData(obj));
11018 return SWIG_Py_Void();
11019 }
11020
11021 SWIGINTERN PyObject *InternetFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11022 return SWIG_Python_InitShadowInstance(args);
11023 }
11024
11025 SWIGINTERN PyObject *_wrap_new_ZipFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11026 PyObject *resultobj = 0;
11027 wxZipFSHandler *result = 0 ;
11028
11029 if (!SWIG_Python_UnpackTuple(args,"new_ZipFSHandler",0,0,0)) SWIG_fail;
11030 {
11031 PyThreadState* __tstate = wxPyBeginAllowThreads();
11032 result = (wxZipFSHandler *)new wxZipFSHandler();
11033 wxPyEndAllowThreads(__tstate);
11034 if (PyErr_Occurred()) SWIG_fail;
11035 }
11036 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_NEW | 0 );
11037 return resultobj;
11038 fail:
11039 return NULL;
11040 }
11041
11042
11043 SWIGINTERN PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11044 PyObject *resultobj = 0;
11045 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11046 wxString *arg2 = 0 ;
11047 bool result;
11048 void *argp1 = 0 ;
11049 int res1 = 0 ;
11050 bool temp2 = false ;
11051 PyObject * obj0 = 0 ;
11052 PyObject * obj1 = 0 ;
11053 char * kwnames[] = {
11054 (char *) "self",(char *) "location", NULL
11055 };
11056
11057 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11058 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11059 if (!SWIG_IsOK(res1)) {
11060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11061 }
11062 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11063 {
11064 arg2 = wxString_in_helper(obj1);
11065 if (arg2 == NULL) SWIG_fail;
11066 temp2 = true;
11067 }
11068 {
11069 PyThreadState* __tstate = wxPyBeginAllowThreads();
11070 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11071 wxPyEndAllowThreads(__tstate);
11072 if (PyErr_Occurred()) SWIG_fail;
11073 }
11074 {
11075 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11076 }
11077 {
11078 if (temp2)
11079 delete arg2;
11080 }
11081 return resultobj;
11082 fail:
11083 {
11084 if (temp2)
11085 delete arg2;
11086 }
11087 return NULL;
11088 }
11089
11090
11091 SWIGINTERN PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11092 PyObject *resultobj = 0;
11093 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11094 wxFileSystem *arg2 = 0 ;
11095 wxString *arg3 = 0 ;
11096 wxFSFile *result = 0 ;
11097 void *argp1 = 0 ;
11098 int res1 = 0 ;
11099 void *argp2 = 0 ;
11100 int res2 = 0 ;
11101 bool temp3 = false ;
11102 PyObject * obj0 = 0 ;
11103 PyObject * obj1 = 0 ;
11104 PyObject * obj2 = 0 ;
11105 char * kwnames[] = {
11106 (char *) "self",(char *) "fs",(char *) "location", NULL
11107 };
11108
11109 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11110 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11111 if (!SWIG_IsOK(res1)) {
11112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11113 }
11114 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11115 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11116 if (!SWIG_IsOK(res2)) {
11117 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11118 }
11119 if (!argp2) {
11120 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11121 }
11122 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11123 {
11124 arg3 = wxString_in_helper(obj2);
11125 if (arg3 == NULL) SWIG_fail;
11126 temp3 = true;
11127 }
11128 {
11129 PyThreadState* __tstate = wxPyBeginAllowThreads();
11130 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11131 wxPyEndAllowThreads(__tstate);
11132 if (PyErr_Occurred()) SWIG_fail;
11133 }
11134 {
11135 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
11136 }
11137 {
11138 if (temp3)
11139 delete arg3;
11140 }
11141 return resultobj;
11142 fail:
11143 {
11144 if (temp3)
11145 delete arg3;
11146 }
11147 return NULL;
11148 }
11149
11150
11151 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11152 PyObject *resultobj = 0;
11153 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11154 wxString *arg2 = 0 ;
11155 int arg3 = (int) 0 ;
11156 wxString result;
11157 void *argp1 = 0 ;
11158 int res1 = 0 ;
11159 bool temp2 = false ;
11160 int val3 ;
11161 int ecode3 = 0 ;
11162 PyObject * obj0 = 0 ;
11163 PyObject * obj1 = 0 ;
11164 PyObject * obj2 = 0 ;
11165 char * kwnames[] = {
11166 (char *) "self",(char *) "spec",(char *) "flags", NULL
11167 };
11168
11169 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11170 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11171 if (!SWIG_IsOK(res1)) {
11172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11173 }
11174 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11175 {
11176 arg2 = wxString_in_helper(obj1);
11177 if (arg2 == NULL) SWIG_fail;
11178 temp2 = true;
11179 }
11180 if (obj2) {
11181 ecode3 = SWIG_AsVal_int(obj2, &val3);
11182 if (!SWIG_IsOK(ecode3)) {
11183 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11184 }
11185 arg3 = static_cast< int >(val3);
11186 }
11187 {
11188 PyThreadState* __tstate = wxPyBeginAllowThreads();
11189 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11190 wxPyEndAllowThreads(__tstate);
11191 if (PyErr_Occurred()) SWIG_fail;
11192 }
11193 {
11194 #if wxUSE_UNICODE
11195 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11196 #else
11197 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11198 #endif
11199 }
11200 {
11201 if (temp2)
11202 delete arg2;
11203 }
11204 return resultobj;
11205 fail:
11206 {
11207 if (temp2)
11208 delete arg2;
11209 }
11210 return NULL;
11211 }
11212
11213
11214 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11215 PyObject *resultobj = 0;
11216 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11217 wxString result;
11218 void *argp1 = 0 ;
11219 int res1 = 0 ;
11220 PyObject *swig_obj[1] ;
11221
11222 if (!args) SWIG_fail;
11223 swig_obj[0] = args;
11224 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11225 if (!SWIG_IsOK(res1)) {
11226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindNext" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11227 }
11228 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11229 {
11230 PyThreadState* __tstate = wxPyBeginAllowThreads();
11231 result = (arg1)->FindNext();
11232 wxPyEndAllowThreads(__tstate);
11233 if (PyErr_Occurred()) SWIG_fail;
11234 }
11235 {
11236 #if wxUSE_UNICODE
11237 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11238 #else
11239 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11240 #endif
11241 }
11242 return resultobj;
11243 fail:
11244 return NULL;
11245 }
11246
11247
11248 SWIGINTERN PyObject *ZipFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11249 PyObject *obj;
11250 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11251 SWIG_TypeNewClientData(SWIGTYPE_p_wxZipFSHandler, SWIG_NewClientData(obj));
11252 return SWIG_Py_Void();
11253 }
11254
11255 SWIGINTERN PyObject *ZipFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11256 return SWIG_Python_InitShadowInstance(args);
11257 }
11258
11259 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11260 PyObject *resultobj = 0;
11261 wxString *arg1 = 0 ;
11262 wxImage *arg2 = 0 ;
11263 long arg3 ;
11264 bool temp1 = false ;
11265 void *argp2 = 0 ;
11266 int res2 = 0 ;
11267 long val3 ;
11268 int ecode3 = 0 ;
11269 PyObject * obj0 = 0 ;
11270 PyObject * obj1 = 0 ;
11271 PyObject * obj2 = 0 ;
11272 char * kwnames[] = {
11273 (char *) "filename",(char *) "image",(char *) "type", NULL
11274 };
11275
11276 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11277 {
11278 arg1 = wxString_in_helper(obj0);
11279 if (arg1 == NULL) SWIG_fail;
11280 temp1 = true;
11281 }
11282 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
11283 if (!SWIG_IsOK(res2)) {
11284 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11285 }
11286 if (!argp2) {
11287 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11288 }
11289 arg2 = reinterpret_cast< wxImage * >(argp2);
11290 ecode3 = SWIG_AsVal_long(obj2, &val3);
11291 if (!SWIG_IsOK(ecode3)) {
11292 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "3"" of type '" "long""'");
11293 }
11294 arg3 = static_cast< long >(val3);
11295 {
11296 PyThreadState* __tstate = wxPyBeginAllowThreads();
11297 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
11298 wxPyEndAllowThreads(__tstate);
11299 if (PyErr_Occurred()) SWIG_fail;
11300 }
11301 resultobj = SWIG_Py_Void();
11302 {
11303 if (temp1)
11304 delete arg1;
11305 }
11306 return resultobj;
11307 fail:
11308 {
11309 if (temp1)
11310 delete arg1;
11311 }
11312 return NULL;
11313 }
11314
11315
11316 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11317 PyObject *resultobj = 0;
11318 wxString *arg1 = 0 ;
11319 wxBitmap *arg2 = 0 ;
11320 long arg3 ;
11321 bool temp1 = false ;
11322 void *argp2 = 0 ;
11323 int res2 = 0 ;
11324 long val3 ;
11325 int ecode3 = 0 ;
11326 PyObject * obj0 = 0 ;
11327 PyObject * obj1 = 0 ;
11328 PyObject * obj2 = 0 ;
11329 char * kwnames[] = {
11330 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
11331 };
11332
11333 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11334 {
11335 arg1 = wxString_in_helper(obj0);
11336 if (arg1 == NULL) SWIG_fail;
11337 temp1 = true;
11338 }
11339 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
11340 if (!SWIG_IsOK(res2)) {
11341 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11342 }
11343 if (!argp2) {
11344 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11345 }
11346 arg2 = reinterpret_cast< wxBitmap * >(argp2);
11347 ecode3 = SWIG_AsVal_long(obj2, &val3);
11348 if (!SWIG_IsOK(ecode3)) {
11349 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "3"" of type '" "long""'");
11350 }
11351 arg3 = static_cast< long >(val3);
11352 {
11353 PyThreadState* __tstate = wxPyBeginAllowThreads();
11354 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
11355 wxPyEndAllowThreads(__tstate);
11356 if (PyErr_Occurred()) SWIG_fail;
11357 }
11358 resultobj = SWIG_Py_Void();
11359 {
11360 if (temp1)
11361 delete arg1;
11362 }
11363 return resultobj;
11364 fail:
11365 {
11366 if (temp1)
11367 delete arg1;
11368 }
11369 return NULL;
11370 }
11371
11372
11373 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11374 PyObject *resultobj = 0;
11375 wxString *arg1 = 0 ;
11376 PyObject *arg2 = (PyObject *) 0 ;
11377 bool temp1 = false ;
11378 PyObject * obj0 = 0 ;
11379 PyObject * obj1 = 0 ;
11380 char * kwnames[] = {
11381 (char *) "filename",(char *) "data", NULL
11382 };
11383
11384 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) SWIG_fail;
11385 {
11386 arg1 = wxString_in_helper(obj0);
11387 if (arg1 == NULL) SWIG_fail;
11388 temp1 = true;
11389 }
11390 arg2 = obj1;
11391 {
11392 PyThreadState* __tstate = wxPyBeginAllowThreads();
11393 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
11394 wxPyEndAllowThreads(__tstate);
11395 if (PyErr_Occurred()) SWIG_fail;
11396 }
11397 resultobj = SWIG_Py_Void();
11398 {
11399 if (temp1)
11400 delete arg1;
11401 }
11402 return resultobj;
11403 fail:
11404 {
11405 if (temp1)
11406 delete arg1;
11407 }
11408 return NULL;
11409 }
11410
11411
11412 SWIGINTERN PyObject *_wrap_new_MemoryFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11413 PyObject *resultobj = 0;
11414 wxMemoryFSHandler *result = 0 ;
11415
11416 if (!SWIG_Python_UnpackTuple(args,"new_MemoryFSHandler",0,0,0)) SWIG_fail;
11417 {
11418 PyThreadState* __tstate = wxPyBeginAllowThreads();
11419 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
11420 wxPyEndAllowThreads(__tstate);
11421 if (PyErr_Occurred()) SWIG_fail;
11422 }
11423 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_NEW | 0 );
11424 return resultobj;
11425 fail:
11426 return NULL;
11427 }
11428
11429
11430 SWIGINTERN PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11431 PyObject *resultobj = 0;
11432 wxString *arg1 = 0 ;
11433 bool temp1 = false ;
11434 PyObject * obj0 = 0 ;
11435 char * kwnames[] = {
11436 (char *) "filename", NULL
11437 };
11438
11439 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) SWIG_fail;
11440 {
11441 arg1 = wxString_in_helper(obj0);
11442 if (arg1 == NULL) SWIG_fail;
11443 temp1 = true;
11444 }
11445 {
11446 PyThreadState* __tstate = wxPyBeginAllowThreads();
11447 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
11448 wxPyEndAllowThreads(__tstate);
11449 if (PyErr_Occurred()) SWIG_fail;
11450 }
11451 resultobj = SWIG_Py_Void();
11452 {
11453 if (temp1)
11454 delete arg1;
11455 }
11456 return resultobj;
11457 fail:
11458 {
11459 if (temp1)
11460 delete arg1;
11461 }
11462 return NULL;
11463 }
11464
11465
11466 SWIGINTERN PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11467 PyObject *resultobj = 0;
11468 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11469 wxString *arg2 = 0 ;
11470 bool result;
11471 void *argp1 = 0 ;
11472 int res1 = 0 ;
11473 bool temp2 = false ;
11474 PyObject * obj0 = 0 ;
11475 PyObject * obj1 = 0 ;
11476 char * kwnames[] = {
11477 (char *) "self",(char *) "location", NULL
11478 };
11479
11480 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11481 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11482 if (!SWIG_IsOK(res1)) {
11483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11484 }
11485 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11486 {
11487 arg2 = wxString_in_helper(obj1);
11488 if (arg2 == NULL) SWIG_fail;
11489 temp2 = true;
11490 }
11491 {
11492 PyThreadState* __tstate = wxPyBeginAllowThreads();
11493 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11494 wxPyEndAllowThreads(__tstate);
11495 if (PyErr_Occurred()) SWIG_fail;
11496 }
11497 {
11498 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11499 }
11500 {
11501 if (temp2)
11502 delete arg2;
11503 }
11504 return resultobj;
11505 fail:
11506 {
11507 if (temp2)
11508 delete arg2;
11509 }
11510 return NULL;
11511 }
11512
11513
11514 SWIGINTERN PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11515 PyObject *resultobj = 0;
11516 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11517 wxFileSystem *arg2 = 0 ;
11518 wxString *arg3 = 0 ;
11519 wxFSFile *result = 0 ;
11520 void *argp1 = 0 ;
11521 int res1 = 0 ;
11522 void *argp2 = 0 ;
11523 int res2 = 0 ;
11524 bool temp3 = false ;
11525 PyObject * obj0 = 0 ;
11526 PyObject * obj1 = 0 ;
11527 PyObject * obj2 = 0 ;
11528 char * kwnames[] = {
11529 (char *) "self",(char *) "fs",(char *) "location", NULL
11530 };
11531
11532 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11533 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11534 if (!SWIG_IsOK(res1)) {
11535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11536 }
11537 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11538 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11539 if (!SWIG_IsOK(res2)) {
11540 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11541 }
11542 if (!argp2) {
11543 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11544 }
11545 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11546 {
11547 arg3 = wxString_in_helper(obj2);
11548 if (arg3 == NULL) SWIG_fail;
11549 temp3 = true;
11550 }
11551 {
11552 PyThreadState* __tstate = wxPyBeginAllowThreads();
11553 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11554 wxPyEndAllowThreads(__tstate);
11555 if (PyErr_Occurred()) SWIG_fail;
11556 }
11557 {
11558 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
11559 }
11560 {
11561 if (temp3)
11562 delete arg3;
11563 }
11564 return resultobj;
11565 fail:
11566 {
11567 if (temp3)
11568 delete arg3;
11569 }
11570 return NULL;
11571 }
11572
11573
11574 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11575 PyObject *resultobj = 0;
11576 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11577 wxString *arg2 = 0 ;
11578 int arg3 = (int) 0 ;
11579 wxString result;
11580 void *argp1 = 0 ;
11581 int res1 = 0 ;
11582 bool temp2 = false ;
11583 int val3 ;
11584 int ecode3 = 0 ;
11585 PyObject * obj0 = 0 ;
11586 PyObject * obj1 = 0 ;
11587 PyObject * obj2 = 0 ;
11588 char * kwnames[] = {
11589 (char *) "self",(char *) "spec",(char *) "flags", NULL
11590 };
11591
11592 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11593 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11594 if (!SWIG_IsOK(res1)) {
11595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11596 }
11597 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11598 {
11599 arg2 = wxString_in_helper(obj1);
11600 if (arg2 == NULL) SWIG_fail;
11601 temp2 = true;
11602 }
11603 if (obj2) {
11604 ecode3 = SWIG_AsVal_int(obj2, &val3);
11605 if (!SWIG_IsOK(ecode3)) {
11606 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11607 }
11608 arg3 = static_cast< int >(val3);
11609 }
11610 {
11611 PyThreadState* __tstate = wxPyBeginAllowThreads();
11612 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11613 wxPyEndAllowThreads(__tstate);
11614 if (PyErr_Occurred()) SWIG_fail;
11615 }
11616 {
11617 #if wxUSE_UNICODE
11618 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11619 #else
11620 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11621 #endif
11622 }
11623 {
11624 if (temp2)
11625 delete arg2;
11626 }
11627 return resultobj;
11628 fail:
11629 {
11630 if (temp2)
11631 delete arg2;
11632 }
11633 return NULL;
11634 }
11635
11636
11637 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11638 PyObject *resultobj = 0;
11639 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11640 wxString result;
11641 void *argp1 = 0 ;
11642 int res1 = 0 ;
11643 PyObject *swig_obj[1] ;
11644
11645 if (!args) SWIG_fail;
11646 swig_obj[0] = args;
11647 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11648 if (!SWIG_IsOK(res1)) {
11649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindNext" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11650 }
11651 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11652 {
11653 PyThreadState* __tstate = wxPyBeginAllowThreads();
11654 result = (arg1)->FindNext();
11655 wxPyEndAllowThreads(__tstate);
11656 if (PyErr_Occurred()) SWIG_fail;
11657 }
11658 {
11659 #if wxUSE_UNICODE
11660 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11661 #else
11662 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11663 #endif
11664 }
11665 return resultobj;
11666 fail:
11667 return NULL;
11668 }
11669
11670
11671 SWIGINTERN PyObject *MemoryFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11672 PyObject *obj;
11673 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11674 SWIG_TypeNewClientData(SWIGTYPE_p_wxMemoryFSHandler, SWIG_NewClientData(obj));
11675 return SWIG_Py_Void();
11676 }
11677
11678 SWIGINTERN PyObject *MemoryFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11679 return SWIG_Python_InitShadowInstance(args);
11680 }
11681
11682 SWIGINTERN PyObject *_wrap_ImageHandler_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11683 PyObject *resultobj = 0;
11684 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11685 wxString result;
11686 void *argp1 = 0 ;
11687 int res1 = 0 ;
11688 PyObject *swig_obj[1] ;
11689
11690 if (!args) SWIG_fail;
11691 swig_obj[0] = args;
11692 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11693 if (!SWIG_IsOK(res1)) {
11694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11695 }
11696 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11697 {
11698 PyThreadState* __tstate = wxPyBeginAllowThreads();
11699 result = (arg1)->GetName();
11700 wxPyEndAllowThreads(__tstate);
11701 if (PyErr_Occurred()) SWIG_fail;
11702 }
11703 {
11704 #if wxUSE_UNICODE
11705 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11706 #else
11707 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11708 #endif
11709 }
11710 return resultobj;
11711 fail:
11712 return NULL;
11713 }
11714
11715
11716 SWIGINTERN PyObject *_wrap_ImageHandler_GetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11717 PyObject *resultobj = 0;
11718 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11719 wxString result;
11720 void *argp1 = 0 ;
11721 int res1 = 0 ;
11722 PyObject *swig_obj[1] ;
11723
11724 if (!args) SWIG_fail;
11725 swig_obj[0] = args;
11726 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11727 if (!SWIG_IsOK(res1)) {
11728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11729 }
11730 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11731 {
11732 PyThreadState* __tstate = wxPyBeginAllowThreads();
11733 result = (arg1)->GetExtension();
11734 wxPyEndAllowThreads(__tstate);
11735 if (PyErr_Occurred()) SWIG_fail;
11736 }
11737 {
11738 #if wxUSE_UNICODE
11739 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11740 #else
11741 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11742 #endif
11743 }
11744 return resultobj;
11745 fail:
11746 return NULL;
11747 }
11748
11749
11750 SWIGINTERN PyObject *_wrap_ImageHandler_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11751 PyObject *resultobj = 0;
11752 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11753 long result;
11754 void *argp1 = 0 ;
11755 int res1 = 0 ;
11756 PyObject *swig_obj[1] ;
11757
11758 if (!args) SWIG_fail;
11759 swig_obj[0] = args;
11760 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11761 if (!SWIG_IsOK(res1)) {
11762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11763 }
11764 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11765 {
11766 PyThreadState* __tstate = wxPyBeginAllowThreads();
11767 result = (long)(arg1)->GetType();
11768 wxPyEndAllowThreads(__tstate);
11769 if (PyErr_Occurred()) SWIG_fail;
11770 }
11771 resultobj = SWIG_From_long(static_cast< long >(result));
11772 return resultobj;
11773 fail:
11774 return NULL;
11775 }
11776
11777
11778 SWIGINTERN PyObject *_wrap_ImageHandler_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11779 PyObject *resultobj = 0;
11780 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11781 wxString result;
11782 void *argp1 = 0 ;
11783 int res1 = 0 ;
11784 PyObject *swig_obj[1] ;
11785
11786 if (!args) SWIG_fail;
11787 swig_obj[0] = args;
11788 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11789 if (!SWIG_IsOK(res1)) {
11790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11791 }
11792 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11793 {
11794 PyThreadState* __tstate = wxPyBeginAllowThreads();
11795 result = (arg1)->GetMimeType();
11796 wxPyEndAllowThreads(__tstate);
11797 if (PyErr_Occurred()) SWIG_fail;
11798 }
11799 {
11800 #if wxUSE_UNICODE
11801 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11802 #else
11803 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11804 #endif
11805 }
11806 return resultobj;
11807 fail:
11808 return NULL;
11809 }
11810
11811
11812 SWIGINTERN PyObject *_wrap_ImageHandler_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11813 PyObject *resultobj = 0;
11814 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11815 wxString *arg2 = 0 ;
11816 bool result;
11817 void *argp1 = 0 ;
11818 int res1 = 0 ;
11819 bool temp2 = false ;
11820 PyObject * obj0 = 0 ;
11821 PyObject * obj1 = 0 ;
11822 char * kwnames[] = {
11823 (char *) "self",(char *) "name", NULL
11824 };
11825
11826 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) SWIG_fail;
11827 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11828 if (!SWIG_IsOK(res1)) {
11829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanRead" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11830 }
11831 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11832 {
11833 arg2 = wxString_in_helper(obj1);
11834 if (arg2 == NULL) SWIG_fail;
11835 temp2 = true;
11836 }
11837 {
11838 PyThreadState* __tstate = wxPyBeginAllowThreads();
11839 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
11840 wxPyEndAllowThreads(__tstate);
11841 if (PyErr_Occurred()) SWIG_fail;
11842 }
11843 {
11844 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11845 }
11846 {
11847 if (temp2)
11848 delete arg2;
11849 }
11850 return resultobj;
11851 fail:
11852 {
11853 if (temp2)
11854 delete arg2;
11855 }
11856 return NULL;
11857 }
11858
11859
11860 SWIGINTERN PyObject *_wrap_ImageHandler_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11861 PyObject *resultobj = 0;
11862 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11863 wxString *arg2 = 0 ;
11864 void *argp1 = 0 ;
11865 int res1 = 0 ;
11866 bool temp2 = false ;
11867 PyObject * obj0 = 0 ;
11868 PyObject * obj1 = 0 ;
11869 char * kwnames[] = {
11870 (char *) "self",(char *) "name", NULL
11871 };
11872
11873 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
11874 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11875 if (!SWIG_IsOK(res1)) {
11876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11877 }
11878 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11879 {
11880 arg2 = wxString_in_helper(obj1);
11881 if (arg2 == NULL) SWIG_fail;
11882 temp2 = true;
11883 }
11884 {
11885 PyThreadState* __tstate = wxPyBeginAllowThreads();
11886 (arg1)->SetName((wxString const &)*arg2);
11887 wxPyEndAllowThreads(__tstate);
11888 if (PyErr_Occurred()) SWIG_fail;
11889 }
11890 resultobj = SWIG_Py_Void();
11891 {
11892 if (temp2)
11893 delete arg2;
11894 }
11895 return resultobj;
11896 fail:
11897 {
11898 if (temp2)
11899 delete arg2;
11900 }
11901 return NULL;
11902 }
11903
11904
11905 SWIGINTERN PyObject *_wrap_ImageHandler_SetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11906 PyObject *resultobj = 0;
11907 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11908 wxString *arg2 = 0 ;
11909 void *argp1 = 0 ;
11910 int res1 = 0 ;
11911 bool temp2 = false ;
11912 PyObject * obj0 = 0 ;
11913 PyObject * obj1 = 0 ;
11914 char * kwnames[] = {
11915 (char *) "self",(char *) "extension", NULL
11916 };
11917
11918 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) SWIG_fail;
11919 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11920 if (!SWIG_IsOK(res1)) {
11921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11922 }
11923 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11924 {
11925 arg2 = wxString_in_helper(obj1);
11926 if (arg2 == NULL) SWIG_fail;
11927 temp2 = true;
11928 }
11929 {
11930 PyThreadState* __tstate = wxPyBeginAllowThreads();
11931 (arg1)->SetExtension((wxString const &)*arg2);
11932 wxPyEndAllowThreads(__tstate);
11933 if (PyErr_Occurred()) SWIG_fail;
11934 }
11935 resultobj = SWIG_Py_Void();
11936 {
11937 if (temp2)
11938 delete arg2;
11939 }
11940 return resultobj;
11941 fail:
11942 {
11943 if (temp2)
11944 delete arg2;
11945 }
11946 return NULL;
11947 }
11948
11949
11950 SWIGINTERN PyObject *_wrap_ImageHandler_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11951 PyObject *resultobj = 0;
11952 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11953 long arg2 ;
11954 void *argp1 = 0 ;
11955 int res1 = 0 ;
11956 long val2 ;
11957 int ecode2 = 0 ;
11958 PyObject * obj0 = 0 ;
11959 PyObject * obj1 = 0 ;
11960 char * kwnames[] = {
11961 (char *) "self",(char *) "type", NULL
11962 };
11963
11964 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
11965 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11966 if (!SWIG_IsOK(res1)) {
11967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11968 }
11969 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11970 ecode2 = SWIG_AsVal_long(obj1, &val2);
11971 if (!SWIG_IsOK(ecode2)) {
11972 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHandler_SetType" "', expected argument " "2"" of type '" "long""'");
11973 }
11974 arg2 = static_cast< long >(val2);
11975 {
11976 PyThreadState* __tstate = wxPyBeginAllowThreads();
11977 (arg1)->SetType(arg2);
11978 wxPyEndAllowThreads(__tstate);
11979 if (PyErr_Occurred()) SWIG_fail;
11980 }
11981 resultobj = SWIG_Py_Void();
11982 return resultobj;
11983 fail:
11984 return NULL;
11985 }
11986
11987
11988 SWIGINTERN PyObject *_wrap_ImageHandler_SetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11989 PyObject *resultobj = 0;
11990 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11991 wxString *arg2 = 0 ;
11992 void *argp1 = 0 ;
11993 int res1 = 0 ;
11994 bool temp2 = false ;
11995 PyObject * obj0 = 0 ;
11996 PyObject * obj1 = 0 ;
11997 char * kwnames[] = {
11998 (char *) "self",(char *) "mimetype", NULL
11999 };
12000
12001 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
12002 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12003 if (!SWIG_IsOK(res1)) {
12004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12005 }
12006 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12007 {
12008 arg2 = wxString_in_helper(obj1);
12009 if (arg2 == NULL) SWIG_fail;
12010 temp2 = true;
12011 }
12012 {
12013 PyThreadState* __tstate = wxPyBeginAllowThreads();
12014 (arg1)->SetMimeType((wxString const &)*arg2);
12015 wxPyEndAllowThreads(__tstate);
12016 if (PyErr_Occurred()) SWIG_fail;
12017 }
12018 resultobj = SWIG_Py_Void();
12019 {
12020 if (temp2)
12021 delete arg2;
12022 }
12023 return resultobj;
12024 fail:
12025 {
12026 if (temp2)
12027 delete arg2;
12028 }
12029 return NULL;
12030 }
12031
12032
12033 SWIGINTERN PyObject *ImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12034 PyObject *obj;
12035 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12036 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHandler, SWIG_NewClientData(obj));
12037 return SWIG_Py_Void();
12038 }
12039
12040 SWIGINTERN PyObject *_wrap_new_PyImageHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12041 PyObject *resultobj = 0;
12042 wxPyImageHandler *result = 0 ;
12043
12044 if (!SWIG_Python_UnpackTuple(args,"new_PyImageHandler",0,0,0)) SWIG_fail;
12045 {
12046 PyThreadState* __tstate = wxPyBeginAllowThreads();
12047 result = (wxPyImageHandler *)new wxPyImageHandler();
12048 wxPyEndAllowThreads(__tstate);
12049 if (PyErr_Occurred()) SWIG_fail;
12050 }
12051 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyImageHandler, SWIG_POINTER_NEW | 0 );
12052 return resultobj;
12053 fail:
12054 return NULL;
12055 }
12056
12057
12058 SWIGINTERN PyObject *_wrap_PyImageHandler__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12059 PyObject *resultobj = 0;
12060 wxPyImageHandler *arg1 = (wxPyImageHandler *) 0 ;
12061 PyObject *arg2 = (PyObject *) 0 ;
12062 void *argp1 = 0 ;
12063 int res1 = 0 ;
12064 PyObject * obj0 = 0 ;
12065 PyObject * obj1 = 0 ;
12066 char * kwnames[] = {
12067 (char *) "self",(char *) "self", NULL
12068 };
12069
12070 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyImageHandler__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
12071 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyImageHandler, 0 | 0 );
12072 if (!SWIG_IsOK(res1)) {
12073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyImageHandler__SetSelf" "', expected argument " "1"" of type '" "wxPyImageHandler *""'");
12074 }
12075 arg1 = reinterpret_cast< wxPyImageHandler * >(argp1);
12076 arg2 = obj1;
12077 {
12078 PyThreadState* __tstate = wxPyBeginAllowThreads();
12079 (arg1)->_SetSelf(arg2);
12080 wxPyEndAllowThreads(__tstate);
12081 if (PyErr_Occurred()) SWIG_fail;
12082 }
12083 resultobj = SWIG_Py_Void();
12084 return resultobj;
12085 fail:
12086 return NULL;
12087 }
12088
12089
12090 SWIGINTERN PyObject *PyImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12091 PyObject *obj;
12092 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12093 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyImageHandler, SWIG_NewClientData(obj));
12094 return SWIG_Py_Void();
12095 }
12096
12097 SWIGINTERN PyObject *PyImageHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12098 return SWIG_Python_InitShadowInstance(args);
12099 }
12100
12101 SWIGINTERN PyObject *_wrap_new_ImageHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12102 PyObject *resultobj = 0;
12103 wxImageHistogram *result = 0 ;
12104
12105 if (!SWIG_Python_UnpackTuple(args,"new_ImageHistogram",0,0,0)) SWIG_fail;
12106 {
12107 PyThreadState* __tstate = wxPyBeginAllowThreads();
12108 result = (wxImageHistogram *)new wxImageHistogram();
12109 wxPyEndAllowThreads(__tstate);
12110 if (PyErr_Occurred()) SWIG_fail;
12111 }
12112 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_NEW | 0 );
12113 return resultobj;
12114 fail:
12115 return NULL;
12116 }
12117
12118
12119 SWIGINTERN PyObject *_wrap_ImageHistogram_MakeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12120 PyObject *resultobj = 0;
12121 byte arg1 ;
12122 byte arg2 ;
12123 byte arg3 ;
12124 unsigned long result;
12125 unsigned char val1 ;
12126 int ecode1 = 0 ;
12127 unsigned char val2 ;
12128 int ecode2 = 0 ;
12129 unsigned char val3 ;
12130 int ecode3 = 0 ;
12131 PyObject * obj0 = 0 ;
12132 PyObject * obj1 = 0 ;
12133 PyObject * obj2 = 0 ;
12134 char * kwnames[] = {
12135 (char *) "r",(char *) "g",(char *) "b", NULL
12136 };
12137
12138 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12139 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12140 if (!SWIG_IsOK(ecode1)) {
12141 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ImageHistogram_MakeKey" "', expected argument " "1"" of type '" "byte""'");
12142 }
12143 arg1 = static_cast< byte >(val1);
12144 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12145 if (!SWIG_IsOK(ecode2)) {
12146 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_MakeKey" "', expected argument " "2"" of type '" "byte""'");
12147 }
12148 arg2 = static_cast< byte >(val2);
12149 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12150 if (!SWIG_IsOK(ecode3)) {
12151 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_MakeKey" "', expected argument " "3"" of type '" "byte""'");
12152 }
12153 arg3 = static_cast< byte >(val3);
12154 {
12155 PyThreadState* __tstate = wxPyBeginAllowThreads();
12156 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
12157 wxPyEndAllowThreads(__tstate);
12158 if (PyErr_Occurred()) SWIG_fail;
12159 }
12160 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12161 return resultobj;
12162 fail:
12163 return NULL;
12164 }
12165
12166
12167 SWIGINTERN PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12168 PyObject *resultobj = 0;
12169 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12170 byte *arg2 = (byte *) 0 ;
12171 byte *arg3 = (byte *) 0 ;
12172 byte *arg4 = (byte *) 0 ;
12173 byte arg5 = (byte) 1 ;
12174 byte arg6 = (byte) 0 ;
12175 byte arg7 = (byte) 0 ;
12176 bool result;
12177 void *argp1 = 0 ;
12178 int res1 = 0 ;
12179 byte temp2 ;
12180 int res2 = SWIG_TMPOBJ ;
12181 byte temp3 ;
12182 int res3 = SWIG_TMPOBJ ;
12183 byte temp4 ;
12184 int res4 = SWIG_TMPOBJ ;
12185 unsigned char val5 ;
12186 int ecode5 = 0 ;
12187 unsigned char val6 ;
12188 int ecode6 = 0 ;
12189 unsigned char val7 ;
12190 int ecode7 = 0 ;
12191 PyObject * obj0 = 0 ;
12192 PyObject * obj1 = 0 ;
12193 PyObject * obj2 = 0 ;
12194 PyObject * obj3 = 0 ;
12195 char * kwnames[] = {
12196 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
12197 };
12198
12199 arg2 = &temp2;
12200 arg3 = &temp3;
12201 arg4 = &temp4;
12202 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12203 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12204 if (!SWIG_IsOK(res1)) {
12205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImageHistogram const *""'");
12206 }
12207 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12208 if (obj1) {
12209 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
12210 if (!SWIG_IsOK(ecode5)) {
12211 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
12212 }
12213 arg5 = static_cast< byte >(val5);
12214 }
12215 if (obj2) {
12216 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
12217 if (!SWIG_IsOK(ecode6)) {
12218 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
12219 }
12220 arg6 = static_cast< byte >(val6);
12221 }
12222 if (obj3) {
12223 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
12224 if (!SWIG_IsOK(ecode7)) {
12225 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
12226 }
12227 arg7 = static_cast< byte >(val7);
12228 }
12229 {
12230 PyThreadState* __tstate = wxPyBeginAllowThreads();
12231 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
12232 wxPyEndAllowThreads(__tstate);
12233 if (PyErr_Occurred()) SWIG_fail;
12234 }
12235 {
12236 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12237 }
12238 if (SWIG_IsTmpObj(res2)) {
12239 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
12240 } else {
12241 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12242 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
12243 }
12244 if (SWIG_IsTmpObj(res3)) {
12245 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
12246 } else {
12247 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12248 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
12249 }
12250 if (SWIG_IsTmpObj(res4)) {
12251 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
12252 } else {
12253 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12254 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
12255 }
12256 return resultobj;
12257 fail:
12258 return NULL;
12259 }
12260
12261
12262 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12263 PyObject *resultobj = 0;
12264 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12265 unsigned long arg2 ;
12266 unsigned long result;
12267 void *argp1 = 0 ;
12268 int res1 = 0 ;
12269 unsigned long val2 ;
12270 int ecode2 = 0 ;
12271 PyObject * obj0 = 0 ;
12272 PyObject * obj1 = 0 ;
12273 char * kwnames[] = {
12274 (char *) "self",(char *) "key", NULL
12275 };
12276
12277 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) SWIG_fail;
12278 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12279 if (!SWIG_IsOK(res1)) {
12280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCount" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12281 }
12282 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12283 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
12284 if (!SWIG_IsOK(ecode2)) {
12285 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCount" "', expected argument " "2"" of type '" "unsigned long""'");
12286 }
12287 arg2 = static_cast< unsigned long >(val2);
12288 {
12289 PyThreadState* __tstate = wxPyBeginAllowThreads();
12290 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
12291 wxPyEndAllowThreads(__tstate);
12292 if (PyErr_Occurred()) SWIG_fail;
12293 }
12294 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12295 return resultobj;
12296 fail:
12297 return NULL;
12298 }
12299
12300
12301 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12302 PyObject *resultobj = 0;
12303 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12304 byte arg2 ;
12305 byte arg3 ;
12306 byte arg4 ;
12307 unsigned long result;
12308 void *argp1 = 0 ;
12309 int res1 = 0 ;
12310 unsigned char val2 ;
12311 int ecode2 = 0 ;
12312 unsigned char val3 ;
12313 int ecode3 = 0 ;
12314 unsigned char val4 ;
12315 int ecode4 = 0 ;
12316 PyObject * obj0 = 0 ;
12317 PyObject * obj1 = 0 ;
12318 PyObject * obj2 = 0 ;
12319 PyObject * obj3 = 0 ;
12320 char * kwnames[] = {
12321 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12322 };
12323
12324 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12325 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12326 if (!SWIG_IsOK(res1)) {
12327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12328 }
12329 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12330 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12331 if (!SWIG_IsOK(ecode2)) {
12332 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "2"" of type '" "byte""'");
12333 }
12334 arg2 = static_cast< byte >(val2);
12335 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12336 if (!SWIG_IsOK(ecode3)) {
12337 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "3"" of type '" "byte""'");
12338 }
12339 arg3 = static_cast< byte >(val3);
12340 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
12341 if (!SWIG_IsOK(ecode4)) {
12342 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "4"" of type '" "byte""'");
12343 }
12344 arg4 = static_cast< byte >(val4);
12345 {
12346 PyThreadState* __tstate = wxPyBeginAllowThreads();
12347 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
12348 wxPyEndAllowThreads(__tstate);
12349 if (PyErr_Occurred()) SWIG_fail;
12350 }
12351 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12352 return resultobj;
12353 fail:
12354 return NULL;
12355 }
12356
12357
12358 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12359 PyObject *resultobj = 0;
12360 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12361 wxColour *arg2 = 0 ;
12362 unsigned long result;
12363 void *argp1 = 0 ;
12364 int res1 = 0 ;
12365 wxColour temp2 ;
12366 PyObject * obj0 = 0 ;
12367 PyObject * obj1 = 0 ;
12368 char * kwnames[] = {
12369 (char *) "self",(char *) "colour", NULL
12370 };
12371
12372 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) SWIG_fail;
12373 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12374 if (!SWIG_IsOK(res1)) {
12375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountColour" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12376 }
12377 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12378 {
12379 arg2 = &temp2;
12380 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
12381 }
12382 {
12383 PyThreadState* __tstate = wxPyBeginAllowThreads();
12384 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
12385 wxPyEndAllowThreads(__tstate);
12386 if (PyErr_Occurred()) SWIG_fail;
12387 }
12388 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12389 return resultobj;
12390 fail:
12391 return NULL;
12392 }
12393
12394
12395 SWIGINTERN PyObject *ImageHistogram_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12396 PyObject *obj;
12397 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12398 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHistogram, SWIG_NewClientData(obj));
12399 return SWIG_Py_Void();
12400 }
12401
12402 SWIGINTERN PyObject *ImageHistogram_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12403 return SWIG_Python_InitShadowInstance(args);
12404 }
12405
12406 SWIGINTERN PyObject *_wrap_new_Image_RGBValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12407 PyObject *resultobj = 0;
12408 byte arg1 = (byte) 0 ;
12409 byte arg2 = (byte) 0 ;
12410 byte arg3 = (byte) 0 ;
12411 wxImage_RGBValue *result = 0 ;
12412 unsigned char val1 ;
12413 int ecode1 = 0 ;
12414 unsigned char val2 ;
12415 int ecode2 = 0 ;
12416 unsigned char val3 ;
12417 int ecode3 = 0 ;
12418 PyObject * obj0 = 0 ;
12419 PyObject * obj1 = 0 ;
12420 PyObject * obj2 = 0 ;
12421 char * kwnames[] = {
12422 (char *) "r",(char *) "g",(char *) "b", NULL
12423 };
12424
12425 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_RGBValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12426 if (obj0) {
12427 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12428 if (!SWIG_IsOK(ecode1)) {
12429 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_RGBValue" "', expected argument " "1"" of type '" "byte""'");
12430 }
12431 arg1 = static_cast< byte >(val1);
12432 }
12433 if (obj1) {
12434 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12435 if (!SWIG_IsOK(ecode2)) {
12436 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_RGBValue" "', expected argument " "2"" of type '" "byte""'");
12437 }
12438 arg2 = static_cast< byte >(val2);
12439 }
12440 if (obj2) {
12441 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12442 if (!SWIG_IsOK(ecode3)) {
12443 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_RGBValue" "', expected argument " "3"" of type '" "byte""'");
12444 }
12445 arg3 = static_cast< byte >(val3);
12446 }
12447 {
12448 PyThreadState* __tstate = wxPyBeginAllowThreads();
12449 result = (wxImage_RGBValue *)new wxImage_RGBValue(arg1,arg2,arg3);
12450 wxPyEndAllowThreads(__tstate);
12451 if (PyErr_Occurred()) SWIG_fail;
12452 }
12453 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_NEW | 0 );
12454 return resultobj;
12455 fail:
12456 return NULL;
12457 }
12458
12459
12460 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12461 PyObject *resultobj = 0;
12462 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12463 byte arg2 ;
12464 void *argp1 = 0 ;
12465 int res1 = 0 ;
12466 unsigned char val2 ;
12467 int ecode2 = 0 ;
12468 PyObject *swig_obj[2] ;
12469
12470 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_red_set",2,2,swig_obj)) SWIG_fail;
12471 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12472 if (!SWIG_IsOK(res1)) {
12473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12474 }
12475 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12476 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12477 if (!SWIG_IsOK(ecode2)) {
12478 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_red_set" "', expected argument " "2"" of type '" "byte""'");
12479 }
12480 arg2 = static_cast< byte >(val2);
12481 if (arg1) (arg1)->red = arg2;
12482
12483 resultobj = SWIG_Py_Void();
12484 return resultobj;
12485 fail:
12486 return NULL;
12487 }
12488
12489
12490 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12491 PyObject *resultobj = 0;
12492 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12493 byte result;
12494 void *argp1 = 0 ;
12495 int res1 = 0 ;
12496 PyObject *swig_obj[1] ;
12497
12498 if (!args) SWIG_fail;
12499 swig_obj[0] = args;
12500 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12501 if (!SWIG_IsOK(res1)) {
12502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12503 }
12504 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12505 result = (byte) ((arg1)->red);
12506 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12507 return resultobj;
12508 fail:
12509 return NULL;
12510 }
12511
12512
12513 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12514 PyObject *resultobj = 0;
12515 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12516 byte arg2 ;
12517 void *argp1 = 0 ;
12518 int res1 = 0 ;
12519 unsigned char val2 ;
12520 int ecode2 = 0 ;
12521 PyObject *swig_obj[2] ;
12522
12523 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_green_set",2,2,swig_obj)) SWIG_fail;
12524 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12525 if (!SWIG_IsOK(res1)) {
12526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12527 }
12528 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12529 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12530 if (!SWIG_IsOK(ecode2)) {
12531 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_green_set" "', expected argument " "2"" of type '" "byte""'");
12532 }
12533 arg2 = static_cast< byte >(val2);
12534 if (arg1) (arg1)->green = arg2;
12535
12536 resultobj = SWIG_Py_Void();
12537 return resultobj;
12538 fail:
12539 return NULL;
12540 }
12541
12542
12543 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12544 PyObject *resultobj = 0;
12545 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12546 byte result;
12547 void *argp1 = 0 ;
12548 int res1 = 0 ;
12549 PyObject *swig_obj[1] ;
12550
12551 if (!args) SWIG_fail;
12552 swig_obj[0] = args;
12553 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12554 if (!SWIG_IsOK(res1)) {
12555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12556 }
12557 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12558 result = (byte) ((arg1)->green);
12559 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12560 return resultobj;
12561 fail:
12562 return NULL;
12563 }
12564
12565
12566 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12567 PyObject *resultobj = 0;
12568 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12569 byte arg2 ;
12570 void *argp1 = 0 ;
12571 int res1 = 0 ;
12572 unsigned char val2 ;
12573 int ecode2 = 0 ;
12574 PyObject *swig_obj[2] ;
12575
12576 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_blue_set",2,2,swig_obj)) SWIG_fail;
12577 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12578 if (!SWIG_IsOK(res1)) {
12579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12580 }
12581 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12582 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12583 if (!SWIG_IsOK(ecode2)) {
12584 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_blue_set" "', expected argument " "2"" of type '" "byte""'");
12585 }
12586 arg2 = static_cast< byte >(val2);
12587 if (arg1) (arg1)->blue = arg2;
12588
12589 resultobj = SWIG_Py_Void();
12590 return resultobj;
12591 fail:
12592 return NULL;
12593 }
12594
12595
12596 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12597 PyObject *resultobj = 0;
12598 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12599 byte result;
12600 void *argp1 = 0 ;
12601 int res1 = 0 ;
12602 PyObject *swig_obj[1] ;
12603
12604 if (!args) SWIG_fail;
12605 swig_obj[0] = args;
12606 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12607 if (!SWIG_IsOK(res1)) {
12608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12609 }
12610 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12611 result = (byte) ((arg1)->blue);
12612 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12613 return resultobj;
12614 fail:
12615 return NULL;
12616 }
12617
12618
12619 SWIGINTERN PyObject *Image_RGBValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12620 PyObject *obj;
12621 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12622 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_RGBValue, SWIG_NewClientData(obj));
12623 return SWIG_Py_Void();
12624 }
12625
12626 SWIGINTERN PyObject *Image_RGBValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12627 return SWIG_Python_InitShadowInstance(args);
12628 }
12629
12630 SWIGINTERN PyObject *_wrap_new_Image_HSVValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12631 PyObject *resultobj = 0;
12632 double arg1 = (double) 0.0 ;
12633 double arg2 = (double) 0.0 ;
12634 double arg3 = (double) 0.0 ;
12635 wxImage_HSVValue *result = 0 ;
12636 double val1 ;
12637 int ecode1 = 0 ;
12638 double val2 ;
12639 int ecode2 = 0 ;
12640 double val3 ;
12641 int ecode3 = 0 ;
12642 PyObject * obj0 = 0 ;
12643 PyObject * obj1 = 0 ;
12644 PyObject * obj2 = 0 ;
12645 char * kwnames[] = {
12646 (char *) "h",(char *) "s",(char *) "v", NULL
12647 };
12648
12649 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_HSVValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12650 if (obj0) {
12651 ecode1 = SWIG_AsVal_double(obj0, &val1);
12652 if (!SWIG_IsOK(ecode1)) {
12653 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_HSVValue" "', expected argument " "1"" of type '" "double""'");
12654 }
12655 arg1 = static_cast< double >(val1);
12656 }
12657 if (obj1) {
12658 ecode2 = SWIG_AsVal_double(obj1, &val2);
12659 if (!SWIG_IsOK(ecode2)) {
12660 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_HSVValue" "', expected argument " "2"" of type '" "double""'");
12661 }
12662 arg2 = static_cast< double >(val2);
12663 }
12664 if (obj2) {
12665 ecode3 = SWIG_AsVal_double(obj2, &val3);
12666 if (!SWIG_IsOK(ecode3)) {
12667 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_HSVValue" "', expected argument " "3"" of type '" "double""'");
12668 }
12669 arg3 = static_cast< double >(val3);
12670 }
12671 {
12672 PyThreadState* __tstate = wxPyBeginAllowThreads();
12673 result = (wxImage_HSVValue *)new wxImage_HSVValue(arg1,arg2,arg3);
12674 wxPyEndAllowThreads(__tstate);
12675 if (PyErr_Occurred()) SWIG_fail;
12676 }
12677 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_NEW | 0 );
12678 return resultobj;
12679 fail:
12680 return NULL;
12681 }
12682
12683
12684 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12685 PyObject *resultobj = 0;
12686 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12687 double arg2 ;
12688 void *argp1 = 0 ;
12689 int res1 = 0 ;
12690 double val2 ;
12691 int ecode2 = 0 ;
12692 PyObject *swig_obj[2] ;
12693
12694 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_hue_set",2,2,swig_obj)) SWIG_fail;
12695 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12696 if (!SWIG_IsOK(res1)) {
12697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12698 }
12699 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12700 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12701 if (!SWIG_IsOK(ecode2)) {
12702 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_hue_set" "', expected argument " "2"" of type '" "double""'");
12703 }
12704 arg2 = static_cast< double >(val2);
12705 if (arg1) (arg1)->hue = arg2;
12706
12707 resultobj = SWIG_Py_Void();
12708 return resultobj;
12709 fail:
12710 return NULL;
12711 }
12712
12713
12714 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12715 PyObject *resultobj = 0;
12716 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12717 double result;
12718 void *argp1 = 0 ;
12719 int res1 = 0 ;
12720 PyObject *swig_obj[1] ;
12721
12722 if (!args) SWIG_fail;
12723 swig_obj[0] = args;
12724 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12725 if (!SWIG_IsOK(res1)) {
12726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12727 }
12728 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12729 result = (double) ((arg1)->hue);
12730 resultobj = SWIG_From_double(static_cast< double >(result));
12731 return resultobj;
12732 fail:
12733 return NULL;
12734 }
12735
12736
12737 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12738 PyObject *resultobj = 0;
12739 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12740 double arg2 ;
12741 void *argp1 = 0 ;
12742 int res1 = 0 ;
12743 double val2 ;
12744 int ecode2 = 0 ;
12745 PyObject *swig_obj[2] ;
12746
12747 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_saturation_set",2,2,swig_obj)) SWIG_fail;
12748 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12749 if (!SWIG_IsOK(res1)) {
12750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12751 }
12752 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12753 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12754 if (!SWIG_IsOK(ecode2)) {
12755 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "2"" of type '" "double""'");
12756 }
12757 arg2 = static_cast< double >(val2);
12758 if (arg1) (arg1)->saturation = arg2;
12759
12760 resultobj = SWIG_Py_Void();
12761 return resultobj;
12762 fail:
12763 return NULL;
12764 }
12765
12766
12767 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12768 PyObject *resultobj = 0;
12769 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12770 double result;
12771 void *argp1 = 0 ;
12772 int res1 = 0 ;
12773 PyObject *swig_obj[1] ;
12774
12775 if (!args) SWIG_fail;
12776 swig_obj[0] = args;
12777 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12778 if (!SWIG_IsOK(res1)) {
12779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12780 }
12781 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12782 result = (double) ((arg1)->saturation);
12783 resultobj = SWIG_From_double(static_cast< double >(result));
12784 return resultobj;
12785 fail:
12786 return NULL;
12787 }
12788
12789
12790 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12791 PyObject *resultobj = 0;
12792 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12793 double arg2 ;
12794 void *argp1 = 0 ;
12795 int res1 = 0 ;
12796 double val2 ;
12797 int ecode2 = 0 ;
12798 PyObject *swig_obj[2] ;
12799
12800 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_value_set",2,2,swig_obj)) SWIG_fail;
12801 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12802 if (!SWIG_IsOK(res1)) {
12803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12804 }
12805 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12806 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12807 if (!SWIG_IsOK(ecode2)) {
12808 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_value_set" "', expected argument " "2"" of type '" "double""'");
12809 }
12810 arg2 = static_cast< double >(val2);
12811 if (arg1) (arg1)->value = arg2;
12812
12813 resultobj = SWIG_Py_Void();
12814 return resultobj;
12815 fail:
12816 return NULL;
12817 }
12818
12819
12820 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12821 PyObject *resultobj = 0;
12822 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12823 double result;
12824 void *argp1 = 0 ;
12825 int res1 = 0 ;
12826 PyObject *swig_obj[1] ;
12827
12828 if (!args) SWIG_fail;
12829 swig_obj[0] = args;
12830 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12831 if (!SWIG_IsOK(res1)) {
12832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12833 }
12834 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12835 result = (double) ((arg1)->value);
12836 resultobj = SWIG_From_double(static_cast< double >(result));
12837 return resultobj;
12838 fail:
12839 return NULL;
12840 }
12841
12842
12843 SWIGINTERN PyObject *Image_HSVValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12844 PyObject *obj;
12845 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12846 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_HSVValue, SWIG_NewClientData(obj));
12847 return SWIG_Py_Void();
12848 }
12849
12850 SWIGINTERN PyObject *Image_HSVValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12851 return SWIG_Python_InitShadowInstance(args);
12852 }
12853
12854 SWIGINTERN PyObject *_wrap_new_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12855 PyObject *resultobj = 0;
12856 wxString *arg1 = 0 ;
12857 long arg2 = (long) wxBITMAP_TYPE_ANY ;
12858 int arg3 = (int) -1 ;
12859 wxImage *result = 0 ;
12860 bool temp1 = false ;
12861 long val2 ;
12862 int ecode2 = 0 ;
12863 int val3 ;
12864 int ecode3 = 0 ;
12865 PyObject * obj0 = 0 ;
12866 PyObject * obj1 = 0 ;
12867 PyObject * obj2 = 0 ;
12868 char * kwnames[] = {
12869 (char *) "name",(char *) "type",(char *) "index", NULL
12870 };
12871
12872 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12873 {
12874 arg1 = wxString_in_helper(obj0);
12875 if (arg1 == NULL) SWIG_fail;
12876 temp1 = true;
12877 }
12878 if (obj1) {
12879 ecode2 = SWIG_AsVal_long(obj1, &val2);
12880 if (!SWIG_IsOK(ecode2)) {
12881 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image" "', expected argument " "2"" of type '" "long""'");
12882 }
12883 arg2 = static_cast< long >(val2);
12884 }
12885 if (obj2) {
12886 ecode3 = SWIG_AsVal_int(obj2, &val3);
12887 if (!SWIG_IsOK(ecode3)) {
12888 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image" "', expected argument " "3"" of type '" "int""'");
12889 }
12890 arg3 = static_cast< int >(val3);
12891 }
12892 {
12893 PyThreadState* __tstate = wxPyBeginAllowThreads();
12894 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
12895 wxPyEndAllowThreads(__tstate);
12896 if (PyErr_Occurred()) SWIG_fail;
12897 }
12898 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_NEW | 0 );
12899 {
12900 if (temp1)
12901 delete arg1;
12902 }
12903 return resultobj;
12904 fail:
12905 {
12906 if (temp1)
12907 delete arg1;
12908 }
12909 return NULL;
12910 }
12911
12912
12913 SWIGINTERN PyObject *_wrap_delete_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12914 PyObject *resultobj = 0;
12915 wxImage *arg1 = (wxImage *) 0 ;
12916 void *argp1 = 0 ;
12917 int res1 = 0 ;
12918 PyObject *swig_obj[1] ;
12919
12920 if (!args) SWIG_fail;
12921 swig_obj[0] = args;
12922 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, SWIG_POINTER_DISOWN | 0 );
12923 if (!SWIG_IsOK(res1)) {
12924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Image" "', expected argument " "1"" of type '" "wxImage *""'");
12925 }
12926 arg1 = reinterpret_cast< wxImage * >(argp1);
12927 {
12928 PyThreadState* __tstate = wxPyBeginAllowThreads();
12929 delete arg1;
12930
12931 wxPyEndAllowThreads(__tstate);
12932 if (PyErr_Occurred()) SWIG_fail;
12933 }
12934 resultobj = SWIG_Py_Void();
12935 return resultobj;
12936 fail:
12937 return NULL;
12938 }
12939
12940
12941 SWIGINTERN PyObject *_wrap_new_ImageFromMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12942 PyObject *resultobj = 0;
12943 wxString *arg1 = 0 ;
12944 wxString *arg2 = 0 ;
12945 int arg3 = (int) -1 ;
12946 wxImage *result = 0 ;
12947 bool temp1 = false ;
12948 bool temp2 = false ;
12949 int val3 ;
12950 int ecode3 = 0 ;
12951 PyObject * obj0 = 0 ;
12952 PyObject * obj1 = 0 ;
12953 PyObject * obj2 = 0 ;
12954 char * kwnames[] = {
12955 (char *) "name",(char *) "mimetype",(char *) "index", NULL
12956 };
12957
12958 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12959 {
12960 arg1 = wxString_in_helper(obj0);
12961 if (arg1 == NULL) SWIG_fail;
12962 temp1 = true;
12963 }
12964 {
12965 arg2 = wxString_in_helper(obj1);
12966 if (arg2 == NULL) SWIG_fail;
12967 temp2 = true;
12968 }
12969 if (obj2) {
12970 ecode3 = SWIG_AsVal_int(obj2, &val3);
12971 if (!SWIG_IsOK(ecode3)) {
12972 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromMime" "', expected argument " "3"" of type '" "int""'");
12973 }
12974 arg3 = static_cast< int >(val3);
12975 }
12976 {
12977 PyThreadState* __tstate = wxPyBeginAllowThreads();
12978 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
12979 wxPyEndAllowThreads(__tstate);
12980 if (PyErr_Occurred()) SWIG_fail;
12981 }
12982 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
12983 {
12984 if (temp1)
12985 delete arg1;
12986 }
12987 {
12988 if (temp2)
12989 delete arg2;
12990 }
12991 return resultobj;
12992 fail:
12993 {
12994 if (temp1)
12995 delete arg1;
12996 }
12997 {
12998 if (temp2)
12999 delete arg2;
13000 }
13001 return NULL;
13002 }
13003
13004
13005 SWIGINTERN PyObject *_wrap_new_ImageFromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13006 PyObject *resultobj = 0;
13007 wxInputStream *arg1 = 0 ;
13008 long arg2 = (long) wxBITMAP_TYPE_ANY ;
13009 int arg3 = (int) -1 ;
13010 wxImage *result = 0 ;
13011 wxPyInputStream *temp1 ;
13012 bool created1 ;
13013 long val2 ;
13014 int ecode2 = 0 ;
13015 int val3 ;
13016 int ecode3 = 0 ;
13017 PyObject * obj0 = 0 ;
13018 PyObject * obj1 = 0 ;
13019 PyObject * obj2 = 0 ;
13020 char * kwnames[] = {
13021 (char *) "stream",(char *) "type",(char *) "index", NULL
13022 };
13023
13024 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13025 {
13026 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13027 arg1 = temp1->m_wxis;
13028 created1 = false;
13029 } else {
13030 PyErr_Clear(); // clear the failure of the wxPyConvert above
13031 arg1 = wxPyCBInputStream_create(obj0, false);
13032 if (arg1 == NULL) {
13033 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13034 SWIG_fail;
13035 }
13036 created1 = true;
13037 }
13038 }
13039 if (obj1) {
13040 ecode2 = SWIG_AsVal_long(obj1, &val2);
13041 if (!SWIG_IsOK(ecode2)) {
13042 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromStream" "', expected argument " "2"" of type '" "long""'");
13043 }
13044 arg2 = static_cast< long >(val2);
13045 }
13046 if (obj2) {
13047 ecode3 = SWIG_AsVal_int(obj2, &val3);
13048 if (!SWIG_IsOK(ecode3)) {
13049 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStream" "', expected argument " "3"" of type '" "int""'");
13050 }
13051 arg3 = static_cast< int >(val3);
13052 }
13053 {
13054 PyThreadState* __tstate = wxPyBeginAllowThreads();
13055 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
13056 wxPyEndAllowThreads(__tstate);
13057 if (PyErr_Occurred()) SWIG_fail;
13058 }
13059 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13060 {
13061 if (created1) delete arg1;
13062 }
13063 return resultobj;
13064 fail:
13065 {
13066 if (created1) delete arg1;
13067 }
13068 return NULL;
13069 }
13070
13071
13072 SWIGINTERN PyObject *_wrap_new_ImageFromStreamMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13073 PyObject *resultobj = 0;
13074 wxInputStream *arg1 = 0 ;
13075 wxString *arg2 = 0 ;
13076 int arg3 = (int) -1 ;
13077 wxImage *result = 0 ;
13078 wxPyInputStream *temp1 ;
13079 bool created1 ;
13080 bool temp2 = false ;
13081 int val3 ;
13082 int ecode3 = 0 ;
13083 PyObject * obj0 = 0 ;
13084 PyObject * obj1 = 0 ;
13085 PyObject * obj2 = 0 ;
13086 char * kwnames[] = {
13087 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
13088 };
13089
13090 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13091 {
13092 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13093 arg1 = temp1->m_wxis;
13094 created1 = false;
13095 } else {
13096 PyErr_Clear(); // clear the failure of the wxPyConvert above
13097 arg1 = wxPyCBInputStream_create(obj0, false);
13098 if (arg1 == NULL) {
13099 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13100 SWIG_fail;
13101 }
13102 created1 = true;
13103 }
13104 }
13105 {
13106 arg2 = wxString_in_helper(obj1);
13107 if (arg2 == NULL) SWIG_fail;
13108 temp2 = true;
13109 }
13110 if (obj2) {
13111 ecode3 = SWIG_AsVal_int(obj2, &val3);
13112 if (!SWIG_IsOK(ecode3)) {
13113 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStreamMime" "', expected argument " "3"" of type '" "int""'");
13114 }
13115 arg3 = static_cast< int >(val3);
13116 }
13117 {
13118 PyThreadState* __tstate = wxPyBeginAllowThreads();
13119 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
13120 wxPyEndAllowThreads(__tstate);
13121 if (PyErr_Occurred()) SWIG_fail;
13122 }
13123 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13124 {
13125 if (created1) delete arg1;
13126 }
13127 {
13128 if (temp2)
13129 delete arg2;
13130 }
13131 return resultobj;
13132 fail:
13133 {
13134 if (created1) delete arg1;
13135 }
13136 {
13137 if (temp2)
13138 delete arg2;
13139 }
13140 return NULL;
13141 }
13142
13143
13144 SWIGINTERN PyObject *_wrap_new_EmptyImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13145 PyObject *resultobj = 0;
13146 int arg1 = (int) 0 ;
13147 int arg2 = (int) 0 ;
13148 bool arg3 = (bool) true ;
13149 wxImage *result = 0 ;
13150 int val1 ;
13151 int ecode1 = 0 ;
13152 int val2 ;
13153 int ecode2 = 0 ;
13154 bool val3 ;
13155 int ecode3 = 0 ;
13156 PyObject * obj0 = 0 ;
13157 PyObject * obj1 = 0 ;
13158 PyObject * obj2 = 0 ;
13159 char * kwnames[] = {
13160 (char *) "width",(char *) "height",(char *) "clear", NULL
13161 };
13162
13163 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13164 if (obj0) {
13165 ecode1 = SWIG_AsVal_int(obj0, &val1);
13166 if (!SWIG_IsOK(ecode1)) {
13167 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EmptyImage" "', expected argument " "1"" of type '" "int""'");
13168 }
13169 arg1 = static_cast< int >(val1);
13170 }
13171 if (obj1) {
13172 ecode2 = SWIG_AsVal_int(obj1, &val2);
13173 if (!SWIG_IsOK(ecode2)) {
13174 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EmptyImage" "', expected argument " "2"" of type '" "int""'");
13175 }
13176 arg2 = static_cast< int >(val2);
13177 }
13178 if (obj2) {
13179 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13180 if (!SWIG_IsOK(ecode3)) {
13181 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EmptyImage" "', expected argument " "3"" of type '" "bool""'");
13182 }
13183 arg3 = static_cast< bool >(val3);
13184 }
13185 {
13186 PyThreadState* __tstate = wxPyBeginAllowThreads();
13187 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
13188 wxPyEndAllowThreads(__tstate);
13189 if (PyErr_Occurred()) SWIG_fail;
13190 }
13191 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13192 return resultobj;
13193 fail:
13194 return NULL;
13195 }
13196
13197
13198 SWIGINTERN PyObject *_wrap_new_ImageFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13199 PyObject *resultobj = 0;
13200 wxBitmap *arg1 = 0 ;
13201 wxImage *result = 0 ;
13202 void *argp1 = 0 ;
13203 int res1 = 0 ;
13204 PyObject * obj0 = 0 ;
13205 char * kwnames[] = {
13206 (char *) "bitmap", NULL
13207 };
13208
13209 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) SWIG_fail;
13210 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
13211 if (!SWIG_IsOK(res1)) {
13212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13213 }
13214 if (!argp1) {
13215 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13216 }
13217 arg1 = reinterpret_cast< wxBitmap * >(argp1);
13218 {
13219 if (!wxPyCheckForApp()) SWIG_fail;
13220 PyThreadState* __tstate = wxPyBeginAllowThreads();
13221 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
13222 wxPyEndAllowThreads(__tstate);
13223 if (PyErr_Occurred()) SWIG_fail;
13224 }
13225 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13226 return resultobj;
13227 fail:
13228 return NULL;
13229 }
13230
13231
13232 SWIGINTERN PyObject *_wrap_new_ImageFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13233 PyObject *resultobj = 0;
13234 int arg1 ;
13235 int arg2 ;
13236 buffer arg3 ;
13237 int arg4 ;
13238 wxImage *result = 0 ;
13239 int val1 ;
13240 int ecode1 = 0 ;
13241 int val2 ;
13242 int ecode2 = 0 ;
13243 PyObject * obj0 = 0 ;
13244 PyObject * obj1 = 0 ;
13245 PyObject * obj2 = 0 ;
13246 char * kwnames[] = {
13247 (char *) "width",(char *) "height",(char *) "data", NULL
13248 };
13249
13250 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13251 ecode1 = SWIG_AsVal_int(obj0, &val1);
13252 if (!SWIG_IsOK(ecode1)) {
13253 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromData" "', expected argument " "1"" of type '" "int""'");
13254 }
13255 arg1 = static_cast< int >(val1);
13256 ecode2 = SWIG_AsVal_int(obj1, &val2);
13257 if (!SWIG_IsOK(ecode2)) {
13258 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromData" "', expected argument " "2"" of type '" "int""'");
13259 }
13260 arg2 = static_cast< int >(val2);
13261 {
13262 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
13263 }
13264 {
13265 PyThreadState* __tstate = wxPyBeginAllowThreads();
13266 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
13267 wxPyEndAllowThreads(__tstate);
13268 if (PyErr_Occurred()) SWIG_fail;
13269 }
13270 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13271 return resultobj;
13272 fail:
13273 return NULL;
13274 }
13275
13276
13277 SWIGINTERN PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13278 PyObject *resultobj = 0;
13279 int arg1 ;
13280 int arg2 ;
13281 buffer arg3 ;
13282 int arg4 ;
13283 buffer arg5 ;
13284 int arg6 ;
13285 wxImage *result = 0 ;
13286 int val1 ;
13287 int ecode1 = 0 ;
13288 int val2 ;
13289 int ecode2 = 0 ;
13290 PyObject * obj0 = 0 ;
13291 PyObject * obj1 = 0 ;
13292 PyObject * obj2 = 0 ;
13293 PyObject * obj3 = 0 ;
13294 char * kwnames[] = {
13295 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
13296 };
13297
13298 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13299 ecode1 = SWIG_AsVal_int(obj0, &val1);
13300 if (!SWIG_IsOK(ecode1)) {
13301 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "1"" of type '" "int""'");
13302 }
13303 arg1 = static_cast< int >(val1);
13304 ecode2 = SWIG_AsVal_int(obj1, &val2);
13305 if (!SWIG_IsOK(ecode2)) {
13306 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "2"" of type '" "int""'");
13307 }
13308 arg2 = static_cast< int >(val2);
13309 {
13310 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
13311 }
13312 {
13313 if (!PyArg_Parse(obj3, "t#", &arg5, &arg6)) SWIG_fail;
13314 }
13315 {
13316 PyThreadState* __tstate = wxPyBeginAllowThreads();
13317 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
13318 wxPyEndAllowThreads(__tstate);
13319 if (PyErr_Occurred()) SWIG_fail;
13320 }
13321 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13322 return resultobj;
13323 fail:
13324 return NULL;
13325 }
13326
13327
13328 SWIGINTERN PyObject *_wrap_Image_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13329 PyObject *resultobj = 0;
13330 wxImage *arg1 = (wxImage *) 0 ;
13331 int arg2 ;
13332 int arg3 ;
13333 bool arg4 = (bool) true ;
13334 void *argp1 = 0 ;
13335 int res1 = 0 ;
13336 int val2 ;
13337 int ecode2 = 0 ;
13338 int val3 ;
13339 int ecode3 = 0 ;
13340 bool val4 ;
13341 int ecode4 = 0 ;
13342 PyObject * obj0 = 0 ;
13343 PyObject * obj1 = 0 ;
13344 PyObject * obj2 = 0 ;
13345 PyObject * obj3 = 0 ;
13346 char * kwnames[] = {
13347 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
13348 };
13349
13350 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13351 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13352 if (!SWIG_IsOK(res1)) {
13353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Create" "', expected argument " "1"" of type '" "wxImage *""'");
13354 }
13355 arg1 = reinterpret_cast< wxImage * >(argp1);
13356 ecode2 = SWIG_AsVal_int(obj1, &val2);
13357 if (!SWIG_IsOK(ecode2)) {
13358 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Create" "', expected argument " "2"" of type '" "int""'");
13359 }
13360 arg2 = static_cast< int >(val2);
13361 ecode3 = SWIG_AsVal_int(obj2, &val3);
13362 if (!SWIG_IsOK(ecode3)) {
13363 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Create" "', expected argument " "3"" of type '" "int""'");
13364 }
13365 arg3 = static_cast< int >(val3);
13366 if (obj3) {
13367 ecode4 = SWIG_AsVal_bool(obj3, &val4);
13368 if (!SWIG_IsOK(ecode4)) {
13369 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Create" "', expected argument " "4"" of type '" "bool""'");
13370 }
13371 arg4 = static_cast< bool >(val4);
13372 }
13373 {
13374 PyThreadState* __tstate = wxPyBeginAllowThreads();
13375 (arg1)->Create(arg2,arg3,arg4);
13376 wxPyEndAllowThreads(__tstate);
13377 if (PyErr_Occurred()) SWIG_fail;
13378 }
13379 resultobj = SWIG_Py_Void();
13380 return resultobj;
13381 fail:
13382 return NULL;
13383 }
13384
13385
13386 SWIGINTERN PyObject *_wrap_Image_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13387 PyObject *resultobj = 0;
13388 wxImage *arg1 = (wxImage *) 0 ;
13389 void *argp1 = 0 ;
13390 int res1 = 0 ;
13391 PyObject *swig_obj[1] ;
13392
13393 if (!args) SWIG_fail;
13394 swig_obj[0] = args;
13395 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13396 if (!SWIG_IsOK(res1)) {
13397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Destroy" "', expected argument " "1"" of type '" "wxImage *""'");
13398 }
13399 arg1 = reinterpret_cast< wxImage * >(argp1);
13400 {
13401 PyThreadState* __tstate = wxPyBeginAllowThreads();
13402 (arg1)->Destroy();
13403 wxPyEndAllowThreads(__tstate);
13404 if (PyErr_Occurred()) SWIG_fail;
13405 }
13406 resultobj = SWIG_Py_Void();
13407 return resultobj;
13408 fail:
13409 return NULL;
13410 }
13411
13412
13413 SWIGINTERN PyObject *_wrap_Image_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13414 PyObject *resultobj = 0;
13415 wxImage *arg1 = (wxImage *) 0 ;
13416 int arg2 ;
13417 int arg3 ;
13418 SwigValueWrapper<wxImage > result;
13419 void *argp1 = 0 ;
13420 int res1 = 0 ;
13421 int val2 ;
13422 int ecode2 = 0 ;
13423 int val3 ;
13424 int ecode3 = 0 ;
13425 PyObject * obj0 = 0 ;
13426 PyObject * obj1 = 0 ;
13427 PyObject * obj2 = 0 ;
13428 char * kwnames[] = {
13429 (char *) "self",(char *) "width",(char *) "height", NULL
13430 };
13431
13432 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13433 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13434 if (!SWIG_IsOK(res1)) {
13435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Scale" "', expected argument " "1"" of type '" "wxImage *""'");
13436 }
13437 arg1 = reinterpret_cast< wxImage * >(argp1);
13438 ecode2 = SWIG_AsVal_int(obj1, &val2);
13439 if (!SWIG_IsOK(ecode2)) {
13440 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Scale" "', expected argument " "2"" of type '" "int""'");
13441 }
13442 arg2 = static_cast< int >(val2);
13443 ecode3 = SWIG_AsVal_int(obj2, &val3);
13444 if (!SWIG_IsOK(ecode3)) {
13445 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Scale" "', expected argument " "3"" of type '" "int""'");
13446 }
13447 arg3 = static_cast< int >(val3);
13448 {
13449 PyThreadState* __tstate = wxPyBeginAllowThreads();
13450 result = (arg1)->Scale(arg2,arg3);
13451 wxPyEndAllowThreads(__tstate);
13452 if (PyErr_Occurred()) SWIG_fail;
13453 }
13454 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13455 return resultobj;
13456 fail:
13457 return NULL;
13458 }
13459
13460
13461 SWIGINTERN PyObject *_wrap_Image_ShrinkBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13462 PyObject *resultobj = 0;
13463 wxImage *arg1 = (wxImage *) 0 ;
13464 int arg2 ;
13465 int arg3 ;
13466 SwigValueWrapper<wxImage > result;
13467 void *argp1 = 0 ;
13468 int res1 = 0 ;
13469 int val2 ;
13470 int ecode2 = 0 ;
13471 int val3 ;
13472 int ecode3 = 0 ;
13473 PyObject * obj0 = 0 ;
13474 PyObject * obj1 = 0 ;
13475 PyObject * obj2 = 0 ;
13476 char * kwnames[] = {
13477 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
13478 };
13479
13480 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13481 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13482 if (!SWIG_IsOK(res1)) {
13483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ShrinkBy" "', expected argument " "1"" of type '" "wxImage const *""'");
13484 }
13485 arg1 = reinterpret_cast< wxImage * >(argp1);
13486 ecode2 = SWIG_AsVal_int(obj1, &val2);
13487 if (!SWIG_IsOK(ecode2)) {
13488 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ShrinkBy" "', expected argument " "2"" of type '" "int""'");
13489 }
13490 arg2 = static_cast< int >(val2);
13491 ecode3 = SWIG_AsVal_int(obj2, &val3);
13492 if (!SWIG_IsOK(ecode3)) {
13493 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ShrinkBy" "', expected argument " "3"" of type '" "int""'");
13494 }
13495 arg3 = static_cast< int >(val3);
13496 {
13497 PyThreadState* __tstate = wxPyBeginAllowThreads();
13498 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
13499 wxPyEndAllowThreads(__tstate);
13500 if (PyErr_Occurred()) SWIG_fail;
13501 }
13502 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13503 return resultobj;
13504 fail:
13505 return NULL;
13506 }
13507
13508
13509 SWIGINTERN PyObject *_wrap_Image_Rescale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13510 PyObject *resultobj = 0;
13511 wxImage *arg1 = (wxImage *) 0 ;
13512 int arg2 ;
13513 int arg3 ;
13514 wxImage *result = 0 ;
13515 void *argp1 = 0 ;
13516 int res1 = 0 ;
13517 int val2 ;
13518 int ecode2 = 0 ;
13519 int val3 ;
13520 int ecode3 = 0 ;
13521 PyObject * obj0 = 0 ;
13522 PyObject * obj1 = 0 ;
13523 PyObject * obj2 = 0 ;
13524 char * kwnames[] = {
13525 (char *) "self",(char *) "width",(char *) "height", NULL
13526 };
13527
13528 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Rescale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13529 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13530 if (!SWIG_IsOK(res1)) {
13531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rescale" "', expected argument " "1"" of type '" "wxImage *""'");
13532 }
13533 arg1 = reinterpret_cast< wxImage * >(argp1);
13534 ecode2 = SWIG_AsVal_int(obj1, &val2);
13535 if (!SWIG_IsOK(ecode2)) {
13536 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rescale" "', expected argument " "2"" of type '" "int""'");
13537 }
13538 arg2 = static_cast< int >(val2);
13539 ecode3 = SWIG_AsVal_int(obj2, &val3);
13540 if (!SWIG_IsOK(ecode3)) {
13541 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Rescale" "', expected argument " "3"" of type '" "int""'");
13542 }
13543 arg3 = static_cast< int >(val3);
13544 {
13545 PyThreadState* __tstate = wxPyBeginAllowThreads();
13546 {
13547 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3);
13548 result = (wxImage *) &_result_ref;
13549 }
13550 wxPyEndAllowThreads(__tstate);
13551 if (PyErr_Occurred()) SWIG_fail;
13552 }
13553 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13554 return resultobj;
13555 fail:
13556 return NULL;
13557 }
13558
13559
13560 SWIGINTERN PyObject *_wrap_Image_Resize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13561 PyObject *resultobj = 0;
13562 wxImage *arg1 = (wxImage *) 0 ;
13563 wxSize *arg2 = 0 ;
13564 wxPoint *arg3 = 0 ;
13565 int arg4 = (int) -1 ;
13566 int arg5 = (int) -1 ;
13567 int arg6 = (int) -1 ;
13568 wxImage *result = 0 ;
13569 void *argp1 = 0 ;
13570 int res1 = 0 ;
13571 wxSize temp2 ;
13572 wxPoint temp3 ;
13573 int val4 ;
13574 int ecode4 = 0 ;
13575 int val5 ;
13576 int ecode5 = 0 ;
13577 int val6 ;
13578 int ecode6 = 0 ;
13579 PyObject * obj0 = 0 ;
13580 PyObject * obj1 = 0 ;
13581 PyObject * obj2 = 0 ;
13582 PyObject * obj3 = 0 ;
13583 PyObject * obj4 = 0 ;
13584 PyObject * obj5 = 0 ;
13585 char * kwnames[] = {
13586 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
13587 };
13588
13589 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13590 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13591 if (!SWIG_IsOK(res1)) {
13592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Resize" "', expected argument " "1"" of type '" "wxImage *""'");
13593 }
13594 arg1 = reinterpret_cast< wxImage * >(argp1);
13595 {
13596 arg2 = &temp2;
13597 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
13598 }
13599 {
13600 arg3 = &temp3;
13601 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13602 }
13603 if (obj3) {
13604 ecode4 = SWIG_AsVal_int(obj3, &val4);
13605 if (!SWIG_IsOK(ecode4)) {
13606 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Resize" "', expected argument " "4"" of type '" "int""'");
13607 }
13608 arg4 = static_cast< int >(val4);
13609 }
13610 if (obj4) {
13611 ecode5 = SWIG_AsVal_int(obj4, &val5);
13612 if (!SWIG_IsOK(ecode5)) {
13613 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Resize" "', expected argument " "5"" of type '" "int""'");
13614 }
13615 arg5 = static_cast< int >(val5);
13616 }
13617 if (obj5) {
13618 ecode6 = SWIG_AsVal_int(obj5, &val6);
13619 if (!SWIG_IsOK(ecode6)) {
13620 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Resize" "', expected argument " "6"" of type '" "int""'");
13621 }
13622 arg6 = static_cast< int >(val6);
13623 }
13624 {
13625 PyThreadState* __tstate = wxPyBeginAllowThreads();
13626 {
13627 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
13628 result = (wxImage *) &_result_ref;
13629 }
13630 wxPyEndAllowThreads(__tstate);
13631 if (PyErr_Occurred()) SWIG_fail;
13632 }
13633 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13634 return resultobj;
13635 fail:
13636 return NULL;
13637 }
13638
13639
13640 SWIGINTERN PyObject *_wrap_Image_SetRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13641 PyObject *resultobj = 0;
13642 wxImage *arg1 = (wxImage *) 0 ;
13643 int arg2 ;
13644 int arg3 ;
13645 byte arg4 ;
13646 byte arg5 ;
13647 byte arg6 ;
13648 void *argp1 = 0 ;
13649 int res1 = 0 ;
13650 int val2 ;
13651 int ecode2 = 0 ;
13652 int val3 ;
13653 int ecode3 = 0 ;
13654 unsigned char val4 ;
13655 int ecode4 = 0 ;
13656 unsigned char val5 ;
13657 int ecode5 = 0 ;
13658 unsigned char val6 ;
13659 int ecode6 = 0 ;
13660 PyObject * obj0 = 0 ;
13661 PyObject * obj1 = 0 ;
13662 PyObject * obj2 = 0 ;
13663 PyObject * obj3 = 0 ;
13664 PyObject * obj4 = 0 ;
13665 PyObject * obj5 = 0 ;
13666 char * kwnames[] = {
13667 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
13668 };
13669
13670 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13671 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13672 if (!SWIG_IsOK(res1)) {
13673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGB" "', expected argument " "1"" of type '" "wxImage *""'");
13674 }
13675 arg1 = reinterpret_cast< wxImage * >(argp1);
13676 ecode2 = SWIG_AsVal_int(obj1, &val2);
13677 if (!SWIG_IsOK(ecode2)) {
13678 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetRGB" "', expected argument " "2"" of type '" "int""'");
13679 }
13680 arg2 = static_cast< int >(val2);
13681 ecode3 = SWIG_AsVal_int(obj2, &val3);
13682 if (!SWIG_IsOK(ecode3)) {
13683 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGB" "', expected argument " "3"" of type '" "int""'");
13684 }
13685 arg3 = static_cast< int >(val3);
13686 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13687 if (!SWIG_IsOK(ecode4)) {
13688 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGB" "', expected argument " "4"" of type '" "byte""'");
13689 }
13690 arg4 = static_cast< byte >(val4);
13691 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
13692 if (!SWIG_IsOK(ecode5)) {
13693 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGB" "', expected argument " "5"" of type '" "byte""'");
13694 }
13695 arg5 = static_cast< byte >(val5);
13696 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
13697 if (!SWIG_IsOK(ecode6)) {
13698 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_SetRGB" "', expected argument " "6"" of type '" "byte""'");
13699 }
13700 arg6 = static_cast< byte >(val6);
13701 {
13702 PyThreadState* __tstate = wxPyBeginAllowThreads();
13703 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
13704 wxPyEndAllowThreads(__tstate);
13705 if (PyErr_Occurred()) SWIG_fail;
13706 }
13707 resultobj = SWIG_Py_Void();
13708 return resultobj;
13709 fail:
13710 return NULL;
13711 }
13712
13713
13714 SWIGINTERN PyObject *_wrap_Image_SetRGBRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13715 PyObject *resultobj = 0;
13716 wxImage *arg1 = (wxImage *) 0 ;
13717 wxRect *arg2 = 0 ;
13718 byte arg3 ;
13719 byte arg4 ;
13720 byte arg5 ;
13721 void *argp1 = 0 ;
13722 int res1 = 0 ;
13723 wxRect temp2 ;
13724 unsigned char val3 ;
13725 int ecode3 = 0 ;
13726 unsigned char val4 ;
13727 int ecode4 = 0 ;
13728 unsigned char val5 ;
13729 int ecode5 = 0 ;
13730 PyObject * obj0 = 0 ;
13731 PyObject * obj1 = 0 ;
13732 PyObject * obj2 = 0 ;
13733 PyObject * obj3 = 0 ;
13734 PyObject * obj4 = 0 ;
13735 char * kwnames[] = {
13736 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
13737 };
13738
13739 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
13740 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13741 if (!SWIG_IsOK(res1)) {
13742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGBRect" "', expected argument " "1"" of type '" "wxImage *""'");
13743 }
13744 arg1 = reinterpret_cast< wxImage * >(argp1);
13745 {
13746 arg2 = &temp2;
13747 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13748 }
13749 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
13750 if (!SWIG_IsOK(ecode3)) {
13751 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGBRect" "', expected argument " "3"" of type '" "byte""'");
13752 }
13753 arg3 = static_cast< byte >(val3);
13754 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13755 if (!SWIG_IsOK(ecode4)) {
13756 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGBRect" "', expected argument " "4"" of type '" "byte""'");
13757 }
13758 arg4 = static_cast< byte >(val4);
13759 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
13760 if (!SWIG_IsOK(ecode5)) {
13761 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGBRect" "', expected argument " "5"" of type '" "byte""'");
13762 }
13763 arg5 = static_cast< byte >(val5);
13764 {
13765 PyThreadState* __tstate = wxPyBeginAllowThreads();
13766 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
13767 wxPyEndAllowThreads(__tstate);
13768 if (PyErr_Occurred()) SWIG_fail;
13769 }
13770 resultobj = SWIG_Py_Void();
13771 return resultobj;
13772 fail:
13773 return NULL;
13774 }
13775
13776
13777 SWIGINTERN PyObject *_wrap_Image_GetRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13778 PyObject *resultobj = 0;
13779 wxImage *arg1 = (wxImage *) 0 ;
13780 int arg2 ;
13781 int arg3 ;
13782 byte result;
13783 void *argp1 = 0 ;
13784 int res1 = 0 ;
13785 int val2 ;
13786 int ecode2 = 0 ;
13787 int val3 ;
13788 int ecode3 = 0 ;
13789 PyObject * obj0 = 0 ;
13790 PyObject * obj1 = 0 ;
13791 PyObject * obj2 = 0 ;
13792 char * kwnames[] = {
13793 (char *) "self",(char *) "x",(char *) "y", NULL
13794 };
13795
13796 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13797 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13798 if (!SWIG_IsOK(res1)) {
13799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetRed" "', expected argument " "1"" of type '" "wxImage *""'");
13800 }
13801 arg1 = reinterpret_cast< wxImage * >(argp1);
13802 ecode2 = SWIG_AsVal_int(obj1, &val2);
13803 if (!SWIG_IsOK(ecode2)) {
13804 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetRed" "', expected argument " "2"" of type '" "int""'");
13805 }
13806 arg2 = static_cast< int >(val2);
13807 ecode3 = SWIG_AsVal_int(obj2, &val3);
13808 if (!SWIG_IsOK(ecode3)) {
13809 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetRed" "', expected argument " "3"" of type '" "int""'");
13810 }
13811 arg3 = static_cast< int >(val3);
13812 {
13813 PyThreadState* __tstate = wxPyBeginAllowThreads();
13814 result = (byte)(arg1)->GetRed(arg2,arg3);
13815 wxPyEndAllowThreads(__tstate);
13816 if (PyErr_Occurred()) SWIG_fail;
13817 }
13818 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13819 return resultobj;
13820 fail:
13821 return NULL;
13822 }
13823
13824
13825 SWIGINTERN PyObject *_wrap_Image_GetGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13826 PyObject *resultobj = 0;
13827 wxImage *arg1 = (wxImage *) 0 ;
13828 int arg2 ;
13829 int arg3 ;
13830 byte result;
13831 void *argp1 = 0 ;
13832 int res1 = 0 ;
13833 int val2 ;
13834 int ecode2 = 0 ;
13835 int val3 ;
13836 int ecode3 = 0 ;
13837 PyObject * obj0 = 0 ;
13838 PyObject * obj1 = 0 ;
13839 PyObject * obj2 = 0 ;
13840 char * kwnames[] = {
13841 (char *) "self",(char *) "x",(char *) "y", NULL
13842 };
13843
13844 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13845 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13846 if (!SWIG_IsOK(res1)) {
13847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetGreen" "', expected argument " "1"" of type '" "wxImage *""'");
13848 }
13849 arg1 = reinterpret_cast< wxImage * >(argp1);
13850 ecode2 = SWIG_AsVal_int(obj1, &val2);
13851 if (!SWIG_IsOK(ecode2)) {
13852 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetGreen" "', expected argument " "2"" of type '" "int""'");
13853 }
13854 arg2 = static_cast< int >(val2);
13855 ecode3 = SWIG_AsVal_int(obj2, &val3);
13856 if (!SWIG_IsOK(ecode3)) {
13857 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetGreen" "', expected argument " "3"" of type '" "int""'");
13858 }
13859 arg3 = static_cast< int >(val3);
13860 {
13861 PyThreadState* __tstate = wxPyBeginAllowThreads();
13862 result = (byte)(arg1)->GetGreen(arg2,arg3);
13863 wxPyEndAllowThreads(__tstate);
13864 if (PyErr_Occurred()) SWIG_fail;
13865 }
13866 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13867 return resultobj;
13868 fail:
13869 return NULL;
13870 }
13871
13872
13873 SWIGINTERN PyObject *_wrap_Image_GetBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13874 PyObject *resultobj = 0;
13875 wxImage *arg1 = (wxImage *) 0 ;
13876 int arg2 ;
13877 int arg3 ;
13878 byte result;
13879 void *argp1 = 0 ;
13880 int res1 = 0 ;
13881 int val2 ;
13882 int ecode2 = 0 ;
13883 int val3 ;
13884 int ecode3 = 0 ;
13885 PyObject * obj0 = 0 ;
13886 PyObject * obj1 = 0 ;
13887 PyObject * obj2 = 0 ;
13888 char * kwnames[] = {
13889 (char *) "self",(char *) "x",(char *) "y", NULL
13890 };
13891
13892 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13893 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13894 if (!SWIG_IsOK(res1)) {
13895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetBlue" "', expected argument " "1"" of type '" "wxImage *""'");
13896 }
13897 arg1 = reinterpret_cast< wxImage * >(argp1);
13898 ecode2 = SWIG_AsVal_int(obj1, &val2);
13899 if (!SWIG_IsOK(ecode2)) {
13900 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetBlue" "', expected argument " "2"" of type '" "int""'");
13901 }
13902 arg2 = static_cast< int >(val2);
13903 ecode3 = SWIG_AsVal_int(obj2, &val3);
13904 if (!SWIG_IsOK(ecode3)) {
13905 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetBlue" "', expected argument " "3"" of type '" "int""'");
13906 }
13907 arg3 = static_cast< int >(val3);
13908 {
13909 PyThreadState* __tstate = wxPyBeginAllowThreads();
13910 result = (byte)(arg1)->GetBlue(arg2,arg3);
13911 wxPyEndAllowThreads(__tstate);
13912 if (PyErr_Occurred()) SWIG_fail;
13913 }
13914 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13915 return resultobj;
13916 fail:
13917 return NULL;
13918 }
13919
13920
13921 SWIGINTERN PyObject *_wrap_Image_SetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13922 PyObject *resultobj = 0;
13923 wxImage *arg1 = (wxImage *) 0 ;
13924 int arg2 ;
13925 int arg3 ;
13926 byte arg4 ;
13927 void *argp1 = 0 ;
13928 int res1 = 0 ;
13929 int val2 ;
13930 int ecode2 = 0 ;
13931 int val3 ;
13932 int ecode3 = 0 ;
13933 unsigned char val4 ;
13934 int ecode4 = 0 ;
13935 PyObject * obj0 = 0 ;
13936 PyObject * obj1 = 0 ;
13937 PyObject * obj2 = 0 ;
13938 PyObject * obj3 = 0 ;
13939 char * kwnames[] = {
13940 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
13941 };
13942
13943 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13944 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13945 if (!SWIG_IsOK(res1)) {
13946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
13947 }
13948 arg1 = reinterpret_cast< wxImage * >(argp1);
13949 ecode2 = SWIG_AsVal_int(obj1, &val2);
13950 if (!SWIG_IsOK(ecode2)) {
13951 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetAlpha" "', expected argument " "2"" of type '" "int""'");
13952 }
13953 arg2 = static_cast< int >(val2);
13954 ecode3 = SWIG_AsVal_int(obj2, &val3);
13955 if (!SWIG_IsOK(ecode3)) {
13956 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetAlpha" "', expected argument " "3"" of type '" "int""'");
13957 }
13958 arg3 = static_cast< int >(val3);
13959 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13960 if (!SWIG_IsOK(ecode4)) {
13961 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetAlpha" "', expected argument " "4"" of type '" "byte""'");
13962 }
13963 arg4 = static_cast< byte >(val4);
13964 {
13965 PyThreadState* __tstate = wxPyBeginAllowThreads();
13966 (arg1)->SetAlpha(arg2,arg3,arg4);
13967 wxPyEndAllowThreads(__tstate);
13968 if (PyErr_Occurred()) SWIG_fail;
13969 }
13970 resultobj = SWIG_Py_Void();
13971 return resultobj;
13972 fail:
13973 return NULL;
13974 }
13975
13976
13977 SWIGINTERN PyObject *_wrap_Image_GetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13978 PyObject *resultobj = 0;
13979 wxImage *arg1 = (wxImage *) 0 ;
13980 int arg2 ;
13981 int arg3 ;
13982 byte result;
13983 void *argp1 = 0 ;
13984 int res1 = 0 ;
13985 int val2 ;
13986 int ecode2 = 0 ;
13987 int val3 ;
13988 int ecode3 = 0 ;
13989 PyObject * obj0 = 0 ;
13990 PyObject * obj1 = 0 ;
13991 PyObject * obj2 = 0 ;
13992 char * kwnames[] = {
13993 (char *) "self",(char *) "x",(char *) "y", NULL
13994 };
13995
13996 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13997 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13998 if (!SWIG_IsOK(res1)) {
13999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14000 }
14001 arg1 = reinterpret_cast< wxImage * >(argp1);
14002 ecode2 = SWIG_AsVal_int(obj1, &val2);
14003 if (!SWIG_IsOK(ecode2)) {
14004 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetAlpha" "', expected argument " "2"" of type '" "int""'");
14005 }
14006 arg2 = static_cast< int >(val2);
14007 ecode3 = SWIG_AsVal_int(obj2, &val3);
14008 if (!SWIG_IsOK(ecode3)) {
14009 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetAlpha" "', expected argument " "3"" of type '" "int""'");
14010 }
14011 arg3 = static_cast< int >(val3);
14012 {
14013 PyThreadState* __tstate = wxPyBeginAllowThreads();
14014 result = (byte)(arg1)->GetAlpha(arg2,arg3);
14015 wxPyEndAllowThreads(__tstate);
14016 if (PyErr_Occurred()) SWIG_fail;
14017 }
14018 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14019 return resultobj;
14020 fail:
14021 return NULL;
14022 }
14023
14024
14025 SWIGINTERN PyObject *_wrap_Image_HasAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14026 PyObject *resultobj = 0;
14027 wxImage *arg1 = (wxImage *) 0 ;
14028 bool result;
14029 void *argp1 = 0 ;
14030 int res1 = 0 ;
14031 PyObject *swig_obj[1] ;
14032
14033 if (!args) SWIG_fail;
14034 swig_obj[0] = args;
14035 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14036 if (!SWIG_IsOK(res1)) {
14037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14038 }
14039 arg1 = reinterpret_cast< wxImage * >(argp1);
14040 {
14041 PyThreadState* __tstate = wxPyBeginAllowThreads();
14042 result = (bool)(arg1)->HasAlpha();
14043 wxPyEndAllowThreads(__tstate);
14044 if (PyErr_Occurred()) SWIG_fail;
14045 }
14046 {
14047 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14048 }
14049 return resultobj;
14050 fail:
14051 return NULL;
14052 }
14053
14054
14055 SWIGINTERN PyObject *_wrap_Image_InitAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14056 PyObject *resultobj = 0;
14057 wxImage *arg1 = (wxImage *) 0 ;
14058 void *argp1 = 0 ;
14059 int res1 = 0 ;
14060 PyObject *swig_obj[1] ;
14061
14062 if (!args) SWIG_fail;
14063 swig_obj[0] = args;
14064 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14065 if (!SWIG_IsOK(res1)) {
14066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InitAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14067 }
14068 arg1 = reinterpret_cast< wxImage * >(argp1);
14069 {
14070 PyThreadState* __tstate = wxPyBeginAllowThreads();
14071 (arg1)->InitAlpha();
14072 wxPyEndAllowThreads(__tstate);
14073 if (PyErr_Occurred()) SWIG_fail;
14074 }
14075 resultobj = SWIG_Py_Void();
14076 return resultobj;
14077 fail:
14078 return NULL;
14079 }
14080
14081
14082 SWIGINTERN PyObject *_wrap_Image_IsTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14083 PyObject *resultobj = 0;
14084 wxImage *arg1 = (wxImage *) 0 ;
14085 int arg2 ;
14086 int arg3 ;
14087 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14088 bool result;
14089 void *argp1 = 0 ;
14090 int res1 = 0 ;
14091 int val2 ;
14092 int ecode2 = 0 ;
14093 int val3 ;
14094 int ecode3 = 0 ;
14095 unsigned char val4 ;
14096 int ecode4 = 0 ;
14097 PyObject * obj0 = 0 ;
14098 PyObject * obj1 = 0 ;
14099 PyObject * obj2 = 0 ;
14100 PyObject * obj3 = 0 ;
14101 char * kwnames[] = {
14102 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
14103 };
14104
14105 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14106 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14107 if (!SWIG_IsOK(res1)) {
14108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsTransparent" "', expected argument " "1"" of type '" "wxImage const *""'");
14109 }
14110 arg1 = reinterpret_cast< wxImage * >(argp1);
14111 ecode2 = SWIG_AsVal_int(obj1, &val2);
14112 if (!SWIG_IsOK(ecode2)) {
14113 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_IsTransparent" "', expected argument " "2"" of type '" "int""'");
14114 }
14115 arg2 = static_cast< int >(val2);
14116 ecode3 = SWIG_AsVal_int(obj2, &val3);
14117 if (!SWIG_IsOK(ecode3)) {
14118 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_IsTransparent" "', expected argument " "3"" of type '" "int""'");
14119 }
14120 arg3 = static_cast< int >(val3);
14121 if (obj3) {
14122 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14123 if (!SWIG_IsOK(ecode4)) {
14124 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_IsTransparent" "', expected argument " "4"" of type '" "byte""'");
14125 }
14126 arg4 = static_cast< byte >(val4);
14127 }
14128 {
14129 PyThreadState* __tstate = wxPyBeginAllowThreads();
14130 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
14131 wxPyEndAllowThreads(__tstate);
14132 if (PyErr_Occurred()) SWIG_fail;
14133 }
14134 {
14135 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14136 }
14137 return resultobj;
14138 fail:
14139 return NULL;
14140 }
14141
14142
14143 SWIGINTERN PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14144 PyObject *resultobj = 0;
14145 wxImage *arg1 = (wxImage *) 0 ;
14146 byte *arg2 = (byte *) 0 ;
14147 byte *arg3 = (byte *) 0 ;
14148 byte *arg4 = (byte *) 0 ;
14149 byte arg5 = (byte) 0 ;
14150 byte arg6 = (byte) 0 ;
14151 byte arg7 = (byte) 0 ;
14152 bool result;
14153 void *argp1 = 0 ;
14154 int res1 = 0 ;
14155 byte temp2 ;
14156 int res2 = SWIG_TMPOBJ ;
14157 byte temp3 ;
14158 int res3 = SWIG_TMPOBJ ;
14159 byte temp4 ;
14160 int res4 = SWIG_TMPOBJ ;
14161 unsigned char val5 ;
14162 int ecode5 = 0 ;
14163 unsigned char val6 ;
14164 int ecode6 = 0 ;
14165 unsigned char val7 ;
14166 int ecode7 = 0 ;
14167 PyObject * obj0 = 0 ;
14168 PyObject * obj1 = 0 ;
14169 PyObject * obj2 = 0 ;
14170 PyObject * obj3 = 0 ;
14171 char * kwnames[] = {
14172 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
14173 };
14174
14175 arg2 = &temp2;
14176 arg3 = &temp3;
14177 arg4 = &temp4;
14178 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14179 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14180 if (!SWIG_IsOK(res1)) {
14181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImage const *""'");
14182 }
14183 arg1 = reinterpret_cast< wxImage * >(argp1);
14184 if (obj1) {
14185 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
14186 if (!SWIG_IsOK(ecode5)) {
14187 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
14188 }
14189 arg5 = static_cast< byte >(val5);
14190 }
14191 if (obj2) {
14192 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
14193 if (!SWIG_IsOK(ecode6)) {
14194 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
14195 }
14196 arg6 = static_cast< byte >(val6);
14197 }
14198 if (obj3) {
14199 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
14200 if (!SWIG_IsOK(ecode7)) {
14201 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
14202 }
14203 arg7 = static_cast< byte >(val7);
14204 }
14205 {
14206 PyThreadState* __tstate = wxPyBeginAllowThreads();
14207 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
14208 wxPyEndAllowThreads(__tstate);
14209 if (PyErr_Occurred()) SWIG_fail;
14210 }
14211 {
14212 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14213 }
14214 if (SWIG_IsTmpObj(res2)) {
14215 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
14216 } else {
14217 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14218 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
14219 }
14220 if (SWIG_IsTmpObj(res3)) {
14221 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
14222 } else {
14223 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14224 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
14225 }
14226 if (SWIG_IsTmpObj(res4)) {
14227 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
14228 } else {
14229 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14230 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
14231 }
14232 return resultobj;
14233 fail:
14234 return NULL;
14235 }
14236
14237
14238 SWIGINTERN PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14239 PyObject *resultobj = 0;
14240 wxImage *arg1 = (wxImage *) 0 ;
14241 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14242 bool result;
14243 void *argp1 = 0 ;
14244 int res1 = 0 ;
14245 unsigned char val2 ;
14246 int ecode2 = 0 ;
14247 PyObject * obj0 = 0 ;
14248 PyObject * obj1 = 0 ;
14249 char * kwnames[] = {
14250 (char *) "self",(char *) "threshold", NULL
14251 };
14252
14253 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) SWIG_fail;
14254 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14255 if (!SWIG_IsOK(res1)) {
14256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "1"" of type '" "wxImage *""'");
14257 }
14258 arg1 = reinterpret_cast< wxImage * >(argp1);
14259 if (obj1) {
14260 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14261 if (!SWIG_IsOK(ecode2)) {
14262 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "2"" of type '" "byte""'");
14263 }
14264 arg2 = static_cast< byte >(val2);
14265 }
14266 {
14267 PyThreadState* __tstate = wxPyBeginAllowThreads();
14268 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
14269 wxPyEndAllowThreads(__tstate);
14270 if (PyErr_Occurred()) SWIG_fail;
14271 }
14272 {
14273 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14274 }
14275 return resultobj;
14276 fail:
14277 return NULL;
14278 }
14279
14280
14281 SWIGINTERN PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14282 PyObject *resultobj = 0;
14283 wxImage *arg1 = (wxImage *) 0 ;
14284 byte arg2 ;
14285 byte arg3 ;
14286 byte arg4 ;
14287 bool result;
14288 void *argp1 = 0 ;
14289 int res1 = 0 ;
14290 unsigned char val2 ;
14291 int ecode2 = 0 ;
14292 unsigned char val3 ;
14293 int ecode3 = 0 ;
14294 unsigned char val4 ;
14295 int ecode4 = 0 ;
14296 PyObject * obj0 = 0 ;
14297 PyObject * obj1 = 0 ;
14298 PyObject * obj2 = 0 ;
14299 PyObject * obj3 = 0 ;
14300 char * kwnames[] = {
14301 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
14302 };
14303
14304 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14305 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14306 if (!SWIG_IsOK(res1)) {
14307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14308 }
14309 arg1 = reinterpret_cast< wxImage * >(argp1);
14310 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14311 if (!SWIG_IsOK(ecode2)) {
14312 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "2"" of type '" "byte""'");
14313 }
14314 arg2 = static_cast< byte >(val2);
14315 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14316 if (!SWIG_IsOK(ecode3)) {
14317 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "3"" of type '" "byte""'");
14318 }
14319 arg3 = static_cast< byte >(val3);
14320 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14321 if (!SWIG_IsOK(ecode4)) {
14322 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "4"" of type '" "byte""'");
14323 }
14324 arg4 = static_cast< byte >(val4);
14325 {
14326 PyThreadState* __tstate = wxPyBeginAllowThreads();
14327 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
14328 wxPyEndAllowThreads(__tstate);
14329 if (PyErr_Occurred()) SWIG_fail;
14330 }
14331 {
14332 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14333 }
14334 return resultobj;
14335 fail:
14336 return NULL;
14337 }
14338
14339
14340 SWIGINTERN PyObject *_wrap_Image_SetMaskFromImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14341 PyObject *resultobj = 0;
14342 wxImage *arg1 = (wxImage *) 0 ;
14343 wxImage *arg2 = 0 ;
14344 byte arg3 ;
14345 byte arg4 ;
14346 byte arg5 ;
14347 bool result;
14348 void *argp1 = 0 ;
14349 int res1 = 0 ;
14350 void *argp2 = 0 ;
14351 int res2 = 0 ;
14352 unsigned char val3 ;
14353 int ecode3 = 0 ;
14354 unsigned char val4 ;
14355 int ecode4 = 0 ;
14356 unsigned char val5 ;
14357 int ecode5 = 0 ;
14358 PyObject * obj0 = 0 ;
14359 PyObject * obj1 = 0 ;
14360 PyObject * obj2 = 0 ;
14361 PyObject * obj3 = 0 ;
14362 PyObject * obj4 = 0 ;
14363 char * kwnames[] = {
14364 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
14365 };
14366
14367 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
14368 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14369 if (!SWIG_IsOK(res1)) {
14370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskFromImage" "', expected argument " "1"" of type '" "wxImage *""'");
14371 }
14372 arg1 = reinterpret_cast< wxImage * >(argp1);
14373 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
14374 if (!SWIG_IsOK(res2)) {
14375 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14376 }
14377 if (!argp2) {
14378 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14379 }
14380 arg2 = reinterpret_cast< wxImage * >(argp2);
14381 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14382 if (!SWIG_IsOK(ecode3)) {
14383 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskFromImage" "', expected argument " "3"" of type '" "byte""'");
14384 }
14385 arg3 = static_cast< byte >(val3);
14386 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14387 if (!SWIG_IsOK(ecode4)) {
14388 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskFromImage" "', expected argument " "4"" of type '" "byte""'");
14389 }
14390 arg4 = static_cast< byte >(val4);
14391 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
14392 if (!SWIG_IsOK(ecode5)) {
14393 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetMaskFromImage" "', expected argument " "5"" of type '" "byte""'");
14394 }
14395 arg5 = static_cast< byte >(val5);
14396 {
14397 PyThreadState* __tstate = wxPyBeginAllowThreads();
14398 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
14399 wxPyEndAllowThreads(__tstate);
14400 if (PyErr_Occurred()) SWIG_fail;
14401 }
14402 {
14403 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14404 }
14405 return resultobj;
14406 fail:
14407 return NULL;
14408 }
14409
14410
14411 SWIGINTERN PyObject *_wrap_Image_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14412 PyObject *resultobj = 0;
14413 wxString *arg1 = 0 ;
14414 bool result;
14415 bool temp1 = false ;
14416 PyObject * obj0 = 0 ;
14417 char * kwnames[] = {
14418 (char *) "filename", NULL
14419 };
14420
14421 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) SWIG_fail;
14422 {
14423 arg1 = wxString_in_helper(obj0);
14424 if (arg1 == NULL) SWIG_fail;
14425 temp1 = true;
14426 }
14427 {
14428 PyThreadState* __tstate = wxPyBeginAllowThreads();
14429 result = (bool)wxImage::CanRead((wxString const &)*arg1);
14430 wxPyEndAllowThreads(__tstate);
14431 if (PyErr_Occurred()) SWIG_fail;
14432 }
14433 {
14434 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14435 }
14436 {
14437 if (temp1)
14438 delete arg1;
14439 }
14440 return resultobj;
14441 fail:
14442 {
14443 if (temp1)
14444 delete arg1;
14445 }
14446 return NULL;
14447 }
14448
14449
14450 SWIGINTERN PyObject *_wrap_Image_GetImageCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14451 PyObject *resultobj = 0;
14452 wxString *arg1 = 0 ;
14453 long arg2 = (long) wxBITMAP_TYPE_ANY ;
14454 int result;
14455 bool temp1 = false ;
14456 long val2 ;
14457 int ecode2 = 0 ;
14458 PyObject * obj0 = 0 ;
14459 PyObject * obj1 = 0 ;
14460 char * kwnames[] = {
14461 (char *) "filename",(char *) "type", NULL
14462 };
14463
14464 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) SWIG_fail;
14465 {
14466 arg1 = wxString_in_helper(obj0);
14467 if (arg1 == NULL) SWIG_fail;
14468 temp1 = true;
14469 }
14470 if (obj1) {
14471 ecode2 = SWIG_AsVal_long(obj1, &val2);
14472 if (!SWIG_IsOK(ecode2)) {
14473 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetImageCount" "', expected argument " "2"" of type '" "long""'");
14474 }
14475 arg2 = static_cast< long >(val2);
14476 }
14477 {
14478 PyThreadState* __tstate = wxPyBeginAllowThreads();
14479 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
14480 wxPyEndAllowThreads(__tstate);
14481 if (PyErr_Occurred()) SWIG_fail;
14482 }
14483 resultobj = SWIG_From_int(static_cast< int >(result));
14484 {
14485 if (temp1)
14486 delete arg1;
14487 }
14488 return resultobj;
14489 fail:
14490 {
14491 if (temp1)
14492 delete arg1;
14493 }
14494 return NULL;
14495 }
14496
14497
14498 SWIGINTERN PyObject *_wrap_Image_LoadFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14499 PyObject *resultobj = 0;
14500 wxImage *arg1 = (wxImage *) 0 ;
14501 wxString *arg2 = 0 ;
14502 long arg3 = (long) wxBITMAP_TYPE_ANY ;
14503 int arg4 = (int) -1 ;
14504 bool result;
14505 void *argp1 = 0 ;
14506 int res1 = 0 ;
14507 bool temp2 = false ;
14508 long val3 ;
14509 int ecode3 = 0 ;
14510 int val4 ;
14511 int ecode4 = 0 ;
14512 PyObject * obj0 = 0 ;
14513 PyObject * obj1 = 0 ;
14514 PyObject * obj2 = 0 ;
14515 PyObject * obj3 = 0 ;
14516 char * kwnames[] = {
14517 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
14518 };
14519
14520 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14521 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14522 if (!SWIG_IsOK(res1)) {
14523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadFile" "', expected argument " "1"" of type '" "wxImage *""'");
14524 }
14525 arg1 = reinterpret_cast< wxImage * >(argp1);
14526 {
14527 arg2 = wxString_in_helper(obj1);
14528 if (arg2 == NULL) SWIG_fail;
14529 temp2 = true;
14530 }
14531 if (obj2) {
14532 ecode3 = SWIG_AsVal_long(obj2, &val3);
14533 if (!SWIG_IsOK(ecode3)) {
14534 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadFile" "', expected argument " "3"" of type '" "long""'");
14535 }
14536 arg3 = static_cast< long >(val3);
14537 }
14538 if (obj3) {
14539 ecode4 = SWIG_AsVal_int(obj3, &val4);
14540 if (!SWIG_IsOK(ecode4)) {
14541 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadFile" "', expected argument " "4"" of type '" "int""'");
14542 }
14543 arg4 = static_cast< int >(val4);
14544 }
14545 {
14546 PyThreadState* __tstate = wxPyBeginAllowThreads();
14547 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
14548 wxPyEndAllowThreads(__tstate);
14549 if (PyErr_Occurred()) SWIG_fail;
14550 }
14551 {
14552 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14553 }
14554 {
14555 if (temp2)
14556 delete arg2;
14557 }
14558 return resultobj;
14559 fail:
14560 {
14561 if (temp2)
14562 delete arg2;
14563 }
14564 return NULL;
14565 }
14566
14567
14568 SWIGINTERN PyObject *_wrap_Image_LoadMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14569 PyObject *resultobj = 0;
14570 wxImage *arg1 = (wxImage *) 0 ;
14571 wxString *arg2 = 0 ;
14572 wxString *arg3 = 0 ;
14573 int arg4 = (int) -1 ;
14574 bool result;
14575 void *argp1 = 0 ;
14576 int res1 = 0 ;
14577 bool temp2 = false ;
14578 bool temp3 = false ;
14579 int val4 ;
14580 int ecode4 = 0 ;
14581 PyObject * obj0 = 0 ;
14582 PyObject * obj1 = 0 ;
14583 PyObject * obj2 = 0 ;
14584 PyObject * obj3 = 0 ;
14585 char * kwnames[] = {
14586 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
14587 };
14588
14589 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14590 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14591 if (!SWIG_IsOK(res1)) {
14592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14593 }
14594 arg1 = reinterpret_cast< wxImage * >(argp1);
14595 {
14596 arg2 = wxString_in_helper(obj1);
14597 if (arg2 == NULL) SWIG_fail;
14598 temp2 = true;
14599 }
14600 {
14601 arg3 = wxString_in_helper(obj2);
14602 if (arg3 == NULL) SWIG_fail;
14603 temp3 = true;
14604 }
14605 if (obj3) {
14606 ecode4 = SWIG_AsVal_int(obj3, &val4);
14607 if (!SWIG_IsOK(ecode4)) {
14608 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeFile" "', expected argument " "4"" of type '" "int""'");
14609 }
14610 arg4 = static_cast< int >(val4);
14611 }
14612 {
14613 PyThreadState* __tstate = wxPyBeginAllowThreads();
14614 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
14615 wxPyEndAllowThreads(__tstate);
14616 if (PyErr_Occurred()) SWIG_fail;
14617 }
14618 {
14619 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14620 }
14621 {
14622 if (temp2)
14623 delete arg2;
14624 }
14625 {
14626 if (temp3)
14627 delete arg3;
14628 }
14629 return resultobj;
14630 fail:
14631 {
14632 if (temp2)
14633 delete arg2;
14634 }
14635 {
14636 if (temp3)
14637 delete arg3;
14638 }
14639 return NULL;
14640 }
14641
14642
14643 SWIGINTERN PyObject *_wrap_Image_SaveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14644 PyObject *resultobj = 0;
14645 wxImage *arg1 = (wxImage *) 0 ;
14646 wxString *arg2 = 0 ;
14647 int arg3 ;
14648 bool result;
14649 void *argp1 = 0 ;
14650 int res1 = 0 ;
14651 bool temp2 = false ;
14652 int val3 ;
14653 int ecode3 = 0 ;
14654 PyObject * obj0 = 0 ;
14655 PyObject * obj1 = 0 ;
14656 PyObject * obj2 = 0 ;
14657 char * kwnames[] = {
14658 (char *) "self",(char *) "name",(char *) "type", NULL
14659 };
14660
14661 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14662 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14663 if (!SWIG_IsOK(res1)) {
14664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveFile" "', expected argument " "1"" of type '" "wxImage *""'");
14665 }
14666 arg1 = reinterpret_cast< wxImage * >(argp1);
14667 {
14668 arg2 = wxString_in_helper(obj1);
14669 if (arg2 == NULL) SWIG_fail;
14670 temp2 = true;
14671 }
14672 ecode3 = SWIG_AsVal_int(obj2, &val3);
14673 if (!SWIG_IsOK(ecode3)) {
14674 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SaveFile" "', expected argument " "3"" of type '" "int""'");
14675 }
14676 arg3 = static_cast< int >(val3);
14677 {
14678 PyThreadState* __tstate = wxPyBeginAllowThreads();
14679 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
14680 wxPyEndAllowThreads(__tstate);
14681 if (PyErr_Occurred()) SWIG_fail;
14682 }
14683 {
14684 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14685 }
14686 {
14687 if (temp2)
14688 delete arg2;
14689 }
14690 return resultobj;
14691 fail:
14692 {
14693 if (temp2)
14694 delete arg2;
14695 }
14696 return NULL;
14697 }
14698
14699
14700 SWIGINTERN PyObject *_wrap_Image_SaveMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14701 PyObject *resultobj = 0;
14702 wxImage *arg1 = (wxImage *) 0 ;
14703 wxString *arg2 = 0 ;
14704 wxString *arg3 = 0 ;
14705 bool result;
14706 void *argp1 = 0 ;
14707 int res1 = 0 ;
14708 bool temp2 = false ;
14709 bool temp3 = false ;
14710 PyObject * obj0 = 0 ;
14711 PyObject * obj1 = 0 ;
14712 PyObject * obj2 = 0 ;
14713 char * kwnames[] = {
14714 (char *) "self",(char *) "name",(char *) "mimetype", NULL
14715 };
14716
14717 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14718 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14719 if (!SWIG_IsOK(res1)) {
14720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14721 }
14722 arg1 = reinterpret_cast< wxImage * >(argp1);
14723 {
14724 arg2 = wxString_in_helper(obj1);
14725 if (arg2 == NULL) SWIG_fail;
14726 temp2 = true;
14727 }
14728 {
14729 arg3 = wxString_in_helper(obj2);
14730 if (arg3 == NULL) SWIG_fail;
14731 temp3 = true;
14732 }
14733 {
14734 PyThreadState* __tstate = wxPyBeginAllowThreads();
14735 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
14736 wxPyEndAllowThreads(__tstate);
14737 if (PyErr_Occurred()) SWIG_fail;
14738 }
14739 {
14740 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14741 }
14742 {
14743 if (temp2)
14744 delete arg2;
14745 }
14746 {
14747 if (temp3)
14748 delete arg3;
14749 }
14750 return resultobj;
14751 fail:
14752 {
14753 if (temp2)
14754 delete arg2;
14755 }
14756 {
14757 if (temp3)
14758 delete arg3;
14759 }
14760 return NULL;
14761 }
14762
14763
14764 SWIGINTERN PyObject *_wrap_Image_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14765 PyObject *resultobj = 0;
14766 wxInputStream *arg1 = 0 ;
14767 bool result;
14768 wxPyInputStream *temp1 ;
14769 bool created1 ;
14770 PyObject * obj0 = 0 ;
14771 char * kwnames[] = {
14772 (char *) "stream", NULL
14773 };
14774
14775 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) SWIG_fail;
14776 {
14777 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
14778 arg1 = temp1->m_wxis;
14779 created1 = false;
14780 } else {
14781 PyErr_Clear(); // clear the failure of the wxPyConvert above
14782 arg1 = wxPyCBInputStream_create(obj0, false);
14783 if (arg1 == NULL) {
14784 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14785 SWIG_fail;
14786 }
14787 created1 = true;
14788 }
14789 }
14790 {
14791 PyThreadState* __tstate = wxPyBeginAllowThreads();
14792 result = (bool)wxImage::CanRead(*arg1);
14793 wxPyEndAllowThreads(__tstate);
14794 if (PyErr_Occurred()) SWIG_fail;
14795 }
14796 {
14797 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14798 }
14799 {
14800 if (created1) delete arg1;
14801 }
14802 return resultobj;
14803 fail:
14804 {
14805 if (created1) delete arg1;
14806 }
14807 return NULL;
14808 }
14809
14810
14811 SWIGINTERN PyObject *_wrap_Image_LoadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14812 PyObject *resultobj = 0;
14813 wxImage *arg1 = (wxImage *) 0 ;
14814 wxInputStream *arg2 = 0 ;
14815 long arg3 = (long) wxBITMAP_TYPE_ANY ;
14816 int arg4 = (int) -1 ;
14817 bool result;
14818 void *argp1 = 0 ;
14819 int res1 = 0 ;
14820 wxPyInputStream *temp2 ;
14821 bool created2 ;
14822 long val3 ;
14823 int ecode3 = 0 ;
14824 int val4 ;
14825 int ecode4 = 0 ;
14826 PyObject * obj0 = 0 ;
14827 PyObject * obj1 = 0 ;
14828 PyObject * obj2 = 0 ;
14829 PyObject * obj3 = 0 ;
14830 char * kwnames[] = {
14831 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
14832 };
14833
14834 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14835 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14836 if (!SWIG_IsOK(res1)) {
14837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadStream" "', expected argument " "1"" of type '" "wxImage *""'");
14838 }
14839 arg1 = reinterpret_cast< wxImage * >(argp1);
14840 {
14841 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
14842 arg2 = temp2->m_wxis;
14843 created2 = false;
14844 } else {
14845 PyErr_Clear(); // clear the failure of the wxPyConvert above
14846 arg2 = wxPyCBInputStream_create(obj1, false);
14847 if (arg2 == NULL) {
14848 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14849 SWIG_fail;
14850 }
14851 created2 = true;
14852 }
14853 }
14854 if (obj2) {
14855 ecode3 = SWIG_AsVal_long(obj2, &val3);
14856 if (!SWIG_IsOK(ecode3)) {
14857 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadStream" "', expected argument " "3"" of type '" "long""'");
14858 }
14859 arg3 = static_cast< long >(val3);
14860 }
14861 if (obj3) {
14862 ecode4 = SWIG_AsVal_int(obj3, &val4);
14863 if (!SWIG_IsOK(ecode4)) {
14864 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadStream" "', expected argument " "4"" of type '" "int""'");
14865 }
14866 arg4 = static_cast< int >(val4);
14867 }
14868 {
14869 PyThreadState* __tstate = wxPyBeginAllowThreads();
14870 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
14871 wxPyEndAllowThreads(__tstate);
14872 if (PyErr_Occurred()) SWIG_fail;
14873 }
14874 {
14875 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14876 }
14877 {
14878 if (created2) delete arg2;
14879 }
14880 return resultobj;
14881 fail:
14882 {
14883 if (created2) delete arg2;
14884 }
14885 return NULL;
14886 }
14887
14888
14889 SWIGINTERN PyObject *_wrap_Image_LoadMimeStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14890 PyObject *resultobj = 0;
14891 wxImage *arg1 = (wxImage *) 0 ;
14892 wxInputStream *arg2 = 0 ;
14893 wxString *arg3 = 0 ;
14894 int arg4 = (int) -1 ;
14895 bool result;
14896 void *argp1 = 0 ;
14897 int res1 = 0 ;
14898 wxPyInputStream *temp2 ;
14899 bool created2 ;
14900 bool temp3 = false ;
14901 int val4 ;
14902 int ecode4 = 0 ;
14903 PyObject * obj0 = 0 ;
14904 PyObject * obj1 = 0 ;
14905 PyObject * obj2 = 0 ;
14906 PyObject * obj3 = 0 ;
14907 char * kwnames[] = {
14908 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
14909 };
14910
14911 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14912 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14913 if (!SWIG_IsOK(res1)) {
14914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeStream" "', expected argument " "1"" of type '" "wxImage *""'");
14915 }
14916 arg1 = reinterpret_cast< wxImage * >(argp1);
14917 {
14918 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
14919 arg2 = temp2->m_wxis;
14920 created2 = false;
14921 } else {
14922 PyErr_Clear(); // clear the failure of the wxPyConvert above
14923 arg2 = wxPyCBInputStream_create(obj1, false);
14924 if (arg2 == NULL) {
14925 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14926 SWIG_fail;
14927 }
14928 created2 = true;
14929 }
14930 }
14931 {
14932 arg3 = wxString_in_helper(obj2);
14933 if (arg3 == NULL) SWIG_fail;
14934 temp3 = true;
14935 }
14936 if (obj3) {
14937 ecode4 = SWIG_AsVal_int(obj3, &val4);
14938 if (!SWIG_IsOK(ecode4)) {
14939 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeStream" "', expected argument " "4"" of type '" "int""'");
14940 }
14941 arg4 = static_cast< int >(val4);
14942 }
14943 {
14944 PyThreadState* __tstate = wxPyBeginAllowThreads();
14945 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
14946 wxPyEndAllowThreads(__tstate);
14947 if (PyErr_Occurred()) SWIG_fail;
14948 }
14949 {
14950 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14951 }
14952 {
14953 if (created2) delete arg2;
14954 }
14955 {
14956 if (temp3)
14957 delete arg3;
14958 }
14959 return resultobj;
14960 fail:
14961 {
14962 if (created2) delete arg2;
14963 }
14964 {
14965 if (temp3)
14966 delete arg3;
14967 }
14968 return NULL;
14969 }
14970
14971
14972 SWIGINTERN PyObject *_wrap_Image_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14973 PyObject *resultobj = 0;
14974 wxImage *arg1 = (wxImage *) 0 ;
14975 bool result;
14976 void *argp1 = 0 ;
14977 int res1 = 0 ;
14978 PyObject *swig_obj[1] ;
14979
14980 if (!args) SWIG_fail;
14981 swig_obj[0] = args;
14982 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14983 if (!SWIG_IsOK(res1)) {
14984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Ok" "', expected argument " "1"" of type '" "wxImage *""'");
14985 }
14986 arg1 = reinterpret_cast< wxImage * >(argp1);
14987 {
14988 PyThreadState* __tstate = wxPyBeginAllowThreads();
14989 result = (bool)(arg1)->Ok();
14990 wxPyEndAllowThreads(__tstate);
14991 if (PyErr_Occurred()) SWIG_fail;
14992 }
14993 {
14994 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14995 }
14996 return resultobj;
14997 fail:
14998 return NULL;
14999 }
15000
15001
15002 SWIGINTERN PyObject *_wrap_Image_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15003 PyObject *resultobj = 0;
15004 wxImage *arg1 = (wxImage *) 0 ;
15005 int result;
15006 void *argp1 = 0 ;
15007 int res1 = 0 ;
15008 PyObject *swig_obj[1] ;
15009
15010 if (!args) SWIG_fail;
15011 swig_obj[0] = args;
15012 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15013 if (!SWIG_IsOK(res1)) {
15014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetWidth" "', expected argument " "1"" of type '" "wxImage *""'");
15015 }
15016 arg1 = reinterpret_cast< wxImage * >(argp1);
15017 {
15018 PyThreadState* __tstate = wxPyBeginAllowThreads();
15019 result = (int)(arg1)->GetWidth();
15020 wxPyEndAllowThreads(__tstate);
15021 if (PyErr_Occurred()) SWIG_fail;
15022 }
15023 resultobj = SWIG_From_int(static_cast< int >(result));
15024 return resultobj;
15025 fail:
15026 return NULL;
15027 }
15028
15029
15030 SWIGINTERN PyObject *_wrap_Image_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15031 PyObject *resultobj = 0;
15032 wxImage *arg1 = (wxImage *) 0 ;
15033 int result;
15034 void *argp1 = 0 ;
15035 int res1 = 0 ;
15036 PyObject *swig_obj[1] ;
15037
15038 if (!args) SWIG_fail;
15039 swig_obj[0] = args;
15040 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15041 if (!SWIG_IsOK(res1)) {
15042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetHeight" "', expected argument " "1"" of type '" "wxImage *""'");
15043 }
15044 arg1 = reinterpret_cast< wxImage * >(argp1);
15045 {
15046 PyThreadState* __tstate = wxPyBeginAllowThreads();
15047 result = (int)(arg1)->GetHeight();
15048 wxPyEndAllowThreads(__tstate);
15049 if (PyErr_Occurred()) SWIG_fail;
15050 }
15051 resultobj = SWIG_From_int(static_cast< int >(result));
15052 return resultobj;
15053 fail:
15054 return NULL;
15055 }
15056
15057
15058 SWIGINTERN PyObject *_wrap_Image_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15059 PyObject *resultobj = 0;
15060 wxImage *arg1 = (wxImage *) 0 ;
15061 wxSize result;
15062 void *argp1 = 0 ;
15063 int res1 = 0 ;
15064 PyObject *swig_obj[1] ;
15065
15066 if (!args) SWIG_fail;
15067 swig_obj[0] = args;
15068 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15069 if (!SWIG_IsOK(res1)) {
15070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSize" "', expected argument " "1"" of type '" "wxImage *""'");
15071 }
15072 arg1 = reinterpret_cast< wxImage * >(argp1);
15073 {
15074 PyThreadState* __tstate = wxPyBeginAllowThreads();
15075 result = wxImage_GetSize(arg1);
15076 wxPyEndAllowThreads(__tstate);
15077 if (PyErr_Occurred()) SWIG_fail;
15078 }
15079 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
15080 return resultobj;
15081 fail:
15082 return NULL;
15083 }
15084
15085
15086 SWIGINTERN PyObject *_wrap_Image_GetSubImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15087 PyObject *resultobj = 0;
15088 wxImage *arg1 = (wxImage *) 0 ;
15089 wxRect *arg2 = 0 ;
15090 SwigValueWrapper<wxImage > result;
15091 void *argp1 = 0 ;
15092 int res1 = 0 ;
15093 wxRect temp2 ;
15094 PyObject * obj0 = 0 ;
15095 PyObject * obj1 = 0 ;
15096 char * kwnames[] = {
15097 (char *) "self",(char *) "rect", NULL
15098 };
15099
15100 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) SWIG_fail;
15101 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15102 if (!SWIG_IsOK(res1)) {
15103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSubImage" "', expected argument " "1"" of type '" "wxImage *""'");
15104 }
15105 arg1 = reinterpret_cast< wxImage * >(argp1);
15106 {
15107 arg2 = &temp2;
15108 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
15109 }
15110 {
15111 PyThreadState* __tstate = wxPyBeginAllowThreads();
15112 result = (arg1)->GetSubImage((wxRect const &)*arg2);
15113 wxPyEndAllowThreads(__tstate);
15114 if (PyErr_Occurred()) SWIG_fail;
15115 }
15116 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15117 return resultobj;
15118 fail:
15119 return NULL;
15120 }
15121
15122
15123 SWIGINTERN PyObject *_wrap_Image_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15124 PyObject *resultobj = 0;
15125 wxImage *arg1 = (wxImage *) 0 ;
15126 wxSize *arg2 = 0 ;
15127 wxPoint *arg3 = 0 ;
15128 int arg4 = (int) -1 ;
15129 int arg5 = (int) -1 ;
15130 int arg6 = (int) -1 ;
15131 SwigValueWrapper<wxImage > result;
15132 void *argp1 = 0 ;
15133 int res1 = 0 ;
15134 wxSize temp2 ;
15135 wxPoint temp3 ;
15136 int val4 ;
15137 int ecode4 = 0 ;
15138 int val5 ;
15139 int ecode5 = 0 ;
15140 int val6 ;
15141 int ecode6 = 0 ;
15142 PyObject * obj0 = 0 ;
15143 PyObject * obj1 = 0 ;
15144 PyObject * obj2 = 0 ;
15145 PyObject * obj3 = 0 ;
15146 PyObject * obj4 = 0 ;
15147 PyObject * obj5 = 0 ;
15148 char * kwnames[] = {
15149 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
15150 };
15151
15152 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
15153 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15154 if (!SWIG_IsOK(res1)) {
15155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Size" "', expected argument " "1"" of type '" "wxImage const *""'");
15156 }
15157 arg1 = reinterpret_cast< wxImage * >(argp1);
15158 {
15159 arg2 = &temp2;
15160 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
15161 }
15162 {
15163 arg3 = &temp3;
15164 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
15165 }
15166 if (obj3) {
15167 ecode4 = SWIG_AsVal_int(obj3, &val4);
15168 if (!SWIG_IsOK(ecode4)) {
15169 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Size" "', expected argument " "4"" of type '" "int""'");
15170 }
15171 arg4 = static_cast< int >(val4);
15172 }
15173 if (obj4) {
15174 ecode5 = SWIG_AsVal_int(obj4, &val5);
15175 if (!SWIG_IsOK(ecode5)) {
15176 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Size" "', expected argument " "5"" of type '" "int""'");
15177 }
15178 arg5 = static_cast< int >(val5);
15179 }
15180 if (obj5) {
15181 ecode6 = SWIG_AsVal_int(obj5, &val6);
15182 if (!SWIG_IsOK(ecode6)) {
15183 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Size" "', expected argument " "6"" of type '" "int""'");
15184 }
15185 arg6 = static_cast< int >(val6);
15186 }
15187 {
15188 PyThreadState* __tstate = wxPyBeginAllowThreads();
15189 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
15190 wxPyEndAllowThreads(__tstate);
15191 if (PyErr_Occurred()) SWIG_fail;
15192 }
15193 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15194 return resultobj;
15195 fail:
15196 return NULL;
15197 }
15198
15199
15200 SWIGINTERN PyObject *_wrap_Image_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15201 PyObject *resultobj = 0;
15202 wxImage *arg1 = (wxImage *) 0 ;
15203 SwigValueWrapper<wxImage > result;
15204 void *argp1 = 0 ;
15205 int res1 = 0 ;
15206 PyObject *swig_obj[1] ;
15207
15208 if (!args) SWIG_fail;
15209 swig_obj[0] = args;
15210 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15211 if (!SWIG_IsOK(res1)) {
15212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Copy" "', expected argument " "1"" of type '" "wxImage *""'");
15213 }
15214 arg1 = reinterpret_cast< wxImage * >(argp1);
15215 {
15216 PyThreadState* __tstate = wxPyBeginAllowThreads();
15217 result = (arg1)->Copy();
15218 wxPyEndAllowThreads(__tstate);
15219 if (PyErr_Occurred()) SWIG_fail;
15220 }
15221 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15222 return resultobj;
15223 fail:
15224 return NULL;
15225 }
15226
15227
15228 SWIGINTERN PyObject *_wrap_Image_Paste(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15229 PyObject *resultobj = 0;
15230 wxImage *arg1 = (wxImage *) 0 ;
15231 wxImage *arg2 = 0 ;
15232 int arg3 ;
15233 int arg4 ;
15234 void *argp1 = 0 ;
15235 int res1 = 0 ;
15236 void *argp2 = 0 ;
15237 int res2 = 0 ;
15238 int val3 ;
15239 int ecode3 = 0 ;
15240 int val4 ;
15241 int ecode4 = 0 ;
15242 PyObject * obj0 = 0 ;
15243 PyObject * obj1 = 0 ;
15244 PyObject * obj2 = 0 ;
15245 PyObject * obj3 = 0 ;
15246 char * kwnames[] = {
15247 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
15248 };
15249
15250 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15251 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15252 if (!SWIG_IsOK(res1)) {
15253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Paste" "', expected argument " "1"" of type '" "wxImage *""'");
15254 }
15255 arg1 = reinterpret_cast< wxImage * >(argp1);
15256 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
15257 if (!SWIG_IsOK(res2)) {
15258 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15259 }
15260 if (!argp2) {
15261 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15262 }
15263 arg2 = reinterpret_cast< wxImage * >(argp2);
15264 ecode3 = SWIG_AsVal_int(obj2, &val3);
15265 if (!SWIG_IsOK(ecode3)) {
15266 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Paste" "', expected argument " "3"" of type '" "int""'");
15267 }
15268 arg3 = static_cast< int >(val3);
15269 ecode4 = SWIG_AsVal_int(obj3, &val4);
15270 if (!SWIG_IsOK(ecode4)) {
15271 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Paste" "', expected argument " "4"" of type '" "int""'");
15272 }
15273 arg4 = static_cast< int >(val4);
15274 {
15275 PyThreadState* __tstate = wxPyBeginAllowThreads();
15276 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
15277 wxPyEndAllowThreads(__tstate);
15278 if (PyErr_Occurred()) SWIG_fail;
15279 }
15280 resultobj = SWIG_Py_Void();
15281 return resultobj;
15282 fail:
15283 return NULL;
15284 }
15285
15286
15287 SWIGINTERN PyObject *_wrap_Image_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15288 PyObject *resultobj = 0;
15289 wxImage *arg1 = (wxImage *) 0 ;
15290 PyObject *result = 0 ;
15291 void *argp1 = 0 ;
15292 int res1 = 0 ;
15293 PyObject *swig_obj[1] ;
15294
15295 if (!args) SWIG_fail;
15296 swig_obj[0] = args;
15297 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15298 if (!SWIG_IsOK(res1)) {
15299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetData" "', expected argument " "1"" of type '" "wxImage *""'");
15300 }
15301 arg1 = reinterpret_cast< wxImage * >(argp1);
15302 {
15303 PyThreadState* __tstate = wxPyBeginAllowThreads();
15304 result = (PyObject *)wxImage_GetData(arg1);
15305 wxPyEndAllowThreads(__tstate);
15306 if (PyErr_Occurred()) SWIG_fail;
15307 }
15308 resultobj = result;
15309 return resultobj;
15310 fail:
15311 return NULL;
15312 }
15313
15314
15315 SWIGINTERN PyObject *_wrap_Image_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15316 PyObject *resultobj = 0;
15317 wxImage *arg1 = (wxImage *) 0 ;
15318 buffer arg2 ;
15319 int arg3 ;
15320 void *argp1 = 0 ;
15321 int res1 = 0 ;
15322 PyObject * obj0 = 0 ;
15323 PyObject * obj1 = 0 ;
15324 char * kwnames[] = {
15325 (char *) "self",(char *) "data", NULL
15326 };
15327
15328 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
15329 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15330 if (!SWIG_IsOK(res1)) {
15331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetData" "', expected argument " "1"" of type '" "wxImage *""'");
15332 }
15333 arg1 = reinterpret_cast< wxImage * >(argp1);
15334 {
15335 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15336 }
15337 {
15338 PyThreadState* __tstate = wxPyBeginAllowThreads();
15339 wxImage_SetData(arg1,arg2,arg3);
15340 wxPyEndAllowThreads(__tstate);
15341 if (PyErr_Occurred()) SWIG_fail;
15342 }
15343 resultobj = SWIG_Py_Void();
15344 return resultobj;
15345 fail:
15346 return NULL;
15347 }
15348
15349
15350 SWIGINTERN PyObject *_wrap_Image_GetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15351 PyObject *resultobj = 0;
15352 wxImage *arg1 = (wxImage *) 0 ;
15353 PyObject *result = 0 ;
15354 void *argp1 = 0 ;
15355 int res1 = 0 ;
15356 PyObject *swig_obj[1] ;
15357
15358 if (!args) SWIG_fail;
15359 swig_obj[0] = args;
15360 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15361 if (!SWIG_IsOK(res1)) {
15362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15363 }
15364 arg1 = reinterpret_cast< wxImage * >(argp1);
15365 {
15366 PyThreadState* __tstate = wxPyBeginAllowThreads();
15367 result = (PyObject *)wxImage_GetDataBuffer(arg1);
15368 wxPyEndAllowThreads(__tstate);
15369 if (PyErr_Occurred()) SWIG_fail;
15370 }
15371 resultobj = result;
15372 return resultobj;
15373 fail:
15374 return NULL;
15375 }
15376
15377
15378 SWIGINTERN PyObject *_wrap_Image_SetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15379 PyObject *resultobj = 0;
15380 wxImage *arg1 = (wxImage *) 0 ;
15381 buffer arg2 ;
15382 int arg3 ;
15383 void *argp1 = 0 ;
15384 int res1 = 0 ;
15385 PyObject * obj0 = 0 ;
15386 PyObject * obj1 = 0 ;
15387 char * kwnames[] = {
15388 (char *) "self",(char *) "data", NULL
15389 };
15390
15391 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
15392 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15393 if (!SWIG_IsOK(res1)) {
15394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15395 }
15396 arg1 = reinterpret_cast< wxImage * >(argp1);
15397 {
15398 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15399 }
15400 {
15401 PyThreadState* __tstate = wxPyBeginAllowThreads();
15402 wxImage_SetDataBuffer(arg1,arg2,arg3);
15403 wxPyEndAllowThreads(__tstate);
15404 if (PyErr_Occurred()) SWIG_fail;
15405 }
15406 resultobj = SWIG_Py_Void();
15407 return resultobj;
15408 fail:
15409 return NULL;
15410 }
15411
15412
15413 SWIGINTERN PyObject *_wrap_Image_GetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15414 PyObject *resultobj = 0;
15415 wxImage *arg1 = (wxImage *) 0 ;
15416 PyObject *result = 0 ;
15417 void *argp1 = 0 ;
15418 int res1 = 0 ;
15419 PyObject *swig_obj[1] ;
15420
15421 if (!args) SWIG_fail;
15422 swig_obj[0] = args;
15423 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15424 if (!SWIG_IsOK(res1)) {
15425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15426 }
15427 arg1 = reinterpret_cast< wxImage * >(argp1);
15428 {
15429 PyThreadState* __tstate = wxPyBeginAllowThreads();
15430 result = (PyObject *)wxImage_GetAlphaData(arg1);
15431 wxPyEndAllowThreads(__tstate);
15432 if (PyErr_Occurred()) SWIG_fail;
15433 }
15434 resultobj = result;
15435 return resultobj;
15436 fail:
15437 return NULL;
15438 }
15439
15440
15441 SWIGINTERN PyObject *_wrap_Image_SetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15442 PyObject *resultobj = 0;
15443 wxImage *arg1 = (wxImage *) 0 ;
15444 buffer arg2 ;
15445 int arg3 ;
15446 void *argp1 = 0 ;
15447 int res1 = 0 ;
15448 PyObject * obj0 = 0 ;
15449 PyObject * obj1 = 0 ;
15450 char * kwnames[] = {
15451 (char *) "self",(char *) "alpha", NULL
15452 };
15453
15454 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) SWIG_fail;
15455 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15456 if (!SWIG_IsOK(res1)) {
15457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15458 }
15459 arg1 = reinterpret_cast< wxImage * >(argp1);
15460 {
15461 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15462 }
15463 {
15464 PyThreadState* __tstate = wxPyBeginAllowThreads();
15465 wxImage_SetAlphaData(arg1,arg2,arg3);
15466 wxPyEndAllowThreads(__tstate);
15467 if (PyErr_Occurred()) SWIG_fail;
15468 }
15469 resultobj = SWIG_Py_Void();
15470 return resultobj;
15471 fail:
15472 return NULL;
15473 }
15474
15475
15476 SWIGINTERN PyObject *_wrap_Image_GetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15477 PyObject *resultobj = 0;
15478 wxImage *arg1 = (wxImage *) 0 ;
15479 PyObject *result = 0 ;
15480 void *argp1 = 0 ;
15481 int res1 = 0 ;
15482 PyObject *swig_obj[1] ;
15483
15484 if (!args) SWIG_fail;
15485 swig_obj[0] = args;
15486 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15487 if (!SWIG_IsOK(res1)) {
15488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15489 }
15490 arg1 = reinterpret_cast< wxImage * >(argp1);
15491 {
15492 PyThreadState* __tstate = wxPyBeginAllowThreads();
15493 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
15494 wxPyEndAllowThreads(__tstate);
15495 if (PyErr_Occurred()) SWIG_fail;
15496 }
15497 resultobj = result;
15498 return resultobj;
15499 fail:
15500 return NULL;
15501 }
15502
15503
15504 SWIGINTERN PyObject *_wrap_Image_SetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15505 PyObject *resultobj = 0;
15506 wxImage *arg1 = (wxImage *) 0 ;
15507 buffer arg2 ;
15508 int arg3 ;
15509 void *argp1 = 0 ;
15510 int res1 = 0 ;
15511 PyObject * obj0 = 0 ;
15512 PyObject * obj1 = 0 ;
15513 char * kwnames[] = {
15514 (char *) "self",(char *) "alpha", NULL
15515 };
15516
15517 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
15518 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15519 if (!SWIG_IsOK(res1)) {
15520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15521 }
15522 arg1 = reinterpret_cast< wxImage * >(argp1);
15523 {
15524 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15525 }
15526 {
15527 PyThreadState* __tstate = wxPyBeginAllowThreads();
15528 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
15529 wxPyEndAllowThreads(__tstate);
15530 if (PyErr_Occurred()) SWIG_fail;
15531 }
15532 resultobj = SWIG_Py_Void();
15533 return resultobj;
15534 fail:
15535 return NULL;
15536 }
15537
15538
15539 SWIGINTERN PyObject *_wrap_Image_SetMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15540 PyObject *resultobj = 0;
15541 wxImage *arg1 = (wxImage *) 0 ;
15542 byte arg2 ;
15543 byte arg3 ;
15544 byte arg4 ;
15545 void *argp1 = 0 ;
15546 int res1 = 0 ;
15547 unsigned char val2 ;
15548 int ecode2 = 0 ;
15549 unsigned char val3 ;
15550 int ecode3 = 0 ;
15551 unsigned char val4 ;
15552 int ecode4 = 0 ;
15553 PyObject * obj0 = 0 ;
15554 PyObject * obj1 = 0 ;
15555 PyObject * obj2 = 0 ;
15556 PyObject * obj3 = 0 ;
15557 char * kwnames[] = {
15558 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
15559 };
15560
15561 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15562 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15563 if (!SWIG_IsOK(res1)) {
15564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskColour" "', expected argument " "1"" of type '" "wxImage *""'");
15565 }
15566 arg1 = reinterpret_cast< wxImage * >(argp1);
15567 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15568 if (!SWIG_IsOK(ecode2)) {
15569 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMaskColour" "', expected argument " "2"" of type '" "byte""'");
15570 }
15571 arg2 = static_cast< byte >(val2);
15572 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15573 if (!SWIG_IsOK(ecode3)) {
15574 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskColour" "', expected argument " "3"" of type '" "byte""'");
15575 }
15576 arg3 = static_cast< byte >(val3);
15577 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
15578 if (!SWIG_IsOK(ecode4)) {
15579 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskColour" "', expected argument " "4"" of type '" "byte""'");
15580 }
15581 arg4 = static_cast< byte >(val4);
15582 {
15583 PyThreadState* __tstate = wxPyBeginAllowThreads();
15584 (arg1)->SetMaskColour(arg2,arg3,arg4);
15585 wxPyEndAllowThreads(__tstate);
15586 if (PyErr_Occurred()) SWIG_fail;
15587 }
15588 resultobj = SWIG_Py_Void();
15589 return resultobj;
15590 fail:
15591 return NULL;
15592 }
15593
15594
15595 SWIGINTERN PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15596 PyObject *resultobj = 0;
15597 wxImage *arg1 = (wxImage *) 0 ;
15598 byte *arg2 = (byte *) 0 ;
15599 byte *arg3 = (byte *) 0 ;
15600 byte *arg4 = (byte *) 0 ;
15601 void *argp1 = 0 ;
15602 int res1 = 0 ;
15603 byte temp2 ;
15604 int res2 = SWIG_TMPOBJ ;
15605 byte temp3 ;
15606 int res3 = SWIG_TMPOBJ ;
15607 byte temp4 ;
15608 int res4 = SWIG_TMPOBJ ;
15609 PyObject *swig_obj[1] ;
15610
15611 arg2 = &temp2;
15612 arg3 = &temp3;
15613 arg4 = &temp4;
15614 if (!args) SWIG_fail;
15615 swig_obj[0] = args;
15616 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15617 if (!SWIG_IsOK(res1)) {
15618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOrFindMaskColour" "', expected argument " "1"" of type '" "wxImage const *""'");
15619 }
15620 arg1 = reinterpret_cast< wxImage * >(argp1);
15621 {
15622 PyThreadState* __tstate = wxPyBeginAllowThreads();
15623 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
15624 wxPyEndAllowThreads(__tstate);
15625 if (PyErr_Occurred()) SWIG_fail;
15626 }
15627 resultobj = SWIG_Py_Void();
15628 if (SWIG_IsTmpObj(res2)) {
15629 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
15630 } else {
15631 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15632 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
15633 }
15634 if (SWIG_IsTmpObj(res3)) {
15635 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
15636 } else {
15637 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15638 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
15639 }
15640 if (SWIG_IsTmpObj(res4)) {
15641 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
15642 } else {
15643 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15644 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
15645 }
15646 return resultobj;
15647 fail:
15648 return NULL;
15649 }
15650
15651
15652 SWIGINTERN PyObject *_wrap_Image_GetMaskRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15653 PyObject *resultobj = 0;
15654 wxImage *arg1 = (wxImage *) 0 ;
15655 byte result;
15656 void *argp1 = 0 ;
15657 int res1 = 0 ;
15658 PyObject *swig_obj[1] ;
15659
15660 if (!args) SWIG_fail;
15661 swig_obj[0] = args;
15662 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15663 if (!SWIG_IsOK(res1)) {
15664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskRed" "', expected argument " "1"" of type '" "wxImage *""'");
15665 }
15666 arg1 = reinterpret_cast< wxImage * >(argp1);
15667 {
15668 PyThreadState* __tstate = wxPyBeginAllowThreads();
15669 result = (byte)(arg1)->GetMaskRed();
15670 wxPyEndAllowThreads(__tstate);
15671 if (PyErr_Occurred()) SWIG_fail;
15672 }
15673 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15674 return resultobj;
15675 fail:
15676 return NULL;
15677 }
15678
15679
15680 SWIGINTERN PyObject *_wrap_Image_GetMaskGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15681 PyObject *resultobj = 0;
15682 wxImage *arg1 = (wxImage *) 0 ;
15683 byte result;
15684 void *argp1 = 0 ;
15685 int res1 = 0 ;
15686 PyObject *swig_obj[1] ;
15687
15688 if (!args) SWIG_fail;
15689 swig_obj[0] = args;
15690 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15691 if (!SWIG_IsOK(res1)) {
15692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskGreen" "', expected argument " "1"" of type '" "wxImage *""'");
15693 }
15694 arg1 = reinterpret_cast< wxImage * >(argp1);
15695 {
15696 PyThreadState* __tstate = wxPyBeginAllowThreads();
15697 result = (byte)(arg1)->GetMaskGreen();
15698 wxPyEndAllowThreads(__tstate);
15699 if (PyErr_Occurred()) SWIG_fail;
15700 }
15701 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15702 return resultobj;
15703 fail:
15704 return NULL;
15705 }
15706
15707
15708 SWIGINTERN PyObject *_wrap_Image_GetMaskBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15709 PyObject *resultobj = 0;
15710 wxImage *arg1 = (wxImage *) 0 ;
15711 byte result;
15712 void *argp1 = 0 ;
15713 int res1 = 0 ;
15714 PyObject *swig_obj[1] ;
15715
15716 if (!args) SWIG_fail;
15717 swig_obj[0] = args;
15718 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15719 if (!SWIG_IsOK(res1)) {
15720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskBlue" "', expected argument " "1"" of type '" "wxImage *""'");
15721 }
15722 arg1 = reinterpret_cast< wxImage * >(argp1);
15723 {
15724 PyThreadState* __tstate = wxPyBeginAllowThreads();
15725 result = (byte)(arg1)->GetMaskBlue();
15726 wxPyEndAllowThreads(__tstate);
15727 if (PyErr_Occurred()) SWIG_fail;
15728 }
15729 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15730 return resultobj;
15731 fail:
15732 return NULL;
15733 }
15734
15735
15736 SWIGINTERN PyObject *_wrap_Image_SetMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15737 PyObject *resultobj = 0;
15738 wxImage *arg1 = (wxImage *) 0 ;
15739 bool arg2 = (bool) true ;
15740 void *argp1 = 0 ;
15741 int res1 = 0 ;
15742 bool val2 ;
15743 int ecode2 = 0 ;
15744 PyObject * obj0 = 0 ;
15745 PyObject * obj1 = 0 ;
15746 char * kwnames[] = {
15747 (char *) "self",(char *) "mask", NULL
15748 };
15749
15750 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) SWIG_fail;
15751 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15752 if (!SWIG_IsOK(res1)) {
15753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMask" "', expected argument " "1"" of type '" "wxImage *""'");
15754 }
15755 arg1 = reinterpret_cast< wxImage * >(argp1);
15756 if (obj1) {
15757 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15758 if (!SWIG_IsOK(ecode2)) {
15759 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMask" "', expected argument " "2"" of type '" "bool""'");
15760 }
15761 arg2 = static_cast< bool >(val2);
15762 }
15763 {
15764 PyThreadState* __tstate = wxPyBeginAllowThreads();
15765 (arg1)->SetMask(arg2);
15766 wxPyEndAllowThreads(__tstate);
15767 if (PyErr_Occurred()) SWIG_fail;
15768 }
15769 resultobj = SWIG_Py_Void();
15770 return resultobj;
15771 fail:
15772 return NULL;
15773 }
15774
15775
15776 SWIGINTERN PyObject *_wrap_Image_HasMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15777 PyObject *resultobj = 0;
15778 wxImage *arg1 = (wxImage *) 0 ;
15779 bool result;
15780 void *argp1 = 0 ;
15781 int res1 = 0 ;
15782 PyObject *swig_obj[1] ;
15783
15784 if (!args) SWIG_fail;
15785 swig_obj[0] = args;
15786 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15787 if (!SWIG_IsOK(res1)) {
15788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasMask" "', expected argument " "1"" of type '" "wxImage *""'");
15789 }
15790 arg1 = reinterpret_cast< wxImage * >(argp1);
15791 {
15792 PyThreadState* __tstate = wxPyBeginAllowThreads();
15793 result = (bool)(arg1)->HasMask();
15794 wxPyEndAllowThreads(__tstate);
15795 if (PyErr_Occurred()) SWIG_fail;
15796 }
15797 {
15798 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15799 }
15800 return resultobj;
15801 fail:
15802 return NULL;
15803 }
15804
15805
15806 SWIGINTERN PyObject *_wrap_Image_Rotate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15807 PyObject *resultobj = 0;
15808 wxImage *arg1 = (wxImage *) 0 ;
15809 double arg2 ;
15810 wxPoint *arg3 = 0 ;
15811 bool arg4 = (bool) true ;
15812 wxPoint *arg5 = (wxPoint *) NULL ;
15813 SwigValueWrapper<wxImage > result;
15814 void *argp1 = 0 ;
15815 int res1 = 0 ;
15816 double val2 ;
15817 int ecode2 = 0 ;
15818 wxPoint temp3 ;
15819 bool val4 ;
15820 int ecode4 = 0 ;
15821 void *argp5 = 0 ;
15822 int res5 = 0 ;
15823 PyObject * obj0 = 0 ;
15824 PyObject * obj1 = 0 ;
15825 PyObject * obj2 = 0 ;
15826 PyObject * obj3 = 0 ;
15827 PyObject * obj4 = 0 ;
15828 char * kwnames[] = {
15829 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
15830 };
15831
15832 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
15833 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15834 if (!SWIG_IsOK(res1)) {
15835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate" "', expected argument " "1"" of type '" "wxImage const *""'");
15836 }
15837 arg1 = reinterpret_cast< wxImage * >(argp1);
15838 ecode2 = SWIG_AsVal_double(obj1, &val2);
15839 if (!SWIG_IsOK(ecode2)) {
15840 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate" "', expected argument " "2"" of type '" "double""'");
15841 }
15842 arg2 = static_cast< double >(val2);
15843 {
15844 arg3 = &temp3;
15845 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
15846 }
15847 if (obj3) {
15848 ecode4 = SWIG_AsVal_bool(obj3, &val4);
15849 if (!SWIG_IsOK(ecode4)) {
15850 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rotate" "', expected argument " "4"" of type '" "bool""'");
15851 }
15852 arg4 = static_cast< bool >(val4);
15853 }
15854 if (obj4) {
15855 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxPoint, 0 | 0 );
15856 if (!SWIG_IsOK(res5)) {
15857 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Image_Rotate" "', expected argument " "5"" of type '" "wxPoint *""'");
15858 }
15859 arg5 = reinterpret_cast< wxPoint * >(argp5);
15860 }
15861 {
15862 PyThreadState* __tstate = wxPyBeginAllowThreads();
15863 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
15864 wxPyEndAllowThreads(__tstate);
15865 if (PyErr_Occurred()) SWIG_fail;
15866 }
15867 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15868 return resultobj;
15869 fail:
15870 return NULL;
15871 }
15872
15873
15874 SWIGINTERN PyObject *_wrap_Image_Rotate90(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15875 PyObject *resultobj = 0;
15876 wxImage *arg1 = (wxImage *) 0 ;
15877 bool arg2 = (bool) true ;
15878 SwigValueWrapper<wxImage > result;
15879 void *argp1 = 0 ;
15880 int res1 = 0 ;
15881 bool val2 ;
15882 int ecode2 = 0 ;
15883 PyObject * obj0 = 0 ;
15884 PyObject * obj1 = 0 ;
15885 char * kwnames[] = {
15886 (char *) "self",(char *) "clockwise", NULL
15887 };
15888
15889 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) SWIG_fail;
15890 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15891 if (!SWIG_IsOK(res1)) {
15892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate90" "', expected argument " "1"" of type '" "wxImage *""'");
15893 }
15894 arg1 = reinterpret_cast< wxImage * >(argp1);
15895 if (obj1) {
15896 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15897 if (!SWIG_IsOK(ecode2)) {
15898 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate90" "', expected argument " "2"" of type '" "bool""'");
15899 }
15900 arg2 = static_cast< bool >(val2);
15901 }
15902 {
15903 PyThreadState* __tstate = wxPyBeginAllowThreads();
15904 result = (arg1)->Rotate90(arg2);
15905 wxPyEndAllowThreads(__tstate);
15906 if (PyErr_Occurred()) SWIG_fail;
15907 }
15908 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15909 return resultobj;
15910 fail:
15911 return NULL;
15912 }
15913
15914
15915 SWIGINTERN PyObject *_wrap_Image_Mirror(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15916 PyObject *resultobj = 0;
15917 wxImage *arg1 = (wxImage *) 0 ;
15918 bool arg2 = (bool) true ;
15919 SwigValueWrapper<wxImage > result;
15920 void *argp1 = 0 ;
15921 int res1 = 0 ;
15922 bool val2 ;
15923 int ecode2 = 0 ;
15924 PyObject * obj0 = 0 ;
15925 PyObject * obj1 = 0 ;
15926 char * kwnames[] = {
15927 (char *) "self",(char *) "horizontally", NULL
15928 };
15929
15930 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) SWIG_fail;
15931 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15932 if (!SWIG_IsOK(res1)) {
15933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Mirror" "', expected argument " "1"" of type '" "wxImage *""'");
15934 }
15935 arg1 = reinterpret_cast< wxImage * >(argp1);
15936 if (obj1) {
15937 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15938 if (!SWIG_IsOK(ecode2)) {
15939 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Mirror" "', expected argument " "2"" of type '" "bool""'");
15940 }
15941 arg2 = static_cast< bool >(val2);
15942 }
15943 {
15944 PyThreadState* __tstate = wxPyBeginAllowThreads();
15945 result = (arg1)->Mirror(arg2);
15946 wxPyEndAllowThreads(__tstate);
15947 if (PyErr_Occurred()) SWIG_fail;
15948 }
15949 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15950 return resultobj;
15951 fail:
15952 return NULL;
15953 }
15954
15955
15956 SWIGINTERN PyObject *_wrap_Image_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15957 PyObject *resultobj = 0;
15958 wxImage *arg1 = (wxImage *) 0 ;
15959 byte arg2 ;
15960 byte arg3 ;
15961 byte arg4 ;
15962 byte arg5 ;
15963 byte arg6 ;
15964 byte arg7 ;
15965 void *argp1 = 0 ;
15966 int res1 = 0 ;
15967 unsigned char val2 ;
15968 int ecode2 = 0 ;
15969 unsigned char val3 ;
15970 int ecode3 = 0 ;
15971 unsigned char val4 ;
15972 int ecode4 = 0 ;
15973 unsigned char val5 ;
15974 int ecode5 = 0 ;
15975 unsigned char val6 ;
15976 int ecode6 = 0 ;
15977 unsigned char val7 ;
15978 int ecode7 = 0 ;
15979 PyObject * obj0 = 0 ;
15980 PyObject * obj1 = 0 ;
15981 PyObject * obj2 = 0 ;
15982 PyObject * obj3 = 0 ;
15983 PyObject * obj4 = 0 ;
15984 PyObject * obj5 = 0 ;
15985 PyObject * obj6 = 0 ;
15986 char * kwnames[] = {
15987 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
15988 };
15989
15990 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
15991 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15992 if (!SWIG_IsOK(res1)) {
15993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Replace" "', expected argument " "1"" of type '" "wxImage *""'");
15994 }
15995 arg1 = reinterpret_cast< wxImage * >(argp1);
15996 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15997 if (!SWIG_IsOK(ecode2)) {
15998 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Replace" "', expected argument " "2"" of type '" "byte""'");
15999 }
16000 arg2 = static_cast< byte >(val2);
16001 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16002 if (!SWIG_IsOK(ecode3)) {
16003 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Replace" "', expected argument " "3"" of type '" "byte""'");
16004 }
16005 arg3 = static_cast< byte >(val3);
16006 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16007 if (!SWIG_IsOK(ecode4)) {
16008 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Replace" "', expected argument " "4"" of type '" "byte""'");
16009 }
16010 arg4 = static_cast< byte >(val4);
16011 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
16012 if (!SWIG_IsOK(ecode5)) {
16013 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Replace" "', expected argument " "5"" of type '" "byte""'");
16014 }
16015 arg5 = static_cast< byte >(val5);
16016 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
16017 if (!SWIG_IsOK(ecode6)) {
16018 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Replace" "', expected argument " "6"" of type '" "byte""'");
16019 }
16020 arg6 = static_cast< byte >(val6);
16021 ecode7 = SWIG_AsVal_unsigned_SS_char(obj6, &val7);
16022 if (!SWIG_IsOK(ecode7)) {
16023 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_Replace" "', expected argument " "7"" of type '" "byte""'");
16024 }
16025 arg7 = static_cast< byte >(val7);
16026 {
16027 PyThreadState* __tstate = wxPyBeginAllowThreads();
16028 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
16029 wxPyEndAllowThreads(__tstate);
16030 if (PyErr_Occurred()) SWIG_fail;
16031 }
16032 resultobj = SWIG_Py_Void();
16033 return resultobj;
16034 fail:
16035 return NULL;
16036 }
16037
16038
16039 SWIGINTERN PyObject *_wrap_Image_ConvertToGreyscale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16040 PyObject *resultobj = 0;
16041 wxImage *arg1 = (wxImage *) 0 ;
16042 double arg2 = (double) 0.299 ;
16043 double arg3 = (double) 0.587 ;
16044 double arg4 = (double) 0.114 ;
16045 SwigValueWrapper<wxImage > result;
16046 void *argp1 = 0 ;
16047 int res1 = 0 ;
16048 double val2 ;
16049 int ecode2 = 0 ;
16050 double val3 ;
16051 int ecode3 = 0 ;
16052 double val4 ;
16053 int ecode4 = 0 ;
16054 PyObject * obj0 = 0 ;
16055 PyObject * obj1 = 0 ;
16056 PyObject * obj2 = 0 ;
16057 PyObject * obj3 = 0 ;
16058 char * kwnames[] = {
16059 (char *) "self",(char *) "lr",(char *) "lg",(char *) "lb", NULL
16060 };
16061
16062 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_ConvertToGreyscale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16063 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16064 if (!SWIG_IsOK(res1)) {
16065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToGreyscale" "', expected argument " "1"" of type '" "wxImage const *""'");
16066 }
16067 arg1 = reinterpret_cast< wxImage * >(argp1);
16068 if (obj1) {
16069 ecode2 = SWIG_AsVal_double(obj1, &val2);
16070 if (!SWIG_IsOK(ecode2)) {
16071 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToGreyscale" "', expected argument " "2"" of type '" "double""'");
16072 }
16073 arg2 = static_cast< double >(val2);
16074 }
16075 if (obj2) {
16076 ecode3 = SWIG_AsVal_double(obj2, &val3);
16077 if (!SWIG_IsOK(ecode3)) {
16078 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToGreyscale" "', expected argument " "3"" of type '" "double""'");
16079 }
16080 arg3 = static_cast< double >(val3);
16081 }
16082 if (obj3) {
16083 ecode4 = SWIG_AsVal_double(obj3, &val4);
16084 if (!SWIG_IsOK(ecode4)) {
16085 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToGreyscale" "', expected argument " "4"" of type '" "double""'");
16086 }
16087 arg4 = static_cast< double >(val4);
16088 }
16089 {
16090 PyThreadState* __tstate = wxPyBeginAllowThreads();
16091 result = ((wxImage const *)arg1)->ConvertToGreyscale(arg2,arg3,arg4);
16092 wxPyEndAllowThreads(__tstate);
16093 if (PyErr_Occurred()) SWIG_fail;
16094 }
16095 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16096 return resultobj;
16097 fail:
16098 return NULL;
16099 }
16100
16101
16102 SWIGINTERN PyObject *_wrap_Image_ConvertToMono(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16103 PyObject *resultobj = 0;
16104 wxImage *arg1 = (wxImage *) 0 ;
16105 byte arg2 ;
16106 byte arg3 ;
16107 byte arg4 ;
16108 SwigValueWrapper<wxImage > result;
16109 void *argp1 = 0 ;
16110 int res1 = 0 ;
16111 unsigned char val2 ;
16112 int ecode2 = 0 ;
16113 unsigned char val3 ;
16114 int ecode3 = 0 ;
16115 unsigned char val4 ;
16116 int ecode4 = 0 ;
16117 PyObject * obj0 = 0 ;
16118 PyObject * obj1 = 0 ;
16119 PyObject * obj2 = 0 ;
16120 PyObject * obj3 = 0 ;
16121 char * kwnames[] = {
16122 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
16123 };
16124
16125 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16126 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16127 if (!SWIG_IsOK(res1)) {
16128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMono" "', expected argument " "1"" of type '" "wxImage const *""'");
16129 }
16130 arg1 = reinterpret_cast< wxImage * >(argp1);
16131 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16132 if (!SWIG_IsOK(ecode2)) {
16133 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMono" "', expected argument " "2"" of type '" "byte""'");
16134 }
16135 arg2 = static_cast< byte >(val2);
16136 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16137 if (!SWIG_IsOK(ecode3)) {
16138 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMono" "', expected argument " "3"" of type '" "byte""'");
16139 }
16140 arg3 = static_cast< byte >(val3);
16141 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16142 if (!SWIG_IsOK(ecode4)) {
16143 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMono" "', expected argument " "4"" of type '" "byte""'");
16144 }
16145 arg4 = static_cast< byte >(val4);
16146 {
16147 PyThreadState* __tstate = wxPyBeginAllowThreads();
16148 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
16149 wxPyEndAllowThreads(__tstate);
16150 if (PyErr_Occurred()) SWIG_fail;
16151 }
16152 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16153 return resultobj;
16154 fail:
16155 return NULL;
16156 }
16157
16158
16159 SWIGINTERN PyObject *_wrap_Image_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16160 PyObject *resultobj = 0;
16161 wxImage *arg1 = (wxImage *) 0 ;
16162 wxString *arg2 = 0 ;
16163 wxString *arg3 = 0 ;
16164 void *argp1 = 0 ;
16165 int res1 = 0 ;
16166 bool temp2 = false ;
16167 bool temp3 = false ;
16168 PyObject * obj0 = 0 ;
16169 PyObject * obj1 = 0 ;
16170 PyObject * obj2 = 0 ;
16171 char * kwnames[] = {
16172 (char *) "self",(char *) "name",(char *) "value", NULL
16173 };
16174
16175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16176 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16177 if (!SWIG_IsOK(res1)) {
16178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOption" "', expected argument " "1"" of type '" "wxImage *""'");
16179 }
16180 arg1 = reinterpret_cast< wxImage * >(argp1);
16181 {
16182 arg2 = wxString_in_helper(obj1);
16183 if (arg2 == NULL) SWIG_fail;
16184 temp2 = true;
16185 }
16186 {
16187 arg3 = wxString_in_helper(obj2);
16188 if (arg3 == NULL) SWIG_fail;
16189 temp3 = true;
16190 }
16191 {
16192 PyThreadState* __tstate = wxPyBeginAllowThreads();
16193 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
16194 wxPyEndAllowThreads(__tstate);
16195 if (PyErr_Occurred()) SWIG_fail;
16196 }
16197 resultobj = SWIG_Py_Void();
16198 {
16199 if (temp2)
16200 delete arg2;
16201 }
16202 {
16203 if (temp3)
16204 delete arg3;
16205 }
16206 return resultobj;
16207 fail:
16208 {
16209 if (temp2)
16210 delete arg2;
16211 }
16212 {
16213 if (temp3)
16214 delete arg3;
16215 }
16216 return NULL;
16217 }
16218
16219
16220 SWIGINTERN PyObject *_wrap_Image_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16221 PyObject *resultobj = 0;
16222 wxImage *arg1 = (wxImage *) 0 ;
16223 wxString *arg2 = 0 ;
16224 int arg3 ;
16225 void *argp1 = 0 ;
16226 int res1 = 0 ;
16227 bool temp2 = false ;
16228 int val3 ;
16229 int ecode3 = 0 ;
16230 PyObject * obj0 = 0 ;
16231 PyObject * obj1 = 0 ;
16232 PyObject * obj2 = 0 ;
16233 char * kwnames[] = {
16234 (char *) "self",(char *) "name",(char *) "value", NULL
16235 };
16236
16237 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16238 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16239 if (!SWIG_IsOK(res1)) {
16240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOptionInt" "', expected argument " "1"" of type '" "wxImage *""'");
16241 }
16242 arg1 = reinterpret_cast< wxImage * >(argp1);
16243 {
16244 arg2 = wxString_in_helper(obj1);
16245 if (arg2 == NULL) SWIG_fail;
16246 temp2 = true;
16247 }
16248 ecode3 = SWIG_AsVal_int(obj2, &val3);
16249 if (!SWIG_IsOK(ecode3)) {
16250 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetOptionInt" "', expected argument " "3"" of type '" "int""'");
16251 }
16252 arg3 = static_cast< int >(val3);
16253 {
16254 PyThreadState* __tstate = wxPyBeginAllowThreads();
16255 (arg1)->SetOption((wxString const &)*arg2,arg3);
16256 wxPyEndAllowThreads(__tstate);
16257 if (PyErr_Occurred()) SWIG_fail;
16258 }
16259 resultobj = SWIG_Py_Void();
16260 {
16261 if (temp2)
16262 delete arg2;
16263 }
16264 return resultobj;
16265 fail:
16266 {
16267 if (temp2)
16268 delete arg2;
16269 }
16270 return NULL;
16271 }
16272
16273
16274 SWIGINTERN PyObject *_wrap_Image_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16275 PyObject *resultobj = 0;
16276 wxImage *arg1 = (wxImage *) 0 ;
16277 wxString *arg2 = 0 ;
16278 wxString result;
16279 void *argp1 = 0 ;
16280 int res1 = 0 ;
16281 bool temp2 = false ;
16282 PyObject * obj0 = 0 ;
16283 PyObject * obj1 = 0 ;
16284 char * kwnames[] = {
16285 (char *) "self",(char *) "name", NULL
16286 };
16287
16288 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) SWIG_fail;
16289 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16290 if (!SWIG_IsOK(res1)) {
16291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16292 }
16293 arg1 = reinterpret_cast< wxImage * >(argp1);
16294 {
16295 arg2 = wxString_in_helper(obj1);
16296 if (arg2 == NULL) SWIG_fail;
16297 temp2 = true;
16298 }
16299 {
16300 PyThreadState* __tstate = wxPyBeginAllowThreads();
16301 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
16302 wxPyEndAllowThreads(__tstate);
16303 if (PyErr_Occurred()) SWIG_fail;
16304 }
16305 {
16306 #if wxUSE_UNICODE
16307 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16308 #else
16309 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16310 #endif
16311 }
16312 {
16313 if (temp2)
16314 delete arg2;
16315 }
16316 return resultobj;
16317 fail:
16318 {
16319 if (temp2)
16320 delete arg2;
16321 }
16322 return NULL;
16323 }
16324
16325
16326 SWIGINTERN PyObject *_wrap_Image_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16327 PyObject *resultobj = 0;
16328 wxImage *arg1 = (wxImage *) 0 ;
16329 wxString *arg2 = 0 ;
16330 int result;
16331 void *argp1 = 0 ;
16332 int res1 = 0 ;
16333 bool temp2 = false ;
16334 PyObject * obj0 = 0 ;
16335 PyObject * obj1 = 0 ;
16336 char * kwnames[] = {
16337 (char *) "self",(char *) "name", NULL
16338 };
16339
16340 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
16341 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16342 if (!SWIG_IsOK(res1)) {
16343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOptionInt" "', expected argument " "1"" of type '" "wxImage const *""'");
16344 }
16345 arg1 = reinterpret_cast< wxImage * >(argp1);
16346 {
16347 arg2 = wxString_in_helper(obj1);
16348 if (arg2 == NULL) SWIG_fail;
16349 temp2 = true;
16350 }
16351 {
16352 PyThreadState* __tstate = wxPyBeginAllowThreads();
16353 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
16354 wxPyEndAllowThreads(__tstate);
16355 if (PyErr_Occurred()) SWIG_fail;
16356 }
16357 resultobj = SWIG_From_int(static_cast< int >(result));
16358 {
16359 if (temp2)
16360 delete arg2;
16361 }
16362 return resultobj;
16363 fail:
16364 {
16365 if (temp2)
16366 delete arg2;
16367 }
16368 return NULL;
16369 }
16370
16371
16372 SWIGINTERN PyObject *_wrap_Image_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16373 PyObject *resultobj = 0;
16374 wxImage *arg1 = (wxImage *) 0 ;
16375 wxString *arg2 = 0 ;
16376 bool result;
16377 void *argp1 = 0 ;
16378 int res1 = 0 ;
16379 bool temp2 = false ;
16380 PyObject * obj0 = 0 ;
16381 PyObject * obj1 = 0 ;
16382 char * kwnames[] = {
16383 (char *) "self",(char *) "name", NULL
16384 };
16385
16386 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) SWIG_fail;
16387 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16388 if (!SWIG_IsOK(res1)) {
16389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16390 }
16391 arg1 = reinterpret_cast< wxImage * >(argp1);
16392 {
16393 arg2 = wxString_in_helper(obj1);
16394 if (arg2 == NULL) SWIG_fail;
16395 temp2 = true;
16396 }
16397 {
16398 PyThreadState* __tstate = wxPyBeginAllowThreads();
16399 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
16400 wxPyEndAllowThreads(__tstate);
16401 if (PyErr_Occurred()) SWIG_fail;
16402 }
16403 {
16404 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16405 }
16406 {
16407 if (temp2)
16408 delete arg2;
16409 }
16410 return resultobj;
16411 fail:
16412 {
16413 if (temp2)
16414 delete arg2;
16415 }
16416 return NULL;
16417 }
16418
16419
16420 SWIGINTERN PyObject *_wrap_Image_CountColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16421 PyObject *resultobj = 0;
16422 wxImage *arg1 = (wxImage *) 0 ;
16423 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
16424 unsigned long result;
16425 void *argp1 = 0 ;
16426 int res1 = 0 ;
16427 unsigned long val2 ;
16428 int ecode2 = 0 ;
16429 PyObject * obj0 = 0 ;
16430 PyObject * obj1 = 0 ;
16431 char * kwnames[] = {
16432 (char *) "self",(char *) "stopafter", NULL
16433 };
16434
16435 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) SWIG_fail;
16436 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16437 if (!SWIG_IsOK(res1)) {
16438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_CountColours" "', expected argument " "1"" of type '" "wxImage *""'");
16439 }
16440 arg1 = reinterpret_cast< wxImage * >(argp1);
16441 if (obj1) {
16442 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
16443 if (!SWIG_IsOK(ecode2)) {
16444 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_CountColours" "', expected argument " "2"" of type '" "unsigned long""'");
16445 }
16446 arg2 = static_cast< unsigned long >(val2);
16447 }
16448 {
16449 PyThreadState* __tstate = wxPyBeginAllowThreads();
16450 result = (unsigned long)(arg1)->CountColours(arg2);
16451 wxPyEndAllowThreads(__tstate);
16452 if (PyErr_Occurred()) SWIG_fail;
16453 }
16454 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16455 return resultobj;
16456 fail:
16457 return NULL;
16458 }
16459
16460
16461 SWIGINTERN PyObject *_wrap_Image_ComputeHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16462 PyObject *resultobj = 0;
16463 wxImage *arg1 = (wxImage *) 0 ;
16464 wxImageHistogram *arg2 = 0 ;
16465 unsigned long result;
16466 void *argp1 = 0 ;
16467 int res1 = 0 ;
16468 void *argp2 = 0 ;
16469 int res2 = 0 ;
16470 PyObject * obj0 = 0 ;
16471 PyObject * obj1 = 0 ;
16472 char * kwnames[] = {
16473 (char *) "self",(char *) "h", NULL
16474 };
16475
16476 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) SWIG_fail;
16477 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16478 if (!SWIG_IsOK(res1)) {
16479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ComputeHistogram" "', expected argument " "1"" of type '" "wxImage *""'");
16480 }
16481 arg1 = reinterpret_cast< wxImage * >(argp1);
16482 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImageHistogram, 0 );
16483 if (!SWIG_IsOK(res2)) {
16484 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16485 }
16486 if (!argp2) {
16487 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16488 }
16489 arg2 = reinterpret_cast< wxImageHistogram * >(argp2);
16490 {
16491 PyThreadState* __tstate = wxPyBeginAllowThreads();
16492 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
16493 wxPyEndAllowThreads(__tstate);
16494 if (PyErr_Occurred()) SWIG_fail;
16495 }
16496 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16497 return resultobj;
16498 fail:
16499 return NULL;
16500 }
16501
16502
16503 SWIGINTERN PyObject *_wrap_Image_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16504 PyObject *resultobj = 0;
16505 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16506 void *argp1 = 0 ;
16507 int res1 = 0 ;
16508 PyObject * obj0 = 0 ;
16509 char * kwnames[] = {
16510 (char *) "handler", NULL
16511 };
16512
16513 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) SWIG_fail;
16514 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16515 if (!SWIG_IsOK(res1)) {
16516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_AddHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16517 }
16518 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16519 {
16520 PyThreadState* __tstate = wxPyBeginAllowThreads();
16521 wxImage::AddHandler(arg1);
16522 wxPyEndAllowThreads(__tstate);
16523 if (PyErr_Occurred()) SWIG_fail;
16524 }
16525 resultobj = SWIG_Py_Void();
16526 return resultobj;
16527 fail:
16528 return NULL;
16529 }
16530
16531
16532 SWIGINTERN PyObject *_wrap_Image_InsertHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16533 PyObject *resultobj = 0;
16534 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16535 void *argp1 = 0 ;
16536 int res1 = 0 ;
16537 PyObject * obj0 = 0 ;
16538 char * kwnames[] = {
16539 (char *) "handler", NULL
16540 };
16541
16542 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) SWIG_fail;
16543 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16544 if (!SWIG_IsOK(res1)) {
16545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InsertHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16546 }
16547 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16548 {
16549 PyThreadState* __tstate = wxPyBeginAllowThreads();
16550 wxImage::InsertHandler(arg1);
16551 wxPyEndAllowThreads(__tstate);
16552 if (PyErr_Occurred()) SWIG_fail;
16553 }
16554 resultobj = SWIG_Py_Void();
16555 return resultobj;
16556 fail:
16557 return NULL;
16558 }
16559
16560
16561 SWIGINTERN PyObject *_wrap_Image_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16562 PyObject *resultobj = 0;
16563 wxString *arg1 = 0 ;
16564 bool result;
16565 bool temp1 = false ;
16566 PyObject * obj0 = 0 ;
16567 char * kwnames[] = {
16568 (char *) "name", NULL
16569 };
16570
16571 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) SWIG_fail;
16572 {
16573 arg1 = wxString_in_helper(obj0);
16574 if (arg1 == NULL) SWIG_fail;
16575 temp1 = true;
16576 }
16577 {
16578 PyThreadState* __tstate = wxPyBeginAllowThreads();
16579 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
16580 wxPyEndAllowThreads(__tstate);
16581 if (PyErr_Occurred()) SWIG_fail;
16582 }
16583 {
16584 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16585 }
16586 {
16587 if (temp1)
16588 delete arg1;
16589 }
16590 return resultobj;
16591 fail:
16592 {
16593 if (temp1)
16594 delete arg1;
16595 }
16596 return NULL;
16597 }
16598
16599
16600 SWIGINTERN PyObject *_wrap_Image_GetHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16601 PyObject *resultobj = 0;
16602 PyObject *result = 0 ;
16603
16604 if (!SWIG_Python_UnpackTuple(args,"Image_GetHandlers",0,0,0)) SWIG_fail;
16605 {
16606 PyThreadState* __tstate = wxPyBeginAllowThreads();
16607 result = (PyObject *)wxImage_GetHandlers();
16608 wxPyEndAllowThreads(__tstate);
16609 if (PyErr_Occurred()) SWIG_fail;
16610 }
16611 resultobj = result;
16612 return resultobj;
16613 fail:
16614 return NULL;
16615 }
16616
16617
16618 SWIGINTERN PyObject *_wrap_Image_GetImageExtWildcard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16619 PyObject *resultobj = 0;
16620 wxString result;
16621
16622 if (!SWIG_Python_UnpackTuple(args,"Image_GetImageExtWildcard",0,0,0)) SWIG_fail;
16623 {
16624 PyThreadState* __tstate = wxPyBeginAllowThreads();
16625 result = wxImage::GetImageExtWildcard();
16626 wxPyEndAllowThreads(__tstate);
16627 if (PyErr_Occurred()) SWIG_fail;
16628 }
16629 {
16630 #if wxUSE_UNICODE
16631 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16632 #else
16633 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16634 #endif
16635 }
16636 return resultobj;
16637 fail:
16638 return NULL;
16639 }
16640
16641
16642 SWIGINTERN PyObject *_wrap_Image_ConvertToBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16643 PyObject *resultobj = 0;
16644 wxImage *arg1 = (wxImage *) 0 ;
16645 int arg2 = (int) -1 ;
16646 wxBitmap result;
16647 void *argp1 = 0 ;
16648 int res1 = 0 ;
16649 int val2 ;
16650 int ecode2 = 0 ;
16651 PyObject * obj0 = 0 ;
16652 PyObject * obj1 = 0 ;
16653 char * kwnames[] = {
16654 (char *) "self",(char *) "depth", NULL
16655 };
16656
16657 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
16658 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16659 if (!SWIG_IsOK(res1)) {
16660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
16661 }
16662 arg1 = reinterpret_cast< wxImage * >(argp1);
16663 if (obj1) {
16664 ecode2 = SWIG_AsVal_int(obj1, &val2);
16665 if (!SWIG_IsOK(ecode2)) {
16666 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToBitmap" "', expected argument " "2"" of type '" "int""'");
16667 }
16668 arg2 = static_cast< int >(val2);
16669 }
16670 {
16671 if (!wxPyCheckForApp()) SWIG_fail;
16672 PyThreadState* __tstate = wxPyBeginAllowThreads();
16673 result = wxImage_ConvertToBitmap(arg1,arg2);
16674 wxPyEndAllowThreads(__tstate);
16675 if (PyErr_Occurred()) SWIG_fail;
16676 }
16677 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
16678 return resultobj;
16679 fail:
16680 return NULL;
16681 }
16682
16683
16684 SWIGINTERN PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16685 PyObject *resultobj = 0;
16686 wxImage *arg1 = (wxImage *) 0 ;
16687 byte arg2 ;
16688 byte arg3 ;
16689 byte arg4 ;
16690 wxBitmap result;
16691 void *argp1 = 0 ;
16692 int res1 = 0 ;
16693 unsigned char val2 ;
16694 int ecode2 = 0 ;
16695 unsigned char val3 ;
16696 int ecode3 = 0 ;
16697 unsigned char val4 ;
16698 int ecode4 = 0 ;
16699 PyObject * obj0 = 0 ;
16700 PyObject * obj1 = 0 ;
16701 PyObject * obj2 = 0 ;
16702 PyObject * obj3 = 0 ;
16703 char * kwnames[] = {
16704 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
16705 };
16706
16707 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16708 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16709 if (!SWIG_IsOK(res1)) {
16710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
16711 }
16712 arg1 = reinterpret_cast< wxImage * >(argp1);
16713 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16714 if (!SWIG_IsOK(ecode2)) {
16715 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "2"" of type '" "byte""'");
16716 }
16717 arg2 = static_cast< byte >(val2);
16718 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16719 if (!SWIG_IsOK(ecode3)) {
16720 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "3"" of type '" "byte""'");
16721 }
16722 arg3 = static_cast< byte >(val3);
16723 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16724 if (!SWIG_IsOK(ecode4)) {
16725 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "4"" of type '" "byte""'");
16726 }
16727 arg4 = static_cast< byte >(val4);
16728 {
16729 if (!wxPyCheckForApp()) SWIG_fail;
16730 PyThreadState* __tstate = wxPyBeginAllowThreads();
16731 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
16732 wxPyEndAllowThreads(__tstate);
16733 if (PyErr_Occurred()) SWIG_fail;
16734 }
16735 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
16736 return resultobj;
16737 fail:
16738 return NULL;
16739 }
16740
16741
16742 SWIGINTERN PyObject *_wrap_Image_RotateHue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16743 PyObject *resultobj = 0;
16744 wxImage *arg1 = (wxImage *) 0 ;
16745 double arg2 ;
16746 void *argp1 = 0 ;
16747 int res1 = 0 ;
16748 double val2 ;
16749 int ecode2 = 0 ;
16750 PyObject * obj0 = 0 ;
16751 PyObject * obj1 = 0 ;
16752 char * kwnames[] = {
16753 (char *) "self",(char *) "angle", NULL
16754 };
16755
16756 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RotateHue",kwnames,&obj0,&obj1)) SWIG_fail;
16757 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16758 if (!SWIG_IsOK(res1)) {
16759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RotateHue" "', expected argument " "1"" of type '" "wxImage *""'");
16760 }
16761 arg1 = reinterpret_cast< wxImage * >(argp1);
16762 ecode2 = SWIG_AsVal_double(obj1, &val2);
16763 if (!SWIG_IsOK(ecode2)) {
16764 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RotateHue" "', expected argument " "2"" of type '" "double""'");
16765 }
16766 arg2 = static_cast< double >(val2);
16767 {
16768 PyThreadState* __tstate = wxPyBeginAllowThreads();
16769 (arg1)->RotateHue(arg2);
16770 wxPyEndAllowThreads(__tstate);
16771 if (PyErr_Occurred()) SWIG_fail;
16772 }
16773 resultobj = SWIG_Py_Void();
16774 return resultobj;
16775 fail:
16776 return NULL;
16777 }
16778
16779
16780 SWIGINTERN PyObject *_wrap_Image_RGBtoHSV(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16781 PyObject *resultobj = 0;
16782 wxImage_RGBValue arg1 ;
16783 wxImage_HSVValue result;
16784 void *argp1 ;
16785 int res1 = 0 ;
16786 PyObject * obj0 = 0 ;
16787 char * kwnames[] = {
16788 (char *) "rgb", NULL
16789 };
16790
16791 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBtoHSV",kwnames,&obj0)) SWIG_fail;
16792 {
16793 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_RGBValue, 0 | 0);
16794 if (!SWIG_IsOK(res1)) {
16795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
16796 }
16797 if (!argp1) {
16798 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
16799 } else {
16800 wxImage_RGBValue * temp = reinterpret_cast< wxImage_RGBValue * >(argp1);
16801 arg1 = *temp;
16802 if (SWIG_IsNewObj(res1)) delete temp;
16803 }
16804 }
16805 {
16806 PyThreadState* __tstate = wxPyBeginAllowThreads();
16807 result = wxImage::RGBtoHSV(arg1);
16808 wxPyEndAllowThreads(__tstate);
16809 if (PyErr_Occurred()) SWIG_fail;
16810 }
16811 resultobj = SWIG_NewPointerObj((new wxImage_HSVValue(static_cast< const wxImage_HSVValue& >(result))), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_OWN | 0 );
16812 return resultobj;
16813 fail:
16814 return NULL;
16815 }
16816
16817
16818 SWIGINTERN PyObject *_wrap_Image_HSVtoRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16819 PyObject *resultobj = 0;
16820 wxImage_HSVValue arg1 ;
16821 wxImage_RGBValue result;
16822 void *argp1 ;
16823 int res1 = 0 ;
16824 PyObject * obj0 = 0 ;
16825 char * kwnames[] = {
16826 (char *) "hsv", NULL
16827 };
16828
16829 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVtoRGB",kwnames,&obj0)) SWIG_fail;
16830 {
16831 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_HSVValue, 0 | 0);
16832 if (!SWIG_IsOK(res1)) {
16833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
16834 }
16835 if (!argp1) {
16836 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
16837 } else {
16838 wxImage_HSVValue * temp = reinterpret_cast< wxImage_HSVValue * >(argp1);
16839 arg1 = *temp;
16840 if (SWIG_IsNewObj(res1)) delete temp;
16841 }
16842 }
16843 {
16844 PyThreadState* __tstate = wxPyBeginAllowThreads();
16845 result = wxImage::HSVtoRGB(arg1);
16846 wxPyEndAllowThreads(__tstate);
16847 if (PyErr_Occurred()) SWIG_fail;
16848 }
16849 resultobj = SWIG_NewPointerObj((new wxImage_RGBValue(static_cast< const wxImage_RGBValue& >(result))), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_OWN | 0 );
16850 return resultobj;
16851 fail:
16852 return NULL;
16853 }
16854
16855
16856 SWIGINTERN PyObject *Image_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16857 PyObject *obj;
16858 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16859 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage, SWIG_NewClientData(obj));
16860 return SWIG_Py_Void();
16861 }
16862
16863 SWIGINTERN PyObject *Image_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16864 return SWIG_Python_InitShadowInstance(args);
16865 }
16866
16867 SWIGINTERN int NullImage_set(PyObject *) {
16868 SWIG_Error(SWIG_AttributeError,"Variable NullImage is read-only.");
16869 return 1;
16870 }
16871
16872
16873 SWIGINTERN PyObject *NullImage_get(void) {
16874 PyObject *pyobj = 0;
16875
16876 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullImage), SWIGTYPE_p_wxImage, 0 );
16877 return pyobj;
16878 }
16879
16880
16881 SWIGINTERN int IMAGE_OPTION_FILENAME_set(PyObject *) {
16882 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
16883 return 1;
16884 }
16885
16886
16887 SWIGINTERN PyObject *IMAGE_OPTION_FILENAME_get(void) {
16888 PyObject *pyobj = 0;
16889
16890 {
16891 #if wxUSE_UNICODE
16892 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
16893 #else
16894 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
16895 #endif
16896 }
16897 return pyobj;
16898 }
16899
16900
16901 SWIGINTERN int IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
16902 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
16903 return 1;
16904 }
16905
16906
16907 SWIGINTERN PyObject *IMAGE_OPTION_BMP_FORMAT_get(void) {
16908 PyObject *pyobj = 0;
16909
16910 {
16911 #if wxUSE_UNICODE
16912 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
16913 #else
16914 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
16915 #endif
16916 }
16917 return pyobj;
16918 }
16919
16920
16921 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
16922 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
16923 return 1;
16924 }
16925
16926
16927 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
16928 PyObject *pyobj = 0;
16929
16930 {
16931 #if wxUSE_UNICODE
16932 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
16933 #else
16934 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
16935 #endif
16936 }
16937 return pyobj;
16938 }
16939
16940
16941 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
16942 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
16943 return 1;
16944 }
16945
16946
16947 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
16948 PyObject *pyobj = 0;
16949
16950 {
16951 #if wxUSE_UNICODE
16952 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
16953 #else
16954 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
16955 #endif
16956 }
16957 return pyobj;
16958 }
16959
16960
16961 SWIGINTERN int IMAGE_OPTION_RESOLUTION_set(PyObject *) {
16962 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
16963 return 1;
16964 }
16965
16966
16967 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTION_get(void) {
16968 PyObject *pyobj = 0;
16969
16970 {
16971 #if wxUSE_UNICODE
16972 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
16973 #else
16974 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
16975 #endif
16976 }
16977 return pyobj;
16978 }
16979
16980
16981 SWIGINTERN int IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
16982 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
16983 return 1;
16984 }
16985
16986
16987 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONX_get(void) {
16988 PyObject *pyobj = 0;
16989
16990 {
16991 #if wxUSE_UNICODE
16992 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
16993 #else
16994 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
16995 #endif
16996 }
16997 return pyobj;
16998 }
16999
17000
17001 SWIGINTERN int IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
17002 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
17003 return 1;
17004 }
17005
17006
17007 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONY_get(void) {
17008 PyObject *pyobj = 0;
17009
17010 {
17011 #if wxUSE_UNICODE
17012 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
17013 #else
17014 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
17015 #endif
17016 }
17017 return pyobj;
17018 }
17019
17020
17021 SWIGINTERN int IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
17022 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
17023 return 1;
17024 }
17025
17026
17027 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
17028 PyObject *pyobj = 0;
17029
17030 {
17031 #if wxUSE_UNICODE
17032 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17033 #else
17034 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17035 #endif
17036 }
17037 return pyobj;
17038 }
17039
17040
17041 SWIGINTERN int IMAGE_OPTION_QUALITY_set(PyObject *) {
17042 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
17043 return 1;
17044 }
17045
17046
17047 SWIGINTERN PyObject *IMAGE_OPTION_QUALITY_get(void) {
17048 PyObject *pyobj = 0;
17049
17050 {
17051 #if wxUSE_UNICODE
17052 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17053 #else
17054 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17055 #endif
17056 }
17057 return pyobj;
17058 }
17059
17060
17061 SWIGINTERN int IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
17062 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
17063 return 1;
17064 }
17065
17066
17067 SWIGINTERN PyObject *IMAGE_OPTION_BITSPERSAMPLE_get(void) {
17068 PyObject *pyobj = 0;
17069
17070 {
17071 #if wxUSE_UNICODE
17072 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17073 #else
17074 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17075 #endif
17076 }
17077 return pyobj;
17078 }
17079
17080
17081 SWIGINTERN int IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
17082 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
17083 return 1;
17084 }
17085
17086
17087 SWIGINTERN PyObject *IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
17088 PyObject *pyobj = 0;
17089
17090 {
17091 #if wxUSE_UNICODE
17092 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17093 #else
17094 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17095 #endif
17096 }
17097 return pyobj;
17098 }
17099
17100
17101 SWIGINTERN int IMAGE_OPTION_COMPRESSION_set(PyObject *) {
17102 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
17103 return 1;
17104 }
17105
17106
17107 SWIGINTERN PyObject *IMAGE_OPTION_COMPRESSION_get(void) {
17108 PyObject *pyobj = 0;
17109
17110 {
17111 #if wxUSE_UNICODE
17112 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17113 #else
17114 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17115 #endif
17116 }
17117 return pyobj;
17118 }
17119
17120
17121 SWIGINTERN int IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
17122 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
17123 return 1;
17124 }
17125
17126
17127 SWIGINTERN PyObject *IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
17128 PyObject *pyobj = 0;
17129
17130 {
17131 #if wxUSE_UNICODE
17132 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17133 #else
17134 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17135 #endif
17136 }
17137 return pyobj;
17138 }
17139
17140
17141 SWIGINTERN int IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
17142 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
17143 return 1;
17144 }
17145
17146
17147 SWIGINTERN PyObject *IMAGE_OPTION_PNG_FORMAT_get(void) {
17148 PyObject *pyobj = 0;
17149
17150 {
17151 #if wxUSE_UNICODE
17152 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17153 #else
17154 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17155 #endif
17156 }
17157 return pyobj;
17158 }
17159
17160
17161 SWIGINTERN int IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
17162 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
17163 return 1;
17164 }
17165
17166
17167 SWIGINTERN PyObject *IMAGE_OPTION_PNG_BITDEPTH_get(void) {
17168 PyObject *pyobj = 0;
17169
17170 {
17171 #if wxUSE_UNICODE
17172 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17173 #else
17174 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17175 #endif
17176 }
17177 return pyobj;
17178 }
17179
17180
17181 SWIGINTERN PyObject *_wrap_new_BMPHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17182 PyObject *resultobj = 0;
17183 wxBMPHandler *result = 0 ;
17184
17185 if (!SWIG_Python_UnpackTuple(args,"new_BMPHandler",0,0,0)) SWIG_fail;
17186 {
17187 PyThreadState* __tstate = wxPyBeginAllowThreads();
17188 result = (wxBMPHandler *)new wxBMPHandler();
17189 wxPyEndAllowThreads(__tstate);
17190 if (PyErr_Occurred()) SWIG_fail;
17191 }
17192 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBMPHandler, SWIG_POINTER_NEW | 0 );
17193 return resultobj;
17194 fail:
17195 return NULL;
17196 }
17197
17198
17199 SWIGINTERN PyObject *BMPHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17200 PyObject *obj;
17201 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17202 SWIG_TypeNewClientData(SWIGTYPE_p_wxBMPHandler, SWIG_NewClientData(obj));
17203 return SWIG_Py_Void();
17204 }
17205
17206 SWIGINTERN PyObject *BMPHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17207 return SWIG_Python_InitShadowInstance(args);
17208 }
17209
17210 SWIGINTERN PyObject *_wrap_new_ICOHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17211 PyObject *resultobj = 0;
17212 wxICOHandler *result = 0 ;
17213
17214 if (!SWIG_Python_UnpackTuple(args,"new_ICOHandler",0,0,0)) SWIG_fail;
17215 {
17216 PyThreadState* __tstate = wxPyBeginAllowThreads();
17217 result = (wxICOHandler *)new wxICOHandler();
17218 wxPyEndAllowThreads(__tstate);
17219 if (PyErr_Occurred()) SWIG_fail;
17220 }
17221 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxICOHandler, SWIG_POINTER_NEW | 0 );
17222 return resultobj;
17223 fail:
17224 return NULL;
17225 }
17226
17227
17228 SWIGINTERN PyObject *ICOHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17229 PyObject *obj;
17230 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17231 SWIG_TypeNewClientData(SWIGTYPE_p_wxICOHandler, SWIG_NewClientData(obj));
17232 return SWIG_Py_Void();
17233 }
17234
17235 SWIGINTERN PyObject *ICOHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17236 return SWIG_Python_InitShadowInstance(args);
17237 }
17238
17239 SWIGINTERN PyObject *_wrap_new_CURHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17240 PyObject *resultobj = 0;
17241 wxCURHandler *result = 0 ;
17242
17243 if (!SWIG_Python_UnpackTuple(args,"new_CURHandler",0,0,0)) SWIG_fail;
17244 {
17245 PyThreadState* __tstate = wxPyBeginAllowThreads();
17246 result = (wxCURHandler *)new wxCURHandler();
17247 wxPyEndAllowThreads(__tstate);
17248 if (PyErr_Occurred()) SWIG_fail;
17249 }
17250 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCURHandler, SWIG_POINTER_NEW | 0 );
17251 return resultobj;
17252 fail:
17253 return NULL;
17254 }
17255
17256
17257 SWIGINTERN PyObject *CURHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17258 PyObject *obj;
17259 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17260 SWIG_TypeNewClientData(SWIGTYPE_p_wxCURHandler, SWIG_NewClientData(obj));
17261 return SWIG_Py_Void();
17262 }
17263
17264 SWIGINTERN PyObject *CURHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17265 return SWIG_Python_InitShadowInstance(args);
17266 }
17267
17268 SWIGINTERN PyObject *_wrap_new_ANIHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17269 PyObject *resultobj = 0;
17270 wxANIHandler *result = 0 ;
17271
17272 if (!SWIG_Python_UnpackTuple(args,"new_ANIHandler",0,0,0)) SWIG_fail;
17273 {
17274 PyThreadState* __tstate = wxPyBeginAllowThreads();
17275 result = (wxANIHandler *)new wxANIHandler();
17276 wxPyEndAllowThreads(__tstate);
17277 if (PyErr_Occurred()) SWIG_fail;
17278 }
17279 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxANIHandler, SWIG_POINTER_NEW | 0 );
17280 return resultobj;
17281 fail:
17282 return NULL;
17283 }
17284
17285
17286 SWIGINTERN PyObject *ANIHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17287 PyObject *obj;
17288 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17289 SWIG_TypeNewClientData(SWIGTYPE_p_wxANIHandler, SWIG_NewClientData(obj));
17290 return SWIG_Py_Void();
17291 }
17292
17293 SWIGINTERN PyObject *ANIHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17294 return SWIG_Python_InitShadowInstance(args);
17295 }
17296
17297 SWIGINTERN PyObject *_wrap_new_PNGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17298 PyObject *resultobj = 0;
17299 wxPNGHandler *result = 0 ;
17300
17301 if (!SWIG_Python_UnpackTuple(args,"new_PNGHandler",0,0,0)) SWIG_fail;
17302 {
17303 PyThreadState* __tstate = wxPyBeginAllowThreads();
17304 result = (wxPNGHandler *)new wxPNGHandler();
17305 wxPyEndAllowThreads(__tstate);
17306 if (PyErr_Occurred()) SWIG_fail;
17307 }
17308 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNGHandler, SWIG_POINTER_NEW | 0 );
17309 return resultobj;
17310 fail:
17311 return NULL;
17312 }
17313
17314
17315 SWIGINTERN PyObject *PNGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17316 PyObject *obj;
17317 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17318 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNGHandler, SWIG_NewClientData(obj));
17319 return SWIG_Py_Void();
17320 }
17321
17322 SWIGINTERN PyObject *PNGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17323 return SWIG_Python_InitShadowInstance(args);
17324 }
17325
17326 SWIGINTERN PyObject *_wrap_new_GIFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17327 PyObject *resultobj = 0;
17328 wxGIFHandler *result = 0 ;
17329
17330 if (!SWIG_Python_UnpackTuple(args,"new_GIFHandler",0,0,0)) SWIG_fail;
17331 {
17332 PyThreadState* __tstate = wxPyBeginAllowThreads();
17333 result = (wxGIFHandler *)new wxGIFHandler();
17334 wxPyEndAllowThreads(__tstate);
17335 if (PyErr_Occurred()) SWIG_fail;
17336 }
17337 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGIFHandler, SWIG_POINTER_NEW | 0 );
17338 return resultobj;
17339 fail:
17340 return NULL;
17341 }
17342
17343
17344 SWIGINTERN PyObject *GIFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17345 PyObject *obj;
17346 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17347 SWIG_TypeNewClientData(SWIGTYPE_p_wxGIFHandler, SWIG_NewClientData(obj));
17348 return SWIG_Py_Void();
17349 }
17350
17351 SWIGINTERN PyObject *GIFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17352 return SWIG_Python_InitShadowInstance(args);
17353 }
17354
17355 SWIGINTERN PyObject *_wrap_new_PCXHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17356 PyObject *resultobj = 0;
17357 wxPCXHandler *result = 0 ;
17358
17359 if (!SWIG_Python_UnpackTuple(args,"new_PCXHandler",0,0,0)) SWIG_fail;
17360 {
17361 PyThreadState* __tstate = wxPyBeginAllowThreads();
17362 result = (wxPCXHandler *)new wxPCXHandler();
17363 wxPyEndAllowThreads(__tstate);
17364 if (PyErr_Occurred()) SWIG_fail;
17365 }
17366 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPCXHandler, SWIG_POINTER_NEW | 0 );
17367 return resultobj;
17368 fail:
17369 return NULL;
17370 }
17371
17372
17373 SWIGINTERN PyObject *PCXHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17374 PyObject *obj;
17375 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17376 SWIG_TypeNewClientData(SWIGTYPE_p_wxPCXHandler, SWIG_NewClientData(obj));
17377 return SWIG_Py_Void();
17378 }
17379
17380 SWIGINTERN PyObject *PCXHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17381 return SWIG_Python_InitShadowInstance(args);
17382 }
17383
17384 SWIGINTERN PyObject *_wrap_new_JPEGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17385 PyObject *resultobj = 0;
17386 wxJPEGHandler *result = 0 ;
17387
17388 if (!SWIG_Python_UnpackTuple(args,"new_JPEGHandler",0,0,0)) SWIG_fail;
17389 {
17390 PyThreadState* __tstate = wxPyBeginAllowThreads();
17391 result = (wxJPEGHandler *)new wxJPEGHandler();
17392 wxPyEndAllowThreads(__tstate);
17393 if (PyErr_Occurred()) SWIG_fail;
17394 }
17395 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJPEGHandler, SWIG_POINTER_NEW | 0 );
17396 return resultobj;
17397 fail:
17398 return NULL;
17399 }
17400
17401
17402 SWIGINTERN PyObject *JPEGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17403 PyObject *obj;
17404 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17405 SWIG_TypeNewClientData(SWIGTYPE_p_wxJPEGHandler, SWIG_NewClientData(obj));
17406 return SWIG_Py_Void();
17407 }
17408
17409 SWIGINTERN PyObject *JPEGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17410 return SWIG_Python_InitShadowInstance(args);
17411 }
17412
17413 SWIGINTERN PyObject *_wrap_new_PNMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17414 PyObject *resultobj = 0;
17415 wxPNMHandler *result = 0 ;
17416
17417 if (!SWIG_Python_UnpackTuple(args,"new_PNMHandler",0,0,0)) SWIG_fail;
17418 {
17419 PyThreadState* __tstate = wxPyBeginAllowThreads();
17420 result = (wxPNMHandler *)new wxPNMHandler();
17421 wxPyEndAllowThreads(__tstate);
17422 if (PyErr_Occurred()) SWIG_fail;
17423 }
17424 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNMHandler, SWIG_POINTER_NEW | 0 );
17425 return resultobj;
17426 fail:
17427 return NULL;
17428 }
17429
17430
17431 SWIGINTERN PyObject *PNMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17432 PyObject *obj;
17433 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17434 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNMHandler, SWIG_NewClientData(obj));
17435 return SWIG_Py_Void();
17436 }
17437
17438 SWIGINTERN PyObject *PNMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17439 return SWIG_Python_InitShadowInstance(args);
17440 }
17441
17442 SWIGINTERN PyObject *_wrap_new_XPMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17443 PyObject *resultobj = 0;
17444 wxXPMHandler *result = 0 ;
17445
17446 if (!SWIG_Python_UnpackTuple(args,"new_XPMHandler",0,0,0)) SWIG_fail;
17447 {
17448 PyThreadState* __tstate = wxPyBeginAllowThreads();
17449 result = (wxXPMHandler *)new wxXPMHandler();
17450 wxPyEndAllowThreads(__tstate);
17451 if (PyErr_Occurred()) SWIG_fail;
17452 }
17453 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXPMHandler, SWIG_POINTER_NEW | 0 );
17454 return resultobj;
17455 fail:
17456 return NULL;
17457 }
17458
17459
17460 SWIGINTERN PyObject *XPMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17461 PyObject *obj;
17462 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17463 SWIG_TypeNewClientData(SWIGTYPE_p_wxXPMHandler, SWIG_NewClientData(obj));
17464 return SWIG_Py_Void();
17465 }
17466
17467 SWIGINTERN PyObject *XPMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17468 return SWIG_Python_InitShadowInstance(args);
17469 }
17470
17471 SWIGINTERN PyObject *_wrap_new_TIFFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17472 PyObject *resultobj = 0;
17473 wxTIFFHandler *result = 0 ;
17474
17475 if (!SWIG_Python_UnpackTuple(args,"new_TIFFHandler",0,0,0)) SWIG_fail;
17476 {
17477 PyThreadState* __tstate = wxPyBeginAllowThreads();
17478 result = (wxTIFFHandler *)new wxTIFFHandler();
17479 wxPyEndAllowThreads(__tstate);
17480 if (PyErr_Occurred()) SWIG_fail;
17481 }
17482 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTIFFHandler, SWIG_POINTER_NEW | 0 );
17483 return resultobj;
17484 fail:
17485 return NULL;
17486 }
17487
17488
17489 SWIGINTERN PyObject *TIFFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17490 PyObject *obj;
17491 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17492 SWIG_TypeNewClientData(SWIGTYPE_p_wxTIFFHandler, SWIG_NewClientData(obj));
17493 return SWIG_Py_Void();
17494 }
17495
17496 SWIGINTERN PyObject *TIFFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17497 return SWIG_Python_InitShadowInstance(args);
17498 }
17499
17500 SWIGINTERN PyObject *_wrap_Quantize_Quantize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17501 PyObject *resultobj = 0;
17502 wxImage *arg1 = 0 ;
17503 wxImage *arg2 = 0 ;
17504 int arg3 = (int) 236 ;
17505 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
17506 bool result;
17507 void *argp1 = 0 ;
17508 int res1 = 0 ;
17509 void *argp2 = 0 ;
17510 int res2 = 0 ;
17511 int val3 ;
17512 int ecode3 = 0 ;
17513 int val4 ;
17514 int ecode4 = 0 ;
17515 PyObject * obj0 = 0 ;
17516 PyObject * obj1 = 0 ;
17517 PyObject * obj2 = 0 ;
17518 PyObject * obj3 = 0 ;
17519 char * kwnames[] = {
17520 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
17521 };
17522
17523 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17524 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage, 0 | 0);
17525 if (!SWIG_IsOK(res1)) {
17526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17527 }
17528 if (!argp1) {
17529 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17530 }
17531 arg1 = reinterpret_cast< wxImage * >(argp1);
17532 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
17533 if (!SWIG_IsOK(res2)) {
17534 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17535 }
17536 if (!argp2) {
17537 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17538 }
17539 arg2 = reinterpret_cast< wxImage * >(argp2);
17540 if (obj2) {
17541 ecode3 = SWIG_AsVal_int(obj2, &val3);
17542 if (!SWIG_IsOK(ecode3)) {
17543 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Quantize_Quantize" "', expected argument " "3"" of type '" "int""'");
17544 }
17545 arg3 = static_cast< int >(val3);
17546 }
17547 if (obj3) {
17548 ecode4 = SWIG_AsVal_int(obj3, &val4);
17549 if (!SWIG_IsOK(ecode4)) {
17550 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Quantize_Quantize" "', expected argument " "4"" of type '" "int""'");
17551 }
17552 arg4 = static_cast< int >(val4);
17553 }
17554 {
17555 PyThreadState* __tstate = wxPyBeginAllowThreads();
17556 result = (bool)wxQuantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
17557 wxPyEndAllowThreads(__tstate);
17558 if (PyErr_Occurred()) SWIG_fail;
17559 }
17560 {
17561 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17562 }
17563 return resultobj;
17564 fail:
17565 return NULL;
17566 }
17567
17568
17569 SWIGINTERN PyObject *Quantize_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17570 PyObject *obj;
17571 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17572 SWIG_TypeNewClientData(SWIGTYPE_p_wxQuantize, SWIG_NewClientData(obj));
17573 return SWIG_Py_Void();
17574 }
17575
17576 SWIGINTERN PyObject *_wrap_new_EvtHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17577 PyObject *resultobj = 0;
17578 wxEvtHandler *result = 0 ;
17579
17580 if (!SWIG_Python_UnpackTuple(args,"new_EvtHandler",0,0,0)) SWIG_fail;
17581 {
17582 PyThreadState* __tstate = wxPyBeginAllowThreads();
17583 result = (wxEvtHandler *)new wxEvtHandler();
17584 wxPyEndAllowThreads(__tstate);
17585 if (PyErr_Occurred()) SWIG_fail;
17586 }
17587 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_NEW | 0 );
17588 return resultobj;
17589 fail:
17590 return NULL;
17591 }
17592
17593
17594 SWIGINTERN PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17595 PyObject *resultobj = 0;
17596 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17597 wxEvtHandler *result = 0 ;
17598 void *argp1 = 0 ;
17599 int res1 = 0 ;
17600 PyObject *swig_obj[1] ;
17601
17602 if (!args) SWIG_fail;
17603 swig_obj[0] = args;
17604 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17605 if (!SWIG_IsOK(res1)) {
17606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17607 }
17608 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17609 {
17610 PyThreadState* __tstate = wxPyBeginAllowThreads();
17611 result = (wxEvtHandler *)(arg1)->GetNextHandler();
17612 wxPyEndAllowThreads(__tstate);
17613 if (PyErr_Occurred()) SWIG_fail;
17614 }
17615 {
17616 resultobj = wxPyMake_wxObject(result, 0);
17617 }
17618 return resultobj;
17619 fail:
17620 return NULL;
17621 }
17622
17623
17624 SWIGINTERN PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17625 PyObject *resultobj = 0;
17626 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17627 wxEvtHandler *result = 0 ;
17628 void *argp1 = 0 ;
17629 int res1 = 0 ;
17630 PyObject *swig_obj[1] ;
17631
17632 if (!args) SWIG_fail;
17633 swig_obj[0] = args;
17634 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17635 if (!SWIG_IsOK(res1)) {
17636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17637 }
17638 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17639 {
17640 PyThreadState* __tstate = wxPyBeginAllowThreads();
17641 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
17642 wxPyEndAllowThreads(__tstate);
17643 if (PyErr_Occurred()) SWIG_fail;
17644 }
17645 {
17646 resultobj = wxPyMake_wxObject(result, 0);
17647 }
17648 return resultobj;
17649 fail:
17650 return NULL;
17651 }
17652
17653
17654 SWIGINTERN PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17655 PyObject *resultobj = 0;
17656 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17657 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
17658 void *argp1 = 0 ;
17659 int res1 = 0 ;
17660 void *argp2 = 0 ;
17661 int res2 = 0 ;
17662 PyObject * obj0 = 0 ;
17663 PyObject * obj1 = 0 ;
17664 char * kwnames[] = {
17665 (char *) "self",(char *) "handler", NULL
17666 };
17667
17668 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) SWIG_fail;
17669 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17670 if (!SWIG_IsOK(res1)) {
17671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17672 }
17673 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17674 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17675 if (!SWIG_IsOK(res2)) {
17676 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
17677 }
17678 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
17679 {
17680 PyThreadState* __tstate = wxPyBeginAllowThreads();
17681 (arg1)->SetNextHandler(arg2);
17682 wxPyEndAllowThreads(__tstate);
17683 if (PyErr_Occurred()) SWIG_fail;
17684 }
17685 resultobj = SWIG_Py_Void();
17686 return resultobj;
17687 fail:
17688 return NULL;
17689 }
17690
17691
17692 SWIGINTERN PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17693 PyObject *resultobj = 0;
17694 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17695 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
17696 void *argp1 = 0 ;
17697 int res1 = 0 ;
17698 void *argp2 = 0 ;
17699 int res2 = 0 ;
17700 PyObject * obj0 = 0 ;
17701 PyObject * obj1 = 0 ;
17702 char * kwnames[] = {
17703 (char *) "self",(char *) "handler", NULL
17704 };
17705
17706 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) SWIG_fail;
17707 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17708 if (!SWIG_IsOK(res1)) {
17709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17710 }
17711 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17712 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17713 if (!SWIG_IsOK(res2)) {
17714 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
17715 }
17716 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
17717 {
17718 PyThreadState* __tstate = wxPyBeginAllowThreads();
17719 (arg1)->SetPreviousHandler(arg2);
17720 wxPyEndAllowThreads(__tstate);
17721 if (PyErr_Occurred()) SWIG_fail;
17722 }
17723 resultobj = SWIG_Py_Void();
17724 return resultobj;
17725 fail:
17726 return NULL;
17727 }
17728
17729
17730 SWIGINTERN PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17731 PyObject *resultobj = 0;
17732 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17733 bool result;
17734 void *argp1 = 0 ;
17735 int res1 = 0 ;
17736 PyObject *swig_obj[1] ;
17737
17738 if (!args) SWIG_fail;
17739 swig_obj[0] = args;
17740 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17741 if (!SWIG_IsOK(res1)) {
17742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17743 }
17744 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17745 {
17746 PyThreadState* __tstate = wxPyBeginAllowThreads();
17747 result = (bool)(arg1)->GetEvtHandlerEnabled();
17748 wxPyEndAllowThreads(__tstate);
17749 if (PyErr_Occurred()) SWIG_fail;
17750 }
17751 {
17752 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17753 }
17754 return resultobj;
17755 fail:
17756 return NULL;
17757 }
17758
17759
17760 SWIGINTERN PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17761 PyObject *resultobj = 0;
17762 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17763 bool arg2 ;
17764 void *argp1 = 0 ;
17765 int res1 = 0 ;
17766 bool val2 ;
17767 int ecode2 = 0 ;
17768 PyObject * obj0 = 0 ;
17769 PyObject * obj1 = 0 ;
17770 char * kwnames[] = {
17771 (char *) "self",(char *) "enabled", NULL
17772 };
17773
17774 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
17775 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17776 if (!SWIG_IsOK(res1)) {
17777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17778 }
17779 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17780 ecode2 = SWIG_AsVal_bool(obj1, &val2);
17781 if (!SWIG_IsOK(ecode2)) {
17782 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "2"" of type '" "bool""'");
17783 }
17784 arg2 = static_cast< bool >(val2);
17785 {
17786 PyThreadState* __tstate = wxPyBeginAllowThreads();
17787 (arg1)->SetEvtHandlerEnabled(arg2);
17788 wxPyEndAllowThreads(__tstate);
17789 if (PyErr_Occurred()) SWIG_fail;
17790 }
17791 resultobj = SWIG_Py_Void();
17792 return resultobj;
17793 fail:
17794 return NULL;
17795 }
17796
17797
17798 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17799 PyObject *resultobj = 0;
17800 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17801 wxEvent *arg2 = 0 ;
17802 bool result;
17803 void *argp1 = 0 ;
17804 int res1 = 0 ;
17805 void *argp2 = 0 ;
17806 int res2 = 0 ;
17807 PyObject * obj0 = 0 ;
17808 PyObject * obj1 = 0 ;
17809 char * kwnames[] = {
17810 (char *) "self",(char *) "event", NULL
17811 };
17812
17813 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) SWIG_fail;
17814 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17815 if (!SWIG_IsOK(res1)) {
17816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17817 }
17818 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17819 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
17820 if (!SWIG_IsOK(res2)) {
17821 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17822 }
17823 if (!argp2) {
17824 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17825 }
17826 arg2 = reinterpret_cast< wxEvent * >(argp2);
17827 {
17828 PyThreadState* __tstate = wxPyBeginAllowThreads();
17829 result = (bool)(arg1)->ProcessEvent(*arg2);
17830 wxPyEndAllowThreads(__tstate);
17831 if (PyErr_Occurred()) SWIG_fail;
17832 }
17833 {
17834 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17835 }
17836 return resultobj;
17837 fail:
17838 return NULL;
17839 }
17840
17841
17842 SWIGINTERN PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17843 PyObject *resultobj = 0;
17844 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17845 wxEvent *arg2 = 0 ;
17846 void *argp1 = 0 ;
17847 int res1 = 0 ;
17848 void *argp2 = 0 ;
17849 int res2 = 0 ;
17850 PyObject * obj0 = 0 ;
17851 PyObject * obj1 = 0 ;
17852 char * kwnames[] = {
17853 (char *) "self",(char *) "event", NULL
17854 };
17855
17856 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) SWIG_fail;
17857 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17858 if (!SWIG_IsOK(res1)) {
17859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17860 }
17861 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17862 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
17863 if (!SWIG_IsOK(res2)) {
17864 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17865 }
17866 if (!argp2) {
17867 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17868 }
17869 arg2 = reinterpret_cast< wxEvent * >(argp2);
17870 {
17871 PyThreadState* __tstate = wxPyBeginAllowThreads();
17872 (arg1)->AddPendingEvent(*arg2);
17873 wxPyEndAllowThreads(__tstate);
17874 if (PyErr_Occurred()) SWIG_fail;
17875 }
17876 resultobj = SWIG_Py_Void();
17877 return resultobj;
17878 fail:
17879 return NULL;
17880 }
17881
17882
17883 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17884 PyObject *resultobj = 0;
17885 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17886 void *argp1 = 0 ;
17887 int res1 = 0 ;
17888 PyObject *swig_obj[1] ;
17889
17890 if (!args) SWIG_fail;
17891 swig_obj[0] = args;
17892 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17893 if (!SWIG_IsOK(res1)) {
17894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17895 }
17896 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17897 {
17898 PyThreadState* __tstate = wxPyBeginAllowThreads();
17899 (arg1)->ProcessPendingEvents();
17900 wxPyEndAllowThreads(__tstate);
17901 if (PyErr_Occurred()) SWIG_fail;
17902 }
17903 resultobj = SWIG_Py_Void();
17904 return resultobj;
17905 fail:
17906 return NULL;
17907 }
17908
17909
17910 SWIGINTERN PyObject *_wrap_EvtHandler_Connect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17911 PyObject *resultobj = 0;
17912 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17913 int arg2 ;
17914 int arg3 ;
17915 int arg4 ;
17916 PyObject *arg5 = (PyObject *) 0 ;
17917 void *argp1 = 0 ;
17918 int res1 = 0 ;
17919 int val2 ;
17920 int ecode2 = 0 ;
17921 int val3 ;
17922 int ecode3 = 0 ;
17923 int val4 ;
17924 int ecode4 = 0 ;
17925 PyObject * obj0 = 0 ;
17926 PyObject * obj1 = 0 ;
17927 PyObject * obj2 = 0 ;
17928 PyObject * obj3 = 0 ;
17929 PyObject * obj4 = 0 ;
17930 char * kwnames[] = {
17931 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
17932 };
17933
17934 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
17935 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17936 if (!SWIG_IsOK(res1)) {
17937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Connect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17938 }
17939 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17940 ecode2 = SWIG_AsVal_int(obj1, &val2);
17941 if (!SWIG_IsOK(ecode2)) {
17942 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Connect" "', expected argument " "2"" of type '" "int""'");
17943 }
17944 arg2 = static_cast< int >(val2);
17945 ecode3 = SWIG_AsVal_int(obj2, &val3);
17946 if (!SWIG_IsOK(ecode3)) {
17947 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Connect" "', expected argument " "3"" of type '" "int""'");
17948 }
17949 arg3 = static_cast< int >(val3);
17950 ecode4 = SWIG_AsVal_int(obj3, &val4);
17951 if (!SWIG_IsOK(ecode4)) {
17952 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Connect" "', expected argument " "4"" of type '" "int""'");
17953 }
17954 arg4 = static_cast< int >(val4);
17955 arg5 = obj4;
17956 {
17957 PyThreadState* __tstate = wxPyBeginAllowThreads();
17958 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
17959 wxPyEndAllowThreads(__tstate);
17960 if (PyErr_Occurred()) SWIG_fail;
17961 }
17962 resultobj = SWIG_Py_Void();
17963 return resultobj;
17964 fail:
17965 return NULL;
17966 }
17967
17968
17969 SWIGINTERN PyObject *_wrap_EvtHandler_Disconnect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17970 PyObject *resultobj = 0;
17971 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17972 int arg2 ;
17973 int arg3 = (int) -1 ;
17974 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
17975 bool result;
17976 void *argp1 = 0 ;
17977 int res1 = 0 ;
17978 int val2 ;
17979 int ecode2 = 0 ;
17980 int val3 ;
17981 int ecode3 = 0 ;
17982 int val4 ;
17983 int ecode4 = 0 ;
17984 PyObject * obj0 = 0 ;
17985 PyObject * obj1 = 0 ;
17986 PyObject * obj2 = 0 ;
17987 PyObject * obj3 = 0 ;
17988 char * kwnames[] = {
17989 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
17990 };
17991
17992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17993 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17994 if (!SWIG_IsOK(res1)) {
17995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Disconnect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17996 }
17997 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17998 ecode2 = SWIG_AsVal_int(obj1, &val2);
17999 if (!SWIG_IsOK(ecode2)) {
18000 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Disconnect" "', expected argument " "2"" of type '" "int""'");
18001 }
18002 arg2 = static_cast< int >(val2);
18003 if (obj2) {
18004 ecode3 = SWIG_AsVal_int(obj2, &val3);
18005 if (!SWIG_IsOK(ecode3)) {
18006 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Disconnect" "', expected argument " "3"" of type '" "int""'");
18007 }
18008 arg3 = static_cast< int >(val3);
18009 }
18010 if (obj3) {
18011 ecode4 = SWIG_AsVal_int(obj3, &val4);
18012 if (!SWIG_IsOK(ecode4)) {
18013 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Disconnect" "', expected argument " "4"" of type '" "wxEventType""'");
18014 }
18015 arg4 = static_cast< wxEventType >(val4);
18016 }
18017 {
18018 PyThreadState* __tstate = wxPyBeginAllowThreads();
18019 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
18020 wxPyEndAllowThreads(__tstate);
18021 if (PyErr_Occurred()) SWIG_fail;
18022 }
18023 {
18024 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18025 }
18026 return resultobj;
18027 fail:
18028 return NULL;
18029 }
18030
18031
18032 SWIGINTERN PyObject *_wrap_EvtHandler__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18033 PyObject *resultobj = 0;
18034 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18035 PyObject *arg2 = (PyObject *) 0 ;
18036 bool arg3 = (bool) true ;
18037 void *argp1 = 0 ;
18038 int res1 = 0 ;
18039 bool val3 ;
18040 int ecode3 = 0 ;
18041 PyObject * obj0 = 0 ;
18042 PyObject * obj1 = 0 ;
18043 PyObject * obj2 = 0 ;
18044 char * kwnames[] = {
18045 (char *) "self",(char *) "_self",(char *) "incref", NULL
18046 };
18047
18048 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18049 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18050 if (!SWIG_IsOK(res1)) {
18051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler__setOORInfo" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18052 }
18053 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18054 arg2 = obj1;
18055 if (obj2) {
18056 ecode3 = SWIG_AsVal_bool(obj2, &val3);
18057 if (!SWIG_IsOK(ecode3)) {
18058 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler__setOORInfo" "', expected argument " "3"" of type '" "bool""'");
18059 }
18060 arg3 = static_cast< bool >(val3);
18061 }
18062 {
18063 PyThreadState* __tstate = wxPyBeginAllowThreads();
18064 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
18065 wxPyEndAllowThreads(__tstate);
18066 if (PyErr_Occurred()) SWIG_fail;
18067 }
18068 resultobj = SWIG_Py_Void();
18069 return resultobj;
18070 fail:
18071 return NULL;
18072 }
18073
18074
18075 SWIGINTERN PyObject *EvtHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18076 PyObject *obj;
18077 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18078 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvtHandler, SWIG_NewClientData(obj));
18079 return SWIG_Py_Void();
18080 }
18081
18082 SWIGINTERN PyObject *EvtHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18083 return SWIG_Python_InitShadowInstance(args);
18084 }
18085
18086 SWIGINTERN PyObject *_wrap_NewEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18087 PyObject *resultobj = 0;
18088 wxEventType result;
18089
18090 if (!SWIG_Python_UnpackTuple(args,"NewEventType",0,0,0)) SWIG_fail;
18091 {
18092 PyThreadState* __tstate = wxPyBeginAllowThreads();
18093 result = (wxEventType)wxNewEventType();
18094 wxPyEndAllowThreads(__tstate);
18095 if (PyErr_Occurred()) SWIG_fail;
18096 }
18097 resultobj = SWIG_From_int(static_cast< int >(result));
18098 return resultobj;
18099 fail:
18100 return NULL;
18101 }
18102
18103
18104 SWIGINTERN PyObject *_wrap_delete_Event(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18105 PyObject *resultobj = 0;
18106 wxEvent *arg1 = (wxEvent *) 0 ;
18107 void *argp1 = 0 ;
18108 int res1 = 0 ;
18109 PyObject *swig_obj[1] ;
18110
18111 if (!args) SWIG_fail;
18112 swig_obj[0] = args;
18113 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, SWIG_POINTER_DISOWN | 0 );
18114 if (!SWIG_IsOK(res1)) {
18115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Event" "', expected argument " "1"" of type '" "wxEvent *""'");
18116 }
18117 arg1 = reinterpret_cast< wxEvent * >(argp1);
18118 {
18119 PyThreadState* __tstate = wxPyBeginAllowThreads();
18120 delete arg1;
18121
18122 wxPyEndAllowThreads(__tstate);
18123 if (PyErr_Occurred()) SWIG_fail;
18124 }
18125 resultobj = SWIG_Py_Void();
18126 return resultobj;
18127 fail:
18128 return NULL;
18129 }
18130
18131
18132 SWIGINTERN PyObject *_wrap_Event_SetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18133 PyObject *resultobj = 0;
18134 wxEvent *arg1 = (wxEvent *) 0 ;
18135 wxEventType arg2 ;
18136 void *argp1 = 0 ;
18137 int res1 = 0 ;
18138 int val2 ;
18139 int ecode2 = 0 ;
18140 PyObject * obj0 = 0 ;
18141 PyObject * obj1 = 0 ;
18142 char * kwnames[] = {
18143 (char *) "self",(char *) "typ", NULL
18144 };
18145
18146 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) SWIG_fail;
18147 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18148 if (!SWIG_IsOK(res1)) {
18149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventType" "', expected argument " "1"" of type '" "wxEvent *""'");
18150 }
18151 arg1 = reinterpret_cast< wxEvent * >(argp1);
18152 ecode2 = SWIG_AsVal_int(obj1, &val2);
18153 if (!SWIG_IsOK(ecode2)) {
18154 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetEventType" "', expected argument " "2"" of type '" "wxEventType""'");
18155 }
18156 arg2 = static_cast< wxEventType >(val2);
18157 {
18158 PyThreadState* __tstate = wxPyBeginAllowThreads();
18159 (arg1)->SetEventType(arg2);
18160 wxPyEndAllowThreads(__tstate);
18161 if (PyErr_Occurred()) SWIG_fail;
18162 }
18163 resultobj = SWIG_Py_Void();
18164 return resultobj;
18165 fail:
18166 return NULL;
18167 }
18168
18169
18170 SWIGINTERN PyObject *_wrap_Event_GetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18171 PyObject *resultobj = 0;
18172 wxEvent *arg1 = (wxEvent *) 0 ;
18173 wxEventType result;
18174 void *argp1 = 0 ;
18175 int res1 = 0 ;
18176 PyObject *swig_obj[1] ;
18177
18178 if (!args) SWIG_fail;
18179 swig_obj[0] = args;
18180 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18181 if (!SWIG_IsOK(res1)) {
18182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventType" "', expected argument " "1"" of type '" "wxEvent const *""'");
18183 }
18184 arg1 = reinterpret_cast< wxEvent * >(argp1);
18185 {
18186 PyThreadState* __tstate = wxPyBeginAllowThreads();
18187 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
18188 wxPyEndAllowThreads(__tstate);
18189 if (PyErr_Occurred()) SWIG_fail;
18190 }
18191 resultobj = SWIG_From_int(static_cast< int >(result));
18192 return resultobj;
18193 fail:
18194 return NULL;
18195 }
18196
18197
18198 SWIGINTERN PyObject *_wrap_Event_GetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18199 PyObject *resultobj = 0;
18200 wxEvent *arg1 = (wxEvent *) 0 ;
18201 wxObject *result = 0 ;
18202 void *argp1 = 0 ;
18203 int res1 = 0 ;
18204 PyObject *swig_obj[1] ;
18205
18206 if (!args) SWIG_fail;
18207 swig_obj[0] = args;
18208 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18209 if (!SWIG_IsOK(res1)) {
18210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventObject" "', expected argument " "1"" of type '" "wxEvent const *""'");
18211 }
18212 arg1 = reinterpret_cast< wxEvent * >(argp1);
18213 {
18214 PyThreadState* __tstate = wxPyBeginAllowThreads();
18215 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
18216 wxPyEndAllowThreads(__tstate);
18217 if (PyErr_Occurred()) SWIG_fail;
18218 }
18219 {
18220 resultobj = wxPyMake_wxObject(result, (bool)0);
18221 }
18222 return resultobj;
18223 fail:
18224 return NULL;
18225 }
18226
18227
18228 SWIGINTERN PyObject *_wrap_Event_SetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18229 PyObject *resultobj = 0;
18230 wxEvent *arg1 = (wxEvent *) 0 ;
18231 wxObject *arg2 = (wxObject *) 0 ;
18232 void *argp1 = 0 ;
18233 int res1 = 0 ;
18234 void *argp2 = 0 ;
18235 int res2 = 0 ;
18236 PyObject * obj0 = 0 ;
18237 PyObject * obj1 = 0 ;
18238 char * kwnames[] = {
18239 (char *) "self",(char *) "obj", NULL
18240 };
18241
18242 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) SWIG_fail;
18243 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18244 if (!SWIG_IsOK(res1)) {
18245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventObject" "', expected argument " "1"" of type '" "wxEvent *""'");
18246 }
18247 arg1 = reinterpret_cast< wxEvent * >(argp1);
18248 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxObject, 0 | 0 );
18249 if (!SWIG_IsOK(res2)) {
18250 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_SetEventObject" "', expected argument " "2"" of type '" "wxObject *""'");
18251 }
18252 arg2 = reinterpret_cast< wxObject * >(argp2);
18253 {
18254 PyThreadState* __tstate = wxPyBeginAllowThreads();
18255 (arg1)->SetEventObject(arg2);
18256 wxPyEndAllowThreads(__tstate);
18257 if (PyErr_Occurred()) SWIG_fail;
18258 }
18259 resultobj = SWIG_Py_Void();
18260 return resultobj;
18261 fail:
18262 return NULL;
18263 }
18264
18265
18266 SWIGINTERN PyObject *_wrap_Event_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18267 PyObject *resultobj = 0;
18268 wxEvent *arg1 = (wxEvent *) 0 ;
18269 long result;
18270 void *argp1 = 0 ;
18271 int res1 = 0 ;
18272 PyObject *swig_obj[1] ;
18273
18274 if (!args) SWIG_fail;
18275 swig_obj[0] = args;
18276 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18277 if (!SWIG_IsOK(res1)) {
18278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetTimestamp" "', expected argument " "1"" of type '" "wxEvent const *""'");
18279 }
18280 arg1 = reinterpret_cast< wxEvent * >(argp1);
18281 {
18282 PyThreadState* __tstate = wxPyBeginAllowThreads();
18283 result = (long)((wxEvent const *)arg1)->GetTimestamp();
18284 wxPyEndAllowThreads(__tstate);
18285 if (PyErr_Occurred()) SWIG_fail;
18286 }
18287 resultobj = SWIG_From_long(static_cast< long >(result));
18288 return resultobj;
18289 fail:
18290 return NULL;
18291 }
18292
18293
18294 SWIGINTERN PyObject *_wrap_Event_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18295 PyObject *resultobj = 0;
18296 wxEvent *arg1 = (wxEvent *) 0 ;
18297 long arg2 = (long) 0 ;
18298 void *argp1 = 0 ;
18299 int res1 = 0 ;
18300 long val2 ;
18301 int ecode2 = 0 ;
18302 PyObject * obj0 = 0 ;
18303 PyObject * obj1 = 0 ;
18304 char * kwnames[] = {
18305 (char *) "self",(char *) "ts", NULL
18306 };
18307
18308 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) SWIG_fail;
18309 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18310 if (!SWIG_IsOK(res1)) {
18311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetTimestamp" "', expected argument " "1"" of type '" "wxEvent *""'");
18312 }
18313 arg1 = reinterpret_cast< wxEvent * >(argp1);
18314 if (obj1) {
18315 ecode2 = SWIG_AsVal_long(obj1, &val2);
18316 if (!SWIG_IsOK(ecode2)) {
18317 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetTimestamp" "', expected argument " "2"" of type '" "long""'");
18318 }
18319 arg2 = static_cast< long >(val2);
18320 }
18321 {
18322 PyThreadState* __tstate = wxPyBeginAllowThreads();
18323 (arg1)->SetTimestamp(arg2);
18324 wxPyEndAllowThreads(__tstate);
18325 if (PyErr_Occurred()) SWIG_fail;
18326 }
18327 resultobj = SWIG_Py_Void();
18328 return resultobj;
18329 fail:
18330 return NULL;
18331 }
18332
18333
18334 SWIGINTERN PyObject *_wrap_Event_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18335 PyObject *resultobj = 0;
18336 wxEvent *arg1 = (wxEvent *) 0 ;
18337 int result;
18338 void *argp1 = 0 ;
18339 int res1 = 0 ;
18340 PyObject *swig_obj[1] ;
18341
18342 if (!args) SWIG_fail;
18343 swig_obj[0] = args;
18344 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18345 if (!SWIG_IsOK(res1)) {
18346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetId" "', expected argument " "1"" of type '" "wxEvent const *""'");
18347 }
18348 arg1 = reinterpret_cast< wxEvent * >(argp1);
18349 {
18350 PyThreadState* __tstate = wxPyBeginAllowThreads();
18351 result = (int)((wxEvent const *)arg1)->GetId();
18352 wxPyEndAllowThreads(__tstate);
18353 if (PyErr_Occurred()) SWIG_fail;
18354 }
18355 resultobj = SWIG_From_int(static_cast< int >(result));
18356 return resultobj;
18357 fail:
18358 return NULL;
18359 }
18360
18361
18362 SWIGINTERN PyObject *_wrap_Event_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18363 PyObject *resultobj = 0;
18364 wxEvent *arg1 = (wxEvent *) 0 ;
18365 int arg2 ;
18366 void *argp1 = 0 ;
18367 int res1 = 0 ;
18368 int val2 ;
18369 int ecode2 = 0 ;
18370 PyObject * obj0 = 0 ;
18371 PyObject * obj1 = 0 ;
18372 char * kwnames[] = {
18373 (char *) "self",(char *) "Id", NULL
18374 };
18375
18376 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
18377 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18378 if (!SWIG_IsOK(res1)) {
18379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetId" "', expected argument " "1"" of type '" "wxEvent *""'");
18380 }
18381 arg1 = reinterpret_cast< wxEvent * >(argp1);
18382 ecode2 = SWIG_AsVal_int(obj1, &val2);
18383 if (!SWIG_IsOK(ecode2)) {
18384 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetId" "', expected argument " "2"" of type '" "int""'");
18385 }
18386 arg2 = static_cast< int >(val2);
18387 {
18388 PyThreadState* __tstate = wxPyBeginAllowThreads();
18389 (arg1)->SetId(arg2);
18390 wxPyEndAllowThreads(__tstate);
18391 if (PyErr_Occurred()) SWIG_fail;
18392 }
18393 resultobj = SWIG_Py_Void();
18394 return resultobj;
18395 fail:
18396 return NULL;
18397 }
18398
18399
18400 SWIGINTERN PyObject *_wrap_Event_IsCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18401 PyObject *resultobj = 0;
18402 wxEvent *arg1 = (wxEvent *) 0 ;
18403 bool result;
18404 void *argp1 = 0 ;
18405 int res1 = 0 ;
18406 PyObject *swig_obj[1] ;
18407
18408 if (!args) SWIG_fail;
18409 swig_obj[0] = args;
18410 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18411 if (!SWIG_IsOK(res1)) {
18412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_IsCommandEvent" "', expected argument " "1"" of type '" "wxEvent const *""'");
18413 }
18414 arg1 = reinterpret_cast< wxEvent * >(argp1);
18415 {
18416 PyThreadState* __tstate = wxPyBeginAllowThreads();
18417 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
18418 wxPyEndAllowThreads(__tstate);
18419 if (PyErr_Occurred()) SWIG_fail;
18420 }
18421 {
18422 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18423 }
18424 return resultobj;
18425 fail:
18426 return NULL;
18427 }
18428
18429
18430 SWIGINTERN PyObject *_wrap_Event_Skip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18431 PyObject *resultobj = 0;
18432 wxEvent *arg1 = (wxEvent *) 0 ;
18433 bool arg2 = (bool) true ;
18434 void *argp1 = 0 ;
18435 int res1 = 0 ;
18436 bool val2 ;
18437 int ecode2 = 0 ;
18438 PyObject * obj0 = 0 ;
18439 PyObject * obj1 = 0 ;
18440 char * kwnames[] = {
18441 (char *) "self",(char *) "skip", NULL
18442 };
18443
18444 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) SWIG_fail;
18445 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18446 if (!SWIG_IsOK(res1)) {
18447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Skip" "', expected argument " "1"" of type '" "wxEvent *""'");
18448 }
18449 arg1 = reinterpret_cast< wxEvent * >(argp1);
18450 if (obj1) {
18451 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18452 if (!SWIG_IsOK(ecode2)) {
18453 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_Skip" "', expected argument " "2"" of type '" "bool""'");
18454 }
18455 arg2 = static_cast< bool >(val2);
18456 }
18457 {
18458 PyThreadState* __tstate = wxPyBeginAllowThreads();
18459 (arg1)->Skip(arg2);
18460 wxPyEndAllowThreads(__tstate);
18461 if (PyErr_Occurred()) SWIG_fail;
18462 }
18463 resultobj = SWIG_Py_Void();
18464 return resultobj;
18465 fail:
18466 return NULL;
18467 }
18468
18469
18470 SWIGINTERN PyObject *_wrap_Event_GetSkipped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18471 PyObject *resultobj = 0;
18472 wxEvent *arg1 = (wxEvent *) 0 ;
18473 bool result;
18474 void *argp1 = 0 ;
18475 int res1 = 0 ;
18476 PyObject *swig_obj[1] ;
18477
18478 if (!args) SWIG_fail;
18479 swig_obj[0] = args;
18480 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18481 if (!SWIG_IsOK(res1)) {
18482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetSkipped" "', expected argument " "1"" of type '" "wxEvent const *""'");
18483 }
18484 arg1 = reinterpret_cast< wxEvent * >(argp1);
18485 {
18486 PyThreadState* __tstate = wxPyBeginAllowThreads();
18487 result = (bool)((wxEvent const *)arg1)->GetSkipped();
18488 wxPyEndAllowThreads(__tstate);
18489 if (PyErr_Occurred()) SWIG_fail;
18490 }
18491 {
18492 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18493 }
18494 return resultobj;
18495 fail:
18496 return NULL;
18497 }
18498
18499
18500 SWIGINTERN PyObject *_wrap_Event_ShouldPropagate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18501 PyObject *resultobj = 0;
18502 wxEvent *arg1 = (wxEvent *) 0 ;
18503 bool result;
18504 void *argp1 = 0 ;
18505 int res1 = 0 ;
18506 PyObject *swig_obj[1] ;
18507
18508 if (!args) SWIG_fail;
18509 swig_obj[0] = args;
18510 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18511 if (!SWIG_IsOK(res1)) {
18512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ShouldPropagate" "', expected argument " "1"" of type '" "wxEvent const *""'");
18513 }
18514 arg1 = reinterpret_cast< wxEvent * >(argp1);
18515 {
18516 PyThreadState* __tstate = wxPyBeginAllowThreads();
18517 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
18518 wxPyEndAllowThreads(__tstate);
18519 if (PyErr_Occurred()) SWIG_fail;
18520 }
18521 {
18522 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18523 }
18524 return resultobj;
18525 fail:
18526 return NULL;
18527 }
18528
18529
18530 SWIGINTERN PyObject *_wrap_Event_StopPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18531 PyObject *resultobj = 0;
18532 wxEvent *arg1 = (wxEvent *) 0 ;
18533 int result;
18534 void *argp1 = 0 ;
18535 int res1 = 0 ;
18536 PyObject *swig_obj[1] ;
18537
18538 if (!args) SWIG_fail;
18539 swig_obj[0] = args;
18540 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18541 if (!SWIG_IsOK(res1)) {
18542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_StopPropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18543 }
18544 arg1 = reinterpret_cast< wxEvent * >(argp1);
18545 {
18546 PyThreadState* __tstate = wxPyBeginAllowThreads();
18547 result = (int)(arg1)->StopPropagation();
18548 wxPyEndAllowThreads(__tstate);
18549 if (PyErr_Occurred()) SWIG_fail;
18550 }
18551 resultobj = SWIG_From_int(static_cast< int >(result));
18552 return resultobj;
18553 fail:
18554 return NULL;
18555 }
18556
18557
18558 SWIGINTERN PyObject *_wrap_Event_ResumePropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18559 PyObject *resultobj = 0;
18560 wxEvent *arg1 = (wxEvent *) 0 ;
18561 int arg2 ;
18562 void *argp1 = 0 ;
18563 int res1 = 0 ;
18564 int val2 ;
18565 int ecode2 = 0 ;
18566 PyObject * obj0 = 0 ;
18567 PyObject * obj1 = 0 ;
18568 char * kwnames[] = {
18569 (char *) "self",(char *) "propagationLevel", NULL
18570 };
18571
18572 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) SWIG_fail;
18573 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18574 if (!SWIG_IsOK(res1)) {
18575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ResumePropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18576 }
18577 arg1 = reinterpret_cast< wxEvent * >(argp1);
18578 ecode2 = SWIG_AsVal_int(obj1, &val2);
18579 if (!SWIG_IsOK(ecode2)) {
18580 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_ResumePropagation" "', expected argument " "2"" of type '" "int""'");
18581 }
18582 arg2 = static_cast< int >(val2);
18583 {
18584 PyThreadState* __tstate = wxPyBeginAllowThreads();
18585 (arg1)->ResumePropagation(arg2);
18586 wxPyEndAllowThreads(__tstate);
18587 if (PyErr_Occurred()) SWIG_fail;
18588 }
18589 resultobj = SWIG_Py_Void();
18590 return resultobj;
18591 fail:
18592 return NULL;
18593 }
18594
18595
18596 SWIGINTERN PyObject *_wrap_Event_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18597 PyObject *resultobj = 0;
18598 wxEvent *arg1 = (wxEvent *) 0 ;
18599 wxEvent *result = 0 ;
18600 void *argp1 = 0 ;
18601 int res1 = 0 ;
18602 PyObject *swig_obj[1] ;
18603
18604 if (!args) SWIG_fail;
18605 swig_obj[0] = args;
18606 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18607 if (!SWIG_IsOK(res1)) {
18608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Clone" "', expected argument " "1"" of type '" "wxEvent *""'");
18609 }
18610 arg1 = reinterpret_cast< wxEvent * >(argp1);
18611 {
18612 PyThreadState* __tstate = wxPyBeginAllowThreads();
18613 result = (wxEvent *)(arg1)->Clone();
18614 wxPyEndAllowThreads(__tstate);
18615 if (PyErr_Occurred()) SWIG_fail;
18616 }
18617 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
18618 return resultobj;
18619 fail:
18620 return NULL;
18621 }
18622
18623
18624 SWIGINTERN PyObject *Event_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18625 PyObject *obj;
18626 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18627 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvent, SWIG_NewClientData(obj));
18628 return SWIG_Py_Void();
18629 }
18630
18631 SWIGINTERN PyObject *_wrap_new_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18632 PyObject *resultobj = 0;
18633 wxEvent *arg1 = 0 ;
18634 wxPropagationDisabler *result = 0 ;
18635 void *argp1 = 0 ;
18636 int res1 = 0 ;
18637 PyObject * obj0 = 0 ;
18638 char * kwnames[] = {
18639 (char *) "event", NULL
18640 };
18641
18642 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) SWIG_fail;
18643 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
18644 if (!SWIG_IsOK(res1)) {
18645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
18646 }
18647 if (!argp1) {
18648 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
18649 }
18650 arg1 = reinterpret_cast< wxEvent * >(argp1);
18651 {
18652 PyThreadState* __tstate = wxPyBeginAllowThreads();
18653 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
18654 wxPyEndAllowThreads(__tstate);
18655 if (PyErr_Occurred()) SWIG_fail;
18656 }
18657 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_NEW | 0 );
18658 return resultobj;
18659 fail:
18660 return NULL;
18661 }
18662
18663
18664 SWIGINTERN PyObject *_wrap_delete_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18665 PyObject *resultobj = 0;
18666 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
18667 void *argp1 = 0 ;
18668 int res1 = 0 ;
18669 PyObject *swig_obj[1] ;
18670
18671 if (!args) SWIG_fail;
18672 swig_obj[0] = args;
18673 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_DISOWN | 0 );
18674 if (!SWIG_IsOK(res1)) {
18675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagationDisabler" "', expected argument " "1"" of type '" "wxPropagationDisabler *""'");
18676 }
18677 arg1 = reinterpret_cast< wxPropagationDisabler * >(argp1);
18678 {
18679 PyThreadState* __tstate = wxPyBeginAllowThreads();
18680 delete arg1;
18681
18682 wxPyEndAllowThreads(__tstate);
18683 if (PyErr_Occurred()) SWIG_fail;
18684 }
18685 resultobj = SWIG_Py_Void();
18686 return resultobj;
18687 fail:
18688 return NULL;
18689 }
18690
18691
18692 SWIGINTERN PyObject *PropagationDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18693 PyObject *obj;
18694 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18695 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagationDisabler, SWIG_NewClientData(obj));
18696 return SWIG_Py_Void();
18697 }
18698
18699 SWIGINTERN PyObject *PropagationDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18700 return SWIG_Python_InitShadowInstance(args);
18701 }
18702
18703 SWIGINTERN PyObject *_wrap_new_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18704 PyObject *resultobj = 0;
18705 wxEvent *arg1 = 0 ;
18706 wxPropagateOnce *result = 0 ;
18707 void *argp1 = 0 ;
18708 int res1 = 0 ;
18709 PyObject * obj0 = 0 ;
18710 char * kwnames[] = {
18711 (char *) "event", NULL
18712 };
18713
18714 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) SWIG_fail;
18715 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
18716 if (!SWIG_IsOK(res1)) {
18717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
18718 }
18719 if (!argp1) {
18720 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
18721 }
18722 arg1 = reinterpret_cast< wxEvent * >(argp1);
18723 {
18724 PyThreadState* __tstate = wxPyBeginAllowThreads();
18725 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
18726 wxPyEndAllowThreads(__tstate);
18727 if (PyErr_Occurred()) SWIG_fail;
18728 }
18729 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_NEW | 0 );
18730 return resultobj;
18731 fail:
18732 return NULL;
18733 }
18734
18735
18736 SWIGINTERN PyObject *_wrap_delete_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18737 PyObject *resultobj = 0;
18738 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
18739 void *argp1 = 0 ;
18740 int res1 = 0 ;
18741 PyObject *swig_obj[1] ;
18742
18743 if (!args) SWIG_fail;
18744 swig_obj[0] = args;
18745 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_DISOWN | 0 );
18746 if (!SWIG_IsOK(res1)) {
18747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagateOnce" "', expected argument " "1"" of type '" "wxPropagateOnce *""'");
18748 }
18749 arg1 = reinterpret_cast< wxPropagateOnce * >(argp1);
18750 {
18751 PyThreadState* __tstate = wxPyBeginAllowThreads();
18752 delete arg1;
18753
18754 wxPyEndAllowThreads(__tstate);
18755 if (PyErr_Occurred()) SWIG_fail;
18756 }
18757 resultobj = SWIG_Py_Void();
18758 return resultobj;
18759 fail:
18760 return NULL;
18761 }
18762
18763
18764 SWIGINTERN PyObject *PropagateOnce_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18765 PyObject *obj;
18766 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18767 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagateOnce, SWIG_NewClientData(obj));
18768 return SWIG_Py_Void();
18769 }
18770
18771 SWIGINTERN PyObject *PropagateOnce_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18772 return SWIG_Python_InitShadowInstance(args);
18773 }
18774
18775 SWIGINTERN PyObject *_wrap_new_CommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18776 PyObject *resultobj = 0;
18777 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
18778 int arg2 = (int) 0 ;
18779 wxCommandEvent *result = 0 ;
18780 int val1 ;
18781 int ecode1 = 0 ;
18782 int val2 ;
18783 int ecode2 = 0 ;
18784 PyObject * obj0 = 0 ;
18785 PyObject * obj1 = 0 ;
18786 char * kwnames[] = {
18787 (char *) "commandType",(char *) "winid", NULL
18788 };
18789
18790 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
18791 if (obj0) {
18792 ecode1 = SWIG_AsVal_int(obj0, &val1);
18793 if (!SWIG_IsOK(ecode1)) {
18794 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
18795 }
18796 arg1 = static_cast< wxEventType >(val1);
18797 }
18798 if (obj1) {
18799 ecode2 = SWIG_AsVal_int(obj1, &val2);
18800 if (!SWIG_IsOK(ecode2)) {
18801 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CommandEvent" "', expected argument " "2"" of type '" "int""'");
18802 }
18803 arg2 = static_cast< int >(val2);
18804 }
18805 {
18806 PyThreadState* __tstate = wxPyBeginAllowThreads();
18807 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
18808 wxPyEndAllowThreads(__tstate);
18809 if (PyErr_Occurred()) SWIG_fail;
18810 }
18811 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_NEW | 0 );
18812 return resultobj;
18813 fail:
18814 return NULL;
18815 }
18816
18817
18818 SWIGINTERN PyObject *_wrap_CommandEvent_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18819 PyObject *resultobj = 0;
18820 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18821 int result;
18822 void *argp1 = 0 ;
18823 int res1 = 0 ;
18824 PyObject *swig_obj[1] ;
18825
18826 if (!args) SWIG_fail;
18827 swig_obj[0] = args;
18828 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18829 if (!SWIG_IsOK(res1)) {
18830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18831 }
18832 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18833 {
18834 PyThreadState* __tstate = wxPyBeginAllowThreads();
18835 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
18836 wxPyEndAllowThreads(__tstate);
18837 if (PyErr_Occurred()) SWIG_fail;
18838 }
18839 resultobj = SWIG_From_int(static_cast< int >(result));
18840 return resultobj;
18841 fail:
18842 return NULL;
18843 }
18844
18845
18846 SWIGINTERN PyObject *_wrap_CommandEvent_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18847 PyObject *resultobj = 0;
18848 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18849 wxString *arg2 = 0 ;
18850 void *argp1 = 0 ;
18851 int res1 = 0 ;
18852 bool temp2 = false ;
18853 PyObject * obj0 = 0 ;
18854 PyObject * obj1 = 0 ;
18855 char * kwnames[] = {
18856 (char *) "self",(char *) "s", NULL
18857 };
18858
18859 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) SWIG_fail;
18860 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18861 if (!SWIG_IsOK(res1)) {
18862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetString" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
18863 }
18864 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18865 {
18866 arg2 = wxString_in_helper(obj1);
18867 if (arg2 == NULL) SWIG_fail;
18868 temp2 = true;
18869 }
18870 {
18871 PyThreadState* __tstate = wxPyBeginAllowThreads();
18872 (arg1)->SetString((wxString const &)*arg2);
18873 wxPyEndAllowThreads(__tstate);
18874 if (PyErr_Occurred()) SWIG_fail;
18875 }
18876 resultobj = SWIG_Py_Void();
18877 {
18878 if (temp2)
18879 delete arg2;
18880 }
18881 return resultobj;
18882 fail:
18883 {
18884 if (temp2)
18885 delete arg2;
18886 }
18887 return NULL;
18888 }
18889
18890
18891 SWIGINTERN PyObject *_wrap_CommandEvent_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18892 PyObject *resultobj = 0;
18893 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18894 wxString result;
18895 void *argp1 = 0 ;
18896 int res1 = 0 ;
18897 PyObject *swig_obj[1] ;
18898
18899 if (!args) SWIG_fail;
18900 swig_obj[0] = args;
18901 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18902 if (!SWIG_IsOK(res1)) {
18903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetString" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18904 }
18905 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18906 {
18907 PyThreadState* __tstate = wxPyBeginAllowThreads();
18908 result = ((wxCommandEvent const *)arg1)->GetString();
18909 wxPyEndAllowThreads(__tstate);
18910 if (PyErr_Occurred()) SWIG_fail;
18911 }
18912 {
18913 #if wxUSE_UNICODE
18914 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18915 #else
18916 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18917 #endif
18918 }
18919 return resultobj;
18920 fail:
18921 return NULL;
18922 }
18923
18924
18925 SWIGINTERN PyObject *_wrap_CommandEvent_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18926 PyObject *resultobj = 0;
18927 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18928 bool result;
18929 void *argp1 = 0 ;
18930 int res1 = 0 ;
18931 PyObject *swig_obj[1] ;
18932
18933 if (!args) SWIG_fail;
18934 swig_obj[0] = args;
18935 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18936 if (!SWIG_IsOK(res1)) {
18937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsChecked" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18938 }
18939 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18940 {
18941 PyThreadState* __tstate = wxPyBeginAllowThreads();
18942 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
18943 wxPyEndAllowThreads(__tstate);
18944 if (PyErr_Occurred()) SWIG_fail;
18945 }
18946 {
18947 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18948 }
18949 return resultobj;
18950 fail:
18951 return NULL;
18952 }
18953
18954
18955 SWIGINTERN PyObject *_wrap_CommandEvent_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18956 PyObject *resultobj = 0;
18957 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18958 bool result;
18959 void *argp1 = 0 ;
18960 int res1 = 0 ;
18961 PyObject *swig_obj[1] ;
18962
18963 if (!args) SWIG_fail;
18964 swig_obj[0] = args;
18965 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18966 if (!SWIG_IsOK(res1)) {
18967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18968 }
18969 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18970 {
18971 PyThreadState* __tstate = wxPyBeginAllowThreads();
18972 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
18973 wxPyEndAllowThreads(__tstate);
18974 if (PyErr_Occurred()) SWIG_fail;
18975 }
18976 {
18977 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18978 }
18979 return resultobj;
18980 fail:
18981 return NULL;
18982 }
18983
18984
18985 SWIGINTERN PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18986 PyObject *resultobj = 0;
18987 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18988 long arg2 ;
18989 void *argp1 = 0 ;
18990 int res1 = 0 ;
18991 long val2 ;
18992 int ecode2 = 0 ;
18993 PyObject * obj0 = 0 ;
18994 PyObject * obj1 = 0 ;
18995 char * kwnames[] = {
18996 (char *) "self",(char *) "extraLong", NULL
18997 };
18998
18999 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) SWIG_fail;
19000 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19001 if (!SWIG_IsOK(res1)) {
19002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19003 }
19004 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19005 ecode2 = SWIG_AsVal_long(obj1, &val2);
19006 if (!SWIG_IsOK(ecode2)) {
19007 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "2"" of type '" "long""'");
19008 }
19009 arg2 = static_cast< long >(val2);
19010 {
19011 PyThreadState* __tstate = wxPyBeginAllowThreads();
19012 (arg1)->SetExtraLong(arg2);
19013 wxPyEndAllowThreads(__tstate);
19014 if (PyErr_Occurred()) SWIG_fail;
19015 }
19016 resultobj = SWIG_Py_Void();
19017 return resultobj;
19018 fail:
19019 return NULL;
19020 }
19021
19022
19023 SWIGINTERN PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19024 PyObject *resultobj = 0;
19025 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19026 long result;
19027 void *argp1 = 0 ;
19028 int res1 = 0 ;
19029 PyObject *swig_obj[1] ;
19030
19031 if (!args) SWIG_fail;
19032 swig_obj[0] = args;
19033 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19034 if (!SWIG_IsOK(res1)) {
19035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19036 }
19037 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19038 {
19039 PyThreadState* __tstate = wxPyBeginAllowThreads();
19040 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
19041 wxPyEndAllowThreads(__tstate);
19042 if (PyErr_Occurred()) SWIG_fail;
19043 }
19044 resultobj = SWIG_From_long(static_cast< long >(result));
19045 return resultobj;
19046 fail:
19047 return NULL;
19048 }
19049
19050
19051 SWIGINTERN PyObject *_wrap_CommandEvent_SetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19052 PyObject *resultobj = 0;
19053 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19054 int arg2 ;
19055 void *argp1 = 0 ;
19056 int res1 = 0 ;
19057 int val2 ;
19058 int ecode2 = 0 ;
19059 PyObject * obj0 = 0 ;
19060 PyObject * obj1 = 0 ;
19061 char * kwnames[] = {
19062 (char *) "self",(char *) "i", NULL
19063 };
19064
19065 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) SWIG_fail;
19066 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19067 if (!SWIG_IsOK(res1)) {
19068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetInt" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19069 }
19070 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19071 ecode2 = SWIG_AsVal_int(obj1, &val2);
19072 if (!SWIG_IsOK(ecode2)) {
19073 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetInt" "', expected argument " "2"" of type '" "int""'");
19074 }
19075 arg2 = static_cast< int >(val2);
19076 {
19077 PyThreadState* __tstate = wxPyBeginAllowThreads();
19078 (arg1)->SetInt(arg2);
19079 wxPyEndAllowThreads(__tstate);
19080 if (PyErr_Occurred()) SWIG_fail;
19081 }
19082 resultobj = SWIG_Py_Void();
19083 return resultobj;
19084 fail:
19085 return NULL;
19086 }
19087
19088
19089 SWIGINTERN PyObject *_wrap_CommandEvent_GetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19090 PyObject *resultobj = 0;
19091 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19092 int result;
19093 void *argp1 = 0 ;
19094 int res1 = 0 ;
19095 PyObject *swig_obj[1] ;
19096
19097 if (!args) SWIG_fail;
19098 swig_obj[0] = args;
19099 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19100 if (!SWIG_IsOK(res1)) {
19101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetInt" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19102 }
19103 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19104 {
19105 PyThreadState* __tstate = wxPyBeginAllowThreads();
19106 result = (int)((wxCommandEvent const *)arg1)->GetInt();
19107 wxPyEndAllowThreads(__tstate);
19108 if (PyErr_Occurred()) SWIG_fail;
19109 }
19110 resultobj = SWIG_From_int(static_cast< int >(result));
19111 return resultobj;
19112 fail:
19113 return NULL;
19114 }
19115
19116
19117 SWIGINTERN PyObject *_wrap_CommandEvent_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19118 PyObject *resultobj = 0;
19119 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19120 PyObject *result = 0 ;
19121 void *argp1 = 0 ;
19122 int res1 = 0 ;
19123 PyObject *swig_obj[1] ;
19124
19125 if (!args) SWIG_fail;
19126 swig_obj[0] = args;
19127 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19128 if (!SWIG_IsOK(res1)) {
19129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19130 }
19131 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19132 {
19133 PyThreadState* __tstate = wxPyBeginAllowThreads();
19134 result = (PyObject *)wxCommandEvent_GetClientData(arg1);
19135 wxPyEndAllowThreads(__tstate);
19136 if (PyErr_Occurred()) SWIG_fail;
19137 }
19138 resultobj = result;
19139 return resultobj;
19140 fail:
19141 return NULL;
19142 }
19143
19144
19145 SWIGINTERN PyObject *_wrap_CommandEvent_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19146 PyObject *resultobj = 0;
19147 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19148 PyObject *arg2 = (PyObject *) 0 ;
19149 void *argp1 = 0 ;
19150 int res1 = 0 ;
19151 PyObject * obj0 = 0 ;
19152 PyObject * obj1 = 0 ;
19153 char * kwnames[] = {
19154 (char *) "self",(char *) "clientData", NULL
19155 };
19156
19157 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
19158 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19159 if (!SWIG_IsOK(res1)) {
19160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19161 }
19162 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19163 arg2 = obj1;
19164 {
19165 PyThreadState* __tstate = wxPyBeginAllowThreads();
19166 wxCommandEvent_SetClientData(arg1,arg2);
19167 wxPyEndAllowThreads(__tstate);
19168 if (PyErr_Occurred()) SWIG_fail;
19169 }
19170 resultobj = SWIG_Py_Void();
19171 return resultobj;
19172 fail:
19173 return NULL;
19174 }
19175
19176
19177 SWIGINTERN PyObject *_wrap_CommandEvent_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19178 PyObject *resultobj = 0;
19179 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19180 wxEvent *result = 0 ;
19181 void *argp1 = 0 ;
19182 int res1 = 0 ;
19183 PyObject *swig_obj[1] ;
19184
19185 if (!args) SWIG_fail;
19186 swig_obj[0] = args;
19187 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19188 if (!SWIG_IsOK(res1)) {
19189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_Clone" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19190 }
19191 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19192 {
19193 PyThreadState* __tstate = wxPyBeginAllowThreads();
19194 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
19195 wxPyEndAllowThreads(__tstate);
19196 if (PyErr_Occurred()) SWIG_fail;
19197 }
19198 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
19199 return resultobj;
19200 fail:
19201 return NULL;
19202 }
19203
19204
19205 SWIGINTERN PyObject *CommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19206 PyObject *obj;
19207 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19208 SWIG_TypeNewClientData(SWIGTYPE_p_wxCommandEvent, SWIG_NewClientData(obj));
19209 return SWIG_Py_Void();
19210 }
19211
19212 SWIGINTERN PyObject *CommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19213 return SWIG_Python_InitShadowInstance(args);
19214 }
19215
19216 SWIGINTERN PyObject *_wrap_new_NotifyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19217 PyObject *resultobj = 0;
19218 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19219 int arg2 = (int) 0 ;
19220 wxNotifyEvent *result = 0 ;
19221 int val1 ;
19222 int ecode1 = 0 ;
19223 int val2 ;
19224 int ecode2 = 0 ;
19225 PyObject * obj0 = 0 ;
19226 PyObject * obj1 = 0 ;
19227 char * kwnames[] = {
19228 (char *) "commandType",(char *) "winid", NULL
19229 };
19230
19231 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
19232 if (obj0) {
19233 ecode1 = SWIG_AsVal_int(obj0, &val1);
19234 if (!SWIG_IsOK(ecode1)) {
19235 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NotifyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19236 }
19237 arg1 = static_cast< wxEventType >(val1);
19238 }
19239 if (obj1) {
19240 ecode2 = SWIG_AsVal_int(obj1, &val2);
19241 if (!SWIG_IsOK(ecode2)) {
19242 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NotifyEvent" "', expected argument " "2"" of type '" "int""'");
19243 }
19244 arg2 = static_cast< int >(val2);
19245 }
19246 {
19247 PyThreadState* __tstate = wxPyBeginAllowThreads();
19248 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
19249 wxPyEndAllowThreads(__tstate);
19250 if (PyErr_Occurred()) SWIG_fail;
19251 }
19252 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_NEW | 0 );
19253 return resultobj;
19254 fail:
19255 return NULL;
19256 }
19257
19258
19259 SWIGINTERN PyObject *_wrap_NotifyEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19260 PyObject *resultobj = 0;
19261 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19262 void *argp1 = 0 ;
19263 int res1 = 0 ;
19264 PyObject *swig_obj[1] ;
19265
19266 if (!args) SWIG_fail;
19267 swig_obj[0] = args;
19268 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19269 if (!SWIG_IsOK(res1)) {
19270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Veto" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19271 }
19272 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19273 {
19274 PyThreadState* __tstate = wxPyBeginAllowThreads();
19275 (arg1)->Veto();
19276 wxPyEndAllowThreads(__tstate);
19277 if (PyErr_Occurred()) SWIG_fail;
19278 }
19279 resultobj = SWIG_Py_Void();
19280 return resultobj;
19281 fail:
19282 return NULL;
19283 }
19284
19285
19286 SWIGINTERN PyObject *_wrap_NotifyEvent_Allow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19287 PyObject *resultobj = 0;
19288 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19289 void *argp1 = 0 ;
19290 int res1 = 0 ;
19291 PyObject *swig_obj[1] ;
19292
19293 if (!args) SWIG_fail;
19294 swig_obj[0] = args;
19295 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19296 if (!SWIG_IsOK(res1)) {
19297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Allow" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19298 }
19299 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19300 {
19301 PyThreadState* __tstate = wxPyBeginAllowThreads();
19302 (arg1)->Allow();
19303 wxPyEndAllowThreads(__tstate);
19304 if (PyErr_Occurred()) SWIG_fail;
19305 }
19306 resultobj = SWIG_Py_Void();
19307 return resultobj;
19308 fail:
19309 return NULL;
19310 }
19311
19312
19313 SWIGINTERN PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19314 PyObject *resultobj = 0;
19315 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19316 bool result;
19317 void *argp1 = 0 ;
19318 int res1 = 0 ;
19319 PyObject *swig_obj[1] ;
19320
19321 if (!args) SWIG_fail;
19322 swig_obj[0] = args;
19323 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19324 if (!SWIG_IsOK(res1)) {
19325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_IsAllowed" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19326 }
19327 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19328 {
19329 PyThreadState* __tstate = wxPyBeginAllowThreads();
19330 result = (bool)(arg1)->IsAllowed();
19331 wxPyEndAllowThreads(__tstate);
19332 if (PyErr_Occurred()) SWIG_fail;
19333 }
19334 {
19335 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19336 }
19337 return resultobj;
19338 fail:
19339 return NULL;
19340 }
19341
19342
19343 SWIGINTERN PyObject *NotifyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19344 PyObject *obj;
19345 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19346 SWIG_TypeNewClientData(SWIGTYPE_p_wxNotifyEvent, SWIG_NewClientData(obj));
19347 return SWIG_Py_Void();
19348 }
19349
19350 SWIGINTERN PyObject *NotifyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19351 return SWIG_Python_InitShadowInstance(args);
19352 }
19353
19354 SWIGINTERN PyObject *_wrap_new_ScrollEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19355 PyObject *resultobj = 0;
19356 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19357 int arg2 = (int) 0 ;
19358 int arg3 = (int) 0 ;
19359 int arg4 = (int) 0 ;
19360 wxScrollEvent *result = 0 ;
19361 int val1 ;
19362 int ecode1 = 0 ;
19363 int val2 ;
19364 int ecode2 = 0 ;
19365 int val3 ;
19366 int ecode3 = 0 ;
19367 int val4 ;
19368 int ecode4 = 0 ;
19369 PyObject * obj0 = 0 ;
19370 PyObject * obj1 = 0 ;
19371 PyObject * obj2 = 0 ;
19372 PyObject * obj3 = 0 ;
19373 char * kwnames[] = {
19374 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
19375 };
19376
19377 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19378 if (obj0) {
19379 ecode1 = SWIG_AsVal_int(obj0, &val1);
19380 if (!SWIG_IsOK(ecode1)) {
19381 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19382 }
19383 arg1 = static_cast< wxEventType >(val1);
19384 }
19385 if (obj1) {
19386 ecode2 = SWIG_AsVal_int(obj1, &val2);
19387 if (!SWIG_IsOK(ecode2)) {
19388 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollEvent" "', expected argument " "2"" of type '" "int""'");
19389 }
19390 arg2 = static_cast< int >(val2);
19391 }
19392 if (obj2) {
19393 ecode3 = SWIG_AsVal_int(obj2, &val3);
19394 if (!SWIG_IsOK(ecode3)) {
19395 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollEvent" "', expected argument " "3"" of type '" "int""'");
19396 }
19397 arg3 = static_cast< int >(val3);
19398 }
19399 if (obj3) {
19400 ecode4 = SWIG_AsVal_int(obj3, &val4);
19401 if (!SWIG_IsOK(ecode4)) {
19402 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ScrollEvent" "', expected argument " "4"" of type '" "int""'");
19403 }
19404 arg4 = static_cast< int >(val4);
19405 }
19406 {
19407 PyThreadState* __tstate = wxPyBeginAllowThreads();
19408 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
19409 wxPyEndAllowThreads(__tstate);
19410 if (PyErr_Occurred()) SWIG_fail;
19411 }
19412 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_NEW | 0 );
19413 return resultobj;
19414 fail:
19415 return NULL;
19416 }
19417
19418
19419 SWIGINTERN PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19420 PyObject *resultobj = 0;
19421 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19422 int result;
19423 void *argp1 = 0 ;
19424 int res1 = 0 ;
19425 PyObject *swig_obj[1] ;
19426
19427 if (!args) SWIG_fail;
19428 swig_obj[0] = args;
19429 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19430 if (!SWIG_IsOK(res1)) {
19431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19432 }
19433 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19434 {
19435 PyThreadState* __tstate = wxPyBeginAllowThreads();
19436 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
19437 wxPyEndAllowThreads(__tstate);
19438 if (PyErr_Occurred()) SWIG_fail;
19439 }
19440 resultobj = SWIG_From_int(static_cast< int >(result));
19441 return resultobj;
19442 fail:
19443 return NULL;
19444 }
19445
19446
19447 SWIGINTERN PyObject *_wrap_ScrollEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19448 PyObject *resultobj = 0;
19449 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19450 int result;
19451 void *argp1 = 0 ;
19452 int res1 = 0 ;
19453 PyObject *swig_obj[1] ;
19454
19455 if (!args) SWIG_fail;
19456 swig_obj[0] = args;
19457 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19458 if (!SWIG_IsOK(res1)) {
19459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19460 }
19461 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19462 {
19463 PyThreadState* __tstate = wxPyBeginAllowThreads();
19464 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
19465 wxPyEndAllowThreads(__tstate);
19466 if (PyErr_Occurred()) SWIG_fail;
19467 }
19468 resultobj = SWIG_From_int(static_cast< int >(result));
19469 return resultobj;
19470 fail:
19471 return NULL;
19472 }
19473
19474
19475 SWIGINTERN PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19476 PyObject *resultobj = 0;
19477 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19478 int arg2 ;
19479 void *argp1 = 0 ;
19480 int res1 = 0 ;
19481 int val2 ;
19482 int ecode2 = 0 ;
19483 PyObject * obj0 = 0 ;
19484 PyObject * obj1 = 0 ;
19485 char * kwnames[] = {
19486 (char *) "self",(char *) "orient", NULL
19487 };
19488
19489 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19490 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19491 if (!SWIG_IsOK(res1)) {
19492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19493 }
19494 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19495 ecode2 = SWIG_AsVal_int(obj1, &val2);
19496 if (!SWIG_IsOK(ecode2)) {
19497 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
19498 }
19499 arg2 = static_cast< int >(val2);
19500 {
19501 PyThreadState* __tstate = wxPyBeginAllowThreads();
19502 (arg1)->SetOrientation(arg2);
19503 wxPyEndAllowThreads(__tstate);
19504 if (PyErr_Occurred()) SWIG_fail;
19505 }
19506 resultobj = SWIG_Py_Void();
19507 return resultobj;
19508 fail:
19509 return NULL;
19510 }
19511
19512
19513 SWIGINTERN PyObject *_wrap_ScrollEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19514 PyObject *resultobj = 0;
19515 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19516 int arg2 ;
19517 void *argp1 = 0 ;
19518 int res1 = 0 ;
19519 int val2 ;
19520 int ecode2 = 0 ;
19521 PyObject * obj0 = 0 ;
19522 PyObject * obj1 = 0 ;
19523 char * kwnames[] = {
19524 (char *) "self",(char *) "pos", NULL
19525 };
19526
19527 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
19528 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19529 if (!SWIG_IsOK(res1)) {
19530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19531 }
19532 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19533 ecode2 = SWIG_AsVal_int(obj1, &val2);
19534 if (!SWIG_IsOK(ecode2)) {
19535 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
19536 }
19537 arg2 = static_cast< int >(val2);
19538 {
19539 PyThreadState* __tstate = wxPyBeginAllowThreads();
19540 (arg1)->SetPosition(arg2);
19541 wxPyEndAllowThreads(__tstate);
19542 if (PyErr_Occurred()) SWIG_fail;
19543 }
19544 resultobj = SWIG_Py_Void();
19545 return resultobj;
19546 fail:
19547 return NULL;
19548 }
19549
19550
19551 SWIGINTERN PyObject *ScrollEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19552 PyObject *obj;
19553 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19554 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollEvent, SWIG_NewClientData(obj));
19555 return SWIG_Py_Void();
19556 }
19557
19558 SWIGINTERN PyObject *ScrollEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19559 return SWIG_Python_InitShadowInstance(args);
19560 }
19561
19562 SWIGINTERN PyObject *_wrap_new_ScrollWinEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19563 PyObject *resultobj = 0;
19564 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19565 int arg2 = (int) 0 ;
19566 int arg3 = (int) 0 ;
19567 wxScrollWinEvent *result = 0 ;
19568 int val1 ;
19569 int ecode1 = 0 ;
19570 int val2 ;
19571 int ecode2 = 0 ;
19572 int val3 ;
19573 int ecode3 = 0 ;
19574 PyObject * obj0 = 0 ;
19575 PyObject * obj1 = 0 ;
19576 PyObject * obj2 = 0 ;
19577 char * kwnames[] = {
19578 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
19579 };
19580
19581 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19582 if (obj0) {
19583 ecode1 = SWIG_AsVal_int(obj0, &val1);
19584 if (!SWIG_IsOK(ecode1)) {
19585 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollWinEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19586 }
19587 arg1 = static_cast< wxEventType >(val1);
19588 }
19589 if (obj1) {
19590 ecode2 = SWIG_AsVal_int(obj1, &val2);
19591 if (!SWIG_IsOK(ecode2)) {
19592 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollWinEvent" "', expected argument " "2"" of type '" "int""'");
19593 }
19594 arg2 = static_cast< int >(val2);
19595 }
19596 if (obj2) {
19597 ecode3 = SWIG_AsVal_int(obj2, &val3);
19598 if (!SWIG_IsOK(ecode3)) {
19599 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollWinEvent" "', expected argument " "3"" of type '" "int""'");
19600 }
19601 arg3 = static_cast< int >(val3);
19602 }
19603 {
19604 PyThreadState* __tstate = wxPyBeginAllowThreads();
19605 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
19606 wxPyEndAllowThreads(__tstate);
19607 if (PyErr_Occurred()) SWIG_fail;
19608 }
19609 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_NEW | 0 );
19610 return resultobj;
19611 fail:
19612 return NULL;
19613 }
19614
19615
19616 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19617 PyObject *resultobj = 0;
19618 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19619 int result;
19620 void *argp1 = 0 ;
19621 int res1 = 0 ;
19622 PyObject *swig_obj[1] ;
19623
19624 if (!args) SWIG_fail;
19625 swig_obj[0] = args;
19626 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19627 if (!SWIG_IsOK(res1)) {
19628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
19629 }
19630 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19631 {
19632 PyThreadState* __tstate = wxPyBeginAllowThreads();
19633 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
19634 wxPyEndAllowThreads(__tstate);
19635 if (PyErr_Occurred()) SWIG_fail;
19636 }
19637 resultobj = SWIG_From_int(static_cast< int >(result));
19638 return resultobj;
19639 fail:
19640 return NULL;
19641 }
19642
19643
19644 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19645 PyObject *resultobj = 0;
19646 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19647 int result;
19648 void *argp1 = 0 ;
19649 int res1 = 0 ;
19650 PyObject *swig_obj[1] ;
19651
19652 if (!args) SWIG_fail;
19653 swig_obj[0] = args;
19654 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19655 if (!SWIG_IsOK(res1)) {
19656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
19657 }
19658 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19659 {
19660 PyThreadState* __tstate = wxPyBeginAllowThreads();
19661 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
19662 wxPyEndAllowThreads(__tstate);
19663 if (PyErr_Occurred()) SWIG_fail;
19664 }
19665 resultobj = SWIG_From_int(static_cast< int >(result));
19666 return resultobj;
19667 fail:
19668 return NULL;
19669 }
19670
19671
19672 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19673 PyObject *resultobj = 0;
19674 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19675 int arg2 ;
19676 void *argp1 = 0 ;
19677 int res1 = 0 ;
19678 int val2 ;
19679 int ecode2 = 0 ;
19680 PyObject * obj0 = 0 ;
19681 PyObject * obj1 = 0 ;
19682 char * kwnames[] = {
19683 (char *) "self",(char *) "orient", NULL
19684 };
19685
19686 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19687 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19688 if (!SWIG_IsOK(res1)) {
19689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
19690 }
19691 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19692 ecode2 = SWIG_AsVal_int(obj1, &val2);
19693 if (!SWIG_IsOK(ecode2)) {
19694 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
19695 }
19696 arg2 = static_cast< int >(val2);
19697 {
19698 PyThreadState* __tstate = wxPyBeginAllowThreads();
19699 (arg1)->SetOrientation(arg2);
19700 wxPyEndAllowThreads(__tstate);
19701 if (PyErr_Occurred()) SWIG_fail;
19702 }
19703 resultobj = SWIG_Py_Void();
19704 return resultobj;
19705 fail:
19706 return NULL;
19707 }
19708
19709
19710 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19711 PyObject *resultobj = 0;
19712 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19713 int arg2 ;
19714 void *argp1 = 0 ;
19715 int res1 = 0 ;
19716 int val2 ;
19717 int ecode2 = 0 ;
19718 PyObject * obj0 = 0 ;
19719 PyObject * obj1 = 0 ;
19720 char * kwnames[] = {
19721 (char *) "self",(char *) "pos", NULL
19722 };
19723
19724 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
19725 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19726 if (!SWIG_IsOK(res1)) {
19727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
19728 }
19729 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19730 ecode2 = SWIG_AsVal_int(obj1, &val2);
19731 if (!SWIG_IsOK(ecode2)) {
19732 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
19733 }
19734 arg2 = static_cast< int >(val2);
19735 {
19736 PyThreadState* __tstate = wxPyBeginAllowThreads();
19737 (arg1)->SetPosition(arg2);
19738 wxPyEndAllowThreads(__tstate);
19739 if (PyErr_Occurred()) SWIG_fail;
19740 }
19741 resultobj = SWIG_Py_Void();
19742 return resultobj;
19743 fail:
19744 return NULL;
19745 }
19746
19747
19748 SWIGINTERN PyObject *ScrollWinEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19749 PyObject *obj;
19750 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19751 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollWinEvent, SWIG_NewClientData(obj));
19752 return SWIG_Py_Void();
19753 }
19754
19755 SWIGINTERN PyObject *ScrollWinEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19756 return SWIG_Python_InitShadowInstance(args);
19757 }
19758
19759 SWIGINTERN PyObject *_wrap_new_MouseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19760 PyObject *resultobj = 0;
19761 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19762 wxMouseEvent *result = 0 ;
19763 int val1 ;
19764 int ecode1 = 0 ;
19765 PyObject * obj0 = 0 ;
19766 char * kwnames[] = {
19767 (char *) "mouseType", NULL
19768 };
19769
19770 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) SWIG_fail;
19771 if (obj0) {
19772 ecode1 = SWIG_AsVal_int(obj0, &val1);
19773 if (!SWIG_IsOK(ecode1)) {
19774 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19775 }
19776 arg1 = static_cast< wxEventType >(val1);
19777 }
19778 {
19779 PyThreadState* __tstate = wxPyBeginAllowThreads();
19780 result = (wxMouseEvent *)new wxMouseEvent(arg1);
19781 wxPyEndAllowThreads(__tstate);
19782 if (PyErr_Occurred()) SWIG_fail;
19783 }
19784 {
19785 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
19786 }
19787 return resultobj;
19788 fail:
19789 return NULL;
19790 }
19791
19792
19793 SWIGINTERN PyObject *_wrap_MouseEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19794 PyObject *resultobj = 0;
19795 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19796 bool result;
19797 void *argp1 = 0 ;
19798 int res1 = 0 ;
19799 PyObject *swig_obj[1] ;
19800
19801 if (!args) SWIG_fail;
19802 swig_obj[0] = args;
19803 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19804 if (!SWIG_IsOK(res1)) {
19805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19806 }
19807 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19808 {
19809 PyThreadState* __tstate = wxPyBeginAllowThreads();
19810 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
19811 wxPyEndAllowThreads(__tstate);
19812 if (PyErr_Occurred()) SWIG_fail;
19813 }
19814 {
19815 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19816 }
19817 return resultobj;
19818 fail:
19819 return NULL;
19820 }
19821
19822
19823 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19824 PyObject *resultobj = 0;
19825 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19826 int arg2 = (int) wxMOUSE_BTN_ANY ;
19827 bool result;
19828 void *argp1 = 0 ;
19829 int res1 = 0 ;
19830 int val2 ;
19831 int ecode2 = 0 ;
19832 PyObject * obj0 = 0 ;
19833 PyObject * obj1 = 0 ;
19834 char * kwnames[] = {
19835 (char *) "self",(char *) "but", NULL
19836 };
19837
19838 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
19839 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19840 if (!SWIG_IsOK(res1)) {
19841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19842 }
19843 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19844 if (obj1) {
19845 ecode2 = SWIG_AsVal_int(obj1, &val2);
19846 if (!SWIG_IsOK(ecode2)) {
19847 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
19848 }
19849 arg2 = static_cast< int >(val2);
19850 }
19851 {
19852 PyThreadState* __tstate = wxPyBeginAllowThreads();
19853 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
19854 wxPyEndAllowThreads(__tstate);
19855 if (PyErr_Occurred()) SWIG_fail;
19856 }
19857 {
19858 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19859 }
19860 return resultobj;
19861 fail:
19862 return NULL;
19863 }
19864
19865
19866 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19867 PyObject *resultobj = 0;
19868 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19869 int arg2 = (int) wxMOUSE_BTN_ANY ;
19870 bool result;
19871 void *argp1 = 0 ;
19872 int res1 = 0 ;
19873 int val2 ;
19874 int ecode2 = 0 ;
19875 PyObject * obj0 = 0 ;
19876 PyObject * obj1 = 0 ;
19877 char * kwnames[] = {
19878 (char *) "self",(char *) "but", NULL
19879 };
19880
19881 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) SWIG_fail;
19882 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19883 if (!SWIG_IsOK(res1)) {
19884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19885 }
19886 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19887 if (obj1) {
19888 ecode2 = SWIG_AsVal_int(obj1, &val2);
19889 if (!SWIG_IsOK(ecode2)) {
19890 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "2"" of type '" "int""'");
19891 }
19892 arg2 = static_cast< int >(val2);
19893 }
19894 {
19895 PyThreadState* __tstate = wxPyBeginAllowThreads();
19896 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
19897 wxPyEndAllowThreads(__tstate);
19898 if (PyErr_Occurred()) SWIG_fail;
19899 }
19900 {
19901 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19902 }
19903 return resultobj;
19904 fail:
19905 return NULL;
19906 }
19907
19908
19909 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19910 PyObject *resultobj = 0;
19911 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19912 int arg2 = (int) wxMOUSE_BTN_ANY ;
19913 bool result;
19914 void *argp1 = 0 ;
19915 int res1 = 0 ;
19916 int val2 ;
19917 int ecode2 = 0 ;
19918 PyObject * obj0 = 0 ;
19919 PyObject * obj1 = 0 ;
19920 char * kwnames[] = {
19921 (char *) "self",(char *) "but", NULL
19922 };
19923
19924 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
19925 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19926 if (!SWIG_IsOK(res1)) {
19927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19928 }
19929 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19930 if (obj1) {
19931 ecode2 = SWIG_AsVal_int(obj1, &val2);
19932 if (!SWIG_IsOK(ecode2)) {
19933 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
19934 }
19935 arg2 = static_cast< int >(val2);
19936 }
19937 {
19938 PyThreadState* __tstate = wxPyBeginAllowThreads();
19939 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
19940 wxPyEndAllowThreads(__tstate);
19941 if (PyErr_Occurred()) SWIG_fail;
19942 }
19943 {
19944 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19945 }
19946 return resultobj;
19947 fail:
19948 return NULL;
19949 }
19950
19951
19952 SWIGINTERN PyObject *_wrap_MouseEvent_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19953 PyObject *resultobj = 0;
19954 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19955 int arg2 ;
19956 bool result;
19957 void *argp1 = 0 ;
19958 int res1 = 0 ;
19959 int val2 ;
19960 int ecode2 = 0 ;
19961 PyObject * obj0 = 0 ;
19962 PyObject * obj1 = 0 ;
19963 char * kwnames[] = {
19964 (char *) "self",(char *) "button", NULL
19965 };
19966
19967 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) SWIG_fail;
19968 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19969 if (!SWIG_IsOK(res1)) {
19970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Button" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19971 }
19972 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19973 ecode2 = SWIG_AsVal_int(obj1, &val2);
19974 if (!SWIG_IsOK(ecode2)) {
19975 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_Button" "', expected argument " "2"" of type '" "int""'");
19976 }
19977 arg2 = static_cast< int >(val2);
19978 {
19979 PyThreadState* __tstate = wxPyBeginAllowThreads();
19980 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
19981 wxPyEndAllowThreads(__tstate);
19982 if (PyErr_Occurred()) SWIG_fail;
19983 }
19984 {
19985 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19986 }
19987 return resultobj;
19988 fail:
19989 return NULL;
19990 }
19991
19992
19993 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19994 PyObject *resultobj = 0;
19995 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19996 int arg2 ;
19997 bool result;
19998 void *argp1 = 0 ;
19999 int res1 = 0 ;
20000 int val2 ;
20001 int ecode2 = 0 ;
20002 PyObject * obj0 = 0 ;
20003 PyObject * obj1 = 0 ;
20004 char * kwnames[] = {
20005 (char *) "self",(char *) "but", NULL
20006 };
20007
20008 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
20009 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20010 if (!SWIG_IsOK(res1)) {
20011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20012 }
20013 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20014 ecode2 = SWIG_AsVal_int(obj1, &val2);
20015 if (!SWIG_IsOK(ecode2)) {
20016 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
20017 }
20018 arg2 = static_cast< int >(val2);
20019 {
20020 PyThreadState* __tstate = wxPyBeginAllowThreads();
20021 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
20022 wxPyEndAllowThreads(__tstate);
20023 if (PyErr_Occurred()) SWIG_fail;
20024 }
20025 {
20026 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20027 }
20028 return resultobj;
20029 fail:
20030 return NULL;
20031 }
20032
20033
20034 SWIGINTERN PyObject *_wrap_MouseEvent_GetButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20035 PyObject *resultobj = 0;
20036 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20037 int result;
20038 void *argp1 = 0 ;
20039 int res1 = 0 ;
20040 PyObject *swig_obj[1] ;
20041
20042 if (!args) SWIG_fail;
20043 swig_obj[0] = args;
20044 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20045 if (!SWIG_IsOK(res1)) {
20046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20047 }
20048 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20049 {
20050 PyThreadState* __tstate = wxPyBeginAllowThreads();
20051 result = (int)((wxMouseEvent const *)arg1)->GetButton();
20052 wxPyEndAllowThreads(__tstate);
20053 if (PyErr_Occurred()) SWIG_fail;
20054 }
20055 resultobj = SWIG_From_int(static_cast< int >(result));
20056 return resultobj;
20057 fail:
20058 return NULL;
20059 }
20060
20061
20062 SWIGINTERN PyObject *_wrap_MouseEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20063 PyObject *resultobj = 0;
20064 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20065 bool result;
20066 void *argp1 = 0 ;
20067 int res1 = 0 ;
20068 PyObject *swig_obj[1] ;
20069
20070 if (!args) SWIG_fail;
20071 swig_obj[0] = args;
20072 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20073 if (!SWIG_IsOK(res1)) {
20074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ControlDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20075 }
20076 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20077 {
20078 PyThreadState* __tstate = wxPyBeginAllowThreads();
20079 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
20080 wxPyEndAllowThreads(__tstate);
20081 if (PyErr_Occurred()) SWIG_fail;
20082 }
20083 {
20084 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20085 }
20086 return resultobj;
20087 fail:
20088 return NULL;
20089 }
20090
20091
20092 SWIGINTERN PyObject *_wrap_MouseEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20093 PyObject *resultobj = 0;
20094 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20095 bool result;
20096 void *argp1 = 0 ;
20097 int res1 = 0 ;
20098 PyObject *swig_obj[1] ;
20099
20100 if (!args) SWIG_fail;
20101 swig_obj[0] = args;
20102 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20103 if (!SWIG_IsOK(res1)) {
20104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MetaDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20105 }
20106 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20107 {
20108 PyThreadState* __tstate = wxPyBeginAllowThreads();
20109 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
20110 wxPyEndAllowThreads(__tstate);
20111 if (PyErr_Occurred()) SWIG_fail;
20112 }
20113 {
20114 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20115 }
20116 return resultobj;
20117 fail:
20118 return NULL;
20119 }
20120
20121
20122 SWIGINTERN PyObject *_wrap_MouseEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20123 PyObject *resultobj = 0;
20124 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20125 bool result;
20126 void *argp1 = 0 ;
20127 int res1 = 0 ;
20128 PyObject *swig_obj[1] ;
20129
20130 if (!args) SWIG_fail;
20131 swig_obj[0] = args;
20132 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20133 if (!SWIG_IsOK(res1)) {
20134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_AltDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20135 }
20136 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20137 {
20138 PyThreadState* __tstate = wxPyBeginAllowThreads();
20139 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
20140 wxPyEndAllowThreads(__tstate);
20141 if (PyErr_Occurred()) SWIG_fail;
20142 }
20143 {
20144 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20145 }
20146 return resultobj;
20147 fail:
20148 return NULL;
20149 }
20150
20151
20152 SWIGINTERN PyObject *_wrap_MouseEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20153 PyObject *resultobj = 0;
20154 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20155 bool result;
20156 void *argp1 = 0 ;
20157 int res1 = 0 ;
20158 PyObject *swig_obj[1] ;
20159
20160 if (!args) SWIG_fail;
20161 swig_obj[0] = args;
20162 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20163 if (!SWIG_IsOK(res1)) {
20164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ShiftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20165 }
20166 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20167 {
20168 PyThreadState* __tstate = wxPyBeginAllowThreads();
20169 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
20170 wxPyEndAllowThreads(__tstate);
20171 if (PyErr_Occurred()) SWIG_fail;
20172 }
20173 {
20174 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20175 }
20176 return resultobj;
20177 fail:
20178 return NULL;
20179 }
20180
20181
20182 SWIGINTERN PyObject *_wrap_MouseEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20183 PyObject *resultobj = 0;
20184 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20185 bool result;
20186 void *argp1 = 0 ;
20187 int res1 = 0 ;
20188 PyObject *swig_obj[1] ;
20189
20190 if (!args) SWIG_fail;
20191 swig_obj[0] = args;
20192 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20193 if (!SWIG_IsOK(res1)) {
20194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_CmdDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20195 }
20196 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20197 {
20198 PyThreadState* __tstate = wxPyBeginAllowThreads();
20199 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
20200 wxPyEndAllowThreads(__tstate);
20201 if (PyErr_Occurred()) SWIG_fail;
20202 }
20203 {
20204 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20205 }
20206 return resultobj;
20207 fail:
20208 return NULL;
20209 }
20210
20211
20212 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20213 PyObject *resultobj = 0;
20214 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20215 bool result;
20216 void *argp1 = 0 ;
20217 int res1 = 0 ;
20218 PyObject *swig_obj[1] ;
20219
20220 if (!args) SWIG_fail;
20221 swig_obj[0] = args;
20222 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20223 if (!SWIG_IsOK(res1)) {
20224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20225 }
20226 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20227 {
20228 PyThreadState* __tstate = wxPyBeginAllowThreads();
20229 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
20230 wxPyEndAllowThreads(__tstate);
20231 if (PyErr_Occurred()) SWIG_fail;
20232 }
20233 {
20234 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20235 }
20236 return resultobj;
20237 fail:
20238 return NULL;
20239 }
20240
20241
20242 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20243 PyObject *resultobj = 0;
20244 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20245 bool result;
20246 void *argp1 = 0 ;
20247 int res1 = 0 ;
20248 PyObject *swig_obj[1] ;
20249
20250 if (!args) SWIG_fail;
20251 swig_obj[0] = args;
20252 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20253 if (!SWIG_IsOK(res1)) {
20254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20255 }
20256 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20257 {
20258 PyThreadState* __tstate = wxPyBeginAllowThreads();
20259 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
20260 wxPyEndAllowThreads(__tstate);
20261 if (PyErr_Occurred()) SWIG_fail;
20262 }
20263 {
20264 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20265 }
20266 return resultobj;
20267 fail:
20268 return NULL;
20269 }
20270
20271
20272 SWIGINTERN PyObject *_wrap_MouseEvent_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20273 PyObject *resultobj = 0;
20274 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20275 bool result;
20276 void *argp1 = 0 ;
20277 int res1 = 0 ;
20278 PyObject *swig_obj[1] ;
20279
20280 if (!args) SWIG_fail;
20281 swig_obj[0] = args;
20282 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20283 if (!SWIG_IsOK(res1)) {
20284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20285 }
20286 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20287 {
20288 PyThreadState* __tstate = wxPyBeginAllowThreads();
20289 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
20290 wxPyEndAllowThreads(__tstate);
20291 if (PyErr_Occurred()) SWIG_fail;
20292 }
20293 {
20294 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20295 }
20296 return resultobj;
20297 fail:
20298 return NULL;
20299 }
20300
20301
20302 SWIGINTERN PyObject *_wrap_MouseEvent_LeftUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20303 PyObject *resultobj = 0;
20304 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20305 bool result;
20306 void *argp1 = 0 ;
20307 int res1 = 0 ;
20308 PyObject *swig_obj[1] ;
20309
20310 if (!args) SWIG_fail;
20311 swig_obj[0] = args;
20312 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20313 if (!SWIG_IsOK(res1)) {
20314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20315 }
20316 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20317 {
20318 PyThreadState* __tstate = wxPyBeginAllowThreads();
20319 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
20320 wxPyEndAllowThreads(__tstate);
20321 if (PyErr_Occurred()) SWIG_fail;
20322 }
20323 {
20324 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20325 }
20326 return resultobj;
20327 fail:
20328 return NULL;
20329 }
20330
20331
20332 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20333 PyObject *resultobj = 0;
20334 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20335 bool result;
20336 void *argp1 = 0 ;
20337 int res1 = 0 ;
20338 PyObject *swig_obj[1] ;
20339
20340 if (!args) SWIG_fail;
20341 swig_obj[0] = args;
20342 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20343 if (!SWIG_IsOK(res1)) {
20344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20345 }
20346 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20347 {
20348 PyThreadState* __tstate = wxPyBeginAllowThreads();
20349 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
20350 wxPyEndAllowThreads(__tstate);
20351 if (PyErr_Occurred()) SWIG_fail;
20352 }
20353 {
20354 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20355 }
20356 return resultobj;
20357 fail:
20358 return NULL;
20359 }
20360
20361
20362 SWIGINTERN PyObject *_wrap_MouseEvent_RightUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20363 PyObject *resultobj = 0;
20364 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20365 bool result;
20366 void *argp1 = 0 ;
20367 int res1 = 0 ;
20368 PyObject *swig_obj[1] ;
20369
20370 if (!args) SWIG_fail;
20371 swig_obj[0] = args;
20372 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20373 if (!SWIG_IsOK(res1)) {
20374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20375 }
20376 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20377 {
20378 PyThreadState* __tstate = wxPyBeginAllowThreads();
20379 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
20380 wxPyEndAllowThreads(__tstate);
20381 if (PyErr_Occurred()) SWIG_fail;
20382 }
20383 {
20384 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20385 }
20386 return resultobj;
20387 fail:
20388 return NULL;
20389 }
20390
20391
20392 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20393 PyObject *resultobj = 0;
20394 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20395 bool result;
20396 void *argp1 = 0 ;
20397 int res1 = 0 ;
20398 PyObject *swig_obj[1] ;
20399
20400 if (!args) SWIG_fail;
20401 swig_obj[0] = args;
20402 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20403 if (!SWIG_IsOK(res1)) {
20404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20405 }
20406 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20407 {
20408 PyThreadState* __tstate = wxPyBeginAllowThreads();
20409 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
20410 wxPyEndAllowThreads(__tstate);
20411 if (PyErr_Occurred()) SWIG_fail;
20412 }
20413 {
20414 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20415 }
20416 return resultobj;
20417 fail:
20418 return NULL;
20419 }
20420
20421
20422 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20423 PyObject *resultobj = 0;
20424 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20425 bool result;
20426 void *argp1 = 0 ;
20427 int res1 = 0 ;
20428 PyObject *swig_obj[1] ;
20429
20430 if (!args) SWIG_fail;
20431 swig_obj[0] = args;
20432 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20433 if (!SWIG_IsOK(res1)) {
20434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20435 }
20436 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20437 {
20438 PyThreadState* __tstate = wxPyBeginAllowThreads();
20439 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
20440 wxPyEndAllowThreads(__tstate);
20441 if (PyErr_Occurred()) SWIG_fail;
20442 }
20443 {
20444 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20445 }
20446 return resultobj;
20447 fail:
20448 return NULL;
20449 }
20450
20451
20452 SWIGINTERN PyObject *_wrap_MouseEvent_RightDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20453 PyObject *resultobj = 0;
20454 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20455 bool result;
20456 void *argp1 = 0 ;
20457 int res1 = 0 ;
20458 PyObject *swig_obj[1] ;
20459
20460 if (!args) SWIG_fail;
20461 swig_obj[0] = args;
20462 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20463 if (!SWIG_IsOK(res1)) {
20464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20465 }
20466 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20467 {
20468 PyThreadState* __tstate = wxPyBeginAllowThreads();
20469 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
20470 wxPyEndAllowThreads(__tstate);
20471 if (PyErr_Occurred()) SWIG_fail;
20472 }
20473 {
20474 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20475 }
20476 return resultobj;
20477 fail:
20478 return NULL;
20479 }
20480
20481
20482 SWIGINTERN PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20483 PyObject *resultobj = 0;
20484 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20485 bool result;
20486 void *argp1 = 0 ;
20487 int res1 = 0 ;
20488 PyObject *swig_obj[1] ;
20489
20490 if (!args) SWIG_fail;
20491 swig_obj[0] = args;
20492 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20493 if (!SWIG_IsOK(res1)) {
20494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20495 }
20496 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20497 {
20498 PyThreadState* __tstate = wxPyBeginAllowThreads();
20499 result = (bool)(arg1)->LeftIsDown();
20500 wxPyEndAllowThreads(__tstate);
20501 if (PyErr_Occurred()) SWIG_fail;
20502 }
20503 {
20504 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20505 }
20506 return resultobj;
20507 fail:
20508 return NULL;
20509 }
20510
20511
20512 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20513 PyObject *resultobj = 0;
20514 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20515 bool result;
20516 void *argp1 = 0 ;
20517 int res1 = 0 ;
20518 PyObject *swig_obj[1] ;
20519
20520 if (!args) SWIG_fail;
20521 swig_obj[0] = args;
20522 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20523 if (!SWIG_IsOK(res1)) {
20524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20525 }
20526 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20527 {
20528 PyThreadState* __tstate = wxPyBeginAllowThreads();
20529 result = (bool)(arg1)->MiddleIsDown();
20530 wxPyEndAllowThreads(__tstate);
20531 if (PyErr_Occurred()) SWIG_fail;
20532 }
20533 {
20534 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20535 }
20536 return resultobj;
20537 fail:
20538 return NULL;
20539 }
20540
20541
20542 SWIGINTERN PyObject *_wrap_MouseEvent_RightIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20543 PyObject *resultobj = 0;
20544 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20545 bool result;
20546 void *argp1 = 0 ;
20547 int res1 = 0 ;
20548 PyObject *swig_obj[1] ;
20549
20550 if (!args) SWIG_fail;
20551 swig_obj[0] = args;
20552 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20553 if (!SWIG_IsOK(res1)) {
20554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20555 }
20556 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20557 {
20558 PyThreadState* __tstate = wxPyBeginAllowThreads();
20559 result = (bool)(arg1)->RightIsDown();
20560 wxPyEndAllowThreads(__tstate);
20561 if (PyErr_Occurred()) SWIG_fail;
20562 }
20563 {
20564 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20565 }
20566 return resultobj;
20567 fail:
20568 return NULL;
20569 }
20570
20571
20572 SWIGINTERN PyObject *_wrap_MouseEvent_Dragging(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20573 PyObject *resultobj = 0;
20574 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20575 bool result;
20576 void *argp1 = 0 ;
20577 int res1 = 0 ;
20578 PyObject *swig_obj[1] ;
20579
20580 if (!args) SWIG_fail;
20581 swig_obj[0] = args;
20582 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20583 if (!SWIG_IsOK(res1)) {
20584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Dragging" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20585 }
20586 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20587 {
20588 PyThreadState* __tstate = wxPyBeginAllowThreads();
20589 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
20590 wxPyEndAllowThreads(__tstate);
20591 if (PyErr_Occurred()) SWIG_fail;
20592 }
20593 {
20594 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20595 }
20596 return resultobj;
20597 fail:
20598 return NULL;
20599 }
20600
20601
20602 SWIGINTERN PyObject *_wrap_MouseEvent_Moving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20603 PyObject *resultobj = 0;
20604 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20605 bool result;
20606 void *argp1 = 0 ;
20607 int res1 = 0 ;
20608 PyObject *swig_obj[1] ;
20609
20610 if (!args) SWIG_fail;
20611 swig_obj[0] = args;
20612 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20613 if (!SWIG_IsOK(res1)) {
20614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Moving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20615 }
20616 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20617 {
20618 PyThreadState* __tstate = wxPyBeginAllowThreads();
20619 result = (bool)((wxMouseEvent const *)arg1)->Moving();
20620 wxPyEndAllowThreads(__tstate);
20621 if (PyErr_Occurred()) SWIG_fail;
20622 }
20623 {
20624 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20625 }
20626 return resultobj;
20627 fail:
20628 return NULL;
20629 }
20630
20631
20632 SWIGINTERN PyObject *_wrap_MouseEvent_Entering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20633 PyObject *resultobj = 0;
20634 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20635 bool result;
20636 void *argp1 = 0 ;
20637 int res1 = 0 ;
20638 PyObject *swig_obj[1] ;
20639
20640 if (!args) SWIG_fail;
20641 swig_obj[0] = args;
20642 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20643 if (!SWIG_IsOK(res1)) {
20644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Entering" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20645 }
20646 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20647 {
20648 PyThreadState* __tstate = wxPyBeginAllowThreads();
20649 result = (bool)((wxMouseEvent const *)arg1)->Entering();
20650 wxPyEndAllowThreads(__tstate);
20651 if (PyErr_Occurred()) SWIG_fail;
20652 }
20653 {
20654 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20655 }
20656 return resultobj;
20657 fail:
20658 return NULL;
20659 }
20660
20661
20662 SWIGINTERN PyObject *_wrap_MouseEvent_Leaving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20663 PyObject *resultobj = 0;
20664 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20665 bool result;
20666 void *argp1 = 0 ;
20667 int res1 = 0 ;
20668 PyObject *swig_obj[1] ;
20669
20670 if (!args) SWIG_fail;
20671 swig_obj[0] = args;
20672 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20673 if (!SWIG_IsOK(res1)) {
20674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Leaving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20675 }
20676 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20677 {
20678 PyThreadState* __tstate = wxPyBeginAllowThreads();
20679 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
20680 wxPyEndAllowThreads(__tstate);
20681 if (PyErr_Occurred()) SWIG_fail;
20682 }
20683 {
20684 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20685 }
20686 return resultobj;
20687 fail:
20688 return NULL;
20689 }
20690
20691
20692 SWIGINTERN PyObject *_wrap_MouseEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20693 PyObject *resultobj = 0;
20694 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20695 wxPoint result;
20696 void *argp1 = 0 ;
20697 int res1 = 0 ;
20698 PyObject *swig_obj[1] ;
20699
20700 if (!args) SWIG_fail;
20701 swig_obj[0] = args;
20702 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20703 if (!SWIG_IsOK(res1)) {
20704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPosition" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20705 }
20706 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20707 {
20708 PyThreadState* __tstate = wxPyBeginAllowThreads();
20709 result = (arg1)->GetPosition();
20710 wxPyEndAllowThreads(__tstate);
20711 if (PyErr_Occurred()) SWIG_fail;
20712 }
20713 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
20714 return resultobj;
20715 fail:
20716 return NULL;
20717 }
20718
20719
20720 SWIGINTERN PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20721 PyObject *resultobj = 0;
20722 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20723 long *arg2 = (long *) 0 ;
20724 long *arg3 = (long *) 0 ;
20725 void *argp1 = 0 ;
20726 int res1 = 0 ;
20727 long temp2 ;
20728 int res2 = SWIG_TMPOBJ ;
20729 long temp3 ;
20730 int res3 = SWIG_TMPOBJ ;
20731 PyObject *swig_obj[1] ;
20732
20733 arg2 = &temp2;
20734 arg3 = &temp3;
20735 if (!args) SWIG_fail;
20736 swig_obj[0] = args;
20737 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20738 if (!SWIG_IsOK(res1)) {
20739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20740 }
20741 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20742 {
20743 PyThreadState* __tstate = wxPyBeginAllowThreads();
20744 (arg1)->GetPosition(arg2,arg3);
20745 wxPyEndAllowThreads(__tstate);
20746 if (PyErr_Occurred()) SWIG_fail;
20747 }
20748 resultobj = SWIG_Py_Void();
20749 if (SWIG_IsTmpObj(res2)) {
20750 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
20751 } else {
20752 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20753 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
20754 }
20755 if (SWIG_IsTmpObj(res3)) {
20756 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
20757 } else {
20758 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20759 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
20760 }
20761 return resultobj;
20762 fail:
20763 return NULL;
20764 }
20765
20766
20767 SWIGINTERN PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20768 PyObject *resultobj = 0;
20769 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20770 wxDC *arg2 = 0 ;
20771 wxPoint result;
20772 void *argp1 = 0 ;
20773 int res1 = 0 ;
20774 void *argp2 = 0 ;
20775 int res2 = 0 ;
20776 PyObject * obj0 = 0 ;
20777 PyObject * obj1 = 0 ;
20778 char * kwnames[] = {
20779 (char *) "self",(char *) "dc", NULL
20780 };
20781
20782 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) SWIG_fail;
20783 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20784 if (!SWIG_IsOK(res1)) {
20785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20786 }
20787 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20788 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
20789 if (!SWIG_IsOK(res2)) {
20790 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
20791 }
20792 if (!argp2) {
20793 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
20794 }
20795 arg2 = reinterpret_cast< wxDC * >(argp2);
20796 {
20797 PyThreadState* __tstate = wxPyBeginAllowThreads();
20798 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
20799 wxPyEndAllowThreads(__tstate);
20800 if (PyErr_Occurred()) SWIG_fail;
20801 }
20802 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
20803 return resultobj;
20804 fail:
20805 return NULL;
20806 }
20807
20808
20809 SWIGINTERN PyObject *_wrap_MouseEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20810 PyObject *resultobj = 0;
20811 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20812 int result;
20813 void *argp1 = 0 ;
20814 int res1 = 0 ;
20815 PyObject *swig_obj[1] ;
20816
20817 if (!args) SWIG_fail;
20818 swig_obj[0] = args;
20819 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20820 if (!SWIG_IsOK(res1)) {
20821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetX" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20822 }
20823 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20824 {
20825 PyThreadState* __tstate = wxPyBeginAllowThreads();
20826 result = (int)((wxMouseEvent const *)arg1)->GetX();
20827 wxPyEndAllowThreads(__tstate);
20828 if (PyErr_Occurred()) SWIG_fail;
20829 }
20830 resultobj = SWIG_From_int(static_cast< int >(result));
20831 return resultobj;
20832 fail:
20833 return NULL;
20834 }
20835
20836
20837 SWIGINTERN PyObject *_wrap_MouseEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20838 PyObject *resultobj = 0;
20839 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20840 int result;
20841 void *argp1 = 0 ;
20842 int res1 = 0 ;
20843 PyObject *swig_obj[1] ;
20844
20845 if (!args) SWIG_fail;
20846 swig_obj[0] = args;
20847 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20848 if (!SWIG_IsOK(res1)) {
20849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetY" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20850 }
20851 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20852 {
20853 PyThreadState* __tstate = wxPyBeginAllowThreads();
20854 result = (int)((wxMouseEvent const *)arg1)->GetY();
20855 wxPyEndAllowThreads(__tstate);
20856 if (PyErr_Occurred()) SWIG_fail;
20857 }
20858 resultobj = SWIG_From_int(static_cast< int >(result));
20859 return resultobj;
20860 fail:
20861 return NULL;
20862 }
20863
20864
20865 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20866 PyObject *resultobj = 0;
20867 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20868 int result;
20869 void *argp1 = 0 ;
20870 int res1 = 0 ;
20871 PyObject *swig_obj[1] ;
20872
20873 if (!args) SWIG_fail;
20874 swig_obj[0] = args;
20875 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20876 if (!SWIG_IsOK(res1)) {
20877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelRotation" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20878 }
20879 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20880 {
20881 PyThreadState* __tstate = wxPyBeginAllowThreads();
20882 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
20883 wxPyEndAllowThreads(__tstate);
20884 if (PyErr_Occurred()) SWIG_fail;
20885 }
20886 resultobj = SWIG_From_int(static_cast< int >(result));
20887 return resultobj;
20888 fail:
20889 return NULL;
20890 }
20891
20892
20893 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20894 PyObject *resultobj = 0;
20895 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20896 int result;
20897 void *argp1 = 0 ;
20898 int res1 = 0 ;
20899 PyObject *swig_obj[1] ;
20900
20901 if (!args) SWIG_fail;
20902 swig_obj[0] = args;
20903 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20904 if (!SWIG_IsOK(res1)) {
20905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelDelta" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20906 }
20907 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20908 {
20909 PyThreadState* __tstate = wxPyBeginAllowThreads();
20910 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
20911 wxPyEndAllowThreads(__tstate);
20912 if (PyErr_Occurred()) SWIG_fail;
20913 }
20914 resultobj = SWIG_From_int(static_cast< int >(result));
20915 return resultobj;
20916 fail:
20917 return NULL;
20918 }
20919
20920
20921 SWIGINTERN PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20922 PyObject *resultobj = 0;
20923 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20924 int result;
20925 void *argp1 = 0 ;
20926 int res1 = 0 ;
20927 PyObject *swig_obj[1] ;
20928
20929 if (!args) SWIG_fail;
20930 swig_obj[0] = args;
20931 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20932 if (!SWIG_IsOK(res1)) {
20933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLinesPerAction" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20934 }
20935 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20936 {
20937 PyThreadState* __tstate = wxPyBeginAllowThreads();
20938 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
20939 wxPyEndAllowThreads(__tstate);
20940 if (PyErr_Occurred()) SWIG_fail;
20941 }
20942 resultobj = SWIG_From_int(static_cast< int >(result));
20943 return resultobj;
20944 fail:
20945 return NULL;
20946 }
20947
20948
20949 SWIGINTERN PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20950 PyObject *resultobj = 0;
20951 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20952 bool result;
20953 void *argp1 = 0 ;
20954 int res1 = 0 ;
20955 PyObject *swig_obj[1] ;
20956
20957 if (!args) SWIG_fail;
20958 swig_obj[0] = args;
20959 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20960 if (!SWIG_IsOK(res1)) {
20961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsPageScroll" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20962 }
20963 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20964 {
20965 PyThreadState* __tstate = wxPyBeginAllowThreads();
20966 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
20967 wxPyEndAllowThreads(__tstate);
20968 if (PyErr_Occurred()) SWIG_fail;
20969 }
20970 {
20971 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20972 }
20973 return resultobj;
20974 fail:
20975 return NULL;
20976 }
20977
20978
20979 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20980 PyObject *resultobj = 0;
20981 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20982 int arg2 ;
20983 void *argp1 = 0 ;
20984 int res1 = 0 ;
20985 int val2 ;
20986 int ecode2 = 0 ;
20987 PyObject *swig_obj[2] ;
20988
20989 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
20990 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20991 if (!SWIG_IsOK(res1)) {
20992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20993 }
20994 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20995 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
20996 if (!SWIG_IsOK(ecode2)) {
20997 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
20998 }
20999 arg2 = static_cast< int >(val2);
21000 if (arg1) (arg1)->m_x = arg2;
21001
21002 resultobj = SWIG_Py_Void();
21003 return resultobj;
21004 fail:
21005 return NULL;
21006 }
21007
21008
21009 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21010 PyObject *resultobj = 0;
21011 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21012 int result;
21013 void *argp1 = 0 ;
21014 int res1 = 0 ;
21015 PyObject *swig_obj[1] ;
21016
21017 if (!args) SWIG_fail;
21018 swig_obj[0] = args;
21019 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21020 if (!SWIG_IsOK(res1)) {
21021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21022 }
21023 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21024 result = (int) ((arg1)->m_x);
21025 resultobj = SWIG_From_int(static_cast< int >(result));
21026 return resultobj;
21027 fail:
21028 return NULL;
21029 }
21030
21031
21032 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21033 PyObject *resultobj = 0;
21034 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21035 int arg2 ;
21036 void *argp1 = 0 ;
21037 int res1 = 0 ;
21038 int val2 ;
21039 int ecode2 = 0 ;
21040 PyObject *swig_obj[2] ;
21041
21042 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
21043 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21044 if (!SWIG_IsOK(res1)) {
21045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21046 }
21047 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21048 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21049 if (!SWIG_IsOK(ecode2)) {
21050 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
21051 }
21052 arg2 = static_cast< int >(val2);
21053 if (arg1) (arg1)->m_y = arg2;
21054
21055 resultobj = SWIG_Py_Void();
21056 return resultobj;
21057 fail:
21058 return NULL;
21059 }
21060
21061
21062 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21063 PyObject *resultobj = 0;
21064 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21065 int result;
21066 void *argp1 = 0 ;
21067 int res1 = 0 ;
21068 PyObject *swig_obj[1] ;
21069
21070 if (!args) SWIG_fail;
21071 swig_obj[0] = args;
21072 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21073 if (!SWIG_IsOK(res1)) {
21074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21075 }
21076 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21077 result = (int) ((arg1)->m_y);
21078 resultobj = SWIG_From_int(static_cast< int >(result));
21079 return resultobj;
21080 fail:
21081 return NULL;
21082 }
21083
21084
21085 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21086 PyObject *resultobj = 0;
21087 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21088 bool arg2 ;
21089 void *argp1 = 0 ;
21090 int res1 = 0 ;
21091 bool val2 ;
21092 int ecode2 = 0 ;
21093 PyObject *swig_obj[2] ;
21094
21095 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_leftDown_set",2,2,swig_obj)) SWIG_fail;
21096 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21097 if (!SWIG_IsOK(res1)) {
21098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21099 }
21100 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21101 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21102 if (!SWIG_IsOK(ecode2)) {
21103 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "2"" of type '" "bool""'");
21104 }
21105 arg2 = static_cast< bool >(val2);
21106 if (arg1) (arg1)->m_leftDown = arg2;
21107
21108 resultobj = SWIG_Py_Void();
21109 return resultobj;
21110 fail:
21111 return NULL;
21112 }
21113
21114
21115 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21116 PyObject *resultobj = 0;
21117 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21118 bool result;
21119 void *argp1 = 0 ;
21120 int res1 = 0 ;
21121 PyObject *swig_obj[1] ;
21122
21123 if (!args) SWIG_fail;
21124 swig_obj[0] = args;
21125 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21126 if (!SWIG_IsOK(res1)) {
21127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21128 }
21129 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21130 result = (bool) ((arg1)->m_leftDown);
21131 {
21132 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21133 }
21134 return resultobj;
21135 fail:
21136 return NULL;
21137 }
21138
21139
21140 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21141 PyObject *resultobj = 0;
21142 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21143 bool arg2 ;
21144 void *argp1 = 0 ;
21145 int res1 = 0 ;
21146 bool val2 ;
21147 int ecode2 = 0 ;
21148 PyObject *swig_obj[2] ;
21149
21150 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_middleDown_set",2,2,swig_obj)) SWIG_fail;
21151 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21152 if (!SWIG_IsOK(res1)) {
21153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21154 }
21155 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21156 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21157 if (!SWIG_IsOK(ecode2)) {
21158 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "2"" of type '" "bool""'");
21159 }
21160 arg2 = static_cast< bool >(val2);
21161 if (arg1) (arg1)->m_middleDown = arg2;
21162
21163 resultobj = SWIG_Py_Void();
21164 return resultobj;
21165 fail:
21166 return NULL;
21167 }
21168
21169
21170 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21171 PyObject *resultobj = 0;
21172 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21173 bool result;
21174 void *argp1 = 0 ;
21175 int res1 = 0 ;
21176 PyObject *swig_obj[1] ;
21177
21178 if (!args) SWIG_fail;
21179 swig_obj[0] = args;
21180 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21181 if (!SWIG_IsOK(res1)) {
21182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21183 }
21184 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21185 result = (bool) ((arg1)->m_middleDown);
21186 {
21187 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21188 }
21189 return resultobj;
21190 fail:
21191 return NULL;
21192 }
21193
21194
21195 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21196 PyObject *resultobj = 0;
21197 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21198 bool arg2 ;
21199 void *argp1 = 0 ;
21200 int res1 = 0 ;
21201 bool val2 ;
21202 int ecode2 = 0 ;
21203 PyObject *swig_obj[2] ;
21204
21205 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_rightDown_set",2,2,swig_obj)) SWIG_fail;
21206 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21207 if (!SWIG_IsOK(res1)) {
21208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21209 }
21210 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21211 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21212 if (!SWIG_IsOK(ecode2)) {
21213 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "2"" of type '" "bool""'");
21214 }
21215 arg2 = static_cast< bool >(val2);
21216 if (arg1) (arg1)->m_rightDown = arg2;
21217
21218 resultobj = SWIG_Py_Void();
21219 return resultobj;
21220 fail:
21221 return NULL;
21222 }
21223
21224
21225 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21226 PyObject *resultobj = 0;
21227 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21228 bool result;
21229 void *argp1 = 0 ;
21230 int res1 = 0 ;
21231 PyObject *swig_obj[1] ;
21232
21233 if (!args) SWIG_fail;
21234 swig_obj[0] = args;
21235 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21236 if (!SWIG_IsOK(res1)) {
21237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21238 }
21239 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21240 result = (bool) ((arg1)->m_rightDown);
21241 {
21242 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21243 }
21244 return resultobj;
21245 fail:
21246 return NULL;
21247 }
21248
21249
21250 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21251 PyObject *resultobj = 0;
21252 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21253 bool arg2 ;
21254 void *argp1 = 0 ;
21255 int res1 = 0 ;
21256 bool val2 ;
21257 int ecode2 = 0 ;
21258 PyObject *swig_obj[2] ;
21259
21260 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
21261 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21262 if (!SWIG_IsOK(res1)) {
21263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21264 }
21265 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21266 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21267 if (!SWIG_IsOK(ecode2)) {
21268 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
21269 }
21270 arg2 = static_cast< bool >(val2);
21271 if (arg1) (arg1)->m_controlDown = arg2;
21272
21273 resultobj = SWIG_Py_Void();
21274 return resultobj;
21275 fail:
21276 return NULL;
21277 }
21278
21279
21280 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21281 PyObject *resultobj = 0;
21282 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21283 bool result;
21284 void *argp1 = 0 ;
21285 int res1 = 0 ;
21286 PyObject *swig_obj[1] ;
21287
21288 if (!args) SWIG_fail;
21289 swig_obj[0] = args;
21290 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21291 if (!SWIG_IsOK(res1)) {
21292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21293 }
21294 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21295 result = (bool) ((arg1)->m_controlDown);
21296 {
21297 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21298 }
21299 return resultobj;
21300 fail:
21301 return NULL;
21302 }
21303
21304
21305 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21306 PyObject *resultobj = 0;
21307 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21308 bool arg2 ;
21309 void *argp1 = 0 ;
21310 int res1 = 0 ;
21311 bool val2 ;
21312 int ecode2 = 0 ;
21313 PyObject *swig_obj[2] ;
21314
21315 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
21316 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21317 if (!SWIG_IsOK(res1)) {
21318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21319 }
21320 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21321 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21322 if (!SWIG_IsOK(ecode2)) {
21323 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
21324 }
21325 arg2 = static_cast< bool >(val2);
21326 if (arg1) (arg1)->m_shiftDown = arg2;
21327
21328 resultobj = SWIG_Py_Void();
21329 return resultobj;
21330 fail:
21331 return NULL;
21332 }
21333
21334
21335 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21336 PyObject *resultobj = 0;
21337 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21338 bool result;
21339 void *argp1 = 0 ;
21340 int res1 = 0 ;
21341 PyObject *swig_obj[1] ;
21342
21343 if (!args) SWIG_fail;
21344 swig_obj[0] = args;
21345 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21346 if (!SWIG_IsOK(res1)) {
21347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21348 }
21349 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21350 result = (bool) ((arg1)->m_shiftDown);
21351 {
21352 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21353 }
21354 return resultobj;
21355 fail:
21356 return NULL;
21357 }
21358
21359
21360 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21361 PyObject *resultobj = 0;
21362 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21363 bool arg2 ;
21364 void *argp1 = 0 ;
21365 int res1 = 0 ;
21366 bool val2 ;
21367 int ecode2 = 0 ;
21368 PyObject *swig_obj[2] ;
21369
21370 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
21371 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21372 if (!SWIG_IsOK(res1)) {
21373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21374 }
21375 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21376 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21377 if (!SWIG_IsOK(ecode2)) {
21378 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
21379 }
21380 arg2 = static_cast< bool >(val2);
21381 if (arg1) (arg1)->m_altDown = arg2;
21382
21383 resultobj = SWIG_Py_Void();
21384 return resultobj;
21385 fail:
21386 return NULL;
21387 }
21388
21389
21390 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21391 PyObject *resultobj = 0;
21392 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21393 bool result;
21394 void *argp1 = 0 ;
21395 int res1 = 0 ;
21396 PyObject *swig_obj[1] ;
21397
21398 if (!args) SWIG_fail;
21399 swig_obj[0] = args;
21400 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21401 if (!SWIG_IsOK(res1)) {
21402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21403 }
21404 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21405 result = (bool) ((arg1)->m_altDown);
21406 {
21407 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21408 }
21409 return resultobj;
21410 fail:
21411 return NULL;
21412 }
21413
21414
21415 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21416 PyObject *resultobj = 0;
21417 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21418 bool arg2 ;
21419 void *argp1 = 0 ;
21420 int res1 = 0 ;
21421 bool val2 ;
21422 int ecode2 = 0 ;
21423 PyObject *swig_obj[2] ;
21424
21425 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
21426 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21427 if (!SWIG_IsOK(res1)) {
21428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21429 }
21430 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21431 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21432 if (!SWIG_IsOK(ecode2)) {
21433 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
21434 }
21435 arg2 = static_cast< bool >(val2);
21436 if (arg1) (arg1)->m_metaDown = arg2;
21437
21438 resultobj = SWIG_Py_Void();
21439 return resultobj;
21440 fail:
21441 return NULL;
21442 }
21443
21444
21445 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21446 PyObject *resultobj = 0;
21447 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21448 bool result;
21449 void *argp1 = 0 ;
21450 int res1 = 0 ;
21451 PyObject *swig_obj[1] ;
21452
21453 if (!args) SWIG_fail;
21454 swig_obj[0] = args;
21455 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21456 if (!SWIG_IsOK(res1)) {
21457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21458 }
21459 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21460 result = (bool) ((arg1)->m_metaDown);
21461 {
21462 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21463 }
21464 return resultobj;
21465 fail:
21466 return NULL;
21467 }
21468
21469
21470 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21471 PyObject *resultobj = 0;
21472 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21473 int arg2 ;
21474 void *argp1 = 0 ;
21475 int res1 = 0 ;
21476 int val2 ;
21477 int ecode2 = 0 ;
21478 PyObject *swig_obj[2] ;
21479
21480 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelRotation_set",2,2,swig_obj)) SWIG_fail;
21481 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21482 if (!SWIG_IsOK(res1)) {
21483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21484 }
21485 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21486 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21487 if (!SWIG_IsOK(ecode2)) {
21488 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "2"" of type '" "int""'");
21489 }
21490 arg2 = static_cast< int >(val2);
21491 if (arg1) (arg1)->m_wheelRotation = arg2;
21492
21493 resultobj = SWIG_Py_Void();
21494 return resultobj;
21495 fail:
21496 return NULL;
21497 }
21498
21499
21500 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21501 PyObject *resultobj = 0;
21502 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21503 int result;
21504 void *argp1 = 0 ;
21505 int res1 = 0 ;
21506 PyObject *swig_obj[1] ;
21507
21508 if (!args) SWIG_fail;
21509 swig_obj[0] = args;
21510 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21511 if (!SWIG_IsOK(res1)) {
21512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21513 }
21514 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21515 result = (int) ((arg1)->m_wheelRotation);
21516 resultobj = SWIG_From_int(static_cast< int >(result));
21517 return resultobj;
21518 fail:
21519 return NULL;
21520 }
21521
21522
21523 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21524 PyObject *resultobj = 0;
21525 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21526 int arg2 ;
21527 void *argp1 = 0 ;
21528 int res1 = 0 ;
21529 int val2 ;
21530 int ecode2 = 0 ;
21531 PyObject *swig_obj[2] ;
21532
21533 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelDelta_set",2,2,swig_obj)) SWIG_fail;
21534 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21535 if (!SWIG_IsOK(res1)) {
21536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21537 }
21538 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21539 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21540 if (!SWIG_IsOK(ecode2)) {
21541 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "2"" of type '" "int""'");
21542 }
21543 arg2 = static_cast< int >(val2);
21544 if (arg1) (arg1)->m_wheelDelta = arg2;
21545
21546 resultobj = SWIG_Py_Void();
21547 return resultobj;
21548 fail:
21549 return NULL;
21550 }
21551
21552
21553 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21554 PyObject *resultobj = 0;
21555 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21556 int result;
21557 void *argp1 = 0 ;
21558 int res1 = 0 ;
21559 PyObject *swig_obj[1] ;
21560
21561 if (!args) SWIG_fail;
21562 swig_obj[0] = args;
21563 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21564 if (!SWIG_IsOK(res1)) {
21565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21566 }
21567 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21568 result = (int) ((arg1)->m_wheelDelta);
21569 resultobj = SWIG_From_int(static_cast< int >(result));
21570 return resultobj;
21571 fail:
21572 return NULL;
21573 }
21574
21575
21576 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21577 PyObject *resultobj = 0;
21578 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21579 int arg2 ;
21580 void *argp1 = 0 ;
21581 int res1 = 0 ;
21582 int val2 ;
21583 int ecode2 = 0 ;
21584 PyObject *swig_obj[2] ;
21585
21586 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_linesPerAction_set",2,2,swig_obj)) SWIG_fail;
21587 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21588 if (!SWIG_IsOK(res1)) {
21589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21590 }
21591 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21592 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21593 if (!SWIG_IsOK(ecode2)) {
21594 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "2"" of type '" "int""'");
21595 }
21596 arg2 = static_cast< int >(val2);
21597 if (arg1) (arg1)->m_linesPerAction = arg2;
21598
21599 resultobj = SWIG_Py_Void();
21600 return resultobj;
21601 fail:
21602 return NULL;
21603 }
21604
21605
21606 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21607 PyObject *resultobj = 0;
21608 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21609 int result;
21610 void *argp1 = 0 ;
21611 int res1 = 0 ;
21612 PyObject *swig_obj[1] ;
21613
21614 if (!args) SWIG_fail;
21615 swig_obj[0] = args;
21616 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21617 if (!SWIG_IsOK(res1)) {
21618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21619 }
21620 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21621 result = (int) ((arg1)->m_linesPerAction);
21622 resultobj = SWIG_From_int(static_cast< int >(result));
21623 return resultobj;
21624 fail:
21625 return NULL;
21626 }
21627
21628
21629 SWIGINTERN PyObject *MouseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21630 PyObject *obj;
21631 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21632 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseEvent, SWIG_NewClientData(obj));
21633 return SWIG_Py_Void();
21634 }
21635
21636 SWIGINTERN PyObject *MouseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21637 return SWIG_Python_InitShadowInstance(args);
21638 }
21639
21640 SWIGINTERN PyObject *_wrap_new_SetCursorEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21641 PyObject *resultobj = 0;
21642 int arg1 = (int) 0 ;
21643 int arg2 = (int) 0 ;
21644 wxSetCursorEvent *result = 0 ;
21645 int val1 ;
21646 int ecode1 = 0 ;
21647 int val2 ;
21648 int ecode2 = 0 ;
21649 PyObject * obj0 = 0 ;
21650 PyObject * obj1 = 0 ;
21651 char * kwnames[] = {
21652 (char *) "x",(char *) "y", NULL
21653 };
21654
21655 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) SWIG_fail;
21656 if (obj0) {
21657 ecode1 = SWIG_AsVal_int(obj0, &val1);
21658 if (!SWIG_IsOK(ecode1)) {
21659 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SetCursorEvent" "', expected argument " "1"" of type '" "int""'");
21660 }
21661 arg1 = static_cast< int >(val1);
21662 }
21663 if (obj1) {
21664 ecode2 = SWIG_AsVal_int(obj1, &val2);
21665 if (!SWIG_IsOK(ecode2)) {
21666 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SetCursorEvent" "', expected argument " "2"" of type '" "int""'");
21667 }
21668 arg2 = static_cast< int >(val2);
21669 }
21670 {
21671 PyThreadState* __tstate = wxPyBeginAllowThreads();
21672 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
21673 wxPyEndAllowThreads(__tstate);
21674 if (PyErr_Occurred()) SWIG_fail;
21675 }
21676 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_NEW | 0 );
21677 return resultobj;
21678 fail:
21679 return NULL;
21680 }
21681
21682
21683 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21684 PyObject *resultobj = 0;
21685 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21686 int result;
21687 void *argp1 = 0 ;
21688 int res1 = 0 ;
21689 PyObject *swig_obj[1] ;
21690
21691 if (!args) SWIG_fail;
21692 swig_obj[0] = args;
21693 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21694 if (!SWIG_IsOK(res1)) {
21695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetX" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21696 }
21697 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21698 {
21699 PyThreadState* __tstate = wxPyBeginAllowThreads();
21700 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
21701 wxPyEndAllowThreads(__tstate);
21702 if (PyErr_Occurred()) SWIG_fail;
21703 }
21704 resultobj = SWIG_From_int(static_cast< int >(result));
21705 return resultobj;
21706 fail:
21707 return NULL;
21708 }
21709
21710
21711 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21712 PyObject *resultobj = 0;
21713 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21714 int result;
21715 void *argp1 = 0 ;
21716 int res1 = 0 ;
21717 PyObject *swig_obj[1] ;
21718
21719 if (!args) SWIG_fail;
21720 swig_obj[0] = args;
21721 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21722 if (!SWIG_IsOK(res1)) {
21723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetY" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21724 }
21725 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21726 {
21727 PyThreadState* __tstate = wxPyBeginAllowThreads();
21728 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
21729 wxPyEndAllowThreads(__tstate);
21730 if (PyErr_Occurred()) SWIG_fail;
21731 }
21732 resultobj = SWIG_From_int(static_cast< int >(result));
21733 return resultobj;
21734 fail:
21735 return NULL;
21736 }
21737
21738
21739 SWIGINTERN PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21740 PyObject *resultobj = 0;
21741 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21742 wxCursor *arg2 = 0 ;
21743 void *argp1 = 0 ;
21744 int res1 = 0 ;
21745 void *argp2 = 0 ;
21746 int res2 = 0 ;
21747 PyObject * obj0 = 0 ;
21748 PyObject * obj1 = 0 ;
21749 char * kwnames[] = {
21750 (char *) "self",(char *) "cursor", NULL
21751 };
21752
21753 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
21754 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21755 if (!SWIG_IsOK(res1)) {
21756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent *""'");
21757 }
21758 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21759 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
21760 if (!SWIG_IsOK(res2)) {
21761 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
21762 }
21763 if (!argp2) {
21764 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
21765 }
21766 arg2 = reinterpret_cast< wxCursor * >(argp2);
21767 {
21768 PyThreadState* __tstate = wxPyBeginAllowThreads();
21769 (arg1)->SetCursor((wxCursor const &)*arg2);
21770 wxPyEndAllowThreads(__tstate);
21771 if (PyErr_Occurred()) SWIG_fail;
21772 }
21773 resultobj = SWIG_Py_Void();
21774 return resultobj;
21775 fail:
21776 return NULL;
21777 }
21778
21779
21780 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21781 PyObject *resultobj = 0;
21782 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21783 wxCursor *result = 0 ;
21784 void *argp1 = 0 ;
21785 int res1 = 0 ;
21786 PyObject *swig_obj[1] ;
21787
21788 if (!args) SWIG_fail;
21789 swig_obj[0] = args;
21790 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21791 if (!SWIG_IsOK(res1)) {
21792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21793 }
21794 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21795 {
21796 PyThreadState* __tstate = wxPyBeginAllowThreads();
21797 {
21798 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
21799 result = (wxCursor *) &_result_ref;
21800 }
21801 wxPyEndAllowThreads(__tstate);
21802 if (PyErr_Occurred()) SWIG_fail;
21803 }
21804 {
21805 wxCursor* resultptr = new wxCursor(*result);
21806 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
21807 }
21808 return resultobj;
21809 fail:
21810 return NULL;
21811 }
21812
21813
21814 SWIGINTERN PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21815 PyObject *resultobj = 0;
21816 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21817 bool result;
21818 void *argp1 = 0 ;
21819 int res1 = 0 ;
21820 PyObject *swig_obj[1] ;
21821
21822 if (!args) SWIG_fail;
21823 swig_obj[0] = args;
21824 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21825 if (!SWIG_IsOK(res1)) {
21826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_HasCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21827 }
21828 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21829 {
21830 PyThreadState* __tstate = wxPyBeginAllowThreads();
21831 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
21832 wxPyEndAllowThreads(__tstate);
21833 if (PyErr_Occurred()) SWIG_fail;
21834 }
21835 {
21836 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21837 }
21838 return resultobj;
21839 fail:
21840 return NULL;
21841 }
21842
21843
21844 SWIGINTERN PyObject *SetCursorEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21845 PyObject *obj;
21846 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21847 SWIG_TypeNewClientData(SWIGTYPE_p_wxSetCursorEvent, SWIG_NewClientData(obj));
21848 return SWIG_Py_Void();
21849 }
21850
21851 SWIGINTERN PyObject *SetCursorEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21852 return SWIG_Python_InitShadowInstance(args);
21853 }
21854
21855 SWIGINTERN PyObject *_wrap_new_KeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21856 PyObject *resultobj = 0;
21857 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21858 wxKeyEvent *result = 0 ;
21859 int val1 ;
21860 int ecode1 = 0 ;
21861 PyObject * obj0 = 0 ;
21862 char * kwnames[] = {
21863 (char *) "eventType", NULL
21864 };
21865
21866 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) SWIG_fail;
21867 if (obj0) {
21868 ecode1 = SWIG_AsVal_int(obj0, &val1);
21869 if (!SWIG_IsOK(ecode1)) {
21870 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_KeyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
21871 }
21872 arg1 = static_cast< wxEventType >(val1);
21873 }
21874 {
21875 PyThreadState* __tstate = wxPyBeginAllowThreads();
21876 result = (wxKeyEvent *)new wxKeyEvent(arg1);
21877 wxPyEndAllowThreads(__tstate);
21878 if (PyErr_Occurred()) SWIG_fail;
21879 }
21880 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_NEW | 0 );
21881 return resultobj;
21882 fail:
21883 return NULL;
21884 }
21885
21886
21887 SWIGINTERN PyObject *_wrap_KeyEvent_GetModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21888 PyObject *resultobj = 0;
21889 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21890 int result;
21891 void *argp1 = 0 ;
21892 int res1 = 0 ;
21893 PyObject *swig_obj[1] ;
21894
21895 if (!args) SWIG_fail;
21896 swig_obj[0] = args;
21897 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21898 if (!SWIG_IsOK(res1)) {
21899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21900 }
21901 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21902 {
21903 PyThreadState* __tstate = wxPyBeginAllowThreads();
21904 result = (int)((wxKeyEvent const *)arg1)->GetModifiers();
21905 wxPyEndAllowThreads(__tstate);
21906 if (PyErr_Occurred()) SWIG_fail;
21907 }
21908 resultobj = SWIG_From_int(static_cast< int >(result));
21909 return resultobj;
21910 fail:
21911 return NULL;
21912 }
21913
21914
21915 SWIGINTERN PyObject *_wrap_KeyEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21916 PyObject *resultobj = 0;
21917 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21918 bool result;
21919 void *argp1 = 0 ;
21920 int res1 = 0 ;
21921 PyObject *swig_obj[1] ;
21922
21923 if (!args) SWIG_fail;
21924 swig_obj[0] = args;
21925 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21926 if (!SWIG_IsOK(res1)) {
21927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ControlDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21928 }
21929 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21930 {
21931 PyThreadState* __tstate = wxPyBeginAllowThreads();
21932 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
21933 wxPyEndAllowThreads(__tstate);
21934 if (PyErr_Occurred()) SWIG_fail;
21935 }
21936 {
21937 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21938 }
21939 return resultobj;
21940 fail:
21941 return NULL;
21942 }
21943
21944
21945 SWIGINTERN PyObject *_wrap_KeyEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21946 PyObject *resultobj = 0;
21947 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21948 bool result;
21949 void *argp1 = 0 ;
21950 int res1 = 0 ;
21951 PyObject *swig_obj[1] ;
21952
21953 if (!args) SWIG_fail;
21954 swig_obj[0] = args;
21955 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21956 if (!SWIG_IsOK(res1)) {
21957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_MetaDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21958 }
21959 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21960 {
21961 PyThreadState* __tstate = wxPyBeginAllowThreads();
21962 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
21963 wxPyEndAllowThreads(__tstate);
21964 if (PyErr_Occurred()) SWIG_fail;
21965 }
21966 {
21967 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21968 }
21969 return resultobj;
21970 fail:
21971 return NULL;
21972 }
21973
21974
21975 SWIGINTERN PyObject *_wrap_KeyEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21976 PyObject *resultobj = 0;
21977 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21978 bool result;
21979 void *argp1 = 0 ;
21980 int res1 = 0 ;
21981 PyObject *swig_obj[1] ;
21982
21983 if (!args) SWIG_fail;
21984 swig_obj[0] = args;
21985 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21986 if (!SWIG_IsOK(res1)) {
21987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_AltDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21988 }
21989 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21990 {
21991 PyThreadState* __tstate = wxPyBeginAllowThreads();
21992 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
21993 wxPyEndAllowThreads(__tstate);
21994 if (PyErr_Occurred()) SWIG_fail;
21995 }
21996 {
21997 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21998 }
21999 return resultobj;
22000 fail:
22001 return NULL;
22002 }
22003
22004
22005 SWIGINTERN PyObject *_wrap_KeyEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22006 PyObject *resultobj = 0;
22007 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22008 bool result;
22009 void *argp1 = 0 ;
22010 int res1 = 0 ;
22011 PyObject *swig_obj[1] ;
22012
22013 if (!args) SWIG_fail;
22014 swig_obj[0] = args;
22015 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22016 if (!SWIG_IsOK(res1)) {
22017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ShiftDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22018 }
22019 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22020 {
22021 PyThreadState* __tstate = wxPyBeginAllowThreads();
22022 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
22023 wxPyEndAllowThreads(__tstate);
22024 if (PyErr_Occurred()) SWIG_fail;
22025 }
22026 {
22027 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22028 }
22029 return resultobj;
22030 fail:
22031 return NULL;
22032 }
22033
22034
22035 SWIGINTERN PyObject *_wrap_KeyEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22036 PyObject *resultobj = 0;
22037 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22038 bool result;
22039 void *argp1 = 0 ;
22040 int res1 = 0 ;
22041 PyObject *swig_obj[1] ;
22042
22043 if (!args) SWIG_fail;
22044 swig_obj[0] = args;
22045 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22046 if (!SWIG_IsOK(res1)) {
22047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_CmdDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22048 }
22049 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22050 {
22051 PyThreadState* __tstate = wxPyBeginAllowThreads();
22052 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
22053 wxPyEndAllowThreads(__tstate);
22054 if (PyErr_Occurred()) SWIG_fail;
22055 }
22056 {
22057 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22058 }
22059 return resultobj;
22060 fail:
22061 return NULL;
22062 }
22063
22064
22065 SWIGINTERN PyObject *_wrap_KeyEvent_HasModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22066 PyObject *resultobj = 0;
22067 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22068 bool result;
22069 void *argp1 = 0 ;
22070 int res1 = 0 ;
22071 PyObject *swig_obj[1] ;
22072
22073 if (!args) SWIG_fail;
22074 swig_obj[0] = args;
22075 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22076 if (!SWIG_IsOK(res1)) {
22077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_HasModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22078 }
22079 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22080 {
22081 PyThreadState* __tstate = wxPyBeginAllowThreads();
22082 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
22083 wxPyEndAllowThreads(__tstate);
22084 if (PyErr_Occurred()) SWIG_fail;
22085 }
22086 {
22087 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22088 }
22089 return resultobj;
22090 fail:
22091 return NULL;
22092 }
22093
22094
22095 SWIGINTERN PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22096 PyObject *resultobj = 0;
22097 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22098 int result;
22099 void *argp1 = 0 ;
22100 int res1 = 0 ;
22101 PyObject *swig_obj[1] ;
22102
22103 if (!args) SWIG_fail;
22104 swig_obj[0] = args;
22105 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22106 if (!SWIG_IsOK(res1)) {
22107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22108 }
22109 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22110 {
22111 PyThreadState* __tstate = wxPyBeginAllowThreads();
22112 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
22113 wxPyEndAllowThreads(__tstate);
22114 if (PyErr_Occurred()) SWIG_fail;
22115 }
22116 resultobj = SWIG_From_int(static_cast< int >(result));
22117 return resultobj;
22118 fail:
22119 return NULL;
22120 }
22121
22122
22123 SWIGINTERN PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22124 PyObject *resultobj = 0;
22125 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22126 int result;
22127 void *argp1 = 0 ;
22128 int res1 = 0 ;
22129 PyObject *swig_obj[1] ;
22130
22131 if (!args) SWIG_fail;
22132 swig_obj[0] = args;
22133 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22134 if (!SWIG_IsOK(res1)) {
22135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22136 }
22137 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22138 {
22139 PyThreadState* __tstate = wxPyBeginAllowThreads();
22140 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
22141 wxPyEndAllowThreads(__tstate);
22142 if (PyErr_Occurred()) SWIG_fail;
22143 }
22144 resultobj = SWIG_From_int(static_cast< int >(result));
22145 return resultobj;
22146 fail:
22147 return NULL;
22148 }
22149
22150
22151 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22152 PyObject *resultobj = 0;
22153 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22154 unsigned int result;
22155 void *argp1 = 0 ;
22156 int res1 = 0 ;
22157 PyObject *swig_obj[1] ;
22158
22159 if (!args) SWIG_fail;
22160 swig_obj[0] = args;
22161 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22162 if (!SWIG_IsOK(res1)) {
22163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22164 }
22165 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22166 {
22167 PyThreadState* __tstate = wxPyBeginAllowThreads();
22168 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
22169 wxPyEndAllowThreads(__tstate);
22170 if (PyErr_Occurred()) SWIG_fail;
22171 }
22172 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22173 return resultobj;
22174 fail:
22175 return NULL;
22176 }
22177
22178
22179 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22180 PyObject *resultobj = 0;
22181 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22182 unsigned int result;
22183 void *argp1 = 0 ;
22184 int res1 = 0 ;
22185 PyObject *swig_obj[1] ;
22186
22187 if (!args) SWIG_fail;
22188 swig_obj[0] = args;
22189 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22190 if (!SWIG_IsOK(res1)) {
22191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyFlags" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22192 }
22193 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22194 {
22195 PyThreadState* __tstate = wxPyBeginAllowThreads();
22196 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
22197 wxPyEndAllowThreads(__tstate);
22198 if (PyErr_Occurred()) SWIG_fail;
22199 }
22200 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22201 return resultobj;
22202 fail:
22203 return NULL;
22204 }
22205
22206
22207 SWIGINTERN PyObject *_wrap_KeyEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22208 PyObject *resultobj = 0;
22209 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22210 wxPoint result;
22211 void *argp1 = 0 ;
22212 int res1 = 0 ;
22213 PyObject *swig_obj[1] ;
22214
22215 if (!args) SWIG_fail;
22216 swig_obj[0] = args;
22217 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22218 if (!SWIG_IsOK(res1)) {
22219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPosition" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22220 }
22221 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22222 {
22223 PyThreadState* __tstate = wxPyBeginAllowThreads();
22224 result = (arg1)->GetPosition();
22225 wxPyEndAllowThreads(__tstate);
22226 if (PyErr_Occurred()) SWIG_fail;
22227 }
22228 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
22229 return resultobj;
22230 fail:
22231 return NULL;
22232 }
22233
22234
22235 SWIGINTERN PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22236 PyObject *resultobj = 0;
22237 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22238 long *arg2 = (long *) 0 ;
22239 long *arg3 = (long *) 0 ;
22240 void *argp1 = 0 ;
22241 int res1 = 0 ;
22242 long temp2 ;
22243 int res2 = SWIG_TMPOBJ ;
22244 long temp3 ;
22245 int res3 = SWIG_TMPOBJ ;
22246 PyObject *swig_obj[1] ;
22247
22248 arg2 = &temp2;
22249 arg3 = &temp3;
22250 if (!args) SWIG_fail;
22251 swig_obj[0] = args;
22252 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22253 if (!SWIG_IsOK(res1)) {
22254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22255 }
22256 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22257 {
22258 PyThreadState* __tstate = wxPyBeginAllowThreads();
22259 (arg1)->GetPosition(arg2,arg3);
22260 wxPyEndAllowThreads(__tstate);
22261 if (PyErr_Occurred()) SWIG_fail;
22262 }
22263 resultobj = SWIG_Py_Void();
22264 if (SWIG_IsTmpObj(res2)) {
22265 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
22266 } else {
22267 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22268 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
22269 }
22270 if (SWIG_IsTmpObj(res3)) {
22271 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
22272 } else {
22273 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22274 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
22275 }
22276 return resultobj;
22277 fail:
22278 return NULL;
22279 }
22280
22281
22282 SWIGINTERN PyObject *_wrap_KeyEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22283 PyObject *resultobj = 0;
22284 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22285 int result;
22286 void *argp1 = 0 ;
22287 int res1 = 0 ;
22288 PyObject *swig_obj[1] ;
22289
22290 if (!args) SWIG_fail;
22291 swig_obj[0] = args;
22292 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22293 if (!SWIG_IsOK(res1)) {
22294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetX" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22295 }
22296 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22297 {
22298 PyThreadState* __tstate = wxPyBeginAllowThreads();
22299 result = (int)((wxKeyEvent const *)arg1)->GetX();
22300 wxPyEndAllowThreads(__tstate);
22301 if (PyErr_Occurred()) SWIG_fail;
22302 }
22303 resultobj = SWIG_From_int(static_cast< int >(result));
22304 return resultobj;
22305 fail:
22306 return NULL;
22307 }
22308
22309
22310 SWIGINTERN PyObject *_wrap_KeyEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22311 PyObject *resultobj = 0;
22312 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22313 int result;
22314 void *argp1 = 0 ;
22315 int res1 = 0 ;
22316 PyObject *swig_obj[1] ;
22317
22318 if (!args) SWIG_fail;
22319 swig_obj[0] = args;
22320 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22321 if (!SWIG_IsOK(res1)) {
22322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetY" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22323 }
22324 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22325 {
22326 PyThreadState* __tstate = wxPyBeginAllowThreads();
22327 result = (int)((wxKeyEvent const *)arg1)->GetY();
22328 wxPyEndAllowThreads(__tstate);
22329 if (PyErr_Occurred()) SWIG_fail;
22330 }
22331 resultobj = SWIG_From_int(static_cast< int >(result));
22332 return resultobj;
22333 fail:
22334 return NULL;
22335 }
22336
22337
22338 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22339 PyObject *resultobj = 0;
22340 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22341 int arg2 ;
22342 void *argp1 = 0 ;
22343 int res1 = 0 ;
22344 int val2 ;
22345 int ecode2 = 0 ;
22346 PyObject *swig_obj[2] ;
22347
22348 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
22349 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22350 if (!SWIG_IsOK(res1)) {
22351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22352 }
22353 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22354 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22355 if (!SWIG_IsOK(ecode2)) {
22356 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
22357 }
22358 arg2 = static_cast< int >(val2);
22359 if (arg1) (arg1)->m_x = arg2;
22360
22361 resultobj = SWIG_Py_Void();
22362 return resultobj;
22363 fail:
22364 return NULL;
22365 }
22366
22367
22368 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22369 PyObject *resultobj = 0;
22370 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22371 int result;
22372 void *argp1 = 0 ;
22373 int res1 = 0 ;
22374 PyObject *swig_obj[1] ;
22375
22376 if (!args) SWIG_fail;
22377 swig_obj[0] = args;
22378 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22379 if (!SWIG_IsOK(res1)) {
22380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22381 }
22382 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22383 result = (int) ((arg1)->m_x);
22384 resultobj = SWIG_From_int(static_cast< int >(result));
22385 return resultobj;
22386 fail:
22387 return NULL;
22388 }
22389
22390
22391 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22392 PyObject *resultobj = 0;
22393 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22394 int arg2 ;
22395 void *argp1 = 0 ;
22396 int res1 = 0 ;
22397 int val2 ;
22398 int ecode2 = 0 ;
22399 PyObject *swig_obj[2] ;
22400
22401 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
22402 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22403 if (!SWIG_IsOK(res1)) {
22404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22405 }
22406 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22407 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22408 if (!SWIG_IsOK(ecode2)) {
22409 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
22410 }
22411 arg2 = static_cast< int >(val2);
22412 if (arg1) (arg1)->m_y = arg2;
22413
22414 resultobj = SWIG_Py_Void();
22415 return resultobj;
22416 fail:
22417 return NULL;
22418 }
22419
22420
22421 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22422 PyObject *resultobj = 0;
22423 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22424 int result;
22425 void *argp1 = 0 ;
22426 int res1 = 0 ;
22427 PyObject *swig_obj[1] ;
22428
22429 if (!args) SWIG_fail;
22430 swig_obj[0] = args;
22431 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22432 if (!SWIG_IsOK(res1)) {
22433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22434 }
22435 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22436 result = (int) ((arg1)->m_y);
22437 resultobj = SWIG_From_int(static_cast< int >(result));
22438 return resultobj;
22439 fail:
22440 return NULL;
22441 }
22442
22443
22444 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22445 PyObject *resultobj = 0;
22446 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22447 long arg2 ;
22448 void *argp1 = 0 ;
22449 int res1 = 0 ;
22450 long val2 ;
22451 int ecode2 = 0 ;
22452 PyObject *swig_obj[2] ;
22453
22454 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_keyCode_set",2,2,swig_obj)) SWIG_fail;
22455 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22456 if (!SWIG_IsOK(res1)) {
22457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22458 }
22459 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22460 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
22461 if (!SWIG_IsOK(ecode2)) {
22462 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "2"" of type '" "long""'");
22463 }
22464 arg2 = static_cast< long >(val2);
22465 if (arg1) (arg1)->m_keyCode = arg2;
22466
22467 resultobj = SWIG_Py_Void();
22468 return resultobj;
22469 fail:
22470 return NULL;
22471 }
22472
22473
22474 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22475 PyObject *resultobj = 0;
22476 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22477 long result;
22478 void *argp1 = 0 ;
22479 int res1 = 0 ;
22480 PyObject *swig_obj[1] ;
22481
22482 if (!args) SWIG_fail;
22483 swig_obj[0] = args;
22484 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22485 if (!SWIG_IsOK(res1)) {
22486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22487 }
22488 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22489 result = (long) ((arg1)->m_keyCode);
22490 resultobj = SWIG_From_long(static_cast< long >(result));
22491 return resultobj;
22492 fail:
22493 return NULL;
22494 }
22495
22496
22497 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22498 PyObject *resultobj = 0;
22499 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22500 bool arg2 ;
22501 void *argp1 = 0 ;
22502 int res1 = 0 ;
22503 bool val2 ;
22504 int ecode2 = 0 ;
22505 PyObject *swig_obj[2] ;
22506
22507 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
22508 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22509 if (!SWIG_IsOK(res1)) {
22510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22511 }
22512 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22513 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22514 if (!SWIG_IsOK(ecode2)) {
22515 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
22516 }
22517 arg2 = static_cast< bool >(val2);
22518 if (arg1) (arg1)->m_controlDown = arg2;
22519
22520 resultobj = SWIG_Py_Void();
22521 return resultobj;
22522 fail:
22523 return NULL;
22524 }
22525
22526
22527 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22528 PyObject *resultobj = 0;
22529 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22530 bool result;
22531 void *argp1 = 0 ;
22532 int res1 = 0 ;
22533 PyObject *swig_obj[1] ;
22534
22535 if (!args) SWIG_fail;
22536 swig_obj[0] = args;
22537 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22538 if (!SWIG_IsOK(res1)) {
22539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22540 }
22541 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22542 result = (bool) ((arg1)->m_controlDown);
22543 {
22544 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22545 }
22546 return resultobj;
22547 fail:
22548 return NULL;
22549 }
22550
22551
22552 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22553 PyObject *resultobj = 0;
22554 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22555 bool arg2 ;
22556 void *argp1 = 0 ;
22557 int res1 = 0 ;
22558 bool val2 ;
22559 int ecode2 = 0 ;
22560 PyObject *swig_obj[2] ;
22561
22562 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
22563 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22564 if (!SWIG_IsOK(res1)) {
22565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22566 }
22567 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22568 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22569 if (!SWIG_IsOK(ecode2)) {
22570 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
22571 }
22572 arg2 = static_cast< bool >(val2);
22573 if (arg1) (arg1)->m_shiftDown = arg2;
22574
22575 resultobj = SWIG_Py_Void();
22576 return resultobj;
22577 fail:
22578 return NULL;
22579 }
22580
22581
22582 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22583 PyObject *resultobj = 0;
22584 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22585 bool result;
22586 void *argp1 = 0 ;
22587 int res1 = 0 ;
22588 PyObject *swig_obj[1] ;
22589
22590 if (!args) SWIG_fail;
22591 swig_obj[0] = args;
22592 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22593 if (!SWIG_IsOK(res1)) {
22594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22595 }
22596 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22597 result = (bool) ((arg1)->m_shiftDown);
22598 {
22599 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22600 }
22601 return resultobj;
22602 fail:
22603 return NULL;
22604 }
22605
22606
22607 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22608 PyObject *resultobj = 0;
22609 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22610 bool arg2 ;
22611 void *argp1 = 0 ;
22612 int res1 = 0 ;
22613 bool val2 ;
22614 int ecode2 = 0 ;
22615 PyObject *swig_obj[2] ;
22616
22617 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
22618 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22619 if (!SWIG_IsOK(res1)) {
22620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22621 }
22622 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22623 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22624 if (!SWIG_IsOK(ecode2)) {
22625 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
22626 }
22627 arg2 = static_cast< bool >(val2);
22628 if (arg1) (arg1)->m_altDown = arg2;
22629
22630 resultobj = SWIG_Py_Void();
22631 return resultobj;
22632 fail:
22633 return NULL;
22634 }
22635
22636
22637 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22638 PyObject *resultobj = 0;
22639 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22640 bool result;
22641 void *argp1 = 0 ;
22642 int res1 = 0 ;
22643 PyObject *swig_obj[1] ;
22644
22645 if (!args) SWIG_fail;
22646 swig_obj[0] = args;
22647 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22648 if (!SWIG_IsOK(res1)) {
22649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22650 }
22651 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22652 result = (bool) ((arg1)->m_altDown);
22653 {
22654 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22655 }
22656 return resultobj;
22657 fail:
22658 return NULL;
22659 }
22660
22661
22662 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22663 PyObject *resultobj = 0;
22664 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22665 bool arg2 ;
22666 void *argp1 = 0 ;
22667 int res1 = 0 ;
22668 bool val2 ;
22669 int ecode2 = 0 ;
22670 PyObject *swig_obj[2] ;
22671
22672 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
22673 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22674 if (!SWIG_IsOK(res1)) {
22675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22676 }
22677 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22678 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22679 if (!SWIG_IsOK(ecode2)) {
22680 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
22681 }
22682 arg2 = static_cast< bool >(val2);
22683 if (arg1) (arg1)->m_metaDown = arg2;
22684
22685 resultobj = SWIG_Py_Void();
22686 return resultobj;
22687 fail:
22688 return NULL;
22689 }
22690
22691
22692 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22693 PyObject *resultobj = 0;
22694 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22695 bool result;
22696 void *argp1 = 0 ;
22697 int res1 = 0 ;
22698 PyObject *swig_obj[1] ;
22699
22700 if (!args) SWIG_fail;
22701 swig_obj[0] = args;
22702 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22703 if (!SWIG_IsOK(res1)) {
22704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22705 }
22706 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22707 result = (bool) ((arg1)->m_metaDown);
22708 {
22709 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22710 }
22711 return resultobj;
22712 fail:
22713 return NULL;
22714 }
22715
22716
22717 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22718 PyObject *resultobj = 0;
22719 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22720 bool arg2 ;
22721 void *argp1 = 0 ;
22722 int res1 = 0 ;
22723 bool val2 ;
22724 int ecode2 = 0 ;
22725 PyObject *swig_obj[2] ;
22726
22727 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_scanCode_set",2,2,swig_obj)) SWIG_fail;
22728 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22729 if (!SWIG_IsOK(res1)) {
22730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22731 }
22732 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22733 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22734 if (!SWIG_IsOK(ecode2)) {
22735 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "2"" of type '" "bool""'");
22736 }
22737 arg2 = static_cast< bool >(val2);
22738 if (arg1) (arg1)->m_scanCode = arg2;
22739
22740 resultobj = SWIG_Py_Void();
22741 return resultobj;
22742 fail:
22743 return NULL;
22744 }
22745
22746
22747 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22748 PyObject *resultobj = 0;
22749 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22750 bool result;
22751 void *argp1 = 0 ;
22752 int res1 = 0 ;
22753 PyObject *swig_obj[1] ;
22754
22755 if (!args) SWIG_fail;
22756 swig_obj[0] = args;
22757 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22758 if (!SWIG_IsOK(res1)) {
22759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22760 }
22761 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22762 result = (bool) ((arg1)->m_scanCode);
22763 {
22764 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22765 }
22766 return resultobj;
22767 fail:
22768 return NULL;
22769 }
22770
22771
22772 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22773 PyObject *resultobj = 0;
22774 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22775 unsigned int arg2 ;
22776 void *argp1 = 0 ;
22777 int res1 = 0 ;
22778 unsigned int val2 ;
22779 int ecode2 = 0 ;
22780 PyObject *swig_obj[2] ;
22781
22782 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawCode_set",2,2,swig_obj)) SWIG_fail;
22783 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22784 if (!SWIG_IsOK(res1)) {
22785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22786 }
22787 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22788 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
22789 if (!SWIG_IsOK(ecode2)) {
22790 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "2"" of type '" "unsigned int""'");
22791 }
22792 arg2 = static_cast< unsigned int >(val2);
22793 if (arg1) (arg1)->m_rawCode = arg2;
22794
22795 resultobj = SWIG_Py_Void();
22796 return resultobj;
22797 fail:
22798 return NULL;
22799 }
22800
22801
22802 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22803 PyObject *resultobj = 0;
22804 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22805 unsigned int result;
22806 void *argp1 = 0 ;
22807 int res1 = 0 ;
22808 PyObject *swig_obj[1] ;
22809
22810 if (!args) SWIG_fail;
22811 swig_obj[0] = args;
22812 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22813 if (!SWIG_IsOK(res1)) {
22814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22815 }
22816 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22817 result = (unsigned int) ((arg1)->m_rawCode);
22818 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22819 return resultobj;
22820 fail:
22821 return NULL;
22822 }
22823
22824
22825 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22826 PyObject *resultobj = 0;
22827 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22828 unsigned int arg2 ;
22829 void *argp1 = 0 ;
22830 int res1 = 0 ;
22831 unsigned int val2 ;
22832 int ecode2 = 0 ;
22833 PyObject *swig_obj[2] ;
22834
22835 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawFlags_set",2,2,swig_obj)) SWIG_fail;
22836 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22837 if (!SWIG_IsOK(res1)) {
22838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22839 }
22840 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22841 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
22842 if (!SWIG_IsOK(ecode2)) {
22843 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "2"" of type '" "unsigned int""'");
22844 }
22845 arg2 = static_cast< unsigned int >(val2);
22846 if (arg1) (arg1)->m_rawFlags = arg2;
22847
22848 resultobj = SWIG_Py_Void();
22849 return resultobj;
22850 fail:
22851 return NULL;
22852 }
22853
22854
22855 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22856 PyObject *resultobj = 0;
22857 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22858 unsigned int result;
22859 void *argp1 = 0 ;
22860 int res1 = 0 ;
22861 PyObject *swig_obj[1] ;
22862
22863 if (!args) SWIG_fail;
22864 swig_obj[0] = args;
22865 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22866 if (!SWIG_IsOK(res1)) {
22867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22868 }
22869 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22870 result = (unsigned int) ((arg1)->m_rawFlags);
22871 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22872 return resultobj;
22873 fail:
22874 return NULL;
22875 }
22876
22877
22878 SWIGINTERN PyObject *KeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22879 PyObject *obj;
22880 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22881 SWIG_TypeNewClientData(SWIGTYPE_p_wxKeyEvent, SWIG_NewClientData(obj));
22882 return SWIG_Py_Void();
22883 }
22884
22885 SWIGINTERN PyObject *KeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22886 return SWIG_Python_InitShadowInstance(args);
22887 }
22888
22889 SWIGINTERN PyObject *_wrap_new_SizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22890 PyObject *resultobj = 0;
22891 wxSize const &arg1_defvalue = wxDefaultSize ;
22892 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
22893 int arg2 = (int) 0 ;
22894 wxSizeEvent *result = 0 ;
22895 wxSize temp1 ;
22896 int val2 ;
22897 int ecode2 = 0 ;
22898 PyObject * obj0 = 0 ;
22899 PyObject * obj1 = 0 ;
22900 char * kwnames[] = {
22901 (char *) "sz",(char *) "winid", NULL
22902 };
22903
22904 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
22905 if (obj0) {
22906 {
22907 arg1 = &temp1;
22908 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
22909 }
22910 }
22911 if (obj1) {
22912 ecode2 = SWIG_AsVal_int(obj1, &val2);
22913 if (!SWIG_IsOK(ecode2)) {
22914 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizeEvent" "', expected argument " "2"" of type '" "int""'");
22915 }
22916 arg2 = static_cast< int >(val2);
22917 }
22918 {
22919 PyThreadState* __tstate = wxPyBeginAllowThreads();
22920 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
22921 wxPyEndAllowThreads(__tstate);
22922 if (PyErr_Occurred()) SWIG_fail;
22923 }
22924 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_NEW | 0 );
22925 return resultobj;
22926 fail:
22927 return NULL;
22928 }
22929
22930
22931 SWIGINTERN PyObject *_wrap_SizeEvent_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22932 PyObject *resultobj = 0;
22933 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
22934 wxSize result;
22935 void *argp1 = 0 ;
22936 int res1 = 0 ;
22937 PyObject *swig_obj[1] ;
22938
22939 if (!args) SWIG_fail;
22940 swig_obj[0] = args;
22941 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
22942 if (!SWIG_IsOK(res1)) {
22943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetSize" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
22944 }
22945 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
22946 {
22947 PyThreadState* __tstate = wxPyBeginAllowThreads();
22948 result = ((wxSizeEvent const *)arg1)->GetSize();
22949 wxPyEndAllowThreads(__tstate);
22950 if (PyErr_Occurred()) SWIG_fail;
22951 }
22952 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
22953 return resultobj;
22954 fail:
22955 return NULL;
22956 }
22957
22958
22959 SWIGINTERN PyObject *_wrap_SizeEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22960 PyObject *resultobj = 0;
22961 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
22962 wxRect result;
22963 void *argp1 = 0 ;
22964 int res1 = 0 ;
22965 PyObject *swig_obj[1] ;
22966
22967 if (!args) SWIG_fail;
22968 swig_obj[0] = args;
22969 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
22970 if (!SWIG_IsOK(res1)) {
22971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetRect" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
22972 }
22973 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
22974 {
22975 PyThreadState* __tstate = wxPyBeginAllowThreads();
22976 result = ((wxSizeEvent const *)arg1)->GetRect();
22977 wxPyEndAllowThreads(__tstate);
22978 if (PyErr_Occurred()) SWIG_fail;
22979 }
22980 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
22981 return resultobj;
22982 fail:
22983 return NULL;
22984 }
22985
22986
22987 SWIGINTERN PyObject *_wrap_SizeEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22988 PyObject *resultobj = 0;
22989 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
22990 wxRect arg2 ;
22991 void *argp1 = 0 ;
22992 int res1 = 0 ;
22993 void *argp2 ;
22994 int res2 = 0 ;
22995 PyObject * obj0 = 0 ;
22996 PyObject * obj1 = 0 ;
22997 char * kwnames[] = {
22998 (char *) "self",(char *) "rect", NULL
22999 };
23000
23001 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
23002 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23003 if (!SWIG_IsOK(res1)) {
23004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetRect" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23005 }
23006 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23007 {
23008 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRect, 0 | 0);
23009 if (!SWIG_IsOK(res2)) {
23010 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
23011 }
23012 if (!argp2) {
23013 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
23014 } else {
23015 wxRect * temp = reinterpret_cast< wxRect * >(argp2);
23016 arg2 = *temp;
23017 if (SWIG_IsNewObj(res2)) delete temp;
23018 }
23019 }
23020 {
23021 PyThreadState* __tstate = wxPyBeginAllowThreads();
23022 (arg1)->SetRect(arg2);
23023 wxPyEndAllowThreads(__tstate);
23024 if (PyErr_Occurred()) SWIG_fail;
23025 }
23026 resultobj = SWIG_Py_Void();
23027 return resultobj;
23028 fail:
23029 return NULL;
23030 }
23031
23032
23033 SWIGINTERN PyObject *_wrap_SizeEvent_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23034 PyObject *resultobj = 0;
23035 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23036 wxSize arg2 ;
23037 void *argp1 = 0 ;
23038 int res1 = 0 ;
23039 void *argp2 ;
23040 int res2 = 0 ;
23041 PyObject * obj0 = 0 ;
23042 PyObject * obj1 = 0 ;
23043 char * kwnames[] = {
23044 (char *) "self",(char *) "size", NULL
23045 };
23046
23047 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
23048 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23049 if (!SWIG_IsOK(res1)) {
23050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetSize" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23051 }
23052 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23053 {
23054 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxSize, 0 | 0);
23055 if (!SWIG_IsOK(res2)) {
23056 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23057 }
23058 if (!argp2) {
23059 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23060 } else {
23061 wxSize * temp = reinterpret_cast< wxSize * >(argp2);
23062 arg2 = *temp;
23063 if (SWIG_IsNewObj(res2)) delete temp;
23064 }
23065 }
23066 {
23067 PyThreadState* __tstate = wxPyBeginAllowThreads();
23068 wxSizeEvent_SetSize(arg1,arg2);
23069 wxPyEndAllowThreads(__tstate);
23070 if (PyErr_Occurred()) SWIG_fail;
23071 }
23072 resultobj = SWIG_Py_Void();
23073 return resultobj;
23074 fail:
23075 return NULL;
23076 }
23077
23078
23079 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23080 PyObject *resultobj = 0;
23081 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23082 wxSize *arg2 = (wxSize *) 0 ;
23083 void *argp1 = 0 ;
23084 int res1 = 0 ;
23085 void *argp2 = 0 ;
23086 int res2 = 0 ;
23087 PyObject *swig_obj[2] ;
23088
23089 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_size_set",2,2,swig_obj)) SWIG_fail;
23090 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23091 if (!SWIG_IsOK(res1)) {
23092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23093 }
23094 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23095 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSize, 0 | 0 );
23096 if (!SWIG_IsOK(res2)) {
23097 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_size_set" "', expected argument " "2"" of type '" "wxSize *""'");
23098 }
23099 arg2 = reinterpret_cast< wxSize * >(argp2);
23100 if (arg1) (arg1)->m_size = *arg2;
23101
23102 resultobj = SWIG_Py_Void();
23103 return resultobj;
23104 fail:
23105 return NULL;
23106 }
23107
23108
23109 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23110 PyObject *resultobj = 0;
23111 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23112 wxSize *result = 0 ;
23113 void *argp1 = 0 ;
23114 int res1 = 0 ;
23115 PyObject *swig_obj[1] ;
23116
23117 if (!args) SWIG_fail;
23118 swig_obj[0] = args;
23119 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23120 if (!SWIG_IsOK(res1)) {
23121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23122 }
23123 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23124 result = (wxSize *)& ((arg1)->m_size);
23125 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
23126 return resultobj;
23127 fail:
23128 return NULL;
23129 }
23130
23131
23132 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23133 PyObject *resultobj = 0;
23134 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23135 wxRect *arg2 = (wxRect *) 0 ;
23136 void *argp1 = 0 ;
23137 int res1 = 0 ;
23138 void *argp2 = 0 ;
23139 int res2 = 0 ;
23140 PyObject *swig_obj[2] ;
23141
23142 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_rect_set",2,2,swig_obj)) SWIG_fail;
23143 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23144 if (!SWIG_IsOK(res1)) {
23145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23146 }
23147 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23148 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
23149 if (!SWIG_IsOK(res2)) {
23150 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_rect_set" "', expected argument " "2"" of type '" "wxRect *""'");
23151 }
23152 arg2 = reinterpret_cast< wxRect * >(argp2);
23153 if (arg1) (arg1)->m_rect = *arg2;
23154
23155 resultobj = SWIG_Py_Void();
23156 return resultobj;
23157 fail:
23158 return NULL;
23159 }
23160
23161
23162 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23163 PyObject *resultobj = 0;
23164 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23165 wxRect *result = 0 ;
23166 void *argp1 = 0 ;
23167 int res1 = 0 ;
23168 PyObject *swig_obj[1] ;
23169
23170 if (!args) SWIG_fail;
23171 swig_obj[0] = args;
23172 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23173 if (!SWIG_IsOK(res1)) {
23174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23175 }
23176 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23177 result = (wxRect *)& ((arg1)->m_rect);
23178 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
23179 return resultobj;
23180 fail:
23181 return NULL;
23182 }
23183
23184
23185 SWIGINTERN PyObject *SizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23186 PyObject *obj;
23187 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23188 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizeEvent, SWIG_NewClientData(obj));
23189 return SWIG_Py_Void();
23190 }
23191
23192 SWIGINTERN PyObject *SizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23193 return SWIG_Python_InitShadowInstance(args);
23194 }
23195
23196 SWIGINTERN PyObject *_wrap_new_MoveEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23197 PyObject *resultobj = 0;
23198 wxPoint const &arg1_defvalue = wxDefaultPosition ;
23199 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
23200 int arg2 = (int) 0 ;
23201 wxMoveEvent *result = 0 ;
23202 wxPoint temp1 ;
23203 int val2 ;
23204 int ecode2 = 0 ;
23205 PyObject * obj0 = 0 ;
23206 PyObject * obj1 = 0 ;
23207 char * kwnames[] = {
23208 (char *) "pos",(char *) "winid", NULL
23209 };
23210
23211 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23212 if (obj0) {
23213 {
23214 arg1 = &temp1;
23215 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
23216 }
23217 }
23218 if (obj1) {
23219 ecode2 = SWIG_AsVal_int(obj1, &val2);
23220 if (!SWIG_IsOK(ecode2)) {
23221 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MoveEvent" "', expected argument " "2"" of type '" "int""'");
23222 }
23223 arg2 = static_cast< int >(val2);
23224 }
23225 {
23226 PyThreadState* __tstate = wxPyBeginAllowThreads();
23227 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
23228 wxPyEndAllowThreads(__tstate);
23229 if (PyErr_Occurred()) SWIG_fail;
23230 }
23231 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_NEW | 0 );
23232 return resultobj;
23233 fail:
23234 return NULL;
23235 }
23236
23237
23238 SWIGINTERN PyObject *_wrap_MoveEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23239 PyObject *resultobj = 0;
23240 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23241 wxPoint result;
23242 void *argp1 = 0 ;
23243 int res1 = 0 ;
23244 PyObject *swig_obj[1] ;
23245
23246 if (!args) SWIG_fail;
23247 swig_obj[0] = args;
23248 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23249 if (!SWIG_IsOK(res1)) {
23250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetPosition" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23251 }
23252 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23253 {
23254 PyThreadState* __tstate = wxPyBeginAllowThreads();
23255 result = ((wxMoveEvent const *)arg1)->GetPosition();
23256 wxPyEndAllowThreads(__tstate);
23257 if (PyErr_Occurred()) SWIG_fail;
23258 }
23259 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23260 return resultobj;
23261 fail:
23262 return NULL;
23263 }
23264
23265
23266 SWIGINTERN PyObject *_wrap_MoveEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23267 PyObject *resultobj = 0;
23268 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23269 wxRect result;
23270 void *argp1 = 0 ;
23271 int res1 = 0 ;
23272 PyObject *swig_obj[1] ;
23273
23274 if (!args) SWIG_fail;
23275 swig_obj[0] = args;
23276 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23277 if (!SWIG_IsOK(res1)) {
23278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetRect" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23279 }
23280 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23281 {
23282 PyThreadState* __tstate = wxPyBeginAllowThreads();
23283 result = ((wxMoveEvent const *)arg1)->GetRect();
23284 wxPyEndAllowThreads(__tstate);
23285 if (PyErr_Occurred()) SWIG_fail;
23286 }
23287 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
23288 return resultobj;
23289 fail:
23290 return NULL;
23291 }
23292
23293
23294 SWIGINTERN PyObject *_wrap_MoveEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23295 PyObject *resultobj = 0;
23296 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23297 wxRect *arg2 = 0 ;
23298 void *argp1 = 0 ;
23299 int res1 = 0 ;
23300 wxRect temp2 ;
23301 PyObject * obj0 = 0 ;
23302 PyObject * obj1 = 0 ;
23303 char * kwnames[] = {
23304 (char *) "self",(char *) "rect", NULL
23305 };
23306
23307 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
23308 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23309 if (!SWIG_IsOK(res1)) {
23310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetRect" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23311 }
23312 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23313 {
23314 arg2 = &temp2;
23315 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
23316 }
23317 {
23318 PyThreadState* __tstate = wxPyBeginAllowThreads();
23319 (arg1)->SetRect((wxRect const &)*arg2);
23320 wxPyEndAllowThreads(__tstate);
23321 if (PyErr_Occurred()) SWIG_fail;
23322 }
23323 resultobj = SWIG_Py_Void();
23324 return resultobj;
23325 fail:
23326 return NULL;
23327 }
23328
23329
23330 SWIGINTERN PyObject *_wrap_MoveEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23331 PyObject *resultobj = 0;
23332 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23333 wxPoint *arg2 = 0 ;
23334 void *argp1 = 0 ;
23335 int res1 = 0 ;
23336 wxPoint temp2 ;
23337 PyObject * obj0 = 0 ;
23338 PyObject * obj1 = 0 ;
23339 char * kwnames[] = {
23340 (char *) "self",(char *) "pos", NULL
23341 };
23342
23343 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
23344 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23345 if (!SWIG_IsOK(res1)) {
23346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetPosition" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23347 }
23348 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23349 {
23350 arg2 = &temp2;
23351 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
23352 }
23353 {
23354 PyThreadState* __tstate = wxPyBeginAllowThreads();
23355 (arg1)->SetPosition((wxPoint const &)*arg2);
23356 wxPyEndAllowThreads(__tstate);
23357 if (PyErr_Occurred()) SWIG_fail;
23358 }
23359 resultobj = SWIG_Py_Void();
23360 return resultobj;
23361 fail:
23362 return NULL;
23363 }
23364
23365
23366 SWIGINTERN PyObject *MoveEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23367 PyObject *obj;
23368 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23369 SWIG_TypeNewClientData(SWIGTYPE_p_wxMoveEvent, SWIG_NewClientData(obj));
23370 return SWIG_Py_Void();
23371 }
23372
23373 SWIGINTERN PyObject *MoveEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23374 return SWIG_Python_InitShadowInstance(args);
23375 }
23376
23377 SWIGINTERN PyObject *_wrap_new_PaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23378 PyObject *resultobj = 0;
23379 int arg1 = (int) 0 ;
23380 wxPaintEvent *result = 0 ;
23381 int val1 ;
23382 int ecode1 = 0 ;
23383 PyObject * obj0 = 0 ;
23384 char * kwnames[] = {
23385 (char *) "Id", NULL
23386 };
23387
23388 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) SWIG_fail;
23389 if (obj0) {
23390 ecode1 = SWIG_AsVal_int(obj0, &val1);
23391 if (!SWIG_IsOK(ecode1)) {
23392 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaintEvent" "', expected argument " "1"" of type '" "int""'");
23393 }
23394 arg1 = static_cast< int >(val1);
23395 }
23396 {
23397 PyThreadState* __tstate = wxPyBeginAllowThreads();
23398 result = (wxPaintEvent *)new wxPaintEvent(arg1);
23399 wxPyEndAllowThreads(__tstate);
23400 if (PyErr_Occurred()) SWIG_fail;
23401 }
23402 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_NEW | 0 );
23403 return resultobj;
23404 fail:
23405 return NULL;
23406 }
23407
23408
23409 SWIGINTERN PyObject *PaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23410 PyObject *obj;
23411 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23412 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaintEvent, SWIG_NewClientData(obj));
23413 return SWIG_Py_Void();
23414 }
23415
23416 SWIGINTERN PyObject *PaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23417 return SWIG_Python_InitShadowInstance(args);
23418 }
23419
23420 SWIGINTERN PyObject *_wrap_new_NcPaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23421 PyObject *resultobj = 0;
23422 int arg1 = (int) 0 ;
23423 wxNcPaintEvent *result = 0 ;
23424 int val1 ;
23425 int ecode1 = 0 ;
23426 PyObject * obj0 = 0 ;
23427 char * kwnames[] = {
23428 (char *) "winid", NULL
23429 };
23430
23431 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) SWIG_fail;
23432 if (obj0) {
23433 ecode1 = SWIG_AsVal_int(obj0, &val1);
23434 if (!SWIG_IsOK(ecode1)) {
23435 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NcPaintEvent" "', expected argument " "1"" of type '" "int""'");
23436 }
23437 arg1 = static_cast< int >(val1);
23438 }
23439 {
23440 PyThreadState* __tstate = wxPyBeginAllowThreads();
23441 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
23442 wxPyEndAllowThreads(__tstate);
23443 if (PyErr_Occurred()) SWIG_fail;
23444 }
23445 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNcPaintEvent, SWIG_POINTER_NEW | 0 );
23446 return resultobj;
23447 fail:
23448 return NULL;
23449 }
23450
23451
23452 SWIGINTERN PyObject *NcPaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23453 PyObject *obj;
23454 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23455 SWIG_TypeNewClientData(SWIGTYPE_p_wxNcPaintEvent, SWIG_NewClientData(obj));
23456 return SWIG_Py_Void();
23457 }
23458
23459 SWIGINTERN PyObject *NcPaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23460 return SWIG_Python_InitShadowInstance(args);
23461 }
23462
23463 SWIGINTERN PyObject *_wrap_new_EraseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23464 PyObject *resultobj = 0;
23465 int arg1 = (int) 0 ;
23466 wxDC *arg2 = (wxDC *) NULL ;
23467 wxEraseEvent *result = 0 ;
23468 int val1 ;
23469 int ecode1 = 0 ;
23470 void *argp2 = 0 ;
23471 int res2 = 0 ;
23472 PyObject * obj0 = 0 ;
23473 PyObject * obj1 = 0 ;
23474 char * kwnames[] = {
23475 (char *) "Id",(char *) "dc", NULL
23476 };
23477
23478 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23479 if (obj0) {
23480 ecode1 = SWIG_AsVal_int(obj0, &val1);
23481 if (!SWIG_IsOK(ecode1)) {
23482 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EraseEvent" "', expected argument " "1"" of type '" "int""'");
23483 }
23484 arg1 = static_cast< int >(val1);
23485 }
23486 if (obj1) {
23487 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDC, 0 | 0 );
23488 if (!SWIG_IsOK(res2)) {
23489 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EraseEvent" "', expected argument " "2"" of type '" "wxDC *""'");
23490 }
23491 arg2 = reinterpret_cast< wxDC * >(argp2);
23492 }
23493 {
23494 PyThreadState* __tstate = wxPyBeginAllowThreads();
23495 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
23496 wxPyEndAllowThreads(__tstate);
23497 if (PyErr_Occurred()) SWIG_fail;
23498 }
23499 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_NEW | 0 );
23500 return resultobj;
23501 fail:
23502 return NULL;
23503 }
23504
23505
23506 SWIGINTERN PyObject *_wrap_EraseEvent_GetDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23507 PyObject *resultobj = 0;
23508 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
23509 wxDC *result = 0 ;
23510 void *argp1 = 0 ;
23511 int res1 = 0 ;
23512 PyObject *swig_obj[1] ;
23513
23514 if (!args) SWIG_fail;
23515 swig_obj[0] = args;
23516 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEraseEvent, 0 | 0 );
23517 if (!SWIG_IsOK(res1)) {
23518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EraseEvent_GetDC" "', expected argument " "1"" of type '" "wxEraseEvent const *""'");
23519 }
23520 arg1 = reinterpret_cast< wxEraseEvent * >(argp1);
23521 {
23522 PyThreadState* __tstate = wxPyBeginAllowThreads();
23523 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
23524 wxPyEndAllowThreads(__tstate);
23525 if (PyErr_Occurred()) SWIG_fail;
23526 }
23527 {
23528 resultobj = wxPyMake_wxObject(result, (bool)0);
23529 }
23530 return resultobj;
23531 fail:
23532 return NULL;
23533 }
23534
23535
23536 SWIGINTERN PyObject *EraseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23537 PyObject *obj;
23538 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23539 SWIG_TypeNewClientData(SWIGTYPE_p_wxEraseEvent, SWIG_NewClientData(obj));
23540 return SWIG_Py_Void();
23541 }
23542
23543 SWIGINTERN PyObject *EraseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23544 return SWIG_Python_InitShadowInstance(args);
23545 }
23546
23547 SWIGINTERN PyObject *_wrap_new_FocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23548 PyObject *resultobj = 0;
23549 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23550 int arg2 = (int) 0 ;
23551 wxFocusEvent *result = 0 ;
23552 int val1 ;
23553 int ecode1 = 0 ;
23554 int val2 ;
23555 int ecode2 = 0 ;
23556 PyObject * obj0 = 0 ;
23557 PyObject * obj1 = 0 ;
23558 char * kwnames[] = {
23559 (char *) "type",(char *) "winid", NULL
23560 };
23561
23562 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23563 if (obj0) {
23564 ecode1 = SWIG_AsVal_int(obj0, &val1);
23565 if (!SWIG_IsOK(ecode1)) {
23566 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FocusEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23567 }
23568 arg1 = static_cast< wxEventType >(val1);
23569 }
23570 if (obj1) {
23571 ecode2 = SWIG_AsVal_int(obj1, &val2);
23572 if (!SWIG_IsOK(ecode2)) {
23573 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FocusEvent" "', expected argument " "2"" of type '" "int""'");
23574 }
23575 arg2 = static_cast< int >(val2);
23576 }
23577 {
23578 PyThreadState* __tstate = wxPyBeginAllowThreads();
23579 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
23580 wxPyEndAllowThreads(__tstate);
23581 if (PyErr_Occurred()) SWIG_fail;
23582 }
23583 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_NEW | 0 );
23584 return resultobj;
23585 fail:
23586 return NULL;
23587 }
23588
23589
23590 SWIGINTERN PyObject *_wrap_FocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23591 PyObject *resultobj = 0;
23592 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
23593 wxWindow *result = 0 ;
23594 void *argp1 = 0 ;
23595 int res1 = 0 ;
23596 PyObject *swig_obj[1] ;
23597
23598 if (!args) SWIG_fail;
23599 swig_obj[0] = args;
23600 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
23601 if (!SWIG_IsOK(res1)) {
23602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxFocusEvent const *""'");
23603 }
23604 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
23605 {
23606 PyThreadState* __tstate = wxPyBeginAllowThreads();
23607 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
23608 wxPyEndAllowThreads(__tstate);
23609 if (PyErr_Occurred()) SWIG_fail;
23610 }
23611 {
23612 resultobj = wxPyMake_wxObject(result, (bool)0);
23613 }
23614 return resultobj;
23615 fail:
23616 return NULL;
23617 }
23618
23619
23620 SWIGINTERN PyObject *_wrap_FocusEvent_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23621 PyObject *resultobj = 0;
23622 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
23623 wxWindow *arg2 = (wxWindow *) 0 ;
23624 void *argp1 = 0 ;
23625 int res1 = 0 ;
23626 void *argp2 = 0 ;
23627 int res2 = 0 ;
23628 PyObject * obj0 = 0 ;
23629 PyObject * obj1 = 0 ;
23630 char * kwnames[] = {
23631 (char *) "self",(char *) "win", NULL
23632 };
23633
23634 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
23635 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
23636 if (!SWIG_IsOK(res1)) {
23637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_SetWindow" "', expected argument " "1"" of type '" "wxFocusEvent *""'");
23638 }
23639 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
23640 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
23641 if (!SWIG_IsOK(res2)) {
23642 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FocusEvent_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
23643 }
23644 arg2 = reinterpret_cast< wxWindow * >(argp2);
23645 {
23646 PyThreadState* __tstate = wxPyBeginAllowThreads();
23647 (arg1)->SetWindow(arg2);
23648 wxPyEndAllowThreads(__tstate);
23649 if (PyErr_Occurred()) SWIG_fail;
23650 }
23651 resultobj = SWIG_Py_Void();
23652 return resultobj;
23653 fail:
23654 return NULL;
23655 }
23656
23657
23658 SWIGINTERN PyObject *FocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23659 PyObject *obj;
23660 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23661 SWIG_TypeNewClientData(SWIGTYPE_p_wxFocusEvent, SWIG_NewClientData(obj));
23662 return SWIG_Py_Void();
23663 }
23664
23665 SWIGINTERN PyObject *FocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23666 return SWIG_Python_InitShadowInstance(args);
23667 }
23668
23669 SWIGINTERN PyObject *_wrap_new_ChildFocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23670 PyObject *resultobj = 0;
23671 wxWindow *arg1 = (wxWindow *) NULL ;
23672 wxChildFocusEvent *result = 0 ;
23673 void *argp1 = 0 ;
23674 int res1 = 0 ;
23675 PyObject * obj0 = 0 ;
23676 char * kwnames[] = {
23677 (char *) "win", NULL
23678 };
23679
23680 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) SWIG_fail;
23681 if (obj0) {
23682 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
23683 if (!SWIG_IsOK(res1)) {
23684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ChildFocusEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
23685 }
23686 arg1 = reinterpret_cast< wxWindow * >(argp1);
23687 }
23688 {
23689 PyThreadState* __tstate = wxPyBeginAllowThreads();
23690 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
23691 wxPyEndAllowThreads(__tstate);
23692 if (PyErr_Occurred()) SWIG_fail;
23693 }
23694 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_NEW | 0 );
23695 return resultobj;
23696 fail:
23697 return NULL;
23698 }
23699
23700
23701 SWIGINTERN PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23702 PyObject *resultobj = 0;
23703 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
23704 wxWindow *result = 0 ;
23705 void *argp1 = 0 ;
23706 int res1 = 0 ;
23707 PyObject *swig_obj[1] ;
23708
23709 if (!args) SWIG_fail;
23710 swig_obj[0] = args;
23711 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxChildFocusEvent, 0 | 0 );
23712 if (!SWIG_IsOK(res1)) {
23713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChildFocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxChildFocusEvent const *""'");
23714 }
23715 arg1 = reinterpret_cast< wxChildFocusEvent * >(argp1);
23716 {
23717 PyThreadState* __tstate = wxPyBeginAllowThreads();
23718 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
23719 wxPyEndAllowThreads(__tstate);
23720 if (PyErr_Occurred()) SWIG_fail;
23721 }
23722 {
23723 resultobj = wxPyMake_wxObject(result, (bool)0);
23724 }
23725 return resultobj;
23726 fail:
23727 return NULL;
23728 }
23729
23730
23731 SWIGINTERN PyObject *ChildFocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23732 PyObject *obj;
23733 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23734 SWIG_TypeNewClientData(SWIGTYPE_p_wxChildFocusEvent, SWIG_NewClientData(obj));
23735 return SWIG_Py_Void();
23736 }
23737
23738 SWIGINTERN PyObject *ChildFocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23739 return SWIG_Python_InitShadowInstance(args);
23740 }
23741
23742 SWIGINTERN PyObject *_wrap_new_ActivateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23743 PyObject *resultobj = 0;
23744 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23745 bool arg2 = (bool) true ;
23746 int arg3 = (int) 0 ;
23747 wxActivateEvent *result = 0 ;
23748 int val1 ;
23749 int ecode1 = 0 ;
23750 bool val2 ;
23751 int ecode2 = 0 ;
23752 int val3 ;
23753 int ecode3 = 0 ;
23754 PyObject * obj0 = 0 ;
23755 PyObject * obj1 = 0 ;
23756 PyObject * obj2 = 0 ;
23757 char * kwnames[] = {
23758 (char *) "type",(char *) "active",(char *) "Id", NULL
23759 };
23760
23761 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23762 if (obj0) {
23763 ecode1 = SWIG_AsVal_int(obj0, &val1);
23764 if (!SWIG_IsOK(ecode1)) {
23765 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ActivateEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23766 }
23767 arg1 = static_cast< wxEventType >(val1);
23768 }
23769 if (obj1) {
23770 ecode2 = SWIG_AsVal_bool(obj1, &val2);
23771 if (!SWIG_IsOK(ecode2)) {
23772 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ActivateEvent" "', expected argument " "2"" of type '" "bool""'");
23773 }
23774 arg2 = static_cast< bool >(val2);
23775 }
23776 if (obj2) {
23777 ecode3 = SWIG_AsVal_int(obj2, &val3);
23778 if (!SWIG_IsOK(ecode3)) {
23779 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ActivateEvent" "', expected argument " "3"" of type '" "int""'");
23780 }
23781 arg3 = static_cast< int >(val3);
23782 }
23783 {
23784 PyThreadState* __tstate = wxPyBeginAllowThreads();
23785 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
23786 wxPyEndAllowThreads(__tstate);
23787 if (PyErr_Occurred()) SWIG_fail;
23788 }
23789 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_NEW | 0 );
23790 return resultobj;
23791 fail:
23792 return NULL;
23793 }
23794
23795
23796 SWIGINTERN PyObject *_wrap_ActivateEvent_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23797 PyObject *resultobj = 0;
23798 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
23799 bool result;
23800 void *argp1 = 0 ;
23801 int res1 = 0 ;
23802 PyObject *swig_obj[1] ;
23803
23804 if (!args) SWIG_fail;
23805 swig_obj[0] = args;
23806 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxActivateEvent, 0 | 0 );
23807 if (!SWIG_IsOK(res1)) {
23808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActivateEvent_GetActive" "', expected argument " "1"" of type '" "wxActivateEvent const *""'");
23809 }
23810 arg1 = reinterpret_cast< wxActivateEvent * >(argp1);
23811 {
23812 PyThreadState* __tstate = wxPyBeginAllowThreads();
23813 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
23814 wxPyEndAllowThreads(__tstate);
23815 if (PyErr_Occurred()) SWIG_fail;
23816 }
23817 {
23818 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23819 }
23820 return resultobj;
23821 fail:
23822 return NULL;
23823 }
23824
23825
23826 SWIGINTERN PyObject *ActivateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23827 PyObject *obj;
23828 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23829 SWIG_TypeNewClientData(SWIGTYPE_p_wxActivateEvent, SWIG_NewClientData(obj));
23830 return SWIG_Py_Void();
23831 }
23832
23833 SWIGINTERN PyObject *ActivateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23834 return SWIG_Python_InitShadowInstance(args);
23835 }
23836
23837 SWIGINTERN PyObject *_wrap_new_InitDialogEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23838 PyObject *resultobj = 0;
23839 int arg1 = (int) 0 ;
23840 wxInitDialogEvent *result = 0 ;
23841 int val1 ;
23842 int ecode1 = 0 ;
23843 PyObject * obj0 = 0 ;
23844 char * kwnames[] = {
23845 (char *) "Id", NULL
23846 };
23847
23848 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) SWIG_fail;
23849 if (obj0) {
23850 ecode1 = SWIG_AsVal_int(obj0, &val1);
23851 if (!SWIG_IsOK(ecode1)) {
23852 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InitDialogEvent" "', expected argument " "1"" of type '" "int""'");
23853 }
23854 arg1 = static_cast< int >(val1);
23855 }
23856 {
23857 PyThreadState* __tstate = wxPyBeginAllowThreads();
23858 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
23859 wxPyEndAllowThreads(__tstate);
23860 if (PyErr_Occurred()) SWIG_fail;
23861 }
23862 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInitDialogEvent, SWIG_POINTER_NEW | 0 );
23863 return resultobj;
23864 fail:
23865 return NULL;
23866 }
23867
23868
23869 SWIGINTERN PyObject *InitDialogEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23870 PyObject *obj;
23871 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23872 SWIG_TypeNewClientData(SWIGTYPE_p_wxInitDialogEvent, SWIG_NewClientData(obj));
23873 return SWIG_Py_Void();
23874 }
23875
23876 SWIGINTERN PyObject *InitDialogEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23877 return SWIG_Python_InitShadowInstance(args);
23878 }
23879
23880 SWIGINTERN PyObject *_wrap_new_MenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23881 PyObject *resultobj = 0;
23882 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23883 int arg2 = (int) 0 ;
23884 wxMenu *arg3 = (wxMenu *) NULL ;
23885 wxMenuEvent *result = 0 ;
23886 int val1 ;
23887 int ecode1 = 0 ;
23888 int val2 ;
23889 int ecode2 = 0 ;
23890 void *argp3 = 0 ;
23891 int res3 = 0 ;
23892 PyObject * obj0 = 0 ;
23893 PyObject * obj1 = 0 ;
23894 PyObject * obj2 = 0 ;
23895 char * kwnames[] = {
23896 (char *) "type",(char *) "winid",(char *) "menu", NULL
23897 };
23898
23899 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23900 if (obj0) {
23901 ecode1 = SWIG_AsVal_int(obj0, &val1);
23902 if (!SWIG_IsOK(ecode1)) {
23903 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23904 }
23905 arg1 = static_cast< wxEventType >(val1);
23906 }
23907 if (obj1) {
23908 ecode2 = SWIG_AsVal_int(obj1, &val2);
23909 if (!SWIG_IsOK(ecode2)) {
23910 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuEvent" "', expected argument " "2"" of type '" "int""'");
23911 }
23912 arg2 = static_cast< int >(val2);
23913 }
23914 if (obj2) {
23915 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
23916 if (!SWIG_IsOK(res3)) {
23917 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MenuEvent" "', expected argument " "3"" of type '" "wxMenu *""'");
23918 }
23919 arg3 = reinterpret_cast< wxMenu * >(argp3);
23920 }
23921 {
23922 PyThreadState* __tstate = wxPyBeginAllowThreads();
23923 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
23924 wxPyEndAllowThreads(__tstate);
23925 if (PyErr_Occurred()) SWIG_fail;
23926 }
23927 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_NEW | 0 );
23928 return resultobj;
23929 fail:
23930 return NULL;
23931 }
23932
23933
23934 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenuId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23935 PyObject *resultobj = 0;
23936 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
23937 int result;
23938 void *argp1 = 0 ;
23939 int res1 = 0 ;
23940 PyObject *swig_obj[1] ;
23941
23942 if (!args) SWIG_fail;
23943 swig_obj[0] = args;
23944 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
23945 if (!SWIG_IsOK(res1)) {
23946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenuId" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
23947 }
23948 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
23949 {
23950 PyThreadState* __tstate = wxPyBeginAllowThreads();
23951 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
23952 wxPyEndAllowThreads(__tstate);
23953 if (PyErr_Occurred()) SWIG_fail;
23954 }
23955 resultobj = SWIG_From_int(static_cast< int >(result));
23956 return resultobj;
23957 fail:
23958 return NULL;
23959 }
23960
23961
23962 SWIGINTERN PyObject *_wrap_MenuEvent_IsPopup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23963 PyObject *resultobj = 0;
23964 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
23965 bool result;
23966 void *argp1 = 0 ;
23967 int res1 = 0 ;
23968 PyObject *swig_obj[1] ;
23969
23970 if (!args) SWIG_fail;
23971 swig_obj[0] = args;
23972 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
23973 if (!SWIG_IsOK(res1)) {
23974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_IsPopup" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
23975 }
23976 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
23977 {
23978 PyThreadState* __tstate = wxPyBeginAllowThreads();
23979 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
23980 wxPyEndAllowThreads(__tstate);
23981 if (PyErr_Occurred()) SWIG_fail;
23982 }
23983 {
23984 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23985 }
23986 return resultobj;
23987 fail:
23988 return NULL;
23989 }
23990
23991
23992 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23993 PyObject *resultobj = 0;
23994 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
23995 wxMenu *result = 0 ;
23996 void *argp1 = 0 ;
23997 int res1 = 0 ;
23998 PyObject *swig_obj[1] ;
23999
24000 if (!args) SWIG_fail;
24001 swig_obj[0] = args;
24002 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24003 if (!SWIG_IsOK(res1)) {
24004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenu" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24005 }
24006 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24007 {
24008 PyThreadState* __tstate = wxPyBeginAllowThreads();
24009 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
24010 wxPyEndAllowThreads(__tstate);
24011 if (PyErr_Occurred()) SWIG_fail;
24012 }
24013 {
24014 resultobj = wxPyMake_wxObject(result, (bool)0);
24015 }
24016 return resultobj;
24017 fail:
24018 return NULL;
24019 }
24020
24021
24022 SWIGINTERN PyObject *MenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24023 PyObject *obj;
24024 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24025 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuEvent, SWIG_NewClientData(obj));
24026 return SWIG_Py_Void();
24027 }
24028
24029 SWIGINTERN PyObject *MenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24030 return SWIG_Python_InitShadowInstance(args);
24031 }
24032
24033 SWIGINTERN PyObject *_wrap_new_CloseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24034 PyObject *resultobj = 0;
24035 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24036 int arg2 = (int) 0 ;
24037 wxCloseEvent *result = 0 ;
24038 int val1 ;
24039 int ecode1 = 0 ;
24040 int val2 ;
24041 int ecode2 = 0 ;
24042 PyObject * obj0 = 0 ;
24043 PyObject * obj1 = 0 ;
24044 char * kwnames[] = {
24045 (char *) "type",(char *) "winid", NULL
24046 };
24047
24048 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24049 if (obj0) {
24050 ecode1 = SWIG_AsVal_int(obj0, &val1);
24051 if (!SWIG_IsOK(ecode1)) {
24052 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CloseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24053 }
24054 arg1 = static_cast< wxEventType >(val1);
24055 }
24056 if (obj1) {
24057 ecode2 = SWIG_AsVal_int(obj1, &val2);
24058 if (!SWIG_IsOK(ecode2)) {
24059 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CloseEvent" "', expected argument " "2"" of type '" "int""'");
24060 }
24061 arg2 = static_cast< int >(val2);
24062 }
24063 {
24064 PyThreadState* __tstate = wxPyBeginAllowThreads();
24065 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
24066 wxPyEndAllowThreads(__tstate);
24067 if (PyErr_Occurred()) SWIG_fail;
24068 }
24069 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_NEW | 0 );
24070 return resultobj;
24071 fail:
24072 return NULL;
24073 }
24074
24075
24076 SWIGINTERN PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24077 PyObject *resultobj = 0;
24078 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24079 bool arg2 ;
24080 void *argp1 = 0 ;
24081 int res1 = 0 ;
24082 bool val2 ;
24083 int ecode2 = 0 ;
24084 PyObject * obj0 = 0 ;
24085 PyObject * obj1 = 0 ;
24086 char * kwnames[] = {
24087 (char *) "self",(char *) "logOff", NULL
24088 };
24089
24090 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) SWIG_fail;
24091 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24092 if (!SWIG_IsOK(res1)) {
24093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24094 }
24095 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24096 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24097 if (!SWIG_IsOK(ecode2)) {
24098 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "2"" of type '" "bool""'");
24099 }
24100 arg2 = static_cast< bool >(val2);
24101 {
24102 PyThreadState* __tstate = wxPyBeginAllowThreads();
24103 (arg1)->SetLoggingOff(arg2);
24104 wxPyEndAllowThreads(__tstate);
24105 if (PyErr_Occurred()) SWIG_fail;
24106 }
24107 resultobj = SWIG_Py_Void();
24108 return resultobj;
24109 fail:
24110 return NULL;
24111 }
24112
24113
24114 SWIGINTERN PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24115 PyObject *resultobj = 0;
24116 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24117 bool result;
24118 void *argp1 = 0 ;
24119 int res1 = 0 ;
24120 PyObject *swig_obj[1] ;
24121
24122 if (!args) SWIG_fail;
24123 swig_obj[0] = args;
24124 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24125 if (!SWIG_IsOK(res1)) {
24126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24127 }
24128 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24129 {
24130 PyThreadState* __tstate = wxPyBeginAllowThreads();
24131 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
24132 wxPyEndAllowThreads(__tstate);
24133 if (PyErr_Occurred()) SWIG_fail;
24134 }
24135 {
24136 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24137 }
24138 return resultobj;
24139 fail:
24140 return NULL;
24141 }
24142
24143
24144 SWIGINTERN PyObject *_wrap_CloseEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24145 PyObject *resultobj = 0;
24146 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24147 bool arg2 = (bool) true ;
24148 void *argp1 = 0 ;
24149 int res1 = 0 ;
24150 bool val2 ;
24151 int ecode2 = 0 ;
24152 PyObject * obj0 = 0 ;
24153 PyObject * obj1 = 0 ;
24154 char * kwnames[] = {
24155 (char *) "self",(char *) "veto", NULL
24156 };
24157
24158 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) SWIG_fail;
24159 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24160 if (!SWIG_IsOK(res1)) {
24161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_Veto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24162 }
24163 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24164 if (obj1) {
24165 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24166 if (!SWIG_IsOK(ecode2)) {
24167 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_Veto" "', expected argument " "2"" of type '" "bool""'");
24168 }
24169 arg2 = static_cast< bool >(val2);
24170 }
24171 {
24172 PyThreadState* __tstate = wxPyBeginAllowThreads();
24173 (arg1)->Veto(arg2);
24174 wxPyEndAllowThreads(__tstate);
24175 if (PyErr_Occurred()) SWIG_fail;
24176 }
24177 resultobj = SWIG_Py_Void();
24178 return resultobj;
24179 fail:
24180 return NULL;
24181 }
24182
24183
24184 SWIGINTERN PyObject *_wrap_CloseEvent_GetVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24185 PyObject *resultobj = 0;
24186 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24187 bool result;
24188 void *argp1 = 0 ;
24189 int res1 = 0 ;
24190 PyObject *swig_obj[1] ;
24191
24192 if (!args) SWIG_fail;
24193 swig_obj[0] = args;
24194 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24195 if (!SWIG_IsOK(res1)) {
24196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24197 }
24198 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24199 {
24200 PyThreadState* __tstate = wxPyBeginAllowThreads();
24201 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
24202 wxPyEndAllowThreads(__tstate);
24203 if (PyErr_Occurred()) SWIG_fail;
24204 }
24205 {
24206 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24207 }
24208 return resultobj;
24209 fail:
24210 return NULL;
24211 }
24212
24213
24214 SWIGINTERN PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24215 PyObject *resultobj = 0;
24216 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24217 bool arg2 ;
24218 void *argp1 = 0 ;
24219 int res1 = 0 ;
24220 bool val2 ;
24221 int ecode2 = 0 ;
24222 PyObject * obj0 = 0 ;
24223 PyObject * obj1 = 0 ;
24224 char * kwnames[] = {
24225 (char *) "self",(char *) "canVeto", NULL
24226 };
24227
24228 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) SWIG_fail;
24229 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24230 if (!SWIG_IsOK(res1)) {
24231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24232 }
24233 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24234 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24235 if (!SWIG_IsOK(ecode2)) {
24236 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "2"" of type '" "bool""'");
24237 }
24238 arg2 = static_cast< bool >(val2);
24239 {
24240 PyThreadState* __tstate = wxPyBeginAllowThreads();
24241 (arg1)->SetCanVeto(arg2);
24242 wxPyEndAllowThreads(__tstate);
24243 if (PyErr_Occurred()) SWIG_fail;
24244 }
24245 resultobj = SWIG_Py_Void();
24246 return resultobj;
24247 fail:
24248 return NULL;
24249 }
24250
24251
24252 SWIGINTERN PyObject *_wrap_CloseEvent_CanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24253 PyObject *resultobj = 0;
24254 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24255 bool result;
24256 void *argp1 = 0 ;
24257 int res1 = 0 ;
24258 PyObject *swig_obj[1] ;
24259
24260 if (!args) SWIG_fail;
24261 swig_obj[0] = args;
24262 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24263 if (!SWIG_IsOK(res1)) {
24264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_CanVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24265 }
24266 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24267 {
24268 PyThreadState* __tstate = wxPyBeginAllowThreads();
24269 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
24270 wxPyEndAllowThreads(__tstate);
24271 if (PyErr_Occurred()) SWIG_fail;
24272 }
24273 {
24274 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24275 }
24276 return resultobj;
24277 fail:
24278 return NULL;
24279 }
24280
24281
24282 SWIGINTERN PyObject *CloseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24283 PyObject *obj;
24284 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24285 SWIG_TypeNewClientData(SWIGTYPE_p_wxCloseEvent, SWIG_NewClientData(obj));
24286 return SWIG_Py_Void();
24287 }
24288
24289 SWIGINTERN PyObject *CloseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24290 return SWIG_Python_InitShadowInstance(args);
24291 }
24292
24293 SWIGINTERN PyObject *_wrap_new_ShowEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24294 PyObject *resultobj = 0;
24295 int arg1 = (int) 0 ;
24296 bool arg2 = (bool) false ;
24297 wxShowEvent *result = 0 ;
24298 int val1 ;
24299 int ecode1 = 0 ;
24300 bool val2 ;
24301 int ecode2 = 0 ;
24302 PyObject * obj0 = 0 ;
24303 PyObject * obj1 = 0 ;
24304 char * kwnames[] = {
24305 (char *) "winid",(char *) "show", NULL
24306 };
24307
24308 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24309 if (obj0) {
24310 ecode1 = SWIG_AsVal_int(obj0, &val1);
24311 if (!SWIG_IsOK(ecode1)) {
24312 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ShowEvent" "', expected argument " "1"" of type '" "int""'");
24313 }
24314 arg1 = static_cast< int >(val1);
24315 }
24316 if (obj1) {
24317 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24318 if (!SWIG_IsOK(ecode2)) {
24319 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ShowEvent" "', expected argument " "2"" of type '" "bool""'");
24320 }
24321 arg2 = static_cast< bool >(val2);
24322 }
24323 {
24324 PyThreadState* __tstate = wxPyBeginAllowThreads();
24325 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
24326 wxPyEndAllowThreads(__tstate);
24327 if (PyErr_Occurred()) SWIG_fail;
24328 }
24329 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxShowEvent, SWIG_POINTER_NEW | 0 );
24330 return resultobj;
24331 fail:
24332 return NULL;
24333 }
24334
24335
24336 SWIGINTERN PyObject *_wrap_ShowEvent_SetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24337 PyObject *resultobj = 0;
24338 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24339 bool arg2 ;
24340 void *argp1 = 0 ;
24341 int res1 = 0 ;
24342 bool val2 ;
24343 int ecode2 = 0 ;
24344 PyObject * obj0 = 0 ;
24345 PyObject * obj1 = 0 ;
24346 char * kwnames[] = {
24347 (char *) "self",(char *) "show", NULL
24348 };
24349
24350 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) SWIG_fail;
24351 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24352 if (!SWIG_IsOK(res1)) {
24353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_SetShow" "', expected argument " "1"" of type '" "wxShowEvent *""'");
24354 }
24355 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24356 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24357 if (!SWIG_IsOK(ecode2)) {
24358 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShowEvent_SetShow" "', expected argument " "2"" of type '" "bool""'");
24359 }
24360 arg2 = static_cast< bool >(val2);
24361 {
24362 PyThreadState* __tstate = wxPyBeginAllowThreads();
24363 (arg1)->SetShow(arg2);
24364 wxPyEndAllowThreads(__tstate);
24365 if (PyErr_Occurred()) SWIG_fail;
24366 }
24367 resultobj = SWIG_Py_Void();
24368 return resultobj;
24369 fail:
24370 return NULL;
24371 }
24372
24373
24374 SWIGINTERN PyObject *_wrap_ShowEvent_GetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24375 PyObject *resultobj = 0;
24376 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24377 bool result;
24378 void *argp1 = 0 ;
24379 int res1 = 0 ;
24380 PyObject *swig_obj[1] ;
24381
24382 if (!args) SWIG_fail;
24383 swig_obj[0] = args;
24384 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24385 if (!SWIG_IsOK(res1)) {
24386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_GetShow" "', expected argument " "1"" of type '" "wxShowEvent const *""'");
24387 }
24388 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24389 {
24390 PyThreadState* __tstate = wxPyBeginAllowThreads();
24391 result = (bool)((wxShowEvent const *)arg1)->GetShow();
24392 wxPyEndAllowThreads(__tstate);
24393 if (PyErr_Occurred()) SWIG_fail;
24394 }
24395 {
24396 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24397 }
24398 return resultobj;
24399 fail:
24400 return NULL;
24401 }
24402
24403
24404 SWIGINTERN PyObject *ShowEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24405 PyObject *obj;
24406 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24407 SWIG_TypeNewClientData(SWIGTYPE_p_wxShowEvent, SWIG_NewClientData(obj));
24408 return SWIG_Py_Void();
24409 }
24410
24411 SWIGINTERN PyObject *ShowEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24412 return SWIG_Python_InitShadowInstance(args);
24413 }
24414
24415 SWIGINTERN PyObject *_wrap_new_IconizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24416 PyObject *resultobj = 0;
24417 int arg1 = (int) 0 ;
24418 bool arg2 = (bool) true ;
24419 wxIconizeEvent *result = 0 ;
24420 int val1 ;
24421 int ecode1 = 0 ;
24422 bool val2 ;
24423 int ecode2 = 0 ;
24424 PyObject * obj0 = 0 ;
24425 PyObject * obj1 = 0 ;
24426 char * kwnames[] = {
24427 (char *) "id",(char *) "iconized", NULL
24428 };
24429
24430 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24431 if (obj0) {
24432 ecode1 = SWIG_AsVal_int(obj0, &val1);
24433 if (!SWIG_IsOK(ecode1)) {
24434 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IconizeEvent" "', expected argument " "1"" of type '" "int""'");
24435 }
24436 arg1 = static_cast< int >(val1);
24437 }
24438 if (obj1) {
24439 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24440 if (!SWIG_IsOK(ecode2)) {
24441 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IconizeEvent" "', expected argument " "2"" of type '" "bool""'");
24442 }
24443 arg2 = static_cast< bool >(val2);
24444 }
24445 {
24446 PyThreadState* __tstate = wxPyBeginAllowThreads();
24447 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
24448 wxPyEndAllowThreads(__tstate);
24449 if (PyErr_Occurred()) SWIG_fail;
24450 }
24451 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_NEW | 0 );
24452 return resultobj;
24453 fail:
24454 return NULL;
24455 }
24456
24457
24458 SWIGINTERN PyObject *_wrap_IconizeEvent_Iconized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24459 PyObject *resultobj = 0;
24460 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
24461 bool result;
24462 void *argp1 = 0 ;
24463 int res1 = 0 ;
24464 PyObject *swig_obj[1] ;
24465
24466 if (!args) SWIG_fail;
24467 swig_obj[0] = args;
24468 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconizeEvent, 0 | 0 );
24469 if (!SWIG_IsOK(res1)) {
24470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconizeEvent_Iconized" "', expected argument " "1"" of type '" "wxIconizeEvent *""'");
24471 }
24472 arg1 = reinterpret_cast< wxIconizeEvent * >(argp1);
24473 {
24474 PyThreadState* __tstate = wxPyBeginAllowThreads();
24475 result = (bool)(arg1)->Iconized();
24476 wxPyEndAllowThreads(__tstate);
24477 if (PyErr_Occurred()) SWIG_fail;
24478 }
24479 {
24480 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24481 }
24482 return resultobj;
24483 fail:
24484 return NULL;
24485 }
24486
24487
24488 SWIGINTERN PyObject *IconizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24489 PyObject *obj;
24490 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24491 SWIG_TypeNewClientData(SWIGTYPE_p_wxIconizeEvent, SWIG_NewClientData(obj));
24492 return SWIG_Py_Void();
24493 }
24494
24495 SWIGINTERN PyObject *IconizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24496 return SWIG_Python_InitShadowInstance(args);
24497 }
24498
24499 SWIGINTERN PyObject *_wrap_new_MaximizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24500 PyObject *resultobj = 0;
24501 int arg1 = (int) 0 ;
24502 wxMaximizeEvent *result = 0 ;
24503 int val1 ;
24504 int ecode1 = 0 ;
24505 PyObject * obj0 = 0 ;
24506 char * kwnames[] = {
24507 (char *) "id", NULL
24508 };
24509
24510 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) SWIG_fail;
24511 if (obj0) {
24512 ecode1 = SWIG_AsVal_int(obj0, &val1);
24513 if (!SWIG_IsOK(ecode1)) {
24514 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MaximizeEvent" "', expected argument " "1"" of type '" "int""'");
24515 }
24516 arg1 = static_cast< int >(val1);
24517 }
24518 {
24519 PyThreadState* __tstate = wxPyBeginAllowThreads();
24520 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
24521 wxPyEndAllowThreads(__tstate);
24522 if (PyErr_Occurred()) SWIG_fail;
24523 }
24524 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMaximizeEvent, SWIG_POINTER_NEW | 0 );
24525 return resultobj;
24526 fail:
24527 return NULL;
24528 }
24529
24530
24531 SWIGINTERN PyObject *MaximizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24532 PyObject *obj;
24533 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24534 SWIG_TypeNewClientData(SWIGTYPE_p_wxMaximizeEvent, SWIG_NewClientData(obj));
24535 return SWIG_Py_Void();
24536 }
24537
24538 SWIGINTERN PyObject *MaximizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24539 return SWIG_Python_InitShadowInstance(args);
24540 }
24541
24542 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24543 PyObject *resultobj = 0;
24544 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24545 wxPoint result;
24546 void *argp1 = 0 ;
24547 int res1 = 0 ;
24548 PyObject *swig_obj[1] ;
24549
24550 if (!args) SWIG_fail;
24551 swig_obj[0] = args;
24552 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24553 if (!SWIG_IsOK(res1)) {
24554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetPosition" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24555 }
24556 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24557 {
24558 PyThreadState* __tstate = wxPyBeginAllowThreads();
24559 result = (arg1)->GetPosition();
24560 wxPyEndAllowThreads(__tstate);
24561 if (PyErr_Occurred()) SWIG_fail;
24562 }
24563 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
24564 return resultobj;
24565 fail:
24566 return NULL;
24567 }
24568
24569
24570 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24571 PyObject *resultobj = 0;
24572 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24573 int result;
24574 void *argp1 = 0 ;
24575 int res1 = 0 ;
24576 PyObject *swig_obj[1] ;
24577
24578 if (!args) SWIG_fail;
24579 swig_obj[0] = args;
24580 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24581 if (!SWIG_IsOK(res1)) {
24582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetNumberOfFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24583 }
24584 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24585 {
24586 PyThreadState* __tstate = wxPyBeginAllowThreads();
24587 result = (int)(arg1)->GetNumberOfFiles();
24588 wxPyEndAllowThreads(__tstate);
24589 if (PyErr_Occurred()) SWIG_fail;
24590 }
24591 resultobj = SWIG_From_int(static_cast< int >(result));
24592 return resultobj;
24593 fail:
24594 return NULL;
24595 }
24596
24597
24598 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24599 PyObject *resultobj = 0;
24600 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24601 PyObject *result = 0 ;
24602 void *argp1 = 0 ;
24603 int res1 = 0 ;
24604 PyObject *swig_obj[1] ;
24605
24606 if (!args) SWIG_fail;
24607 swig_obj[0] = args;
24608 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24609 if (!SWIG_IsOK(res1)) {
24610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24611 }
24612 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24613 {
24614 PyThreadState* __tstate = wxPyBeginAllowThreads();
24615 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
24616 wxPyEndAllowThreads(__tstate);
24617 if (PyErr_Occurred()) SWIG_fail;
24618 }
24619 resultobj = result;
24620 return resultobj;
24621 fail:
24622 return NULL;
24623 }
24624
24625
24626 SWIGINTERN PyObject *DropFilesEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24627 PyObject *obj;
24628 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24629 SWIG_TypeNewClientData(SWIGTYPE_p_wxDropFilesEvent, SWIG_NewClientData(obj));
24630 return SWIG_Py_Void();
24631 }
24632
24633 SWIGINTERN PyObject *_wrap_new_UpdateUIEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24634 PyObject *resultobj = 0;
24635 int arg1 = (int) 0 ;
24636 wxUpdateUIEvent *result = 0 ;
24637 int val1 ;
24638 int ecode1 = 0 ;
24639 PyObject * obj0 = 0 ;
24640 char * kwnames[] = {
24641 (char *) "commandId", NULL
24642 };
24643
24644 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) SWIG_fail;
24645 if (obj0) {
24646 ecode1 = SWIG_AsVal_int(obj0, &val1);
24647 if (!SWIG_IsOK(ecode1)) {
24648 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UpdateUIEvent" "', expected argument " "1"" of type '" "int""'");
24649 }
24650 arg1 = static_cast< int >(val1);
24651 }
24652 {
24653 PyThreadState* __tstate = wxPyBeginAllowThreads();
24654 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
24655 wxPyEndAllowThreads(__tstate);
24656 if (PyErr_Occurred()) SWIG_fail;
24657 }
24658 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_NEW | 0 );
24659 return resultobj;
24660 fail:
24661 return NULL;
24662 }
24663
24664
24665 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24666 PyObject *resultobj = 0;
24667 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24668 bool result;
24669 void *argp1 = 0 ;
24670 int res1 = 0 ;
24671 PyObject *swig_obj[1] ;
24672
24673 if (!args) SWIG_fail;
24674 swig_obj[0] = args;
24675 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24676 if (!SWIG_IsOK(res1)) {
24677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24678 }
24679 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24680 {
24681 PyThreadState* __tstate = wxPyBeginAllowThreads();
24682 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
24683 wxPyEndAllowThreads(__tstate);
24684 if (PyErr_Occurred()) SWIG_fail;
24685 }
24686 {
24687 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24688 }
24689 return resultobj;
24690 fail:
24691 return NULL;
24692 }
24693
24694
24695 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24696 PyObject *resultobj = 0;
24697 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24698 bool result;
24699 void *argp1 = 0 ;
24700 int res1 = 0 ;
24701 PyObject *swig_obj[1] ;
24702
24703 if (!args) SWIG_fail;
24704 swig_obj[0] = args;
24705 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24706 if (!SWIG_IsOK(res1)) {
24707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24708 }
24709 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24710 {
24711 PyThreadState* __tstate = wxPyBeginAllowThreads();
24712 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
24713 wxPyEndAllowThreads(__tstate);
24714 if (PyErr_Occurred()) SWIG_fail;
24715 }
24716 {
24717 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24718 }
24719 return resultobj;
24720 fail:
24721 return NULL;
24722 }
24723
24724
24725 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24726 PyObject *resultobj = 0;
24727 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24728 bool result;
24729 void *argp1 = 0 ;
24730 int res1 = 0 ;
24731 PyObject *swig_obj[1] ;
24732
24733 if (!args) SWIG_fail;
24734 swig_obj[0] = args;
24735 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24736 if (!SWIG_IsOK(res1)) {
24737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24738 }
24739 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24740 {
24741 PyThreadState* __tstate = wxPyBeginAllowThreads();
24742 result = (bool)((wxUpdateUIEvent const *)arg1)->GetShown();
24743 wxPyEndAllowThreads(__tstate);
24744 if (PyErr_Occurred()) SWIG_fail;
24745 }
24746 {
24747 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24748 }
24749 return resultobj;
24750 fail:
24751 return NULL;
24752 }
24753
24754
24755 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24756 PyObject *resultobj = 0;
24757 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24758 wxString result;
24759 void *argp1 = 0 ;
24760 int res1 = 0 ;
24761 PyObject *swig_obj[1] ;
24762
24763 if (!args) SWIG_fail;
24764 swig_obj[0] = args;
24765 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24766 if (!SWIG_IsOK(res1)) {
24767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24768 }
24769 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24770 {
24771 PyThreadState* __tstate = wxPyBeginAllowThreads();
24772 result = ((wxUpdateUIEvent const *)arg1)->GetText();
24773 wxPyEndAllowThreads(__tstate);
24774 if (PyErr_Occurred()) SWIG_fail;
24775 }
24776 {
24777 #if wxUSE_UNICODE
24778 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24779 #else
24780 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24781 #endif
24782 }
24783 return resultobj;
24784 fail:
24785 return NULL;
24786 }
24787
24788
24789 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24790 PyObject *resultobj = 0;
24791 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24792 bool result;
24793 void *argp1 = 0 ;
24794 int res1 = 0 ;
24795 PyObject *swig_obj[1] ;
24796
24797 if (!args) SWIG_fail;
24798 swig_obj[0] = args;
24799 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24800 if (!SWIG_IsOK(res1)) {
24801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24802 }
24803 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24804 {
24805 PyThreadState* __tstate = wxPyBeginAllowThreads();
24806 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
24807 wxPyEndAllowThreads(__tstate);
24808 if (PyErr_Occurred()) SWIG_fail;
24809 }
24810 {
24811 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24812 }
24813 return resultobj;
24814 fail:
24815 return NULL;
24816 }
24817
24818
24819 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24820 PyObject *resultobj = 0;
24821 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24822 bool result;
24823 void *argp1 = 0 ;
24824 int res1 = 0 ;
24825 PyObject *swig_obj[1] ;
24826
24827 if (!args) SWIG_fail;
24828 swig_obj[0] = args;
24829 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24830 if (!SWIG_IsOK(res1)) {
24831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24832 }
24833 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24834 {
24835 PyThreadState* __tstate = wxPyBeginAllowThreads();
24836 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
24837 wxPyEndAllowThreads(__tstate);
24838 if (PyErr_Occurred()) SWIG_fail;
24839 }
24840 {
24841 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24842 }
24843 return resultobj;
24844 fail:
24845 return NULL;
24846 }
24847
24848
24849 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24850 PyObject *resultobj = 0;
24851 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24852 bool result;
24853 void *argp1 = 0 ;
24854 int res1 = 0 ;
24855 PyObject *swig_obj[1] ;
24856
24857 if (!args) SWIG_fail;
24858 swig_obj[0] = args;
24859 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24860 if (!SWIG_IsOK(res1)) {
24861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24862 }
24863 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24864 {
24865 PyThreadState* __tstate = wxPyBeginAllowThreads();
24866 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
24867 wxPyEndAllowThreads(__tstate);
24868 if (PyErr_Occurred()) SWIG_fail;
24869 }
24870 {
24871 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24872 }
24873 return resultobj;
24874 fail:
24875 return NULL;
24876 }
24877
24878
24879 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24880 PyObject *resultobj = 0;
24881 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24882 bool result;
24883 void *argp1 = 0 ;
24884 int res1 = 0 ;
24885 PyObject *swig_obj[1] ;
24886
24887 if (!args) SWIG_fail;
24888 swig_obj[0] = args;
24889 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24890 if (!SWIG_IsOK(res1)) {
24891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24892 }
24893 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24894 {
24895 PyThreadState* __tstate = wxPyBeginAllowThreads();
24896 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetShown();
24897 wxPyEndAllowThreads(__tstate);
24898 if (PyErr_Occurred()) SWIG_fail;
24899 }
24900 {
24901 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24902 }
24903 return resultobj;
24904 fail:
24905 return NULL;
24906 }
24907
24908
24909 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24910 PyObject *resultobj = 0;
24911 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24912 bool arg2 ;
24913 void *argp1 = 0 ;
24914 int res1 = 0 ;
24915 bool val2 ;
24916 int ecode2 = 0 ;
24917 PyObject * obj0 = 0 ;
24918 PyObject * obj1 = 0 ;
24919 char * kwnames[] = {
24920 (char *) "self",(char *) "check", NULL
24921 };
24922
24923 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) SWIG_fail;
24924 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24925 if (!SWIG_IsOK(res1)) {
24926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Check" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
24927 }
24928 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24929 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24930 if (!SWIG_IsOK(ecode2)) {
24931 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Check" "', expected argument " "2"" of type '" "bool""'");
24932 }
24933 arg2 = static_cast< bool >(val2);
24934 {
24935 PyThreadState* __tstate = wxPyBeginAllowThreads();
24936 (arg1)->Check(arg2);
24937 wxPyEndAllowThreads(__tstate);
24938 if (PyErr_Occurred()) SWIG_fail;
24939 }
24940 resultobj = SWIG_Py_Void();
24941 return resultobj;
24942 fail:
24943 return NULL;
24944 }
24945
24946
24947 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24948 PyObject *resultobj = 0;
24949 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24950 bool arg2 ;
24951 void *argp1 = 0 ;
24952 int res1 = 0 ;
24953 bool val2 ;
24954 int ecode2 = 0 ;
24955 PyObject * obj0 = 0 ;
24956 PyObject * obj1 = 0 ;
24957 char * kwnames[] = {
24958 (char *) "self",(char *) "enable", NULL
24959 };
24960
24961 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
24962 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24963 if (!SWIG_IsOK(res1)) {
24964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Enable" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
24965 }
24966 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24967 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24968 if (!SWIG_IsOK(ecode2)) {
24969 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Enable" "', expected argument " "2"" of type '" "bool""'");
24970 }
24971 arg2 = static_cast< bool >(val2);
24972 {
24973 PyThreadState* __tstate = wxPyBeginAllowThreads();
24974 (arg1)->Enable(arg2);
24975 wxPyEndAllowThreads(__tstate);
24976 if (PyErr_Occurred()) SWIG_fail;
24977 }
24978 resultobj = SWIG_Py_Void();
24979 return resultobj;
24980 fail:
24981 return NULL;
24982 }
24983
24984
24985 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24986 PyObject *resultobj = 0;
24987 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24988 bool arg2 ;
24989 void *argp1 = 0 ;
24990 int res1 = 0 ;
24991 bool val2 ;
24992 int ecode2 = 0 ;
24993 PyObject * obj0 = 0 ;
24994 PyObject * obj1 = 0 ;
24995 char * kwnames[] = {
24996 (char *) "self",(char *) "show", NULL
24997 };
24998
24999 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Show",kwnames,&obj0,&obj1)) SWIG_fail;
25000 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25001 if (!SWIG_IsOK(res1)) {
25002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Show" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25003 }
25004 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25005 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25006 if (!SWIG_IsOK(ecode2)) {
25007 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Show" "', expected argument " "2"" of type '" "bool""'");
25008 }
25009 arg2 = static_cast< bool >(val2);
25010 {
25011 PyThreadState* __tstate = wxPyBeginAllowThreads();
25012 (arg1)->Show(arg2);
25013 wxPyEndAllowThreads(__tstate);
25014 if (PyErr_Occurred()) SWIG_fail;
25015 }
25016 resultobj = SWIG_Py_Void();
25017 return resultobj;
25018 fail:
25019 return NULL;
25020 }
25021
25022
25023 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25024 PyObject *resultobj = 0;
25025 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25026 wxString *arg2 = 0 ;
25027 void *argp1 = 0 ;
25028 int res1 = 0 ;
25029 bool temp2 = false ;
25030 PyObject * obj0 = 0 ;
25031 PyObject * obj1 = 0 ;
25032 char * kwnames[] = {
25033 (char *) "self",(char *) "text", NULL
25034 };
25035
25036 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
25037 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25038 if (!SWIG_IsOK(res1)) {
25039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_SetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25040 }
25041 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25042 {
25043 arg2 = wxString_in_helper(obj1);
25044 if (arg2 == NULL) SWIG_fail;
25045 temp2 = true;
25046 }
25047 {
25048 PyThreadState* __tstate = wxPyBeginAllowThreads();
25049 (arg1)->SetText((wxString const &)*arg2);
25050 wxPyEndAllowThreads(__tstate);
25051 if (PyErr_Occurred()) SWIG_fail;
25052 }
25053 resultobj = SWIG_Py_Void();
25054 {
25055 if (temp2)
25056 delete arg2;
25057 }
25058 return resultobj;
25059 fail:
25060 {
25061 if (temp2)
25062 delete arg2;
25063 }
25064 return NULL;
25065 }
25066
25067
25068 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25069 PyObject *resultobj = 0;
25070 long arg1 ;
25071 long val1 ;
25072 int ecode1 = 0 ;
25073 PyObject * obj0 = 0 ;
25074 char * kwnames[] = {
25075 (char *) "updateInterval", NULL
25076 };
25077
25078 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) SWIG_fail;
25079 ecode1 = SWIG_AsVal_long(obj0, &val1);
25080 if (!SWIG_IsOK(ecode1)) {
25081 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetUpdateInterval" "', expected argument " "1"" of type '" "long""'");
25082 }
25083 arg1 = static_cast< long >(val1);
25084 {
25085 PyThreadState* __tstate = wxPyBeginAllowThreads();
25086 wxUpdateUIEvent::SetUpdateInterval(arg1);
25087 wxPyEndAllowThreads(__tstate);
25088 if (PyErr_Occurred()) SWIG_fail;
25089 }
25090 resultobj = SWIG_Py_Void();
25091 return resultobj;
25092 fail:
25093 return NULL;
25094 }
25095
25096
25097 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25098 PyObject *resultobj = 0;
25099 long result;
25100
25101 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetUpdateInterval",0,0,0)) SWIG_fail;
25102 {
25103 PyThreadState* __tstate = wxPyBeginAllowThreads();
25104 result = (long)wxUpdateUIEvent::GetUpdateInterval();
25105 wxPyEndAllowThreads(__tstate);
25106 if (PyErr_Occurred()) SWIG_fail;
25107 }
25108 resultobj = SWIG_From_long(static_cast< long >(result));
25109 return resultobj;
25110 fail:
25111 return NULL;
25112 }
25113
25114
25115 SWIGINTERN PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25116 PyObject *resultobj = 0;
25117 wxWindow *arg1 = (wxWindow *) 0 ;
25118 bool result;
25119 void *argp1 = 0 ;
25120 int res1 = 0 ;
25121 PyObject * obj0 = 0 ;
25122 char * kwnames[] = {
25123 (char *) "win", NULL
25124 };
25125
25126 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) SWIG_fail;
25127 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
25128 if (!SWIG_IsOK(res1)) {
25129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_CanUpdate" "', expected argument " "1"" of type '" "wxWindow *""'");
25130 }
25131 arg1 = reinterpret_cast< wxWindow * >(argp1);
25132 {
25133 PyThreadState* __tstate = wxPyBeginAllowThreads();
25134 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
25135 wxPyEndAllowThreads(__tstate);
25136 if (PyErr_Occurred()) SWIG_fail;
25137 }
25138 {
25139 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25140 }
25141 return resultobj;
25142 fail:
25143 return NULL;
25144 }
25145
25146
25147 SWIGINTERN PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25148 PyObject *resultobj = 0;
25149
25150 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_ResetUpdateTime",0,0,0)) SWIG_fail;
25151 {
25152 PyThreadState* __tstate = wxPyBeginAllowThreads();
25153 wxUpdateUIEvent::ResetUpdateTime();
25154 wxPyEndAllowThreads(__tstate);
25155 if (PyErr_Occurred()) SWIG_fail;
25156 }
25157 resultobj = SWIG_Py_Void();
25158 return resultobj;
25159 fail:
25160 return NULL;
25161 }
25162
25163
25164 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25165 PyObject *resultobj = 0;
25166 wxUpdateUIMode arg1 ;
25167 int val1 ;
25168 int ecode1 = 0 ;
25169 PyObject * obj0 = 0 ;
25170 char * kwnames[] = {
25171 (char *) "mode", NULL
25172 };
25173
25174 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) SWIG_fail;
25175 ecode1 = SWIG_AsVal_int(obj0, &val1);
25176 if (!SWIG_IsOK(ecode1)) {
25177 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetMode" "', expected argument " "1"" of type '" "wxUpdateUIMode""'");
25178 }
25179 arg1 = static_cast< wxUpdateUIMode >(val1);
25180 {
25181 PyThreadState* __tstate = wxPyBeginAllowThreads();
25182 wxUpdateUIEvent::SetMode(arg1);
25183 wxPyEndAllowThreads(__tstate);
25184 if (PyErr_Occurred()) SWIG_fail;
25185 }
25186 resultobj = SWIG_Py_Void();
25187 return resultobj;
25188 fail:
25189 return NULL;
25190 }
25191
25192
25193 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25194 PyObject *resultobj = 0;
25195 wxUpdateUIMode result;
25196
25197 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetMode",0,0,0)) SWIG_fail;
25198 {
25199 PyThreadState* __tstate = wxPyBeginAllowThreads();
25200 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
25201 wxPyEndAllowThreads(__tstate);
25202 if (PyErr_Occurred()) SWIG_fail;
25203 }
25204 resultobj = SWIG_From_int(static_cast< int >(result));
25205 return resultobj;
25206 fail:
25207 return NULL;
25208 }
25209
25210
25211 SWIGINTERN PyObject *UpdateUIEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25212 PyObject *obj;
25213 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25214 SWIG_TypeNewClientData(SWIGTYPE_p_wxUpdateUIEvent, SWIG_NewClientData(obj));
25215 return SWIG_Py_Void();
25216 }
25217
25218 SWIGINTERN PyObject *UpdateUIEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25219 return SWIG_Python_InitShadowInstance(args);
25220 }
25221
25222 SWIGINTERN PyObject *_wrap_new_SysColourChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25223 PyObject *resultobj = 0;
25224 wxSysColourChangedEvent *result = 0 ;
25225
25226 if (!SWIG_Python_UnpackTuple(args,"new_SysColourChangedEvent",0,0,0)) SWIG_fail;
25227 {
25228 PyThreadState* __tstate = wxPyBeginAllowThreads();
25229 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
25230 wxPyEndAllowThreads(__tstate);
25231 if (PyErr_Occurred()) SWIG_fail;
25232 }
25233 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSysColourChangedEvent, SWIG_POINTER_NEW | 0 );
25234 return resultobj;
25235 fail:
25236 return NULL;
25237 }
25238
25239
25240 SWIGINTERN PyObject *SysColourChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25241 PyObject *obj;
25242 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25243 SWIG_TypeNewClientData(SWIGTYPE_p_wxSysColourChangedEvent, SWIG_NewClientData(obj));
25244 return SWIG_Py_Void();
25245 }
25246
25247 SWIGINTERN PyObject *SysColourChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25248 return SWIG_Python_InitShadowInstance(args);
25249 }
25250
25251 SWIGINTERN PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25252 PyObject *resultobj = 0;
25253 int arg1 = (int) 0 ;
25254 wxWindow *arg2 = (wxWindow *) NULL ;
25255 wxMouseCaptureChangedEvent *result = 0 ;
25256 int val1 ;
25257 int ecode1 = 0 ;
25258 void *argp2 = 0 ;
25259 int res2 = 0 ;
25260 PyObject * obj0 = 0 ;
25261 PyObject * obj1 = 0 ;
25262 char * kwnames[] = {
25263 (char *) "winid",(char *) "gainedCapture", NULL
25264 };
25265
25266 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) SWIG_fail;
25267 if (obj0) {
25268 ecode1 = SWIG_AsVal_int(obj0, &val1);
25269 if (!SWIG_IsOK(ecode1)) {
25270 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "1"" of type '" "int""'");
25271 }
25272 arg1 = static_cast< int >(val1);
25273 }
25274 if (obj1) {
25275 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25276 if (!SWIG_IsOK(res2)) {
25277 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "2"" of type '" "wxWindow *""'");
25278 }
25279 arg2 = reinterpret_cast< wxWindow * >(argp2);
25280 }
25281 {
25282 PyThreadState* __tstate = wxPyBeginAllowThreads();
25283 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
25284 wxPyEndAllowThreads(__tstate);
25285 if (PyErr_Occurred()) SWIG_fail;
25286 }
25287 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_NEW | 0 );
25288 return resultobj;
25289 fail:
25290 return NULL;
25291 }
25292
25293
25294 SWIGINTERN PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25295 PyObject *resultobj = 0;
25296 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
25297 wxWindow *result = 0 ;
25298 void *argp1 = 0 ;
25299 int res1 = 0 ;
25300 PyObject *swig_obj[1] ;
25301
25302 if (!args) SWIG_fail;
25303 swig_obj[0] = args;
25304 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseCaptureChangedEvent, 0 | 0 );
25305 if (!SWIG_IsOK(res1)) {
25306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseCaptureChangedEvent_GetCapturedWindow" "', expected argument " "1"" of type '" "wxMouseCaptureChangedEvent const *""'");
25307 }
25308 arg1 = reinterpret_cast< wxMouseCaptureChangedEvent * >(argp1);
25309 {
25310 PyThreadState* __tstate = wxPyBeginAllowThreads();
25311 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
25312 wxPyEndAllowThreads(__tstate);
25313 if (PyErr_Occurred()) SWIG_fail;
25314 }
25315 {
25316 resultobj = wxPyMake_wxObject(result, (bool)0);
25317 }
25318 return resultobj;
25319 fail:
25320 return NULL;
25321 }
25322
25323
25324 SWIGINTERN PyObject *MouseCaptureChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25325 PyObject *obj;
25326 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25327 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_NewClientData(obj));
25328 return SWIG_Py_Void();
25329 }
25330
25331 SWIGINTERN PyObject *MouseCaptureChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25332 return SWIG_Python_InitShadowInstance(args);
25333 }
25334
25335 SWIGINTERN PyObject *_wrap_new_DisplayChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25336 PyObject *resultobj = 0;
25337 wxDisplayChangedEvent *result = 0 ;
25338
25339 if (!SWIG_Python_UnpackTuple(args,"new_DisplayChangedEvent",0,0,0)) SWIG_fail;
25340 {
25341 PyThreadState* __tstate = wxPyBeginAllowThreads();
25342 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
25343 wxPyEndAllowThreads(__tstate);
25344 if (PyErr_Occurred()) SWIG_fail;
25345 }
25346 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplayChangedEvent, SWIG_POINTER_NEW | 0 );
25347 return resultobj;
25348 fail:
25349 return NULL;
25350 }
25351
25352
25353 SWIGINTERN PyObject *DisplayChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25354 PyObject *obj;
25355 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25356 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplayChangedEvent, SWIG_NewClientData(obj));
25357 return SWIG_Py_Void();
25358 }
25359
25360 SWIGINTERN PyObject *DisplayChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25361 return SWIG_Python_InitShadowInstance(args);
25362 }
25363
25364 SWIGINTERN PyObject *_wrap_new_PaletteChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25365 PyObject *resultobj = 0;
25366 int arg1 = (int) 0 ;
25367 wxPaletteChangedEvent *result = 0 ;
25368 int val1 ;
25369 int ecode1 = 0 ;
25370 PyObject * obj0 = 0 ;
25371 char * kwnames[] = {
25372 (char *) "id", NULL
25373 };
25374
25375 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) SWIG_fail;
25376 if (obj0) {
25377 ecode1 = SWIG_AsVal_int(obj0, &val1);
25378 if (!SWIG_IsOK(ecode1)) {
25379 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaletteChangedEvent" "', expected argument " "1"" of type '" "int""'");
25380 }
25381 arg1 = static_cast< int >(val1);
25382 }
25383 {
25384 PyThreadState* __tstate = wxPyBeginAllowThreads();
25385 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
25386 wxPyEndAllowThreads(__tstate);
25387 if (PyErr_Occurred()) SWIG_fail;
25388 }
25389 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_NEW | 0 );
25390 return resultobj;
25391 fail:
25392 return NULL;
25393 }
25394
25395
25396 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25397 PyObject *resultobj = 0;
25398 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25399 wxWindow *arg2 = (wxWindow *) 0 ;
25400 void *argp1 = 0 ;
25401 int res1 = 0 ;
25402 void *argp2 = 0 ;
25403 int res2 = 0 ;
25404 PyObject * obj0 = 0 ;
25405 PyObject * obj1 = 0 ;
25406 char * kwnames[] = {
25407 (char *) "self",(char *) "win", NULL
25408 };
25409
25410 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) SWIG_fail;
25411 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25412 if (!SWIG_IsOK(res1)) {
25413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25414 }
25415 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25416 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25417 if (!SWIG_IsOK(res2)) {
25418 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
25419 }
25420 arg2 = reinterpret_cast< wxWindow * >(argp2);
25421 {
25422 PyThreadState* __tstate = wxPyBeginAllowThreads();
25423 (arg1)->SetChangedWindow(arg2);
25424 wxPyEndAllowThreads(__tstate);
25425 if (PyErr_Occurred()) SWIG_fail;
25426 }
25427 resultobj = SWIG_Py_Void();
25428 return resultobj;
25429 fail:
25430 return NULL;
25431 }
25432
25433
25434 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25435 PyObject *resultobj = 0;
25436 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25437 wxWindow *result = 0 ;
25438 void *argp1 = 0 ;
25439 int res1 = 0 ;
25440 PyObject *swig_obj[1] ;
25441
25442 if (!args) SWIG_fail;
25443 swig_obj[0] = args;
25444 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25445 if (!SWIG_IsOK(res1)) {
25446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_GetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25447 }
25448 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25449 {
25450 PyThreadState* __tstate = wxPyBeginAllowThreads();
25451 result = (wxWindow *)(arg1)->GetChangedWindow();
25452 wxPyEndAllowThreads(__tstate);
25453 if (PyErr_Occurred()) SWIG_fail;
25454 }
25455 {
25456 resultobj = wxPyMake_wxObject(result, (bool)0);
25457 }
25458 return resultobj;
25459 fail:
25460 return NULL;
25461 }
25462
25463
25464 SWIGINTERN PyObject *PaletteChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25465 PyObject *obj;
25466 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25467 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaletteChangedEvent, SWIG_NewClientData(obj));
25468 return SWIG_Py_Void();
25469 }
25470
25471 SWIGINTERN PyObject *PaletteChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25472 return SWIG_Python_InitShadowInstance(args);
25473 }
25474
25475 SWIGINTERN PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25476 PyObject *resultobj = 0;
25477 int arg1 = (int) 0 ;
25478 wxQueryNewPaletteEvent *result = 0 ;
25479 int val1 ;
25480 int ecode1 = 0 ;
25481 PyObject * obj0 = 0 ;
25482 char * kwnames[] = {
25483 (char *) "winid", NULL
25484 };
25485
25486 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) SWIG_fail;
25487 if (obj0) {
25488 ecode1 = SWIG_AsVal_int(obj0, &val1);
25489 if (!SWIG_IsOK(ecode1)) {
25490 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_QueryNewPaletteEvent" "', expected argument " "1"" of type '" "int""'");
25491 }
25492 arg1 = static_cast< int >(val1);
25493 }
25494 {
25495 PyThreadState* __tstate = wxPyBeginAllowThreads();
25496 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
25497 wxPyEndAllowThreads(__tstate);
25498 if (PyErr_Occurred()) SWIG_fail;
25499 }
25500 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_NEW | 0 );
25501 return resultobj;
25502 fail:
25503 return NULL;
25504 }
25505
25506
25507 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25508 PyObject *resultobj = 0;
25509 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
25510 bool arg2 ;
25511 void *argp1 = 0 ;
25512 int res1 = 0 ;
25513 bool val2 ;
25514 int ecode2 = 0 ;
25515 PyObject * obj0 = 0 ;
25516 PyObject * obj1 = 0 ;
25517 char * kwnames[] = {
25518 (char *) "self",(char *) "realized", NULL
25519 };
25520
25521 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) SWIG_fail;
25522 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
25523 if (!SWIG_IsOK(res1)) {
25524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent *""'");
25525 }
25526 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
25527 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25528 if (!SWIG_IsOK(ecode2)) {
25529 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "2"" of type '" "bool""'");
25530 }
25531 arg2 = static_cast< bool >(val2);
25532 {
25533 PyThreadState* __tstate = wxPyBeginAllowThreads();
25534 (arg1)->SetPaletteRealized(arg2);
25535 wxPyEndAllowThreads(__tstate);
25536 if (PyErr_Occurred()) SWIG_fail;
25537 }
25538 resultobj = SWIG_Py_Void();
25539 return resultobj;
25540 fail:
25541 return NULL;
25542 }
25543
25544
25545 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25546 PyObject *resultobj = 0;
25547 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
25548 bool result;
25549 void *argp1 = 0 ;
25550 int res1 = 0 ;
25551 PyObject *swig_obj[1] ;
25552
25553 if (!args) SWIG_fail;
25554 swig_obj[0] = args;
25555 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
25556 if (!SWIG_IsOK(res1)) {
25557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_GetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent const *""'");
25558 }
25559 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
25560 {
25561 PyThreadState* __tstate = wxPyBeginAllowThreads();
25562 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
25563 wxPyEndAllowThreads(__tstate);
25564 if (PyErr_Occurred()) SWIG_fail;
25565 }
25566 {
25567 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25568 }
25569 return resultobj;
25570 fail:
25571 return NULL;
25572 }
25573
25574
25575 SWIGINTERN PyObject *QueryNewPaletteEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25576 PyObject *obj;
25577 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25578 SWIG_TypeNewClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_NewClientData(obj));
25579 return SWIG_Py_Void();
25580 }
25581
25582 SWIGINTERN PyObject *QueryNewPaletteEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25583 return SWIG_Python_InitShadowInstance(args);
25584 }
25585
25586 SWIGINTERN PyObject *_wrap_new_NavigationKeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25587 PyObject *resultobj = 0;
25588 wxNavigationKeyEvent *result = 0 ;
25589
25590 if (!SWIG_Python_UnpackTuple(args,"new_NavigationKeyEvent",0,0,0)) SWIG_fail;
25591 {
25592 PyThreadState* __tstate = wxPyBeginAllowThreads();
25593 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
25594 wxPyEndAllowThreads(__tstate);
25595 if (PyErr_Occurred()) SWIG_fail;
25596 }
25597 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_NEW | 0 );
25598 return resultobj;
25599 fail:
25600 return NULL;
25601 }
25602
25603
25604 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25605 PyObject *resultobj = 0;
25606 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25607 bool result;
25608 void *argp1 = 0 ;
25609 int res1 = 0 ;
25610 PyObject *swig_obj[1] ;
25611
25612 if (!args) SWIG_fail;
25613 swig_obj[0] = args;
25614 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25615 if (!SWIG_IsOK(res1)) {
25616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25617 }
25618 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25619 {
25620 PyThreadState* __tstate = wxPyBeginAllowThreads();
25621 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
25622 wxPyEndAllowThreads(__tstate);
25623 if (PyErr_Occurred()) SWIG_fail;
25624 }
25625 {
25626 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25627 }
25628 return resultobj;
25629 fail:
25630 return NULL;
25631 }
25632
25633
25634 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25635 PyObject *resultobj = 0;
25636 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25637 bool arg2 ;
25638 void *argp1 = 0 ;
25639 int res1 = 0 ;
25640 bool val2 ;
25641 int ecode2 = 0 ;
25642 PyObject * obj0 = 0 ;
25643 PyObject * obj1 = 0 ;
25644 char * kwnames[] = {
25645 (char *) "self",(char *) "forward", NULL
25646 };
25647
25648 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) SWIG_fail;
25649 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25650 if (!SWIG_IsOK(res1)) {
25651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25652 }
25653 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25654 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25655 if (!SWIG_IsOK(ecode2)) {
25656 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "2"" of type '" "bool""'");
25657 }
25658 arg2 = static_cast< bool >(val2);
25659 {
25660 PyThreadState* __tstate = wxPyBeginAllowThreads();
25661 (arg1)->SetDirection(arg2);
25662 wxPyEndAllowThreads(__tstate);
25663 if (PyErr_Occurred()) SWIG_fail;
25664 }
25665 resultobj = SWIG_Py_Void();
25666 return resultobj;
25667 fail:
25668 return NULL;
25669 }
25670
25671
25672 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25673 PyObject *resultobj = 0;
25674 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25675 bool result;
25676 void *argp1 = 0 ;
25677 int res1 = 0 ;
25678 PyObject *swig_obj[1] ;
25679
25680 if (!args) SWIG_fail;
25681 swig_obj[0] = args;
25682 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25683 if (!SWIG_IsOK(res1)) {
25684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25685 }
25686 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25687 {
25688 PyThreadState* __tstate = wxPyBeginAllowThreads();
25689 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
25690 wxPyEndAllowThreads(__tstate);
25691 if (PyErr_Occurred()) SWIG_fail;
25692 }
25693 {
25694 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25695 }
25696 return resultobj;
25697 fail:
25698 return NULL;
25699 }
25700
25701
25702 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25703 PyObject *resultobj = 0;
25704 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25705 bool arg2 ;
25706 void *argp1 = 0 ;
25707 int res1 = 0 ;
25708 bool val2 ;
25709 int ecode2 = 0 ;
25710 PyObject * obj0 = 0 ;
25711 PyObject * obj1 = 0 ;
25712 char * kwnames[] = {
25713 (char *) "self",(char *) "ischange", NULL
25714 };
25715
25716 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) SWIG_fail;
25717 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25718 if (!SWIG_IsOK(res1)) {
25719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25720 }
25721 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25722 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25723 if (!SWIG_IsOK(ecode2)) {
25724 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "2"" of type '" "bool""'");
25725 }
25726 arg2 = static_cast< bool >(val2);
25727 {
25728 PyThreadState* __tstate = wxPyBeginAllowThreads();
25729 (arg1)->SetWindowChange(arg2);
25730 wxPyEndAllowThreads(__tstate);
25731 if (PyErr_Occurred()) SWIG_fail;
25732 }
25733 resultobj = SWIG_Py_Void();
25734 return resultobj;
25735 fail:
25736 return NULL;
25737 }
25738
25739
25740 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25741 PyObject *resultobj = 0;
25742 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25743 bool result;
25744 void *argp1 = 0 ;
25745 int res1 = 0 ;
25746 PyObject *swig_obj[1] ;
25747
25748 if (!args) SWIG_fail;
25749 swig_obj[0] = args;
25750 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25751 if (!SWIG_IsOK(res1)) {
25752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25753 }
25754 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25755 {
25756 PyThreadState* __tstate = wxPyBeginAllowThreads();
25757 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
25758 wxPyEndAllowThreads(__tstate);
25759 if (PyErr_Occurred()) SWIG_fail;
25760 }
25761 {
25762 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25763 }
25764 return resultobj;
25765 fail:
25766 return NULL;
25767 }
25768
25769
25770 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25771 PyObject *resultobj = 0;
25772 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25773 bool arg2 ;
25774 void *argp1 = 0 ;
25775 int res1 = 0 ;
25776 bool val2 ;
25777 int ecode2 = 0 ;
25778 PyObject * obj0 = 0 ;
25779 PyObject * obj1 = 0 ;
25780 char * kwnames[] = {
25781 (char *) "self",(char *) "bIs", NULL
25782 };
25783
25784 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) SWIG_fail;
25785 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25786 if (!SWIG_IsOK(res1)) {
25787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25788 }
25789 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25790 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25791 if (!SWIG_IsOK(ecode2)) {
25792 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "2"" of type '" "bool""'");
25793 }
25794 arg2 = static_cast< bool >(val2);
25795 {
25796 PyThreadState* __tstate = wxPyBeginAllowThreads();
25797 (arg1)->SetFromTab(arg2);
25798 wxPyEndAllowThreads(__tstate);
25799 if (PyErr_Occurred()) SWIG_fail;
25800 }
25801 resultobj = SWIG_Py_Void();
25802 return resultobj;
25803 fail:
25804 return NULL;
25805 }
25806
25807
25808 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25809 PyObject *resultobj = 0;
25810 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25811 long arg2 ;
25812 void *argp1 = 0 ;
25813 int res1 = 0 ;
25814 long val2 ;
25815 int ecode2 = 0 ;
25816 PyObject * obj0 = 0 ;
25817 PyObject * obj1 = 0 ;
25818 char * kwnames[] = {
25819 (char *) "self",(char *) "flags", NULL
25820 };
25821
25822 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) SWIG_fail;
25823 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25824 if (!SWIG_IsOK(res1)) {
25825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25826 }
25827 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25828 ecode2 = SWIG_AsVal_long(obj1, &val2);
25829 if (!SWIG_IsOK(ecode2)) {
25830 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "2"" of type '" "long""'");
25831 }
25832 arg2 = static_cast< long >(val2);
25833 {
25834 PyThreadState* __tstate = wxPyBeginAllowThreads();
25835 (arg1)->SetFlags(arg2);
25836 wxPyEndAllowThreads(__tstate);
25837 if (PyErr_Occurred()) SWIG_fail;
25838 }
25839 resultobj = SWIG_Py_Void();
25840 return resultobj;
25841 fail:
25842 return NULL;
25843 }
25844
25845
25846 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25847 PyObject *resultobj = 0;
25848 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25849 wxWindow *result = 0 ;
25850 void *argp1 = 0 ;
25851 int res1 = 0 ;
25852 PyObject *swig_obj[1] ;
25853
25854 if (!args) SWIG_fail;
25855 swig_obj[0] = args;
25856 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25857 if (!SWIG_IsOK(res1)) {
25858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25859 }
25860 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25861 {
25862 PyThreadState* __tstate = wxPyBeginAllowThreads();
25863 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
25864 wxPyEndAllowThreads(__tstate);
25865 if (PyErr_Occurred()) SWIG_fail;
25866 }
25867 {
25868 resultobj = wxPyMake_wxObject(result, (bool)0);
25869 }
25870 return resultobj;
25871 fail:
25872 return NULL;
25873 }
25874
25875
25876 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25877 PyObject *resultobj = 0;
25878 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25879 wxWindow *arg2 = (wxWindow *) 0 ;
25880 void *argp1 = 0 ;
25881 int res1 = 0 ;
25882 void *argp2 = 0 ;
25883 int res2 = 0 ;
25884 PyObject * obj0 = 0 ;
25885 PyObject * obj1 = 0 ;
25886 char * kwnames[] = {
25887 (char *) "self",(char *) "win", NULL
25888 };
25889
25890 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) SWIG_fail;
25891 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25892 if (!SWIG_IsOK(res1)) {
25893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25894 }
25895 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25896 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25897 if (!SWIG_IsOK(res2)) {
25898 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "2"" of type '" "wxWindow *""'");
25899 }
25900 arg2 = reinterpret_cast< wxWindow * >(argp2);
25901 {
25902 PyThreadState* __tstate = wxPyBeginAllowThreads();
25903 (arg1)->SetCurrentFocus(arg2);
25904 wxPyEndAllowThreads(__tstate);
25905 if (PyErr_Occurred()) SWIG_fail;
25906 }
25907 resultobj = SWIG_Py_Void();
25908 return resultobj;
25909 fail:
25910 return NULL;
25911 }
25912
25913
25914 SWIGINTERN PyObject *NavigationKeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25915 PyObject *obj;
25916 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25917 SWIG_TypeNewClientData(SWIGTYPE_p_wxNavigationKeyEvent, SWIG_NewClientData(obj));
25918 return SWIG_Py_Void();
25919 }
25920
25921 SWIGINTERN PyObject *NavigationKeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25922 return SWIG_Python_InitShadowInstance(args);
25923 }
25924
25925 SWIGINTERN PyObject *_wrap_new_WindowCreateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25926 PyObject *resultobj = 0;
25927 wxWindow *arg1 = (wxWindow *) NULL ;
25928 wxWindowCreateEvent *result = 0 ;
25929 void *argp1 = 0 ;
25930 int res1 = 0 ;
25931 PyObject * obj0 = 0 ;
25932 char * kwnames[] = {
25933 (char *) "win", NULL
25934 };
25935
25936 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) SWIG_fail;
25937 if (obj0) {
25938 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
25939 if (!SWIG_IsOK(res1)) {
25940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowCreateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
25941 }
25942 arg1 = reinterpret_cast< wxWindow * >(argp1);
25943 }
25944 {
25945 PyThreadState* __tstate = wxPyBeginAllowThreads();
25946 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
25947 wxPyEndAllowThreads(__tstate);
25948 if (PyErr_Occurred()) SWIG_fail;
25949 }
25950 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_NEW | 0 );
25951 return resultobj;
25952 fail:
25953 return NULL;
25954 }
25955
25956
25957 SWIGINTERN PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25958 PyObject *resultobj = 0;
25959 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
25960 wxWindow *result = 0 ;
25961 void *argp1 = 0 ;
25962 int res1 = 0 ;
25963 PyObject *swig_obj[1] ;
25964
25965 if (!args) SWIG_fail;
25966 swig_obj[0] = args;
25967 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowCreateEvent, 0 | 0 );
25968 if (!SWIG_IsOK(res1)) {
25969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowCreateEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowCreateEvent const *""'");
25970 }
25971 arg1 = reinterpret_cast< wxWindowCreateEvent * >(argp1);
25972 {
25973 PyThreadState* __tstate = wxPyBeginAllowThreads();
25974 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
25975 wxPyEndAllowThreads(__tstate);
25976 if (PyErr_Occurred()) SWIG_fail;
25977 }
25978 {
25979 resultobj = wxPyMake_wxObject(result, (bool)0);
25980 }
25981 return resultobj;
25982 fail:
25983 return NULL;
25984 }
25985
25986
25987 SWIGINTERN PyObject *WindowCreateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25988 PyObject *obj;
25989 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25990 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowCreateEvent, SWIG_NewClientData(obj));
25991 return SWIG_Py_Void();
25992 }
25993
25994 SWIGINTERN PyObject *WindowCreateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25995 return SWIG_Python_InitShadowInstance(args);
25996 }
25997
25998 SWIGINTERN PyObject *_wrap_new_WindowDestroyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25999 PyObject *resultobj = 0;
26000 wxWindow *arg1 = (wxWindow *) NULL ;
26001 wxWindowDestroyEvent *result = 0 ;
26002 void *argp1 = 0 ;
26003 int res1 = 0 ;
26004 PyObject * obj0 = 0 ;
26005 char * kwnames[] = {
26006 (char *) "win", NULL
26007 };
26008
26009 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) SWIG_fail;
26010 if (obj0) {
26011 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26012 if (!SWIG_IsOK(res1)) {
26013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDestroyEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26014 }
26015 arg1 = reinterpret_cast< wxWindow * >(argp1);
26016 }
26017 {
26018 PyThreadState* __tstate = wxPyBeginAllowThreads();
26019 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
26020 wxPyEndAllowThreads(__tstate);
26021 if (PyErr_Occurred()) SWIG_fail;
26022 }
26023 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_NEW | 0 );
26024 return resultobj;
26025 fail:
26026 return NULL;
26027 }
26028
26029
26030 SWIGINTERN PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26031 PyObject *resultobj = 0;
26032 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
26033 wxWindow *result = 0 ;
26034 void *argp1 = 0 ;
26035 int res1 = 0 ;
26036 PyObject *swig_obj[1] ;
26037
26038 if (!args) SWIG_fail;
26039 swig_obj[0] = args;
26040 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDestroyEvent, 0 | 0 );
26041 if (!SWIG_IsOK(res1)) {
26042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowDestroyEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowDestroyEvent const *""'");
26043 }
26044 arg1 = reinterpret_cast< wxWindowDestroyEvent * >(argp1);
26045 {
26046 PyThreadState* __tstate = wxPyBeginAllowThreads();
26047 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
26048 wxPyEndAllowThreads(__tstate);
26049 if (PyErr_Occurred()) SWIG_fail;
26050 }
26051 {
26052 resultobj = wxPyMake_wxObject(result, (bool)0);
26053 }
26054 return resultobj;
26055 fail:
26056 return NULL;
26057 }
26058
26059
26060 SWIGINTERN PyObject *WindowDestroyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26061 PyObject *obj;
26062 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26063 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDestroyEvent, SWIG_NewClientData(obj));
26064 return SWIG_Py_Void();
26065 }
26066
26067 SWIGINTERN PyObject *WindowDestroyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26068 return SWIG_Python_InitShadowInstance(args);
26069 }
26070
26071 SWIGINTERN PyObject *_wrap_new_ContextMenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26072 PyObject *resultobj = 0;
26073 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26074 int arg2 = (int) 0 ;
26075 wxPoint const &arg3_defvalue = wxDefaultPosition ;
26076 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
26077 wxContextMenuEvent *result = 0 ;
26078 int val1 ;
26079 int ecode1 = 0 ;
26080 int val2 ;
26081 int ecode2 = 0 ;
26082 wxPoint temp3 ;
26083 PyObject * obj0 = 0 ;
26084 PyObject * obj1 = 0 ;
26085 PyObject * obj2 = 0 ;
26086 char * kwnames[] = {
26087 (char *) "type",(char *) "winid",(char *) "pt", NULL
26088 };
26089
26090 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26091 if (obj0) {
26092 ecode1 = SWIG_AsVal_int(obj0, &val1);
26093 if (!SWIG_IsOK(ecode1)) {
26094 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ContextMenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26095 }
26096 arg1 = static_cast< wxEventType >(val1);
26097 }
26098 if (obj1) {
26099 ecode2 = SWIG_AsVal_int(obj1, &val2);
26100 if (!SWIG_IsOK(ecode2)) {
26101 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ContextMenuEvent" "', expected argument " "2"" of type '" "int""'");
26102 }
26103 arg2 = static_cast< int >(val2);
26104 }
26105 if (obj2) {
26106 {
26107 arg3 = &temp3;
26108 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
26109 }
26110 }
26111 {
26112 PyThreadState* __tstate = wxPyBeginAllowThreads();
26113 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
26114 wxPyEndAllowThreads(__tstate);
26115 if (PyErr_Occurred()) SWIG_fail;
26116 }
26117 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_NEW | 0 );
26118 return resultobj;
26119 fail:
26120 return NULL;
26121 }
26122
26123
26124 SWIGINTERN PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26125 PyObject *resultobj = 0;
26126 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26127 wxPoint *result = 0 ;
26128 void *argp1 = 0 ;
26129 int res1 = 0 ;
26130 PyObject *swig_obj[1] ;
26131
26132 if (!args) SWIG_fail;
26133 swig_obj[0] = args;
26134 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26135 if (!SWIG_IsOK(res1)) {
26136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_GetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent const *""'");
26137 }
26138 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26139 {
26140 PyThreadState* __tstate = wxPyBeginAllowThreads();
26141 {
26142 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
26143 result = (wxPoint *) &_result_ref;
26144 }
26145 wxPyEndAllowThreads(__tstate);
26146 if (PyErr_Occurred()) SWIG_fail;
26147 }
26148 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, 0 | 0 );
26149 return resultobj;
26150 fail:
26151 return NULL;
26152 }
26153
26154
26155 SWIGINTERN PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26156 PyObject *resultobj = 0;
26157 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26158 wxPoint *arg2 = 0 ;
26159 void *argp1 = 0 ;
26160 int res1 = 0 ;
26161 wxPoint temp2 ;
26162 PyObject * obj0 = 0 ;
26163 PyObject * obj1 = 0 ;
26164 char * kwnames[] = {
26165 (char *) "self",(char *) "pos", NULL
26166 };
26167
26168 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
26169 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26170 if (!SWIG_IsOK(res1)) {
26171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_SetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent *""'");
26172 }
26173 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26174 {
26175 arg2 = &temp2;
26176 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
26177 }
26178 {
26179 PyThreadState* __tstate = wxPyBeginAllowThreads();
26180 (arg1)->SetPosition((wxPoint const &)*arg2);
26181 wxPyEndAllowThreads(__tstate);
26182 if (PyErr_Occurred()) SWIG_fail;
26183 }
26184 resultobj = SWIG_Py_Void();
26185 return resultobj;
26186 fail:
26187 return NULL;
26188 }
26189
26190
26191 SWIGINTERN PyObject *ContextMenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26192 PyObject *obj;
26193 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26194 SWIG_TypeNewClientData(SWIGTYPE_p_wxContextMenuEvent, SWIG_NewClientData(obj));
26195 return SWIG_Py_Void();
26196 }
26197
26198 SWIGINTERN PyObject *ContextMenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26199 return SWIG_Python_InitShadowInstance(args);
26200 }
26201
26202 SWIGINTERN PyObject *_wrap_new_IdleEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26203 PyObject *resultobj = 0;
26204 wxIdleEvent *result = 0 ;
26205
26206 if (!SWIG_Python_UnpackTuple(args,"new_IdleEvent",0,0,0)) SWIG_fail;
26207 {
26208 PyThreadState* __tstate = wxPyBeginAllowThreads();
26209 result = (wxIdleEvent *)new wxIdleEvent();
26210 wxPyEndAllowThreads(__tstate);
26211 if (PyErr_Occurred()) SWIG_fail;
26212 }
26213 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_NEW | 0 );
26214 return resultobj;
26215 fail:
26216 return NULL;
26217 }
26218
26219
26220 SWIGINTERN PyObject *_wrap_IdleEvent_RequestMore(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26221 PyObject *resultobj = 0;
26222 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26223 bool arg2 = (bool) true ;
26224 void *argp1 = 0 ;
26225 int res1 = 0 ;
26226 bool val2 ;
26227 int ecode2 = 0 ;
26228 PyObject * obj0 = 0 ;
26229 PyObject * obj1 = 0 ;
26230 char * kwnames[] = {
26231 (char *) "self",(char *) "needMore", NULL
26232 };
26233
26234 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) SWIG_fail;
26235 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26236 if (!SWIG_IsOK(res1)) {
26237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_RequestMore" "', expected argument " "1"" of type '" "wxIdleEvent *""'");
26238 }
26239 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26240 if (obj1) {
26241 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26242 if (!SWIG_IsOK(ecode2)) {
26243 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IdleEvent_RequestMore" "', expected argument " "2"" of type '" "bool""'");
26244 }
26245 arg2 = static_cast< bool >(val2);
26246 }
26247 {
26248 PyThreadState* __tstate = wxPyBeginAllowThreads();
26249 (arg1)->RequestMore(arg2);
26250 wxPyEndAllowThreads(__tstate);
26251 if (PyErr_Occurred()) SWIG_fail;
26252 }
26253 resultobj = SWIG_Py_Void();
26254 return resultobj;
26255 fail:
26256 return NULL;
26257 }
26258
26259
26260 SWIGINTERN PyObject *_wrap_IdleEvent_MoreRequested(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26261 PyObject *resultobj = 0;
26262 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26263 bool result;
26264 void *argp1 = 0 ;
26265 int res1 = 0 ;
26266 PyObject *swig_obj[1] ;
26267
26268 if (!args) SWIG_fail;
26269 swig_obj[0] = args;
26270 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26271 if (!SWIG_IsOK(res1)) {
26272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_MoreRequested" "', expected argument " "1"" of type '" "wxIdleEvent const *""'");
26273 }
26274 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26275 {
26276 PyThreadState* __tstate = wxPyBeginAllowThreads();
26277 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
26278 wxPyEndAllowThreads(__tstate);
26279 if (PyErr_Occurred()) SWIG_fail;
26280 }
26281 {
26282 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26283 }
26284 return resultobj;
26285 fail:
26286 return NULL;
26287 }
26288
26289
26290 SWIGINTERN PyObject *_wrap_IdleEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26291 PyObject *resultobj = 0;
26292 wxIdleMode arg1 ;
26293 int val1 ;
26294 int ecode1 = 0 ;
26295 PyObject * obj0 = 0 ;
26296 char * kwnames[] = {
26297 (char *) "mode", NULL
26298 };
26299
26300 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) SWIG_fail;
26301 ecode1 = SWIG_AsVal_int(obj0, &val1);
26302 if (!SWIG_IsOK(ecode1)) {
26303 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IdleEvent_SetMode" "', expected argument " "1"" of type '" "wxIdleMode""'");
26304 }
26305 arg1 = static_cast< wxIdleMode >(val1);
26306 {
26307 PyThreadState* __tstate = wxPyBeginAllowThreads();
26308 wxIdleEvent::SetMode(arg1);
26309 wxPyEndAllowThreads(__tstate);
26310 if (PyErr_Occurred()) SWIG_fail;
26311 }
26312 resultobj = SWIG_Py_Void();
26313 return resultobj;
26314 fail:
26315 return NULL;
26316 }
26317
26318
26319 SWIGINTERN PyObject *_wrap_IdleEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26320 PyObject *resultobj = 0;
26321 wxIdleMode result;
26322
26323 if (!SWIG_Python_UnpackTuple(args,"IdleEvent_GetMode",0,0,0)) SWIG_fail;
26324 {
26325 PyThreadState* __tstate = wxPyBeginAllowThreads();
26326 result = (wxIdleMode)wxIdleEvent::GetMode();
26327 wxPyEndAllowThreads(__tstate);
26328 if (PyErr_Occurred()) SWIG_fail;
26329 }
26330 resultobj = SWIG_From_int(static_cast< int >(result));
26331 return resultobj;
26332 fail:
26333 return NULL;
26334 }
26335
26336
26337 SWIGINTERN PyObject *_wrap_IdleEvent_CanSend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26338 PyObject *resultobj = 0;
26339 wxWindow *arg1 = (wxWindow *) 0 ;
26340 bool result;
26341 void *argp1 = 0 ;
26342 int res1 = 0 ;
26343 PyObject * obj0 = 0 ;
26344 char * kwnames[] = {
26345 (char *) "win", NULL
26346 };
26347
26348 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) SWIG_fail;
26349 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26350 if (!SWIG_IsOK(res1)) {
26351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_CanSend" "', expected argument " "1"" of type '" "wxWindow *""'");
26352 }
26353 arg1 = reinterpret_cast< wxWindow * >(argp1);
26354 {
26355 PyThreadState* __tstate = wxPyBeginAllowThreads();
26356 result = (bool)wxIdleEvent::CanSend(arg1);
26357 wxPyEndAllowThreads(__tstate);
26358 if (PyErr_Occurred()) SWIG_fail;
26359 }
26360 {
26361 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26362 }
26363 return resultobj;
26364 fail:
26365 return NULL;
26366 }
26367
26368
26369 SWIGINTERN PyObject *IdleEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26370 PyObject *obj;
26371 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26372 SWIG_TypeNewClientData(SWIGTYPE_p_wxIdleEvent, SWIG_NewClientData(obj));
26373 return SWIG_Py_Void();
26374 }
26375
26376 SWIGINTERN PyObject *IdleEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26377 return SWIG_Python_InitShadowInstance(args);
26378 }
26379
26380 SWIGINTERN PyObject *_wrap_new_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26381 PyObject *resultobj = 0;
26382 int arg1 = (int) 0 ;
26383 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
26384 wxPyEvent *result = 0 ;
26385 int val1 ;
26386 int ecode1 = 0 ;
26387 int val2 ;
26388 int ecode2 = 0 ;
26389 PyObject * obj0 = 0 ;
26390 PyObject * obj1 = 0 ;
26391 char * kwnames[] = {
26392 (char *) "winid",(char *) "eventType", NULL
26393 };
26394
26395 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26396 if (obj0) {
26397 ecode1 = SWIG_AsVal_int(obj0, &val1);
26398 if (!SWIG_IsOK(ecode1)) {
26399 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyEvent" "', expected argument " "1"" of type '" "int""'");
26400 }
26401 arg1 = static_cast< int >(val1);
26402 }
26403 if (obj1) {
26404 ecode2 = SWIG_AsVal_int(obj1, &val2);
26405 if (!SWIG_IsOK(ecode2)) {
26406 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyEvent" "', expected argument " "2"" of type '" "wxEventType""'");
26407 }
26408 arg2 = static_cast< wxEventType >(val2);
26409 }
26410 {
26411 PyThreadState* __tstate = wxPyBeginAllowThreads();
26412 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
26413 wxPyEndAllowThreads(__tstate);
26414 if (PyErr_Occurred()) SWIG_fail;
26415 }
26416 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyEvent, SWIG_POINTER_NEW | 0 );
26417 return resultobj;
26418 fail:
26419 return NULL;
26420 }
26421
26422
26423 SWIGINTERN PyObject *_wrap_delete_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26424 PyObject *resultobj = 0;
26425 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26426 void *argp1 = 0 ;
26427 int res1 = 0 ;
26428 PyObject *swig_obj[1] ;
26429
26430 if (!args) SWIG_fail;
26431 swig_obj[0] = args;
26432 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, SWIG_POINTER_DISOWN | 0 );
26433 if (!SWIG_IsOK(res1)) {
26434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyEvent" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26435 }
26436 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26437 {
26438 PyThreadState* __tstate = wxPyBeginAllowThreads();
26439 delete arg1;
26440
26441 wxPyEndAllowThreads(__tstate);
26442 if (PyErr_Occurred()) SWIG_fail;
26443 }
26444 resultobj = SWIG_Py_Void();
26445 return resultobj;
26446 fail:
26447 return NULL;
26448 }
26449
26450
26451 SWIGINTERN PyObject *_wrap_PyEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26452 PyObject *resultobj = 0;
26453 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26454 PyObject *arg2 = (PyObject *) 0 ;
26455 void *argp1 = 0 ;
26456 int res1 = 0 ;
26457 PyObject * obj0 = 0 ;
26458 PyObject * obj1 = 0 ;
26459 char * kwnames[] = {
26460 (char *) "self",(char *) "self", NULL
26461 };
26462
26463 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
26464 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
26465 if (!SWIG_IsOK(res1)) {
26466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26467 }
26468 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26469 arg2 = obj1;
26470 {
26471 PyThreadState* __tstate = wxPyBeginAllowThreads();
26472 (arg1)->SetSelf(arg2);
26473 wxPyEndAllowThreads(__tstate);
26474 if (PyErr_Occurred()) SWIG_fail;
26475 }
26476 resultobj = SWIG_Py_Void();
26477 return resultobj;
26478 fail:
26479 return NULL;
26480 }
26481
26482
26483 SWIGINTERN PyObject *_wrap_PyEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26484 PyObject *resultobj = 0;
26485 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26486 PyObject *result = 0 ;
26487 void *argp1 = 0 ;
26488 int res1 = 0 ;
26489 PyObject *swig_obj[1] ;
26490
26491 if (!args) SWIG_fail;
26492 swig_obj[0] = args;
26493 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
26494 if (!SWIG_IsOK(res1)) {
26495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26496 }
26497 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26498 {
26499 PyThreadState* __tstate = wxPyBeginAllowThreads();
26500 result = (PyObject *)(arg1)->GetSelf();
26501 wxPyEndAllowThreads(__tstate);
26502 if (PyErr_Occurred()) SWIG_fail;
26503 }
26504 resultobj = result;
26505 return resultobj;
26506 fail:
26507 return NULL;
26508 }
26509
26510
26511 SWIGINTERN PyObject *PyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26512 PyObject *obj;
26513 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26514 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyEvent, SWIG_NewClientData(obj));
26515 return SWIG_Py_Void();
26516 }
26517
26518 SWIGINTERN PyObject *PyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26519 return SWIG_Python_InitShadowInstance(args);
26520 }
26521
26522 SWIGINTERN PyObject *_wrap_new_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26523 PyObject *resultobj = 0;
26524 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26525 int arg2 = (int) 0 ;
26526 wxPyCommandEvent *result = 0 ;
26527 int val1 ;
26528 int ecode1 = 0 ;
26529 int val2 ;
26530 int ecode2 = 0 ;
26531 PyObject * obj0 = 0 ;
26532 PyObject * obj1 = 0 ;
26533 char * kwnames[] = {
26534 (char *) "eventType",(char *) "id", NULL
26535 };
26536
26537 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26538 if (obj0) {
26539 ecode1 = SWIG_AsVal_int(obj0, &val1);
26540 if (!SWIG_IsOK(ecode1)) {
26541 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyCommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26542 }
26543 arg1 = static_cast< wxEventType >(val1);
26544 }
26545 if (obj1) {
26546 ecode2 = SWIG_AsVal_int(obj1, &val2);
26547 if (!SWIG_IsOK(ecode2)) {
26548 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyCommandEvent" "', expected argument " "2"" of type '" "int""'");
26549 }
26550 arg2 = static_cast< int >(val2);
26551 }
26552 {
26553 PyThreadState* __tstate = wxPyBeginAllowThreads();
26554 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
26555 wxPyEndAllowThreads(__tstate);
26556 if (PyErr_Occurred()) SWIG_fail;
26557 }
26558 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_NEW | 0 );
26559 return resultobj;
26560 fail:
26561 return NULL;
26562 }
26563
26564
26565 SWIGINTERN PyObject *_wrap_delete_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26566 PyObject *resultobj = 0;
26567 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26568 void *argp1 = 0 ;
26569 int res1 = 0 ;
26570 PyObject *swig_obj[1] ;
26571
26572 if (!args) SWIG_fail;
26573 swig_obj[0] = args;
26574 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_DISOWN | 0 );
26575 if (!SWIG_IsOK(res1)) {
26576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyCommandEvent" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26577 }
26578 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26579 {
26580 PyThreadState* __tstate = wxPyBeginAllowThreads();
26581 delete arg1;
26582
26583 wxPyEndAllowThreads(__tstate);
26584 if (PyErr_Occurred()) SWIG_fail;
26585 }
26586 resultobj = SWIG_Py_Void();
26587 return resultobj;
26588 fail:
26589 return NULL;
26590 }
26591
26592
26593 SWIGINTERN PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26594 PyObject *resultobj = 0;
26595 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26596 PyObject *arg2 = (PyObject *) 0 ;
26597 void *argp1 = 0 ;
26598 int res1 = 0 ;
26599 PyObject * obj0 = 0 ;
26600 PyObject * obj1 = 0 ;
26601 char * kwnames[] = {
26602 (char *) "self",(char *) "self", NULL
26603 };
26604
26605 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
26606 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
26607 if (!SWIG_IsOK(res1)) {
26608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26609 }
26610 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26611 arg2 = obj1;
26612 {
26613 PyThreadState* __tstate = wxPyBeginAllowThreads();
26614 (arg1)->SetSelf(arg2);
26615 wxPyEndAllowThreads(__tstate);
26616 if (PyErr_Occurred()) SWIG_fail;
26617 }
26618 resultobj = SWIG_Py_Void();
26619 return resultobj;
26620 fail:
26621 return NULL;
26622 }
26623
26624
26625 SWIGINTERN PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26626 PyObject *resultobj = 0;
26627 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26628 PyObject *result = 0 ;
26629 void *argp1 = 0 ;
26630 int res1 = 0 ;
26631 PyObject *swig_obj[1] ;
26632
26633 if (!args) SWIG_fail;
26634 swig_obj[0] = args;
26635 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
26636 if (!SWIG_IsOK(res1)) {
26637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26638 }
26639 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26640 {
26641 PyThreadState* __tstate = wxPyBeginAllowThreads();
26642 result = (PyObject *)(arg1)->GetSelf();
26643 wxPyEndAllowThreads(__tstate);
26644 if (PyErr_Occurred()) SWIG_fail;
26645 }
26646 resultobj = result;
26647 return resultobj;
26648 fail:
26649 return NULL;
26650 }
26651
26652
26653 SWIGINTERN PyObject *PyCommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26654 PyObject *obj;
26655 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26656 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyCommandEvent, SWIG_NewClientData(obj));
26657 return SWIG_Py_Void();
26658 }
26659
26660 SWIGINTERN PyObject *PyCommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26661 return SWIG_Python_InitShadowInstance(args);
26662 }
26663
26664 SWIGINTERN PyObject *_wrap_new_DateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26665 PyObject *resultobj = 0;
26666 wxWindow *arg1 = (wxWindow *) 0 ;
26667 wxDateTime *arg2 = 0 ;
26668 wxEventType arg3 ;
26669 wxDateEvent *result = 0 ;
26670 void *argp1 = 0 ;
26671 int res1 = 0 ;
26672 void *argp2 = 0 ;
26673 int res2 = 0 ;
26674 int val3 ;
26675 int ecode3 = 0 ;
26676 PyObject * obj0 = 0 ;
26677 PyObject * obj1 = 0 ;
26678 PyObject * obj2 = 0 ;
26679 char * kwnames[] = {
26680 (char *) "win",(char *) "dt",(char *) "type", NULL
26681 };
26682
26683 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26684 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26685 if (!SWIG_IsOK(res1)) {
26686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26687 }
26688 arg1 = reinterpret_cast< wxWindow * >(argp1);
26689 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26690 if (!SWIG_IsOK(res2)) {
26691 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26692 }
26693 if (!argp2) {
26694 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26695 }
26696 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26697 ecode3 = SWIG_AsVal_int(obj2, &val3);
26698 if (!SWIG_IsOK(ecode3)) {
26699 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateEvent" "', expected argument " "3"" of type '" "wxEventType""'");
26700 }
26701 arg3 = static_cast< wxEventType >(val3);
26702 {
26703 PyThreadState* __tstate = wxPyBeginAllowThreads();
26704 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
26705 wxPyEndAllowThreads(__tstate);
26706 if (PyErr_Occurred()) SWIG_fail;
26707 }
26708 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateEvent, SWIG_POINTER_NEW | 0 );
26709 return resultobj;
26710 fail:
26711 return NULL;
26712 }
26713
26714
26715 SWIGINTERN PyObject *_wrap_DateEvent_GetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26716 PyObject *resultobj = 0;
26717 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
26718 wxDateTime *result = 0 ;
26719 void *argp1 = 0 ;
26720 int res1 = 0 ;
26721 PyObject *swig_obj[1] ;
26722
26723 if (!args) SWIG_fail;
26724 swig_obj[0] = args;
26725 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
26726 if (!SWIG_IsOK(res1)) {
26727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_GetDate" "', expected argument " "1"" of type '" "wxDateEvent const *""'");
26728 }
26729 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
26730 {
26731 PyThreadState* __tstate = wxPyBeginAllowThreads();
26732 {
26733 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
26734 result = (wxDateTime *) &_result_ref;
26735 }
26736 wxPyEndAllowThreads(__tstate);
26737 if (PyErr_Occurred()) SWIG_fail;
26738 }
26739 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26740 return resultobj;
26741 fail:
26742 return NULL;
26743 }
26744
26745
26746 SWIGINTERN PyObject *_wrap_DateEvent_SetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26747 PyObject *resultobj = 0;
26748 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
26749 wxDateTime *arg2 = 0 ;
26750 void *argp1 = 0 ;
26751 int res1 = 0 ;
26752 void *argp2 = 0 ;
26753 int res2 = 0 ;
26754 PyObject * obj0 = 0 ;
26755 PyObject * obj1 = 0 ;
26756 char * kwnames[] = {
26757 (char *) "self",(char *) "date", NULL
26758 };
26759
26760 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) SWIG_fail;
26761 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
26762 if (!SWIG_IsOK(res1)) {
26763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_SetDate" "', expected argument " "1"" of type '" "wxDateEvent *""'");
26764 }
26765 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
26766 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26767 if (!SWIG_IsOK(res2)) {
26768 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26769 }
26770 if (!argp2) {
26771 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26772 }
26773 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26774 {
26775 PyThreadState* __tstate = wxPyBeginAllowThreads();
26776 (arg1)->SetDate((wxDateTime const &)*arg2);
26777 wxPyEndAllowThreads(__tstate);
26778 if (PyErr_Occurred()) SWIG_fail;
26779 }
26780 resultobj = SWIG_Py_Void();
26781 return resultobj;
26782 fail:
26783 return NULL;
26784 }
26785
26786
26787 SWIGINTERN PyObject *DateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26788 PyObject *obj;
26789 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26790 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateEvent, SWIG_NewClientData(obj));
26791 return SWIG_Py_Void();
26792 }
26793
26794 SWIGINTERN PyObject *DateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26795 return SWIG_Python_InitShadowInstance(args);
26796 }
26797
26798 SWIGINTERN PyObject *_wrap_new_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26799 PyObject *resultobj = 0;
26800 wxPyApp *result = 0 ;
26801
26802 if (!SWIG_Python_UnpackTuple(args,"new_PyApp",0,0,0)) SWIG_fail;
26803 {
26804 PyThreadState* __tstate = wxPyBeginAllowThreads();
26805 result = (wxPyApp *)new_wxPyApp();
26806 wxPyEndAllowThreads(__tstate);
26807 if (PyErr_Occurred()) SWIG_fail;
26808 }
26809 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyApp, SWIG_POINTER_NEW | 0 );
26810 return resultobj;
26811 fail:
26812 return NULL;
26813 }
26814
26815
26816 SWIGINTERN PyObject *_wrap_delete_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26817 PyObject *resultobj = 0;
26818 wxPyApp *arg1 = (wxPyApp *) 0 ;
26819 void *argp1 = 0 ;
26820 int res1 = 0 ;
26821 PyObject *swig_obj[1] ;
26822
26823 if (!args) SWIG_fail;
26824 swig_obj[0] = args;
26825 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, SWIG_POINTER_DISOWN | 0 );
26826 if (!SWIG_IsOK(res1)) {
26827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
26828 }
26829 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26830 {
26831 PyThreadState* __tstate = wxPyBeginAllowThreads();
26832 delete arg1;
26833
26834 wxPyEndAllowThreads(__tstate);
26835 if (PyErr_Occurred()) SWIG_fail;
26836 }
26837 resultobj = SWIG_Py_Void();
26838 return resultobj;
26839 fail:
26840 return NULL;
26841 }
26842
26843
26844 SWIGINTERN PyObject *_wrap_PyApp__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26845 PyObject *resultobj = 0;
26846 wxPyApp *arg1 = (wxPyApp *) 0 ;
26847 PyObject *arg2 = (PyObject *) 0 ;
26848 PyObject *arg3 = (PyObject *) 0 ;
26849 bool arg4 ;
26850 void *argp1 = 0 ;
26851 int res1 = 0 ;
26852 bool val4 ;
26853 int ecode4 = 0 ;
26854 PyObject * obj0 = 0 ;
26855 PyObject * obj1 = 0 ;
26856 PyObject * obj2 = 0 ;
26857 PyObject * obj3 = 0 ;
26858 char * kwnames[] = {
26859 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
26860 };
26861
26862 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
26863 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
26864 if (!SWIG_IsOK(res1)) {
26865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyApp *""'");
26866 }
26867 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26868 arg2 = obj1;
26869 arg3 = obj2;
26870 ecode4 = SWIG_AsVal_bool(obj3, &val4);
26871 if (!SWIG_IsOK(ecode4)) {
26872 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyApp__setCallbackInfo" "', expected argument " "4"" of type '" "bool""'");
26873 }
26874 arg4 = static_cast< bool >(val4);
26875 {
26876 PyThreadState* __tstate = wxPyBeginAllowThreads();
26877 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
26878 wxPyEndAllowThreads(__tstate);
26879 if (PyErr_Occurred()) SWIG_fail;
26880 }
26881 resultobj = SWIG_Py_Void();
26882 return resultobj;
26883 fail:
26884 return NULL;
26885 }
26886
26887
26888 SWIGINTERN PyObject *_wrap_PyApp_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26889 PyObject *resultobj = 0;
26890 wxPyApp *arg1 = (wxPyApp *) 0 ;
26891 wxString result;
26892 void *argp1 = 0 ;
26893 int res1 = 0 ;
26894 PyObject *swig_obj[1] ;
26895
26896 if (!args) SWIG_fail;
26897 swig_obj[0] = args;
26898 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
26899 if (!SWIG_IsOK(res1)) {
26900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAppName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
26901 }
26902 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26903 {
26904 PyThreadState* __tstate = wxPyBeginAllowThreads();
26905 result = ((wxPyApp const *)arg1)->GetAppName();
26906 wxPyEndAllowThreads(__tstate);
26907 if (PyErr_Occurred()) SWIG_fail;
26908 }
26909 {
26910 #if wxUSE_UNICODE
26911 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
26912 #else
26913 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
26914 #endif
26915 }
26916 return resultobj;
26917 fail:
26918 return NULL;
26919 }
26920
26921
26922 SWIGINTERN PyObject *_wrap_PyApp_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26923 PyObject *resultobj = 0;
26924 wxPyApp *arg1 = (wxPyApp *) 0 ;
26925 wxString *arg2 = 0 ;
26926 void *argp1 = 0 ;
26927 int res1 = 0 ;
26928 bool temp2 = false ;
26929 PyObject * obj0 = 0 ;
26930 PyObject * obj1 = 0 ;
26931 char * kwnames[] = {
26932 (char *) "self",(char *) "name", NULL
26933 };
26934
26935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
26936 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
26937 if (!SWIG_IsOK(res1)) {
26938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAppName" "', expected argument " "1"" of type '" "wxPyApp *""'");
26939 }
26940 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26941 {
26942 arg2 = wxString_in_helper(obj1);
26943 if (arg2 == NULL) SWIG_fail;
26944 temp2 = true;
26945 }
26946 {
26947 PyThreadState* __tstate = wxPyBeginAllowThreads();
26948 (arg1)->SetAppName((wxString const &)*arg2);
26949 wxPyEndAllowThreads(__tstate);
26950 if (PyErr_Occurred()) SWIG_fail;
26951 }
26952 resultobj = SWIG_Py_Void();
26953 {
26954 if (temp2)
26955 delete arg2;
26956 }
26957 return resultobj;
26958 fail:
26959 {
26960 if (temp2)
26961 delete arg2;
26962 }
26963 return NULL;
26964 }
26965
26966
26967 SWIGINTERN PyObject *_wrap_PyApp_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26968 PyObject *resultobj = 0;
26969 wxPyApp *arg1 = (wxPyApp *) 0 ;
26970 wxString result;
26971 void *argp1 = 0 ;
26972 int res1 = 0 ;
26973 PyObject *swig_obj[1] ;
26974
26975 if (!args) SWIG_fail;
26976 swig_obj[0] = args;
26977 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
26978 if (!SWIG_IsOK(res1)) {
26979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetClassName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
26980 }
26981 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26982 {
26983 PyThreadState* __tstate = wxPyBeginAllowThreads();
26984 result = ((wxPyApp const *)arg1)->GetClassName();
26985 wxPyEndAllowThreads(__tstate);
26986 if (PyErr_Occurred()) SWIG_fail;
26987 }
26988 {
26989 #if wxUSE_UNICODE
26990 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
26991 #else
26992 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
26993 #endif
26994 }
26995 return resultobj;
26996 fail:
26997 return NULL;
26998 }
26999
27000
27001 SWIGINTERN PyObject *_wrap_PyApp_SetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27002 PyObject *resultobj = 0;
27003 wxPyApp *arg1 = (wxPyApp *) 0 ;
27004 wxString *arg2 = 0 ;
27005 void *argp1 = 0 ;
27006 int res1 = 0 ;
27007 bool temp2 = false ;
27008 PyObject * obj0 = 0 ;
27009 PyObject * obj1 = 0 ;
27010 char * kwnames[] = {
27011 (char *) "self",(char *) "name", NULL
27012 };
27013
27014 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) SWIG_fail;
27015 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27016 if (!SWIG_IsOK(res1)) {
27017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetClassName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27018 }
27019 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27020 {
27021 arg2 = wxString_in_helper(obj1);
27022 if (arg2 == NULL) SWIG_fail;
27023 temp2 = true;
27024 }
27025 {
27026 PyThreadState* __tstate = wxPyBeginAllowThreads();
27027 (arg1)->SetClassName((wxString const &)*arg2);
27028 wxPyEndAllowThreads(__tstate);
27029 if (PyErr_Occurred()) SWIG_fail;
27030 }
27031 resultobj = SWIG_Py_Void();
27032 {
27033 if (temp2)
27034 delete arg2;
27035 }
27036 return resultobj;
27037 fail:
27038 {
27039 if (temp2)
27040 delete arg2;
27041 }
27042 return NULL;
27043 }
27044
27045
27046 SWIGINTERN PyObject *_wrap_PyApp_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27047 PyObject *resultobj = 0;
27048 wxPyApp *arg1 = (wxPyApp *) 0 ;
27049 wxString *result = 0 ;
27050 void *argp1 = 0 ;
27051 int res1 = 0 ;
27052 PyObject *swig_obj[1] ;
27053
27054 if (!args) SWIG_fail;
27055 swig_obj[0] = args;
27056 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27057 if (!SWIG_IsOK(res1)) {
27058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetVendorName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27059 }
27060 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27061 {
27062 PyThreadState* __tstate = wxPyBeginAllowThreads();
27063 {
27064 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
27065 result = (wxString *) &_result_ref;
27066 }
27067 wxPyEndAllowThreads(__tstate);
27068 if (PyErr_Occurred()) SWIG_fail;
27069 }
27070 {
27071 #if wxUSE_UNICODE
27072 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
27073 #else
27074 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
27075 #endif
27076 }
27077 return resultobj;
27078 fail:
27079 return NULL;
27080 }
27081
27082
27083 SWIGINTERN PyObject *_wrap_PyApp_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27084 PyObject *resultobj = 0;
27085 wxPyApp *arg1 = (wxPyApp *) 0 ;
27086 wxString *arg2 = 0 ;
27087 void *argp1 = 0 ;
27088 int res1 = 0 ;
27089 bool temp2 = false ;
27090 PyObject * obj0 = 0 ;
27091 PyObject * obj1 = 0 ;
27092 char * kwnames[] = {
27093 (char *) "self",(char *) "name", NULL
27094 };
27095
27096 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
27097 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27098 if (!SWIG_IsOK(res1)) {
27099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetVendorName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27100 }
27101 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27102 {
27103 arg2 = wxString_in_helper(obj1);
27104 if (arg2 == NULL) SWIG_fail;
27105 temp2 = true;
27106 }
27107 {
27108 PyThreadState* __tstate = wxPyBeginAllowThreads();
27109 (arg1)->SetVendorName((wxString const &)*arg2);
27110 wxPyEndAllowThreads(__tstate);
27111 if (PyErr_Occurred()) SWIG_fail;
27112 }
27113 resultobj = SWIG_Py_Void();
27114 {
27115 if (temp2)
27116 delete arg2;
27117 }
27118 return resultobj;
27119 fail:
27120 {
27121 if (temp2)
27122 delete arg2;
27123 }
27124 return NULL;
27125 }
27126
27127
27128 SWIGINTERN PyObject *_wrap_PyApp_GetTraits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27129 PyObject *resultobj = 0;
27130 wxPyApp *arg1 = (wxPyApp *) 0 ;
27131 wxAppTraits *result = 0 ;
27132 void *argp1 = 0 ;
27133 int res1 = 0 ;
27134 PyObject *swig_obj[1] ;
27135
27136 if (!args) SWIG_fail;
27137 swig_obj[0] = args;
27138 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27139 if (!SWIG_IsOK(res1)) {
27140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTraits" "', expected argument " "1"" of type '" "wxPyApp *""'");
27141 }
27142 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27143 {
27144 PyThreadState* __tstate = wxPyBeginAllowThreads();
27145 result = (wxAppTraits *)(arg1)->GetTraits();
27146 wxPyEndAllowThreads(__tstate);
27147 if (PyErr_Occurred()) SWIG_fail;
27148 }
27149 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAppTraits, 0 | 0 );
27150 return resultobj;
27151 fail:
27152 return NULL;
27153 }
27154
27155
27156 SWIGINTERN PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27157 PyObject *resultobj = 0;
27158 wxPyApp *arg1 = (wxPyApp *) 0 ;
27159 void *argp1 = 0 ;
27160 int res1 = 0 ;
27161 PyObject *swig_obj[1] ;
27162
27163 if (!args) SWIG_fail;
27164 swig_obj[0] = args;
27165 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27166 if (!SWIG_IsOK(res1)) {
27167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27168 }
27169 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27170 {
27171 PyThreadState* __tstate = wxPyBeginAllowThreads();
27172 (arg1)->ProcessPendingEvents();
27173 wxPyEndAllowThreads(__tstate);
27174 if (PyErr_Occurred()) SWIG_fail;
27175 }
27176 resultobj = SWIG_Py_Void();
27177 return resultobj;
27178 fail:
27179 return NULL;
27180 }
27181
27182
27183 SWIGINTERN PyObject *_wrap_PyApp_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27184 PyObject *resultobj = 0;
27185 wxPyApp *arg1 = (wxPyApp *) 0 ;
27186 bool arg2 = (bool) false ;
27187 bool result;
27188 void *argp1 = 0 ;
27189 int res1 = 0 ;
27190 bool val2 ;
27191 int ecode2 = 0 ;
27192 PyObject * obj0 = 0 ;
27193 PyObject * obj1 = 0 ;
27194 char * kwnames[] = {
27195 (char *) "self",(char *) "onlyIfNeeded", NULL
27196 };
27197
27198 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) SWIG_fail;
27199 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27200 if (!SWIG_IsOK(res1)) {
27201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Yield" "', expected argument " "1"" of type '" "wxPyApp *""'");
27202 }
27203 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27204 if (obj1) {
27205 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27206 if (!SWIG_IsOK(ecode2)) {
27207 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_Yield" "', expected argument " "2"" of type '" "bool""'");
27208 }
27209 arg2 = static_cast< bool >(val2);
27210 }
27211 {
27212 PyThreadState* __tstate = wxPyBeginAllowThreads();
27213 result = (bool)(arg1)->Yield(arg2);
27214 wxPyEndAllowThreads(__tstate);
27215 if (PyErr_Occurred()) SWIG_fail;
27216 }
27217 {
27218 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27219 }
27220 return resultobj;
27221 fail:
27222 return NULL;
27223 }
27224
27225
27226 SWIGINTERN PyObject *_wrap_PyApp_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27227 PyObject *resultobj = 0;
27228 wxPyApp *arg1 = (wxPyApp *) 0 ;
27229 void *argp1 = 0 ;
27230 int res1 = 0 ;
27231 PyObject *swig_obj[1] ;
27232
27233 if (!args) SWIG_fail;
27234 swig_obj[0] = args;
27235 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27236 if (!SWIG_IsOK(res1)) {
27237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_WakeUpIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27238 }
27239 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27240 {
27241 PyThreadState* __tstate = wxPyBeginAllowThreads();
27242 (arg1)->WakeUpIdle();
27243 wxPyEndAllowThreads(__tstate);
27244 if (PyErr_Occurred()) SWIG_fail;
27245 }
27246 resultobj = SWIG_Py_Void();
27247 return resultobj;
27248 fail:
27249 return NULL;
27250 }
27251
27252
27253 SWIGINTERN PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27254 PyObject *resultobj = 0;
27255 bool result;
27256
27257 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsMainLoopRunning",0,0,0)) SWIG_fail;
27258 {
27259 PyThreadState* __tstate = wxPyBeginAllowThreads();
27260 result = (bool)wxPyApp::IsMainLoopRunning();
27261 wxPyEndAllowThreads(__tstate);
27262 if (PyErr_Occurred()) SWIG_fail;
27263 }
27264 {
27265 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27266 }
27267 return resultobj;
27268 fail:
27269 return NULL;
27270 }
27271
27272
27273 SWIGINTERN PyObject *_wrap_PyApp_MainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27274 PyObject *resultobj = 0;
27275 wxPyApp *arg1 = (wxPyApp *) 0 ;
27276 int result;
27277 void *argp1 = 0 ;
27278 int res1 = 0 ;
27279 PyObject *swig_obj[1] ;
27280
27281 if (!args) SWIG_fail;
27282 swig_obj[0] = args;
27283 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27284 if (!SWIG_IsOK(res1)) {
27285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_MainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27286 }
27287 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27288 {
27289 PyThreadState* __tstate = wxPyBeginAllowThreads();
27290 result = (int)(arg1)->MainLoop();
27291 wxPyEndAllowThreads(__tstate);
27292 if (PyErr_Occurred()) SWIG_fail;
27293 }
27294 resultobj = SWIG_From_int(static_cast< int >(result));
27295 return resultobj;
27296 fail:
27297 return NULL;
27298 }
27299
27300
27301 SWIGINTERN PyObject *_wrap_PyApp_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27302 PyObject *resultobj = 0;
27303 wxPyApp *arg1 = (wxPyApp *) 0 ;
27304 void *argp1 = 0 ;
27305 int res1 = 0 ;
27306 PyObject *swig_obj[1] ;
27307
27308 if (!args) SWIG_fail;
27309 swig_obj[0] = args;
27310 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27311 if (!SWIG_IsOK(res1)) {
27312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Exit" "', expected argument " "1"" of type '" "wxPyApp *""'");
27313 }
27314 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27315 {
27316 PyThreadState* __tstate = wxPyBeginAllowThreads();
27317 (arg1)->Exit();
27318 wxPyEndAllowThreads(__tstate);
27319 if (PyErr_Occurred()) SWIG_fail;
27320 }
27321 resultobj = SWIG_Py_Void();
27322 return resultobj;
27323 fail:
27324 return NULL;
27325 }
27326
27327
27328 SWIGINTERN PyObject *_wrap_PyApp_ExitMainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27329 PyObject *resultobj = 0;
27330 wxPyApp *arg1 = (wxPyApp *) 0 ;
27331 void *argp1 = 0 ;
27332 int res1 = 0 ;
27333 PyObject *swig_obj[1] ;
27334
27335 if (!args) SWIG_fail;
27336 swig_obj[0] = args;
27337 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27338 if (!SWIG_IsOK(res1)) {
27339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ExitMainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27340 }
27341 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27342 {
27343 PyThreadState* __tstate = wxPyBeginAllowThreads();
27344 (arg1)->ExitMainLoop();
27345 wxPyEndAllowThreads(__tstate);
27346 if (PyErr_Occurred()) SWIG_fail;
27347 }
27348 resultobj = SWIG_Py_Void();
27349 return resultobj;
27350 fail:
27351 return NULL;
27352 }
27353
27354
27355 SWIGINTERN PyObject *_wrap_PyApp_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27356 PyObject *resultobj = 0;
27357 wxPyApp *arg1 = (wxPyApp *) 0 ;
27358 bool result;
27359 void *argp1 = 0 ;
27360 int res1 = 0 ;
27361 PyObject *swig_obj[1] ;
27362
27363 if (!args) SWIG_fail;
27364 swig_obj[0] = args;
27365 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27366 if (!SWIG_IsOK(res1)) {
27367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Pending" "', expected argument " "1"" of type '" "wxPyApp *""'");
27368 }
27369 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27370 {
27371 PyThreadState* __tstate = wxPyBeginAllowThreads();
27372 result = (bool)(arg1)->Pending();
27373 wxPyEndAllowThreads(__tstate);
27374 if (PyErr_Occurred()) SWIG_fail;
27375 }
27376 {
27377 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27378 }
27379 return resultobj;
27380 fail:
27381 return NULL;
27382 }
27383
27384
27385 SWIGINTERN PyObject *_wrap_PyApp_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27386 PyObject *resultobj = 0;
27387 wxPyApp *arg1 = (wxPyApp *) 0 ;
27388 bool result;
27389 void *argp1 = 0 ;
27390 int res1 = 0 ;
27391 PyObject *swig_obj[1] ;
27392
27393 if (!args) SWIG_fail;
27394 swig_obj[0] = args;
27395 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27396 if (!SWIG_IsOK(res1)) {
27397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Dispatch" "', expected argument " "1"" of type '" "wxPyApp *""'");
27398 }
27399 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27400 {
27401 PyThreadState* __tstate = wxPyBeginAllowThreads();
27402 result = (bool)(arg1)->Dispatch();
27403 wxPyEndAllowThreads(__tstate);
27404 if (PyErr_Occurred()) SWIG_fail;
27405 }
27406 {
27407 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27408 }
27409 return resultobj;
27410 fail:
27411 return NULL;
27412 }
27413
27414
27415 SWIGINTERN PyObject *_wrap_PyApp_ProcessIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27416 PyObject *resultobj = 0;
27417 wxPyApp *arg1 = (wxPyApp *) 0 ;
27418 bool result;
27419 void *argp1 = 0 ;
27420 int res1 = 0 ;
27421 PyObject *swig_obj[1] ;
27422
27423 if (!args) SWIG_fail;
27424 swig_obj[0] = args;
27425 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27426 if (!SWIG_IsOK(res1)) {
27427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27428 }
27429 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27430 {
27431 PyThreadState* __tstate = wxPyBeginAllowThreads();
27432 result = (bool)(arg1)->ProcessIdle();
27433 wxPyEndAllowThreads(__tstate);
27434 if (PyErr_Occurred()) SWIG_fail;
27435 }
27436 {
27437 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27438 }
27439 return resultobj;
27440 fail:
27441 return NULL;
27442 }
27443
27444
27445 SWIGINTERN PyObject *_wrap_PyApp_SendIdleEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27446 PyObject *resultobj = 0;
27447 wxPyApp *arg1 = (wxPyApp *) 0 ;
27448 wxWindow *arg2 = (wxWindow *) 0 ;
27449 wxIdleEvent *arg3 = 0 ;
27450 bool result;
27451 void *argp1 = 0 ;
27452 int res1 = 0 ;
27453 void *argp2 = 0 ;
27454 int res2 = 0 ;
27455 void *argp3 = 0 ;
27456 int res3 = 0 ;
27457 PyObject * obj0 = 0 ;
27458 PyObject * obj1 = 0 ;
27459 PyObject * obj2 = 0 ;
27460 char * kwnames[] = {
27461 (char *) "self",(char *) "win",(char *) "event", NULL
27462 };
27463
27464 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27465 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27466 if (!SWIG_IsOK(res1)) {
27467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SendIdleEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27468 }
27469 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27470 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27471 if (!SWIG_IsOK(res2)) {
27472 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SendIdleEvents" "', expected argument " "2"" of type '" "wxWindow *""'");
27473 }
27474 arg2 = reinterpret_cast< wxWindow * >(argp2);
27475 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIdleEvent, 0 );
27476 if (!SWIG_IsOK(res3)) {
27477 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27478 }
27479 if (!argp3) {
27480 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27481 }
27482 arg3 = reinterpret_cast< wxIdleEvent * >(argp3);
27483 {
27484 PyThreadState* __tstate = wxPyBeginAllowThreads();
27485 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
27486 wxPyEndAllowThreads(__tstate);
27487 if (PyErr_Occurred()) SWIG_fail;
27488 }
27489 {
27490 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27491 }
27492 return resultobj;
27493 fail:
27494 return NULL;
27495 }
27496
27497
27498 SWIGINTERN PyObject *_wrap_PyApp_IsActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27499 PyObject *resultobj = 0;
27500 wxPyApp *arg1 = (wxPyApp *) 0 ;
27501 bool result;
27502 void *argp1 = 0 ;
27503 int res1 = 0 ;
27504 PyObject *swig_obj[1] ;
27505
27506 if (!args) SWIG_fail;
27507 swig_obj[0] = args;
27508 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27509 if (!SWIG_IsOK(res1)) {
27510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_IsActive" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27511 }
27512 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27513 {
27514 PyThreadState* __tstate = wxPyBeginAllowThreads();
27515 result = (bool)((wxPyApp const *)arg1)->IsActive();
27516 wxPyEndAllowThreads(__tstate);
27517 if (PyErr_Occurred()) SWIG_fail;
27518 }
27519 {
27520 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27521 }
27522 return resultobj;
27523 fail:
27524 return NULL;
27525 }
27526
27527
27528 SWIGINTERN PyObject *_wrap_PyApp_SetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27529 PyObject *resultobj = 0;
27530 wxPyApp *arg1 = (wxPyApp *) 0 ;
27531 wxWindow *arg2 = (wxWindow *) 0 ;
27532 void *argp1 = 0 ;
27533 int res1 = 0 ;
27534 void *argp2 = 0 ;
27535 int res2 = 0 ;
27536 PyObject * obj0 = 0 ;
27537 PyObject * obj1 = 0 ;
27538 char * kwnames[] = {
27539 (char *) "self",(char *) "win", NULL
27540 };
27541
27542 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) SWIG_fail;
27543 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27544 if (!SWIG_IsOK(res1)) {
27545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetTopWindow" "', expected argument " "1"" of type '" "wxPyApp *""'");
27546 }
27547 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27548 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27549 if (!SWIG_IsOK(res2)) {
27550 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SetTopWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
27551 }
27552 arg2 = reinterpret_cast< wxWindow * >(argp2);
27553 {
27554 PyThreadState* __tstate = wxPyBeginAllowThreads();
27555 (arg1)->SetTopWindow(arg2);
27556 wxPyEndAllowThreads(__tstate);
27557 if (PyErr_Occurred()) SWIG_fail;
27558 }
27559 resultobj = SWIG_Py_Void();
27560 return resultobj;
27561 fail:
27562 return NULL;
27563 }
27564
27565
27566 SWIGINTERN PyObject *_wrap_PyApp_GetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27567 PyObject *resultobj = 0;
27568 wxPyApp *arg1 = (wxPyApp *) 0 ;
27569 wxWindow *result = 0 ;
27570 void *argp1 = 0 ;
27571 int res1 = 0 ;
27572 PyObject *swig_obj[1] ;
27573
27574 if (!args) SWIG_fail;
27575 swig_obj[0] = args;
27576 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27577 if (!SWIG_IsOK(res1)) {
27578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTopWindow" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27579 }
27580 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27581 {
27582 PyThreadState* __tstate = wxPyBeginAllowThreads();
27583 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
27584 wxPyEndAllowThreads(__tstate);
27585 if (PyErr_Occurred()) SWIG_fail;
27586 }
27587 {
27588 resultobj = wxPyMake_wxObject(result, (bool)0);
27589 }
27590 return resultobj;
27591 fail:
27592 return NULL;
27593 }
27594
27595
27596 SWIGINTERN PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27597 PyObject *resultobj = 0;
27598 wxPyApp *arg1 = (wxPyApp *) 0 ;
27599 bool arg2 ;
27600 void *argp1 = 0 ;
27601 int res1 = 0 ;
27602 bool val2 ;
27603 int ecode2 = 0 ;
27604 PyObject * obj0 = 0 ;
27605 PyObject * obj1 = 0 ;
27606 char * kwnames[] = {
27607 (char *) "self",(char *) "flag", NULL
27608 };
27609
27610 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) SWIG_fail;
27611 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27612 if (!SWIG_IsOK(res1)) {
27613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp *""'");
27614 }
27615 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27616 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27617 if (!SWIG_IsOK(ecode2)) {
27618 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "2"" of type '" "bool""'");
27619 }
27620 arg2 = static_cast< bool >(val2);
27621 {
27622 PyThreadState* __tstate = wxPyBeginAllowThreads();
27623 (arg1)->SetExitOnFrameDelete(arg2);
27624 wxPyEndAllowThreads(__tstate);
27625 if (PyErr_Occurred()) SWIG_fail;
27626 }
27627 resultobj = SWIG_Py_Void();
27628 return resultobj;
27629 fail:
27630 return NULL;
27631 }
27632
27633
27634 SWIGINTERN PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27635 PyObject *resultobj = 0;
27636 wxPyApp *arg1 = (wxPyApp *) 0 ;
27637 bool result;
27638 void *argp1 = 0 ;
27639 int res1 = 0 ;
27640 PyObject *swig_obj[1] ;
27641
27642 if (!args) SWIG_fail;
27643 swig_obj[0] = args;
27644 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27645 if (!SWIG_IsOK(res1)) {
27646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27647 }
27648 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27649 {
27650 PyThreadState* __tstate = wxPyBeginAllowThreads();
27651 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
27652 wxPyEndAllowThreads(__tstate);
27653 if (PyErr_Occurred()) SWIG_fail;
27654 }
27655 {
27656 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27657 }
27658 return resultobj;
27659 fail:
27660 return NULL;
27661 }
27662
27663
27664 SWIGINTERN PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27665 PyObject *resultobj = 0;
27666 wxPyApp *arg1 = (wxPyApp *) 0 ;
27667 bool arg2 ;
27668 void *argp1 = 0 ;
27669 int res1 = 0 ;
27670 bool val2 ;
27671 int ecode2 = 0 ;
27672 PyObject * obj0 = 0 ;
27673 PyObject * obj1 = 0 ;
27674 char * kwnames[] = {
27675 (char *) "self",(char *) "flag", NULL
27676 };
27677
27678 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) SWIG_fail;
27679 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27680 if (!SWIG_IsOK(res1)) {
27681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp *""'");
27682 }
27683 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27684 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27685 if (!SWIG_IsOK(ecode2)) {
27686 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "2"" of type '" "bool""'");
27687 }
27688 arg2 = static_cast< bool >(val2);
27689 {
27690 PyThreadState* __tstate = wxPyBeginAllowThreads();
27691 (arg1)->SetUseBestVisual(arg2);
27692 wxPyEndAllowThreads(__tstate);
27693 if (PyErr_Occurred()) SWIG_fail;
27694 }
27695 resultobj = SWIG_Py_Void();
27696 return resultobj;
27697 fail:
27698 return NULL;
27699 }
27700
27701
27702 SWIGINTERN PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27703 PyObject *resultobj = 0;
27704 wxPyApp *arg1 = (wxPyApp *) 0 ;
27705 bool result;
27706 void *argp1 = 0 ;
27707 int res1 = 0 ;
27708 PyObject *swig_obj[1] ;
27709
27710 if (!args) SWIG_fail;
27711 swig_obj[0] = args;
27712 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27713 if (!SWIG_IsOK(res1)) {
27714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27715 }
27716 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27717 {
27718 PyThreadState* __tstate = wxPyBeginAllowThreads();
27719 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
27720 wxPyEndAllowThreads(__tstate);
27721 if (PyErr_Occurred()) SWIG_fail;
27722 }
27723 {
27724 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27725 }
27726 return resultobj;
27727 fail:
27728 return NULL;
27729 }
27730
27731
27732 SWIGINTERN PyObject *_wrap_PyApp_SetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27733 PyObject *resultobj = 0;
27734 wxPyApp *arg1 = (wxPyApp *) 0 ;
27735 int arg2 ;
27736 void *argp1 = 0 ;
27737 int res1 = 0 ;
27738 int val2 ;
27739 int ecode2 = 0 ;
27740 PyObject * obj0 = 0 ;
27741 PyObject * obj1 = 0 ;
27742 char * kwnames[] = {
27743 (char *) "self",(char *) "mode", NULL
27744 };
27745
27746 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) SWIG_fail;
27747 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27748 if (!SWIG_IsOK(res1)) {
27749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetPrintMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
27750 }
27751 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27752 ecode2 = SWIG_AsVal_int(obj1, &val2);
27753 if (!SWIG_IsOK(ecode2)) {
27754 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetPrintMode" "', expected argument " "2"" of type '" "int""'");
27755 }
27756 arg2 = static_cast< int >(val2);
27757 {
27758 PyThreadState* __tstate = wxPyBeginAllowThreads();
27759 (arg1)->SetPrintMode(arg2);
27760 wxPyEndAllowThreads(__tstate);
27761 if (PyErr_Occurred()) SWIG_fail;
27762 }
27763 resultobj = SWIG_Py_Void();
27764 return resultobj;
27765 fail:
27766 return NULL;
27767 }
27768
27769
27770 SWIGINTERN PyObject *_wrap_PyApp_GetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27771 PyObject *resultobj = 0;
27772 wxPyApp *arg1 = (wxPyApp *) 0 ;
27773 int result;
27774 void *argp1 = 0 ;
27775 int res1 = 0 ;
27776 PyObject *swig_obj[1] ;
27777
27778 if (!args) SWIG_fail;
27779 swig_obj[0] = args;
27780 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27781 if (!SWIG_IsOK(res1)) {
27782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetPrintMode" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27783 }
27784 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27785 {
27786 PyThreadState* __tstate = wxPyBeginAllowThreads();
27787 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
27788 wxPyEndAllowThreads(__tstate);
27789 if (PyErr_Occurred()) SWIG_fail;
27790 }
27791 resultobj = SWIG_From_int(static_cast< int >(result));
27792 return resultobj;
27793 fail:
27794 return NULL;
27795 }
27796
27797
27798 SWIGINTERN PyObject *_wrap_PyApp_SetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27799 PyObject *resultobj = 0;
27800 wxPyApp *arg1 = (wxPyApp *) 0 ;
27801 int arg2 ;
27802 void *argp1 = 0 ;
27803 int res1 = 0 ;
27804 int val2 ;
27805 int ecode2 = 0 ;
27806 PyObject * obj0 = 0 ;
27807 PyObject * obj1 = 0 ;
27808 char * kwnames[] = {
27809 (char *) "self",(char *) "mode", NULL
27810 };
27811
27812 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) SWIG_fail;
27813 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27814 if (!SWIG_IsOK(res1)) {
27815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
27816 }
27817 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27818 ecode2 = SWIG_AsVal_int(obj1, &val2);
27819 if (!SWIG_IsOK(ecode2)) {
27820 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetAssertMode" "', expected argument " "2"" of type '" "int""'");
27821 }
27822 arg2 = static_cast< int >(val2);
27823 {
27824 PyThreadState* __tstate = wxPyBeginAllowThreads();
27825 (arg1)->SetAssertMode(arg2);
27826 wxPyEndAllowThreads(__tstate);
27827 if (PyErr_Occurred()) SWIG_fail;
27828 }
27829 resultobj = SWIG_Py_Void();
27830 return resultobj;
27831 fail:
27832 return NULL;
27833 }
27834
27835
27836 SWIGINTERN PyObject *_wrap_PyApp_GetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27837 PyObject *resultobj = 0;
27838 wxPyApp *arg1 = (wxPyApp *) 0 ;
27839 int result;
27840 void *argp1 = 0 ;
27841 int res1 = 0 ;
27842 PyObject *swig_obj[1] ;
27843
27844 if (!args) SWIG_fail;
27845 swig_obj[0] = args;
27846 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27847 if (!SWIG_IsOK(res1)) {
27848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
27849 }
27850 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27851 {
27852 PyThreadState* __tstate = wxPyBeginAllowThreads();
27853 result = (int)(arg1)->GetAssertMode();
27854 wxPyEndAllowThreads(__tstate);
27855 if (PyErr_Occurred()) SWIG_fail;
27856 }
27857 resultobj = SWIG_From_int(static_cast< int >(result));
27858 return resultobj;
27859 fail:
27860 return NULL;
27861 }
27862
27863
27864 SWIGINTERN PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27865 PyObject *resultobj = 0;
27866 bool result;
27867
27868 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacSupportPCMenuShortcuts",0,0,0)) SWIG_fail;
27869 {
27870 PyThreadState* __tstate = wxPyBeginAllowThreads();
27871 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
27872 wxPyEndAllowThreads(__tstate);
27873 if (PyErr_Occurred()) SWIG_fail;
27874 }
27875 {
27876 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27877 }
27878 return resultobj;
27879 fail:
27880 return NULL;
27881 }
27882
27883
27884 SWIGINTERN PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27885 PyObject *resultobj = 0;
27886 long result;
27887
27888 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacAboutMenuItemId",0,0,0)) SWIG_fail;
27889 {
27890 PyThreadState* __tstate = wxPyBeginAllowThreads();
27891 result = (long)wxPyApp::GetMacAboutMenuItemId();
27892 wxPyEndAllowThreads(__tstate);
27893 if (PyErr_Occurred()) SWIG_fail;
27894 }
27895 resultobj = SWIG_From_long(static_cast< long >(result));
27896 return resultobj;
27897 fail:
27898 return NULL;
27899 }
27900
27901
27902 SWIGINTERN PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27903 PyObject *resultobj = 0;
27904 long result;
27905
27906 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacPreferencesMenuItemId",0,0,0)) SWIG_fail;
27907 {
27908 PyThreadState* __tstate = wxPyBeginAllowThreads();
27909 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
27910 wxPyEndAllowThreads(__tstate);
27911 if (PyErr_Occurred()) SWIG_fail;
27912 }
27913 resultobj = SWIG_From_long(static_cast< long >(result));
27914 return resultobj;
27915 fail:
27916 return NULL;
27917 }
27918
27919
27920 SWIGINTERN PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27921 PyObject *resultobj = 0;
27922 long result;
27923
27924 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacExitMenuItemId",0,0,0)) SWIG_fail;
27925 {
27926 PyThreadState* __tstate = wxPyBeginAllowThreads();
27927 result = (long)wxPyApp::GetMacExitMenuItemId();
27928 wxPyEndAllowThreads(__tstate);
27929 if (PyErr_Occurred()) SWIG_fail;
27930 }
27931 resultobj = SWIG_From_long(static_cast< long >(result));
27932 return resultobj;
27933 fail:
27934 return NULL;
27935 }
27936
27937
27938 SWIGINTERN PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27939 PyObject *resultobj = 0;
27940 wxString result;
27941
27942 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacHelpMenuTitleName",0,0,0)) SWIG_fail;
27943 {
27944 PyThreadState* __tstate = wxPyBeginAllowThreads();
27945 result = wxPyApp::GetMacHelpMenuTitleName();
27946 wxPyEndAllowThreads(__tstate);
27947 if (PyErr_Occurred()) SWIG_fail;
27948 }
27949 {
27950 #if wxUSE_UNICODE
27951 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27952 #else
27953 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27954 #endif
27955 }
27956 return resultobj;
27957 fail:
27958 return NULL;
27959 }
27960
27961
27962 SWIGINTERN PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27963 PyObject *resultobj = 0;
27964 bool arg1 ;
27965 bool val1 ;
27966 int ecode1 = 0 ;
27967 PyObject * obj0 = 0 ;
27968 char * kwnames[] = {
27969 (char *) "val", NULL
27970 };
27971
27972 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) SWIG_fail;
27973 ecode1 = SWIG_AsVal_bool(obj0, &val1);
27974 if (!SWIG_IsOK(ecode1)) {
27975 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacSupportPCMenuShortcuts" "', expected argument " "1"" of type '" "bool""'");
27976 }
27977 arg1 = static_cast< bool >(val1);
27978 {
27979 PyThreadState* __tstate = wxPyBeginAllowThreads();
27980 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
27981 wxPyEndAllowThreads(__tstate);
27982 if (PyErr_Occurred()) SWIG_fail;
27983 }
27984 resultobj = SWIG_Py_Void();
27985 return resultobj;
27986 fail:
27987 return NULL;
27988 }
27989
27990
27991 SWIGINTERN PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27992 PyObject *resultobj = 0;
27993 long arg1 ;
27994 long val1 ;
27995 int ecode1 = 0 ;
27996 PyObject * obj0 = 0 ;
27997 char * kwnames[] = {
27998 (char *) "val", NULL
27999 };
28000
28001 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) SWIG_fail;
28002 ecode1 = SWIG_AsVal_long(obj0, &val1);
28003 if (!SWIG_IsOK(ecode1)) {
28004 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacAboutMenuItemId" "', expected argument " "1"" of type '" "long""'");
28005 }
28006 arg1 = static_cast< long >(val1);
28007 {
28008 PyThreadState* __tstate = wxPyBeginAllowThreads();
28009 wxPyApp::SetMacAboutMenuItemId(arg1);
28010 wxPyEndAllowThreads(__tstate);
28011 if (PyErr_Occurred()) SWIG_fail;
28012 }
28013 resultobj = SWIG_Py_Void();
28014 return resultobj;
28015 fail:
28016 return NULL;
28017 }
28018
28019
28020 SWIGINTERN PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28021 PyObject *resultobj = 0;
28022 long arg1 ;
28023 long val1 ;
28024 int ecode1 = 0 ;
28025 PyObject * obj0 = 0 ;
28026 char * kwnames[] = {
28027 (char *) "val", NULL
28028 };
28029
28030 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) SWIG_fail;
28031 ecode1 = SWIG_AsVal_long(obj0, &val1);
28032 if (!SWIG_IsOK(ecode1)) {
28033 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacPreferencesMenuItemId" "', expected argument " "1"" of type '" "long""'");
28034 }
28035 arg1 = static_cast< long >(val1);
28036 {
28037 PyThreadState* __tstate = wxPyBeginAllowThreads();
28038 wxPyApp::SetMacPreferencesMenuItemId(arg1);
28039 wxPyEndAllowThreads(__tstate);
28040 if (PyErr_Occurred()) SWIG_fail;
28041 }
28042 resultobj = SWIG_Py_Void();
28043 return resultobj;
28044 fail:
28045 return NULL;
28046 }
28047
28048
28049 SWIGINTERN PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28050 PyObject *resultobj = 0;
28051 long arg1 ;
28052 long val1 ;
28053 int ecode1 = 0 ;
28054 PyObject * obj0 = 0 ;
28055 char * kwnames[] = {
28056 (char *) "val", NULL
28057 };
28058
28059 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) SWIG_fail;
28060 ecode1 = SWIG_AsVal_long(obj0, &val1);
28061 if (!SWIG_IsOK(ecode1)) {
28062 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacExitMenuItemId" "', expected argument " "1"" of type '" "long""'");
28063 }
28064 arg1 = static_cast< long >(val1);
28065 {
28066 PyThreadState* __tstate = wxPyBeginAllowThreads();
28067 wxPyApp::SetMacExitMenuItemId(arg1);
28068 wxPyEndAllowThreads(__tstate);
28069 if (PyErr_Occurred()) SWIG_fail;
28070 }
28071 resultobj = SWIG_Py_Void();
28072 return resultobj;
28073 fail:
28074 return NULL;
28075 }
28076
28077
28078 SWIGINTERN PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28079 PyObject *resultobj = 0;
28080 wxString *arg1 = 0 ;
28081 bool temp1 = false ;
28082 PyObject * obj0 = 0 ;
28083 char * kwnames[] = {
28084 (char *) "val", NULL
28085 };
28086
28087 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) SWIG_fail;
28088 {
28089 arg1 = wxString_in_helper(obj0);
28090 if (arg1 == NULL) SWIG_fail;
28091 temp1 = true;
28092 }
28093 {
28094 PyThreadState* __tstate = wxPyBeginAllowThreads();
28095 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
28096 wxPyEndAllowThreads(__tstate);
28097 if (PyErr_Occurred()) SWIG_fail;
28098 }
28099 resultobj = SWIG_Py_Void();
28100 {
28101 if (temp1)
28102 delete arg1;
28103 }
28104 return resultobj;
28105 fail:
28106 {
28107 if (temp1)
28108 delete arg1;
28109 }
28110 return NULL;
28111 }
28112
28113
28114 SWIGINTERN PyObject *_wrap_PyApp__BootstrapApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28115 PyObject *resultobj = 0;
28116 wxPyApp *arg1 = (wxPyApp *) 0 ;
28117 void *argp1 = 0 ;
28118 int res1 = 0 ;
28119 PyObject *swig_obj[1] ;
28120
28121 if (!args) SWIG_fail;
28122 swig_obj[0] = args;
28123 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28124 if (!SWIG_IsOK(res1)) {
28125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__BootstrapApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
28126 }
28127 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28128 {
28129 PyThreadState* __tstate = wxPyBeginAllowThreads();
28130 (arg1)->_BootstrapApp();
28131 wxPyEndAllowThreads(__tstate);
28132 if (PyErr_Occurred()) SWIG_fail;
28133 }
28134 resultobj = SWIG_Py_Void();
28135 return resultobj;
28136 fail:
28137 return NULL;
28138 }
28139
28140
28141 SWIGINTERN PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28142 PyObject *resultobj = 0;
28143 int result;
28144
28145 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetComCtl32Version",0,0,0)) SWIG_fail;
28146 {
28147 PyThreadState* __tstate = wxPyBeginAllowThreads();
28148 result = (int)wxPyApp_GetComCtl32Version();
28149 wxPyEndAllowThreads(__tstate);
28150 if (PyErr_Occurred()) SWIG_fail;
28151 }
28152 resultobj = SWIG_From_int(static_cast< int >(result));
28153 return resultobj;
28154 fail:
28155 return NULL;
28156 }
28157
28158
28159 SWIGINTERN PyObject *PyApp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28160 PyObject *obj;
28161 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28162 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyApp, SWIG_NewClientData(obj));
28163 return SWIG_Py_Void();
28164 }
28165
28166 SWIGINTERN PyObject *PyApp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28167 return SWIG_Python_InitShadowInstance(args);
28168 }
28169
28170 SWIGINTERN PyObject *_wrap_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28171 PyObject *resultobj = 0;
28172
28173 if (!SWIG_Python_UnpackTuple(args,"Exit",0,0,0)) SWIG_fail;
28174 {
28175 PyThreadState* __tstate = wxPyBeginAllowThreads();
28176 wxExit();
28177 wxPyEndAllowThreads(__tstate);
28178 if (PyErr_Occurred()) SWIG_fail;
28179 }
28180 resultobj = SWIG_Py_Void();
28181 return resultobj;
28182 fail:
28183 return NULL;
28184 }
28185
28186
28187 SWIGINTERN PyObject *_wrap_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28188 PyObject *resultobj = 0;
28189 bool result;
28190
28191 if (!SWIG_Python_UnpackTuple(args,"Yield",0,0,0)) SWIG_fail;
28192 {
28193 PyThreadState* __tstate = wxPyBeginAllowThreads();
28194 result = (bool)wxYield();
28195 wxPyEndAllowThreads(__tstate);
28196 if (PyErr_Occurred()) SWIG_fail;
28197 }
28198 {
28199 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28200 }
28201 return resultobj;
28202 fail:
28203 return NULL;
28204 }
28205
28206
28207 SWIGINTERN PyObject *_wrap_YieldIfNeeded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28208 PyObject *resultobj = 0;
28209 bool result;
28210
28211 if (!SWIG_Python_UnpackTuple(args,"YieldIfNeeded",0,0,0)) SWIG_fail;
28212 {
28213 PyThreadState* __tstate = wxPyBeginAllowThreads();
28214 result = (bool)wxYieldIfNeeded();
28215 wxPyEndAllowThreads(__tstate);
28216 if (PyErr_Occurred()) SWIG_fail;
28217 }
28218 {
28219 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28220 }
28221 return resultobj;
28222 fail:
28223 return NULL;
28224 }
28225
28226
28227 SWIGINTERN PyObject *_wrap_SafeYield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28228 PyObject *resultobj = 0;
28229 wxWindow *arg1 = (wxWindow *) NULL ;
28230 bool arg2 = (bool) false ;
28231 bool result;
28232 void *argp1 = 0 ;
28233 int res1 = 0 ;
28234 bool val2 ;
28235 int ecode2 = 0 ;
28236 PyObject * obj0 = 0 ;
28237 PyObject * obj1 = 0 ;
28238 char * kwnames[] = {
28239 (char *) "win",(char *) "onlyIfNeeded", NULL
28240 };
28241
28242 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) SWIG_fail;
28243 if (obj0) {
28244 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
28245 if (!SWIG_IsOK(res1)) {
28246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SafeYield" "', expected argument " "1"" of type '" "wxWindow *""'");
28247 }
28248 arg1 = reinterpret_cast< wxWindow * >(argp1);
28249 }
28250 if (obj1) {
28251 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28252 if (!SWIG_IsOK(ecode2)) {
28253 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SafeYield" "', expected argument " "2"" of type '" "bool""'");
28254 }
28255 arg2 = static_cast< bool >(val2);
28256 }
28257 {
28258 PyThreadState* __tstate = wxPyBeginAllowThreads();
28259 result = (bool)wxSafeYield(arg1,arg2);
28260 wxPyEndAllowThreads(__tstate);
28261 if (PyErr_Occurred()) SWIG_fail;
28262 }
28263 {
28264 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28265 }
28266 return resultobj;
28267 fail:
28268 return NULL;
28269 }
28270
28271
28272 SWIGINTERN PyObject *_wrap_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28273 PyObject *resultobj = 0;
28274
28275 if (!SWIG_Python_UnpackTuple(args,"WakeUpIdle",0,0,0)) SWIG_fail;
28276 {
28277 PyThreadState* __tstate = wxPyBeginAllowThreads();
28278 wxWakeUpIdle();
28279 wxPyEndAllowThreads(__tstate);
28280 if (PyErr_Occurred()) SWIG_fail;
28281 }
28282 resultobj = SWIG_Py_Void();
28283 return resultobj;
28284 fail:
28285 return NULL;
28286 }
28287
28288
28289 SWIGINTERN PyObject *_wrap_PostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28290 PyObject *resultobj = 0;
28291 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
28292 wxEvent *arg2 = 0 ;
28293 void *argp1 = 0 ;
28294 int res1 = 0 ;
28295 void *argp2 = 0 ;
28296 int res2 = 0 ;
28297 PyObject * obj0 = 0 ;
28298 PyObject * obj1 = 0 ;
28299 char * kwnames[] = {
28300 (char *) "dest",(char *) "event", NULL
28301 };
28302
28303 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) SWIG_fail;
28304 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
28305 if (!SWIG_IsOK(res1)) {
28306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
28307 }
28308 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
28309 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
28310 if (!SWIG_IsOK(res2)) {
28311 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28312 }
28313 if (!argp2) {
28314 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28315 }
28316 arg2 = reinterpret_cast< wxEvent * >(argp2);
28317 {
28318 PyThreadState* __tstate = wxPyBeginAllowThreads();
28319 wxPostEvent(arg1,*arg2);
28320 wxPyEndAllowThreads(__tstate);
28321 if (PyErr_Occurred()) SWIG_fail;
28322 }
28323 resultobj = SWIG_Py_Void();
28324 return resultobj;
28325 fail:
28326 return NULL;
28327 }
28328
28329
28330 SWIGINTERN PyObject *_wrap_App_CleanUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28331 PyObject *resultobj = 0;
28332
28333 if (!SWIG_Python_UnpackTuple(args,"App_CleanUp",0,0,0)) SWIG_fail;
28334 {
28335 PyThreadState* __tstate = wxPyBeginAllowThreads();
28336 wxApp_CleanUp();
28337 wxPyEndAllowThreads(__tstate);
28338 if (PyErr_Occurred()) SWIG_fail;
28339 }
28340 resultobj = SWIG_Py_Void();
28341 return resultobj;
28342 fail:
28343 return NULL;
28344 }
28345
28346
28347 SWIGINTERN PyObject *_wrap_GetApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28348 PyObject *resultobj = 0;
28349 wxPyApp *result = 0 ;
28350
28351 if (!SWIG_Python_UnpackTuple(args,"GetApp",0,0,0)) SWIG_fail;
28352 {
28353 PyThreadState* __tstate = wxPyBeginAllowThreads();
28354 result = (wxPyApp *)wxPyGetApp();
28355 wxPyEndAllowThreads(__tstate);
28356 if (PyErr_Occurred()) SWIG_fail;
28357 }
28358 {
28359 resultobj = wxPyMake_wxObject(result, 0);
28360 }
28361 return resultobj;
28362 fail:
28363 return NULL;
28364 }
28365
28366
28367 SWIGINTERN PyObject *_wrap_SetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28368 PyObject *resultobj = 0;
28369 char *arg1 = (char *) 0 ;
28370 int res1 ;
28371 char *buf1 = 0 ;
28372 int alloc1 = 0 ;
28373 PyObject * obj0 = 0 ;
28374 char * kwnames[] = {
28375 (char *) "encoding", NULL
28376 };
28377
28378 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) SWIG_fail;
28379 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
28380 if (!SWIG_IsOK(res1)) {
28381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetDefaultPyEncoding" "', expected argument " "1"" of type '" "char const *""'");
28382 }
28383 arg1 = buf1;
28384 {
28385 PyThreadState* __tstate = wxPyBeginAllowThreads();
28386 wxSetDefaultPyEncoding((char const *)arg1);
28387 wxPyEndAllowThreads(__tstate);
28388 if (PyErr_Occurred()) SWIG_fail;
28389 }
28390 resultobj = SWIG_Py_Void();
28391 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28392 return resultobj;
28393 fail:
28394 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28395 return NULL;
28396 }
28397
28398
28399 SWIGINTERN PyObject *_wrap_GetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28400 PyObject *resultobj = 0;
28401 char *result = 0 ;
28402
28403 if (!SWIG_Python_UnpackTuple(args,"GetDefaultPyEncoding",0,0,0)) SWIG_fail;
28404 {
28405 PyThreadState* __tstate = wxPyBeginAllowThreads();
28406 result = (char *)wxGetDefaultPyEncoding();
28407 wxPyEndAllowThreads(__tstate);
28408 if (PyErr_Occurred()) SWIG_fail;
28409 }
28410 resultobj = SWIG_FromCharPtr(result);
28411 return resultobj;
28412 fail:
28413 return NULL;
28414 }
28415
28416
28417 SWIGINTERN PyObject *_wrap_new_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28418 PyObject *resultobj = 0;
28419 wxEventLoop *result = 0 ;
28420
28421 if (!SWIG_Python_UnpackTuple(args,"new_EventLoop",0,0,0)) SWIG_fail;
28422 {
28423 PyThreadState* __tstate = wxPyBeginAllowThreads();
28424 result = (wxEventLoop *)new wxEventLoop();
28425 wxPyEndAllowThreads(__tstate);
28426 if (PyErr_Occurred()) SWIG_fail;
28427 }
28428 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, SWIG_POINTER_NEW | 0 );
28429 return resultobj;
28430 fail:
28431 return NULL;
28432 }
28433
28434
28435 SWIGINTERN PyObject *_wrap_delete_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28436 PyObject *resultobj = 0;
28437 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28438 void *argp1 = 0 ;
28439 int res1 = 0 ;
28440 PyObject *swig_obj[1] ;
28441
28442 if (!args) SWIG_fail;
28443 swig_obj[0] = args;
28444 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, SWIG_POINTER_DISOWN | 0 );
28445 if (!SWIG_IsOK(res1)) {
28446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoop" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28447 }
28448 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28449 {
28450 PyThreadState* __tstate = wxPyBeginAllowThreads();
28451 delete arg1;
28452
28453 wxPyEndAllowThreads(__tstate);
28454 if (PyErr_Occurred()) SWIG_fail;
28455 }
28456 resultobj = SWIG_Py_Void();
28457 return resultobj;
28458 fail:
28459 return NULL;
28460 }
28461
28462
28463 SWIGINTERN PyObject *_wrap_EventLoop_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28464 PyObject *resultobj = 0;
28465 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28466 int result;
28467 void *argp1 = 0 ;
28468 int res1 = 0 ;
28469 PyObject *swig_obj[1] ;
28470
28471 if (!args) SWIG_fail;
28472 swig_obj[0] = args;
28473 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28474 if (!SWIG_IsOK(res1)) {
28475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Run" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28476 }
28477 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28478 {
28479 PyThreadState* __tstate = wxPyBeginAllowThreads();
28480 result = (int)(arg1)->Run();
28481 wxPyEndAllowThreads(__tstate);
28482 if (PyErr_Occurred()) SWIG_fail;
28483 }
28484 resultobj = SWIG_From_int(static_cast< int >(result));
28485 return resultobj;
28486 fail:
28487 return NULL;
28488 }
28489
28490
28491 SWIGINTERN PyObject *_wrap_EventLoop_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28492 PyObject *resultobj = 0;
28493 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28494 int arg2 = (int) 0 ;
28495 void *argp1 = 0 ;
28496 int res1 = 0 ;
28497 int val2 ;
28498 int ecode2 = 0 ;
28499 PyObject * obj0 = 0 ;
28500 PyObject * obj1 = 0 ;
28501 char * kwnames[] = {
28502 (char *) "self",(char *) "rc", NULL
28503 };
28504
28505 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) SWIG_fail;
28506 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28507 if (!SWIG_IsOK(res1)) {
28508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Exit" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28509 }
28510 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28511 if (obj1) {
28512 ecode2 = SWIG_AsVal_int(obj1, &val2);
28513 if (!SWIG_IsOK(ecode2)) {
28514 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventLoop_Exit" "', expected argument " "2"" of type '" "int""'");
28515 }
28516 arg2 = static_cast< int >(val2);
28517 }
28518 {
28519 PyThreadState* __tstate = wxPyBeginAllowThreads();
28520 (arg1)->Exit(arg2);
28521 wxPyEndAllowThreads(__tstate);
28522 if (PyErr_Occurred()) SWIG_fail;
28523 }
28524 resultobj = SWIG_Py_Void();
28525 return resultobj;
28526 fail:
28527 return NULL;
28528 }
28529
28530
28531 SWIGINTERN PyObject *_wrap_EventLoop_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28532 PyObject *resultobj = 0;
28533 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28534 bool result;
28535 void *argp1 = 0 ;
28536 int res1 = 0 ;
28537 PyObject *swig_obj[1] ;
28538
28539 if (!args) SWIG_fail;
28540 swig_obj[0] = args;
28541 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28542 if (!SWIG_IsOK(res1)) {
28543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Pending" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
28544 }
28545 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28546 {
28547 PyThreadState* __tstate = wxPyBeginAllowThreads();
28548 result = (bool)((wxEventLoop const *)arg1)->Pending();
28549 wxPyEndAllowThreads(__tstate);
28550 if (PyErr_Occurred()) SWIG_fail;
28551 }
28552 {
28553 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28554 }
28555 return resultobj;
28556 fail:
28557 return NULL;
28558 }
28559
28560
28561 SWIGINTERN PyObject *_wrap_EventLoop_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28562 PyObject *resultobj = 0;
28563 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28564 bool result;
28565 void *argp1 = 0 ;
28566 int res1 = 0 ;
28567 PyObject *swig_obj[1] ;
28568
28569 if (!args) SWIG_fail;
28570 swig_obj[0] = args;
28571 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28572 if (!SWIG_IsOK(res1)) {
28573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Dispatch" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28574 }
28575 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28576 {
28577 PyThreadState* __tstate = wxPyBeginAllowThreads();
28578 result = (bool)(arg1)->Dispatch();
28579 wxPyEndAllowThreads(__tstate);
28580 if (PyErr_Occurred()) SWIG_fail;
28581 }
28582 {
28583 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28584 }
28585 return resultobj;
28586 fail:
28587 return NULL;
28588 }
28589
28590
28591 SWIGINTERN PyObject *_wrap_EventLoop_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28592 PyObject *resultobj = 0;
28593 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28594 bool result;
28595 void *argp1 = 0 ;
28596 int res1 = 0 ;
28597 PyObject *swig_obj[1] ;
28598
28599 if (!args) SWIG_fail;
28600 swig_obj[0] = args;
28601 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28602 if (!SWIG_IsOK(res1)) {
28603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_IsRunning" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
28604 }
28605 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28606 {
28607 PyThreadState* __tstate = wxPyBeginAllowThreads();
28608 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
28609 wxPyEndAllowThreads(__tstate);
28610 if (PyErr_Occurred()) SWIG_fail;
28611 }
28612 {
28613 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28614 }
28615 return resultobj;
28616 fail:
28617 return NULL;
28618 }
28619
28620
28621 SWIGINTERN PyObject *_wrap_EventLoop_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28622 PyObject *resultobj = 0;
28623 wxEventLoop *result = 0 ;
28624
28625 if (!SWIG_Python_UnpackTuple(args,"EventLoop_GetActive",0,0,0)) SWIG_fail;
28626 {
28627 PyThreadState* __tstate = wxPyBeginAllowThreads();
28628 result = (wxEventLoop *)wxEventLoop::GetActive();
28629 wxPyEndAllowThreads(__tstate);
28630 if (PyErr_Occurred()) SWIG_fail;
28631 }
28632 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, 0 | 0 );
28633 return resultobj;
28634 fail:
28635 return NULL;
28636 }
28637
28638
28639 SWIGINTERN PyObject *_wrap_EventLoop_SetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28640 PyObject *resultobj = 0;
28641 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28642 void *argp1 = 0 ;
28643 int res1 = 0 ;
28644 PyObject * obj0 = 0 ;
28645 char * kwnames[] = {
28646 (char *) "loop", NULL
28647 };
28648
28649 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) SWIG_fail;
28650 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28651 if (!SWIG_IsOK(res1)) {
28652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_SetActive" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28653 }
28654 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28655 {
28656 PyThreadState* __tstate = wxPyBeginAllowThreads();
28657 wxEventLoop::SetActive(arg1);
28658 wxPyEndAllowThreads(__tstate);
28659 if (PyErr_Occurred()) SWIG_fail;
28660 }
28661 resultobj = SWIG_Py_Void();
28662 return resultobj;
28663 fail:
28664 return NULL;
28665 }
28666
28667
28668 SWIGINTERN PyObject *EventLoop_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28669 PyObject *obj;
28670 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28671 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoop, SWIG_NewClientData(obj));
28672 return SWIG_Py_Void();
28673 }
28674
28675 SWIGINTERN PyObject *EventLoop_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28676 return SWIG_Python_InitShadowInstance(args);
28677 }
28678
28679 SWIGINTERN PyObject *_wrap_new_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28680 PyObject *resultobj = 0;
28681 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28682 wxEventLoopActivator *result = 0 ;
28683 void *argp1 = 0 ;
28684 int res1 = 0 ;
28685 PyObject * obj0 = 0 ;
28686 char * kwnames[] = {
28687 (char *) "evtLoop", NULL
28688 };
28689
28690 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_EventLoopActivator",kwnames,&obj0)) SWIG_fail;
28691 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28692 if (!SWIG_IsOK(res1)) {
28693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28694 }
28695 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28696 {
28697 PyThreadState* __tstate = wxPyBeginAllowThreads();
28698 result = (wxEventLoopActivator *)new wxEventLoopActivator(arg1);
28699 wxPyEndAllowThreads(__tstate);
28700 if (PyErr_Occurred()) SWIG_fail;
28701 }
28702 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_NEW | 0 );
28703 return resultobj;
28704 fail:
28705 return NULL;
28706 }
28707
28708
28709 SWIGINTERN PyObject *_wrap_delete_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28710 PyObject *resultobj = 0;
28711 wxEventLoopActivator *arg1 = (wxEventLoopActivator *) 0 ;
28712 void *argp1 = 0 ;
28713 int res1 = 0 ;
28714 PyObject *swig_obj[1] ;
28715
28716 if (!args) SWIG_fail;
28717 swig_obj[0] = args;
28718 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_DISOWN | 0 );
28719 if (!SWIG_IsOK(res1)) {
28720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoopActivator *""'");
28721 }
28722 arg1 = reinterpret_cast< wxEventLoopActivator * >(argp1);
28723 {
28724 PyThreadState* __tstate = wxPyBeginAllowThreads();
28725 delete arg1;
28726
28727 wxPyEndAllowThreads(__tstate);
28728 if (PyErr_Occurred()) SWIG_fail;
28729 }
28730 resultobj = SWIG_Py_Void();
28731 return resultobj;
28732 fail:
28733 return NULL;
28734 }
28735
28736
28737 SWIGINTERN PyObject *EventLoopActivator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28738 PyObject *obj;
28739 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28740 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoopActivator, SWIG_NewClientData(obj));
28741 return SWIG_Py_Void();
28742 }
28743
28744 SWIGINTERN PyObject *EventLoopActivator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28745 return SWIG_Python_InitShadowInstance(args);
28746 }
28747
28748 SWIGINTERN PyObject *_wrap_new_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28749 PyObject *resultobj = 0;
28750 int arg1 = (int) 0 ;
28751 int arg2 = (int) 0 ;
28752 int arg3 = (int) 0 ;
28753 wxAcceleratorEntry *result = 0 ;
28754 int val1 ;
28755 int ecode1 = 0 ;
28756 int val2 ;
28757 int ecode2 = 0 ;
28758 int val3 ;
28759 int ecode3 = 0 ;
28760 PyObject * obj0 = 0 ;
28761 PyObject * obj1 = 0 ;
28762 PyObject * obj2 = 0 ;
28763 char * kwnames[] = {
28764 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
28765 };
28766
28767 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
28768 if (obj0) {
28769 ecode1 = SWIG_AsVal_int(obj0, &val1);
28770 if (!SWIG_IsOK(ecode1)) {
28771 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AcceleratorEntry" "', expected argument " "1"" of type '" "int""'");
28772 }
28773 arg1 = static_cast< int >(val1);
28774 }
28775 if (obj1) {
28776 ecode2 = SWIG_AsVal_int(obj1, &val2);
28777 if (!SWIG_IsOK(ecode2)) {
28778 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AcceleratorEntry" "', expected argument " "2"" of type '" "int""'");
28779 }
28780 arg2 = static_cast< int >(val2);
28781 }
28782 if (obj2) {
28783 ecode3 = SWIG_AsVal_int(obj2, &val3);
28784 if (!SWIG_IsOK(ecode3)) {
28785 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AcceleratorEntry" "', expected argument " "3"" of type '" "int""'");
28786 }
28787 arg3 = static_cast< int >(val3);
28788 }
28789 {
28790 PyThreadState* __tstate = wxPyBeginAllowThreads();
28791 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
28792 wxPyEndAllowThreads(__tstate);
28793 if (PyErr_Occurred()) SWIG_fail;
28794 }
28795 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_NEW | 0 );
28796 return resultobj;
28797 fail:
28798 return NULL;
28799 }
28800
28801
28802 SWIGINTERN PyObject *_wrap_delete_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28803 PyObject *resultobj = 0;
28804 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28805 void *argp1 = 0 ;
28806 int res1 = 0 ;
28807 PyObject *swig_obj[1] ;
28808
28809 if (!args) SWIG_fail;
28810 swig_obj[0] = args;
28811 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_DISOWN | 0 );
28812 if (!SWIG_IsOK(res1)) {
28813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorEntry" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28814 }
28815 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28816 {
28817 PyThreadState* __tstate = wxPyBeginAllowThreads();
28818 delete arg1;
28819
28820 wxPyEndAllowThreads(__tstate);
28821 if (PyErr_Occurred()) SWIG_fail;
28822 }
28823 resultobj = SWIG_Py_Void();
28824 return resultobj;
28825 fail:
28826 return NULL;
28827 }
28828
28829
28830 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28831 PyObject *resultobj = 0;
28832 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28833 int arg2 ;
28834 int arg3 ;
28835 int arg4 ;
28836 void *argp1 = 0 ;
28837 int res1 = 0 ;
28838 int val2 ;
28839 int ecode2 = 0 ;
28840 int val3 ;
28841 int ecode3 = 0 ;
28842 int val4 ;
28843 int ecode4 = 0 ;
28844 PyObject * obj0 = 0 ;
28845 PyObject * obj1 = 0 ;
28846 PyObject * obj2 = 0 ;
28847 PyObject * obj3 = 0 ;
28848 char * kwnames[] = {
28849 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
28850 };
28851
28852 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
28853 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
28854 if (!SWIG_IsOK(res1)) {
28855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_Set" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28856 }
28857 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28858 ecode2 = SWIG_AsVal_int(obj1, &val2);
28859 if (!SWIG_IsOK(ecode2)) {
28860 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AcceleratorEntry_Set" "', expected argument " "2"" of type '" "int""'");
28861 }
28862 arg2 = static_cast< int >(val2);
28863 ecode3 = SWIG_AsVal_int(obj2, &val3);
28864 if (!SWIG_IsOK(ecode3)) {
28865 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AcceleratorEntry_Set" "', expected argument " "3"" of type '" "int""'");
28866 }
28867 arg3 = static_cast< int >(val3);
28868 ecode4 = SWIG_AsVal_int(obj3, &val4);
28869 if (!SWIG_IsOK(ecode4)) {
28870 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AcceleratorEntry_Set" "', expected argument " "4"" of type '" "int""'");
28871 }
28872 arg4 = static_cast< int >(val4);
28873 {
28874 PyThreadState* __tstate = wxPyBeginAllowThreads();
28875 (arg1)->Set(arg2,arg3,arg4);
28876 wxPyEndAllowThreads(__tstate);
28877 if (PyErr_Occurred()) SWIG_fail;
28878 }
28879 resultobj = SWIG_Py_Void();
28880 return resultobj;
28881 fail:
28882 return NULL;
28883 }
28884
28885
28886 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28887 PyObject *resultobj = 0;
28888 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28889 int result;
28890 void *argp1 = 0 ;
28891 int res1 = 0 ;
28892 PyObject *swig_obj[1] ;
28893
28894 if (!args) SWIG_fail;
28895 swig_obj[0] = args;
28896 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
28897 if (!SWIG_IsOK(res1)) {
28898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetFlags" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28899 }
28900 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28901 {
28902 PyThreadState* __tstate = wxPyBeginAllowThreads();
28903 result = (int)(arg1)->GetFlags();
28904 wxPyEndAllowThreads(__tstate);
28905 if (PyErr_Occurred()) SWIG_fail;
28906 }
28907 resultobj = SWIG_From_int(static_cast< int >(result));
28908 return resultobj;
28909 fail:
28910 return NULL;
28911 }
28912
28913
28914 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28915 PyObject *resultobj = 0;
28916 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28917 int result;
28918 void *argp1 = 0 ;
28919 int res1 = 0 ;
28920 PyObject *swig_obj[1] ;
28921
28922 if (!args) SWIG_fail;
28923 swig_obj[0] = args;
28924 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
28925 if (!SWIG_IsOK(res1)) {
28926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetKeyCode" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28927 }
28928 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28929 {
28930 PyThreadState* __tstate = wxPyBeginAllowThreads();
28931 result = (int)(arg1)->GetKeyCode();
28932 wxPyEndAllowThreads(__tstate);
28933 if (PyErr_Occurred()) SWIG_fail;
28934 }
28935 resultobj = SWIG_From_int(static_cast< int >(result));
28936 return resultobj;
28937 fail:
28938 return NULL;
28939 }
28940
28941
28942 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28943 PyObject *resultobj = 0;
28944 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28945 int result;
28946 void *argp1 = 0 ;
28947 int res1 = 0 ;
28948 PyObject *swig_obj[1] ;
28949
28950 if (!args) SWIG_fail;
28951 swig_obj[0] = args;
28952 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
28953 if (!SWIG_IsOK(res1)) {
28954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetCommand" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28955 }
28956 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28957 {
28958 PyThreadState* __tstate = wxPyBeginAllowThreads();
28959 result = (int)(arg1)->GetCommand();
28960 wxPyEndAllowThreads(__tstate);
28961 if (PyErr_Occurred()) SWIG_fail;
28962 }
28963 resultobj = SWIG_From_int(static_cast< int >(result));
28964 return resultobj;
28965 fail:
28966 return NULL;
28967 }
28968
28969
28970 SWIGINTERN PyObject *AcceleratorEntry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28971 PyObject *obj;
28972 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28973 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorEntry, SWIG_NewClientData(obj));
28974 return SWIG_Py_Void();
28975 }
28976
28977 SWIGINTERN PyObject *AcceleratorEntry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28978 return SWIG_Python_InitShadowInstance(args);
28979 }
28980
28981 SWIGINTERN PyObject *_wrap_new_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28982 PyObject *resultobj = 0;
28983 int arg1 ;
28984 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
28985 wxAcceleratorTable *result = 0 ;
28986 PyObject * obj0 = 0 ;
28987 char * kwnames[] = {
28988 (char *) "n", NULL
28989 };
28990
28991 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) SWIG_fail;
28992 {
28993 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
28994 if (arg2) arg1 = PyList_Size(obj0);
28995 else arg1 = 0;
28996 }
28997 {
28998 PyThreadState* __tstate = wxPyBeginAllowThreads();
28999 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
29000 wxPyEndAllowThreads(__tstate);
29001 if (PyErr_Occurred()) SWIG_fail;
29002 }
29003 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_NEW | 0 );
29004 return resultobj;
29005 fail:
29006 return NULL;
29007 }
29008
29009
29010 SWIGINTERN PyObject *_wrap_delete_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29011 PyObject *resultobj = 0;
29012 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
29013 void *argp1 = 0 ;
29014 int res1 = 0 ;
29015 PyObject *swig_obj[1] ;
29016
29017 if (!args) SWIG_fail;
29018 swig_obj[0] = args;
29019 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_DISOWN | 0 );
29020 if (!SWIG_IsOK(res1)) {
29021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorTable" "', expected argument " "1"" of type '" "wxAcceleratorTable *""'");
29022 }
29023 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
29024 {
29025 PyThreadState* __tstate = wxPyBeginAllowThreads();
29026 delete arg1;
29027
29028 wxPyEndAllowThreads(__tstate);
29029 if (PyErr_Occurred()) SWIG_fail;
29030 }
29031 resultobj = SWIG_Py_Void();
29032 return resultobj;
29033 fail:
29034 return NULL;
29035 }
29036
29037
29038 SWIGINTERN PyObject *_wrap_AcceleratorTable_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29039 PyObject *resultobj = 0;
29040 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
29041 bool result;
29042 void *argp1 = 0 ;
29043 int res1 = 0 ;
29044 PyObject *swig_obj[1] ;
29045
29046 if (!args) SWIG_fail;
29047 swig_obj[0] = args;
29048 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
29049 if (!SWIG_IsOK(res1)) {
29050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorTable_Ok" "', expected argument " "1"" of type '" "wxAcceleratorTable const *""'");
29051 }
29052 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
29053 {
29054 PyThreadState* __tstate = wxPyBeginAllowThreads();
29055 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
29056 wxPyEndAllowThreads(__tstate);
29057 if (PyErr_Occurred()) SWIG_fail;
29058 }
29059 {
29060 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29061 }
29062 return resultobj;
29063 fail:
29064 return NULL;
29065 }
29066
29067
29068 SWIGINTERN PyObject *AcceleratorTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29069 PyObject *obj;
29070 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29071 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorTable, SWIG_NewClientData(obj));
29072 return SWIG_Py_Void();
29073 }
29074
29075 SWIGINTERN PyObject *AcceleratorTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29076 return SWIG_Python_InitShadowInstance(args);
29077 }
29078
29079 SWIGINTERN int NullAcceleratorTable_set(PyObject *) {
29080 SWIG_Error(SWIG_AttributeError,"Variable NullAcceleratorTable is read-only.");
29081 return 1;
29082 }
29083
29084
29085 SWIGINTERN PyObject *NullAcceleratorTable_get(void) {
29086 PyObject *pyobj = 0;
29087
29088 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0 );
29089 return pyobj;
29090 }
29091
29092
29093 SWIGINTERN PyObject *_wrap_GetAccelFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29094 PyObject *resultobj = 0;
29095 wxString *arg1 = 0 ;
29096 wxAcceleratorEntry *result = 0 ;
29097 bool temp1 = false ;
29098 PyObject * obj0 = 0 ;
29099 char * kwnames[] = {
29100 (char *) "label", NULL
29101 };
29102
29103 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) SWIG_fail;
29104 {
29105 arg1 = wxString_in_helper(obj0);
29106 if (arg1 == NULL) SWIG_fail;
29107 temp1 = true;
29108 }
29109 {
29110 PyThreadState* __tstate = wxPyBeginAllowThreads();
29111 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
29112 wxPyEndAllowThreads(__tstate);
29113 if (PyErr_Occurred()) SWIG_fail;
29114 }
29115 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29116 {
29117 if (temp1)
29118 delete arg1;
29119 }
29120 return resultobj;
29121 fail:
29122 {
29123 if (temp1)
29124 delete arg1;
29125 }
29126 return NULL;
29127 }
29128
29129
29130 SWIGINTERN int PanelNameStr_set(PyObject *) {
29131 SWIG_Error(SWIG_AttributeError,"Variable PanelNameStr is read-only.");
29132 return 1;
29133 }
29134
29135
29136 SWIGINTERN PyObject *PanelNameStr_get(void) {
29137 PyObject *pyobj = 0;
29138
29139 {
29140 #if wxUSE_UNICODE
29141 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29142 #else
29143 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29144 #endif
29145 }
29146 return pyobj;
29147 }
29148
29149
29150 SWIGINTERN PyObject *_wrap_new_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29151 PyObject *resultobj = 0;
29152 wxVisualAttributes *result = 0 ;
29153
29154 if (!SWIG_Python_UnpackTuple(args,"new_VisualAttributes",0,0,0)) SWIG_fail;
29155 {
29156 PyThreadState* __tstate = wxPyBeginAllowThreads();
29157 result = (wxVisualAttributes *)new_wxVisualAttributes();
29158 wxPyEndAllowThreads(__tstate);
29159 if (PyErr_Occurred()) SWIG_fail;
29160 }
29161 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_NEW | 0 );
29162 return resultobj;
29163 fail:
29164 return NULL;
29165 }
29166
29167
29168 SWIGINTERN PyObject *_wrap_delete_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29169 PyObject *resultobj = 0;
29170 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29171 void *argp1 = 0 ;
29172 int res1 = 0 ;
29173 PyObject *swig_obj[1] ;
29174
29175 if (!args) SWIG_fail;
29176 swig_obj[0] = args;
29177 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_DISOWN | 0 );
29178 if (!SWIG_IsOK(res1)) {
29179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VisualAttributes" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29180 }
29181 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29182 {
29183 PyThreadState* __tstate = wxPyBeginAllowThreads();
29184 delete_wxVisualAttributes(arg1);
29185
29186 wxPyEndAllowThreads(__tstate);
29187 if (PyErr_Occurred()) SWIG_fail;
29188 }
29189 resultobj = SWIG_Py_Void();
29190 return resultobj;
29191 fail:
29192 return NULL;
29193 }
29194
29195
29196 SWIGINTERN PyObject *_wrap_VisualAttributes_font_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29197 PyObject *resultobj = 0;
29198 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29199 wxFont *arg2 = (wxFont *) 0 ;
29200 void *argp1 = 0 ;
29201 int res1 = 0 ;
29202 void *argp2 = 0 ;
29203 int res2 = 0 ;
29204 PyObject *swig_obj[2] ;
29205
29206 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_font_set",2,2,swig_obj)) SWIG_fail;
29207 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29208 if (!SWIG_IsOK(res1)) {
29209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29210 }
29211 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29212 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
29213 if (!SWIG_IsOK(res2)) {
29214 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_font_set" "', expected argument " "2"" of type '" "wxFont *""'");
29215 }
29216 arg2 = reinterpret_cast< wxFont * >(argp2);
29217 if (arg1) (arg1)->font = *arg2;
29218
29219 resultobj = SWIG_Py_Void();
29220 return resultobj;
29221 fail:
29222 return NULL;
29223 }
29224
29225
29226 SWIGINTERN PyObject *_wrap_VisualAttributes_font_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29227 PyObject *resultobj = 0;
29228 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29229 wxFont *result = 0 ;
29230 void *argp1 = 0 ;
29231 int res1 = 0 ;
29232 PyObject *swig_obj[1] ;
29233
29234 if (!args) SWIG_fail;
29235 swig_obj[0] = args;
29236 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29237 if (!SWIG_IsOK(res1)) {
29238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29239 }
29240 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29241 result = (wxFont *)& ((arg1)->font);
29242 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, 0 | 0 );
29243 return resultobj;
29244 fail:
29245 return NULL;
29246 }
29247
29248
29249 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29250 PyObject *resultobj = 0;
29251 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29252 wxColour *arg2 = (wxColour *) 0 ;
29253 void *argp1 = 0 ;
29254 int res1 = 0 ;
29255 void *argp2 = 0 ;
29256 int res2 = 0 ;
29257 PyObject *swig_obj[2] ;
29258
29259 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colFg_set",2,2,swig_obj)) SWIG_fail;
29260 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29261 if (!SWIG_IsOK(res1)) {
29262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29263 }
29264 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29265 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29266 if (!SWIG_IsOK(res2)) {
29267 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colFg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29268 }
29269 arg2 = reinterpret_cast< wxColour * >(argp2);
29270 if (arg1) (arg1)->colFg = *arg2;
29271
29272 resultobj = SWIG_Py_Void();
29273 return resultobj;
29274 fail:
29275 return NULL;
29276 }
29277
29278
29279 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29280 PyObject *resultobj = 0;
29281 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29282 wxColour *result = 0 ;
29283 void *argp1 = 0 ;
29284 int res1 = 0 ;
29285 PyObject *swig_obj[1] ;
29286
29287 if (!args) SWIG_fail;
29288 swig_obj[0] = args;
29289 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29290 if (!SWIG_IsOK(res1)) {
29291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29292 }
29293 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29294 result = (wxColour *)& ((arg1)->colFg);
29295 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29296 return resultobj;
29297 fail:
29298 return NULL;
29299 }
29300
29301
29302 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29303 PyObject *resultobj = 0;
29304 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29305 wxColour *arg2 = (wxColour *) 0 ;
29306 void *argp1 = 0 ;
29307 int res1 = 0 ;
29308 void *argp2 = 0 ;
29309 int res2 = 0 ;
29310 PyObject *swig_obj[2] ;
29311
29312 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colBg_set",2,2,swig_obj)) SWIG_fail;
29313 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29314 if (!SWIG_IsOK(res1)) {
29315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29316 }
29317 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29318 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29319 if (!SWIG_IsOK(res2)) {
29320 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colBg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29321 }
29322 arg2 = reinterpret_cast< wxColour * >(argp2);
29323 if (arg1) (arg1)->colBg = *arg2;
29324
29325 resultobj = SWIG_Py_Void();
29326 return resultobj;
29327 fail:
29328 return NULL;
29329 }
29330
29331
29332 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29333 PyObject *resultobj = 0;
29334 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29335 wxColour *result = 0 ;
29336 void *argp1 = 0 ;
29337 int res1 = 0 ;
29338 PyObject *swig_obj[1] ;
29339
29340 if (!args) SWIG_fail;
29341 swig_obj[0] = args;
29342 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29343 if (!SWIG_IsOK(res1)) {
29344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29345 }
29346 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29347 result = (wxColour *)& ((arg1)->colBg);
29348 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29349 return resultobj;
29350 fail:
29351 return NULL;
29352 }
29353
29354
29355 SWIGINTERN PyObject *VisualAttributes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29356 PyObject *obj;
29357 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29358 SWIG_TypeNewClientData(SWIGTYPE_p_wxVisualAttributes, SWIG_NewClientData(obj));
29359 return SWIG_Py_Void();
29360 }
29361
29362 SWIGINTERN PyObject *VisualAttributes_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29363 return SWIG_Python_InitShadowInstance(args);
29364 }
29365
29366 SWIGINTERN PyObject *_wrap_new_Window(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29367 PyObject *resultobj = 0;
29368 wxWindow *arg1 = (wxWindow *) 0 ;
29369 int arg2 = (int) (int)-1 ;
29370 wxPoint const &arg3_defvalue = wxDefaultPosition ;
29371 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
29372 wxSize const &arg4_defvalue = wxDefaultSize ;
29373 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
29374 long arg5 = (long) 0 ;
29375 wxString const &arg6_defvalue = wxPyPanelNameStr ;
29376 wxString *arg6 = (wxString *) &arg6_defvalue ;
29377 wxWindow *result = 0 ;
29378 void *argp1 = 0 ;
29379 int res1 = 0 ;
29380 int val2 ;
29381 int ecode2 = 0 ;
29382 wxPoint temp3 ;
29383 wxSize temp4 ;
29384 long val5 ;
29385 int ecode5 = 0 ;
29386 bool temp6 = false ;
29387 PyObject * obj0 = 0 ;
29388 PyObject * obj1 = 0 ;
29389 PyObject * obj2 = 0 ;
29390 PyObject * obj3 = 0 ;
29391 PyObject * obj4 = 0 ;
29392 PyObject * obj5 = 0 ;
29393 char * kwnames[] = {
29394 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
29395 };
29396
29397 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
29398 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29399 if (!SWIG_IsOK(res1)) {
29400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Window" "', expected argument " "1"" of type '" "wxWindow *""'");
29401 }
29402 arg1 = reinterpret_cast< wxWindow * >(argp1);
29403 if (obj1) {
29404 ecode2 = SWIG_AsVal_int(obj1, &val2);
29405 if (!SWIG_IsOK(ecode2)) {
29406 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Window" "', expected argument " "2"" of type '" "int""'");
29407 }
29408 arg2 = static_cast< int >(val2);
29409 }
29410 if (obj2) {
29411 {
29412 arg3 = &temp3;
29413 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
29414 }
29415 }
29416 if (obj3) {
29417 {
29418 arg4 = &temp4;
29419 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
29420 }
29421 }
29422 if (obj4) {
29423 ecode5 = SWIG_AsVal_long(obj4, &val5);
29424 if (!SWIG_IsOK(ecode5)) {
29425 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Window" "', expected argument " "5"" of type '" "long""'");
29426 }
29427 arg5 = static_cast< long >(val5);
29428 }
29429 if (obj5) {
29430 {
29431 arg6 = wxString_in_helper(obj5);
29432 if (arg6 == NULL) SWIG_fail;
29433 temp6 = true;
29434 }
29435 }
29436 {
29437 if (!wxPyCheckForApp()) SWIG_fail;
29438 PyThreadState* __tstate = wxPyBeginAllowThreads();
29439 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
29440 wxPyEndAllowThreads(__tstate);
29441 if (PyErr_Occurred()) SWIG_fail;
29442 }
29443 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_NEW | 0 );
29444 {
29445 if (temp6)
29446 delete arg6;
29447 }
29448 return resultobj;
29449 fail:
29450 {
29451 if (temp6)
29452 delete arg6;
29453 }
29454 return NULL;
29455 }
29456
29457
29458 SWIGINTERN PyObject *_wrap_new_PreWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29459 PyObject *resultobj = 0;
29460 wxWindow *result = 0 ;
29461
29462 if (!SWIG_Python_UnpackTuple(args,"new_PreWindow",0,0,0)) SWIG_fail;
29463 {
29464 if (!wxPyCheckForApp()) SWIG_fail;
29465 PyThreadState* __tstate = wxPyBeginAllowThreads();
29466 result = (wxWindow *)new wxWindow();
29467 wxPyEndAllowThreads(__tstate);
29468 if (PyErr_Occurred()) SWIG_fail;
29469 }
29470 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_OWN | 0 );
29471 return resultobj;
29472 fail:
29473 return NULL;
29474 }
29475
29476
29477 SWIGINTERN PyObject *_wrap_Window_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29478 PyObject *resultobj = 0;
29479 wxWindow *arg1 = (wxWindow *) 0 ;
29480 wxWindow *arg2 = (wxWindow *) 0 ;
29481 int arg3 = (int) (int)-1 ;
29482 wxPoint const &arg4_defvalue = wxDefaultPosition ;
29483 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
29484 wxSize const &arg5_defvalue = wxDefaultSize ;
29485 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
29486 long arg6 = (long) 0 ;
29487 wxString const &arg7_defvalue = wxPyPanelNameStr ;
29488 wxString *arg7 = (wxString *) &arg7_defvalue ;
29489 bool result;
29490 void *argp1 = 0 ;
29491 int res1 = 0 ;
29492 void *argp2 = 0 ;
29493 int res2 = 0 ;
29494 int val3 ;
29495 int ecode3 = 0 ;
29496 wxPoint temp4 ;
29497 wxSize temp5 ;
29498 long val6 ;
29499 int ecode6 = 0 ;
29500 bool temp7 = false ;
29501 PyObject * obj0 = 0 ;
29502 PyObject * obj1 = 0 ;
29503 PyObject * obj2 = 0 ;
29504 PyObject * obj3 = 0 ;
29505 PyObject * obj4 = 0 ;
29506 PyObject * obj5 = 0 ;
29507 PyObject * obj6 = 0 ;
29508 char * kwnames[] = {
29509 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
29510 };
29511
29512 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
29513 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29514 if (!SWIG_IsOK(res1)) {
29515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Create" "', expected argument " "1"" of type '" "wxWindow *""'");
29516 }
29517 arg1 = reinterpret_cast< wxWindow * >(argp1);
29518 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
29519 if (!SWIG_IsOK(res2)) {
29520 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
29521 }
29522 arg2 = reinterpret_cast< wxWindow * >(argp2);
29523 if (obj2) {
29524 ecode3 = SWIG_AsVal_int(obj2, &val3);
29525 if (!SWIG_IsOK(ecode3)) {
29526 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Create" "', expected argument " "3"" of type '" "int""'");
29527 }
29528 arg3 = static_cast< int >(val3);
29529 }
29530 if (obj3) {
29531 {
29532 arg4 = &temp4;
29533 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
29534 }
29535 }
29536 if (obj4) {
29537 {
29538 arg5 = &temp5;
29539 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
29540 }
29541 }
29542 if (obj5) {
29543 ecode6 = SWIG_AsVal_long(obj5, &val6);
29544 if (!SWIG_IsOK(ecode6)) {
29545 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_Create" "', expected argument " "6"" of type '" "long""'");
29546 }
29547 arg6 = static_cast< long >(val6);
29548 }
29549 if (obj6) {
29550 {
29551 arg7 = wxString_in_helper(obj6);
29552 if (arg7 == NULL) SWIG_fail;
29553 temp7 = true;
29554 }
29555 }
29556 {
29557 PyThreadState* __tstate = wxPyBeginAllowThreads();
29558 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
29559 wxPyEndAllowThreads(__tstate);
29560 if (PyErr_Occurred()) SWIG_fail;
29561 }
29562 {
29563 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29564 }
29565 {
29566 if (temp7)
29567 delete arg7;
29568 }
29569 return resultobj;
29570 fail:
29571 {
29572 if (temp7)
29573 delete arg7;
29574 }
29575 return NULL;
29576 }
29577
29578
29579 SWIGINTERN PyObject *_wrap_Window_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29580 PyObject *resultobj = 0;
29581 wxWindow *arg1 = (wxWindow *) 0 ;
29582 bool arg2 = (bool) false ;
29583 bool result;
29584 void *argp1 = 0 ;
29585 int res1 = 0 ;
29586 bool val2 ;
29587 int ecode2 = 0 ;
29588 PyObject * obj0 = 0 ;
29589 PyObject * obj1 = 0 ;
29590 char * kwnames[] = {
29591 (char *) "self",(char *) "force", NULL
29592 };
29593
29594 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) SWIG_fail;
29595 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29596 if (!SWIG_IsOK(res1)) {
29597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Close" "', expected argument " "1"" of type '" "wxWindow *""'");
29598 }
29599 arg1 = reinterpret_cast< wxWindow * >(argp1);
29600 if (obj1) {
29601 ecode2 = SWIG_AsVal_bool(obj1, &val2);
29602 if (!SWIG_IsOK(ecode2)) {
29603 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Close" "', expected argument " "2"" of type '" "bool""'");
29604 }
29605 arg2 = static_cast< bool >(val2);
29606 }
29607 {
29608 PyThreadState* __tstate = wxPyBeginAllowThreads();
29609 result = (bool)(arg1)->Close(arg2);
29610 wxPyEndAllowThreads(__tstate);
29611 if (PyErr_Occurred()) SWIG_fail;
29612 }
29613 {
29614 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29615 }
29616 return resultobj;
29617 fail:
29618 return NULL;
29619 }
29620
29621
29622 SWIGINTERN PyObject *_wrap_Window_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29623 PyObject *resultobj = 0;
29624 wxWindow *arg1 = (wxWindow *) 0 ;
29625 bool result;
29626 void *argp1 = 0 ;
29627 int res1 = 0 ;
29628 PyObject *swig_obj[1] ;
29629
29630 if (!args) SWIG_fail;
29631 swig_obj[0] = args;
29632 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29633 if (!SWIG_IsOK(res1)) {
29634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Destroy" "', expected argument " "1"" of type '" "wxWindow *""'");
29635 }
29636 arg1 = reinterpret_cast< wxWindow * >(argp1);
29637 {
29638 PyThreadState* __tstate = wxPyBeginAllowThreads();
29639 result = (bool)(arg1)->Destroy();
29640 wxPyEndAllowThreads(__tstate);
29641 if (PyErr_Occurred()) SWIG_fail;
29642 }
29643 {
29644 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29645 }
29646 return resultobj;
29647 fail:
29648 return NULL;
29649 }
29650
29651
29652 SWIGINTERN PyObject *_wrap_Window_DestroyChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29653 PyObject *resultobj = 0;
29654 wxWindow *arg1 = (wxWindow *) 0 ;
29655 bool result;
29656 void *argp1 = 0 ;
29657 int res1 = 0 ;
29658 PyObject *swig_obj[1] ;
29659
29660 if (!args) SWIG_fail;
29661 swig_obj[0] = args;
29662 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29663 if (!SWIG_IsOK(res1)) {
29664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DestroyChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
29665 }
29666 arg1 = reinterpret_cast< wxWindow * >(argp1);
29667 {
29668 PyThreadState* __tstate = wxPyBeginAllowThreads();
29669 result = (bool)(arg1)->DestroyChildren();
29670 wxPyEndAllowThreads(__tstate);
29671 if (PyErr_Occurred()) SWIG_fail;
29672 }
29673 {
29674 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29675 }
29676 return resultobj;
29677 fail:
29678 return NULL;
29679 }
29680
29681
29682 SWIGINTERN PyObject *_wrap_Window_IsBeingDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29683 PyObject *resultobj = 0;
29684 wxWindow *arg1 = (wxWindow *) 0 ;
29685 bool result;
29686 void *argp1 = 0 ;
29687 int res1 = 0 ;
29688 PyObject *swig_obj[1] ;
29689
29690 if (!args) SWIG_fail;
29691 swig_obj[0] = args;
29692 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29693 if (!SWIG_IsOK(res1)) {
29694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsBeingDeleted" "', expected argument " "1"" of type '" "wxWindow const *""'");
29695 }
29696 arg1 = reinterpret_cast< wxWindow * >(argp1);
29697 {
29698 PyThreadState* __tstate = wxPyBeginAllowThreads();
29699 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
29700 wxPyEndAllowThreads(__tstate);
29701 if (PyErr_Occurred()) SWIG_fail;
29702 }
29703 {
29704 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29705 }
29706 return resultobj;
29707 fail:
29708 return NULL;
29709 }
29710
29711
29712 SWIGINTERN PyObject *_wrap_Window_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29713 PyObject *resultobj = 0;
29714 wxWindow *arg1 = (wxWindow *) 0 ;
29715 wxString *arg2 = 0 ;
29716 void *argp1 = 0 ;
29717 int res1 = 0 ;
29718 bool temp2 = false ;
29719 PyObject * obj0 = 0 ;
29720 PyObject * obj1 = 0 ;
29721 char * kwnames[] = {
29722 (char *) "self",(char *) "label", NULL
29723 };
29724
29725 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
29726 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29727 if (!SWIG_IsOK(res1)) {
29728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLabel" "', expected argument " "1"" of type '" "wxWindow *""'");
29729 }
29730 arg1 = reinterpret_cast< wxWindow * >(argp1);
29731 {
29732 arg2 = wxString_in_helper(obj1);
29733 if (arg2 == NULL) SWIG_fail;
29734 temp2 = true;
29735 }
29736 {
29737 PyThreadState* __tstate = wxPyBeginAllowThreads();
29738 (arg1)->SetLabel((wxString const &)*arg2);
29739 wxPyEndAllowThreads(__tstate);
29740 if (PyErr_Occurred()) SWIG_fail;
29741 }
29742 resultobj = SWIG_Py_Void();
29743 {
29744 if (temp2)
29745 delete arg2;
29746 }
29747 return resultobj;
29748 fail:
29749 {
29750 if (temp2)
29751 delete arg2;
29752 }
29753 return NULL;
29754 }
29755
29756
29757 SWIGINTERN PyObject *_wrap_Window_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29758 PyObject *resultobj = 0;
29759 wxWindow *arg1 = (wxWindow *) 0 ;
29760 wxString result;
29761 void *argp1 = 0 ;
29762 int res1 = 0 ;
29763 PyObject *swig_obj[1] ;
29764
29765 if (!args) SWIG_fail;
29766 swig_obj[0] = args;
29767 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29768 if (!SWIG_IsOK(res1)) {
29769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLabel" "', expected argument " "1"" of type '" "wxWindow const *""'");
29770 }
29771 arg1 = reinterpret_cast< wxWindow * >(argp1);
29772 {
29773 PyThreadState* __tstate = wxPyBeginAllowThreads();
29774 result = ((wxWindow const *)arg1)->GetLabel();
29775 wxPyEndAllowThreads(__tstate);
29776 if (PyErr_Occurred()) SWIG_fail;
29777 }
29778 {
29779 #if wxUSE_UNICODE
29780 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
29781 #else
29782 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
29783 #endif
29784 }
29785 return resultobj;
29786 fail:
29787 return NULL;
29788 }
29789
29790
29791 SWIGINTERN PyObject *_wrap_Window_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29792 PyObject *resultobj = 0;
29793 wxWindow *arg1 = (wxWindow *) 0 ;
29794 wxString *arg2 = 0 ;
29795 void *argp1 = 0 ;
29796 int res1 = 0 ;
29797 bool temp2 = false ;
29798 PyObject * obj0 = 0 ;
29799 PyObject * obj1 = 0 ;
29800 char * kwnames[] = {
29801 (char *) "self",(char *) "name", NULL
29802 };
29803
29804 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
29805 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29806 if (!SWIG_IsOK(res1)) {
29807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetName" "', expected argument " "1"" of type '" "wxWindow *""'");
29808 }
29809 arg1 = reinterpret_cast< wxWindow * >(argp1);
29810 {
29811 arg2 = wxString_in_helper(obj1);
29812 if (arg2 == NULL) SWIG_fail;
29813 temp2 = true;
29814 }
29815 {
29816 PyThreadState* __tstate = wxPyBeginAllowThreads();
29817 (arg1)->SetName((wxString const &)*arg2);
29818 wxPyEndAllowThreads(__tstate);
29819 if (PyErr_Occurred()) SWIG_fail;
29820 }
29821 resultobj = SWIG_Py_Void();
29822 {
29823 if (temp2)
29824 delete arg2;
29825 }
29826 return resultobj;
29827 fail:
29828 {
29829 if (temp2)
29830 delete arg2;
29831 }
29832 return NULL;
29833 }
29834
29835
29836 SWIGINTERN PyObject *_wrap_Window_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29837 PyObject *resultobj = 0;
29838 wxWindow *arg1 = (wxWindow *) 0 ;
29839 wxString result;
29840 void *argp1 = 0 ;
29841 int res1 = 0 ;
29842 PyObject *swig_obj[1] ;
29843
29844 if (!args) SWIG_fail;
29845 swig_obj[0] = args;
29846 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29847 if (!SWIG_IsOK(res1)) {
29848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetName" "', expected argument " "1"" of type '" "wxWindow const *""'");
29849 }
29850 arg1 = reinterpret_cast< wxWindow * >(argp1);
29851 {
29852 PyThreadState* __tstate = wxPyBeginAllowThreads();
29853 result = ((wxWindow const *)arg1)->GetName();
29854 wxPyEndAllowThreads(__tstate);
29855 if (PyErr_Occurred()) SWIG_fail;
29856 }
29857 {
29858 #if wxUSE_UNICODE
29859 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
29860 #else
29861 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
29862 #endif
29863 }
29864 return resultobj;
29865 fail:
29866 return NULL;
29867 }
29868
29869
29870 SWIGINTERN PyObject *_wrap_Window_SetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29871 PyObject *resultobj = 0;
29872 wxWindow *arg1 = (wxWindow *) 0 ;
29873 wxWindowVariant arg2 ;
29874 void *argp1 = 0 ;
29875 int res1 = 0 ;
29876 int val2 ;
29877 int ecode2 = 0 ;
29878 PyObject * obj0 = 0 ;
29879 PyObject * obj1 = 0 ;
29880 char * kwnames[] = {
29881 (char *) "self",(char *) "variant", NULL
29882 };
29883
29884 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) SWIG_fail;
29885 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29886 if (!SWIG_IsOK(res1)) {
29887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowVariant" "', expected argument " "1"" of type '" "wxWindow *""'");
29888 }
29889 arg1 = reinterpret_cast< wxWindow * >(argp1);
29890 ecode2 = SWIG_AsVal_int(obj1, &val2);
29891 if (!SWIG_IsOK(ecode2)) {
29892 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowVariant" "', expected argument " "2"" of type '" "wxWindowVariant""'");
29893 }
29894 arg2 = static_cast< wxWindowVariant >(val2);
29895 {
29896 PyThreadState* __tstate = wxPyBeginAllowThreads();
29897 (arg1)->SetWindowVariant(arg2);
29898 wxPyEndAllowThreads(__tstate);
29899 if (PyErr_Occurred()) SWIG_fail;
29900 }
29901 resultobj = SWIG_Py_Void();
29902 return resultobj;
29903 fail:
29904 return NULL;
29905 }
29906
29907
29908 SWIGINTERN PyObject *_wrap_Window_GetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29909 PyObject *resultobj = 0;
29910 wxWindow *arg1 = (wxWindow *) 0 ;
29911 wxWindowVariant result;
29912 void *argp1 = 0 ;
29913 int res1 = 0 ;
29914 PyObject *swig_obj[1] ;
29915
29916 if (!args) SWIG_fail;
29917 swig_obj[0] = args;
29918 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29919 if (!SWIG_IsOK(res1)) {
29920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowVariant" "', expected argument " "1"" of type '" "wxWindow const *""'");
29921 }
29922 arg1 = reinterpret_cast< wxWindow * >(argp1);
29923 {
29924 PyThreadState* __tstate = wxPyBeginAllowThreads();
29925 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
29926 wxPyEndAllowThreads(__tstate);
29927 if (PyErr_Occurred()) SWIG_fail;
29928 }
29929 resultobj = SWIG_From_int(static_cast< int >(result));
29930 return resultobj;
29931 fail:
29932 return NULL;
29933 }
29934
29935
29936 SWIGINTERN PyObject *_wrap_Window_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29937 PyObject *resultobj = 0;
29938 wxWindow *arg1 = (wxWindow *) 0 ;
29939 int arg2 ;
29940 void *argp1 = 0 ;
29941 int res1 = 0 ;
29942 int val2 ;
29943 int ecode2 = 0 ;
29944 PyObject * obj0 = 0 ;
29945 PyObject * obj1 = 0 ;
29946 char * kwnames[] = {
29947 (char *) "self",(char *) "winid", NULL
29948 };
29949
29950 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
29951 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29952 if (!SWIG_IsOK(res1)) {
29953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetId" "', expected argument " "1"" of type '" "wxWindow *""'");
29954 }
29955 arg1 = reinterpret_cast< wxWindow * >(argp1);
29956 ecode2 = SWIG_AsVal_int(obj1, &val2);
29957 if (!SWIG_IsOK(ecode2)) {
29958 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetId" "', expected argument " "2"" of type '" "int""'");
29959 }
29960 arg2 = static_cast< int >(val2);
29961 {
29962 PyThreadState* __tstate = wxPyBeginAllowThreads();
29963 (arg1)->SetId(arg2);
29964 wxPyEndAllowThreads(__tstate);
29965 if (PyErr_Occurred()) SWIG_fail;
29966 }
29967 resultobj = SWIG_Py_Void();
29968 return resultobj;
29969 fail:
29970 return NULL;
29971 }
29972
29973
29974 SWIGINTERN PyObject *_wrap_Window_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29975 PyObject *resultobj = 0;
29976 wxWindow *arg1 = (wxWindow *) 0 ;
29977 int result;
29978 void *argp1 = 0 ;
29979 int res1 = 0 ;
29980 PyObject *swig_obj[1] ;
29981
29982 if (!args) SWIG_fail;
29983 swig_obj[0] = args;
29984 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29985 if (!SWIG_IsOK(res1)) {
29986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetId" "', expected argument " "1"" of type '" "wxWindow const *""'");
29987 }
29988 arg1 = reinterpret_cast< wxWindow * >(argp1);
29989 {
29990 PyThreadState* __tstate = wxPyBeginAllowThreads();
29991 result = (int)((wxWindow const *)arg1)->GetId();
29992 wxPyEndAllowThreads(__tstate);
29993 if (PyErr_Occurred()) SWIG_fail;
29994 }
29995 resultobj = SWIG_From_int(static_cast< int >(result));
29996 return resultobj;
29997 fail:
29998 return NULL;
29999 }
30000
30001
30002 SWIGINTERN PyObject *_wrap_Window_NewControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30003 PyObject *resultobj = 0;
30004 int result;
30005
30006 if (!SWIG_Python_UnpackTuple(args,"Window_NewControlId",0,0,0)) SWIG_fail;
30007 {
30008 PyThreadState* __tstate = wxPyBeginAllowThreads();
30009 result = (int)wxWindow::NewControlId();
30010 wxPyEndAllowThreads(__tstate);
30011 if (PyErr_Occurred()) SWIG_fail;
30012 }
30013 resultobj = SWIG_From_int(static_cast< int >(result));
30014 return resultobj;
30015 fail:
30016 return NULL;
30017 }
30018
30019
30020 SWIGINTERN PyObject *_wrap_Window_NextControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30021 PyObject *resultobj = 0;
30022 int arg1 ;
30023 int result;
30024 int val1 ;
30025 int ecode1 = 0 ;
30026 PyObject * obj0 = 0 ;
30027 char * kwnames[] = {
30028 (char *) "winid", NULL
30029 };
30030
30031 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) SWIG_fail;
30032 ecode1 = SWIG_AsVal_int(obj0, &val1);
30033 if (!SWIG_IsOK(ecode1)) {
30034 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_NextControlId" "', expected argument " "1"" of type '" "int""'");
30035 }
30036 arg1 = static_cast< int >(val1);
30037 {
30038 PyThreadState* __tstate = wxPyBeginAllowThreads();
30039 result = (int)wxWindow::NextControlId(arg1);
30040 wxPyEndAllowThreads(__tstate);
30041 if (PyErr_Occurred()) SWIG_fail;
30042 }
30043 resultobj = SWIG_From_int(static_cast< int >(result));
30044 return resultobj;
30045 fail:
30046 return NULL;
30047 }
30048
30049
30050 SWIGINTERN PyObject *_wrap_Window_PrevControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30051 PyObject *resultobj = 0;
30052 int arg1 ;
30053 int result;
30054 int val1 ;
30055 int ecode1 = 0 ;
30056 PyObject * obj0 = 0 ;
30057 char * kwnames[] = {
30058 (char *) "winid", NULL
30059 };
30060
30061 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) SWIG_fail;
30062 ecode1 = SWIG_AsVal_int(obj0, &val1);
30063 if (!SWIG_IsOK(ecode1)) {
30064 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_PrevControlId" "', expected argument " "1"" of type '" "int""'");
30065 }
30066 arg1 = static_cast< int >(val1);
30067 {
30068 PyThreadState* __tstate = wxPyBeginAllowThreads();
30069 result = (int)wxWindow::PrevControlId(arg1);
30070 wxPyEndAllowThreads(__tstate);
30071 if (PyErr_Occurred()) SWIG_fail;
30072 }
30073 resultobj = SWIG_From_int(static_cast< int >(result));
30074 return resultobj;
30075 fail:
30076 return NULL;
30077 }
30078
30079
30080 SWIGINTERN PyObject *_wrap_Window_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30081 PyObject *resultobj = 0;
30082 wxWindow *arg1 = (wxWindow *) 0 ;
30083 wxSize *arg2 = 0 ;
30084 void *argp1 = 0 ;
30085 int res1 = 0 ;
30086 wxSize temp2 ;
30087 PyObject * obj0 = 0 ;
30088 PyObject * obj1 = 0 ;
30089 char * kwnames[] = {
30090 (char *) "self",(char *) "size", NULL
30091 };
30092
30093 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
30094 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30095 if (!SWIG_IsOK(res1)) {
30096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30097 }
30098 arg1 = reinterpret_cast< wxWindow * >(argp1);
30099 {
30100 arg2 = &temp2;
30101 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30102 }
30103 {
30104 PyThreadState* __tstate = wxPyBeginAllowThreads();
30105 (arg1)->SetSize((wxSize const &)*arg2);
30106 wxPyEndAllowThreads(__tstate);
30107 if (PyErr_Occurred()) SWIG_fail;
30108 }
30109 resultobj = SWIG_Py_Void();
30110 return resultobj;
30111 fail:
30112 return NULL;
30113 }
30114
30115
30116 SWIGINTERN PyObject *_wrap_Window_SetDimensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30117 PyObject *resultobj = 0;
30118 wxWindow *arg1 = (wxWindow *) 0 ;
30119 int arg2 ;
30120 int arg3 ;
30121 int arg4 ;
30122 int arg5 ;
30123 int arg6 = (int) wxSIZE_AUTO ;
30124 void *argp1 = 0 ;
30125 int res1 = 0 ;
30126 int val2 ;
30127 int ecode2 = 0 ;
30128 int val3 ;
30129 int ecode3 = 0 ;
30130 int val4 ;
30131 int ecode4 = 0 ;
30132 int val5 ;
30133 int ecode5 = 0 ;
30134 int val6 ;
30135 int ecode6 = 0 ;
30136 PyObject * obj0 = 0 ;
30137 PyObject * obj1 = 0 ;
30138 PyObject * obj2 = 0 ;
30139 PyObject * obj3 = 0 ;
30140 PyObject * obj4 = 0 ;
30141 PyObject * obj5 = 0 ;
30142 char * kwnames[] = {
30143 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
30144 };
30145
30146 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
30147 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30148 if (!SWIG_IsOK(res1)) {
30149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDimensions" "', expected argument " "1"" of type '" "wxWindow *""'");
30150 }
30151 arg1 = reinterpret_cast< wxWindow * >(argp1);
30152 ecode2 = SWIG_AsVal_int(obj1, &val2);
30153 if (!SWIG_IsOK(ecode2)) {
30154 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDimensions" "', expected argument " "2"" of type '" "int""'");
30155 }
30156 arg2 = static_cast< int >(val2);
30157 ecode3 = SWIG_AsVal_int(obj2, &val3);
30158 if (!SWIG_IsOK(ecode3)) {
30159 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetDimensions" "', expected argument " "3"" of type '" "int""'");
30160 }
30161 arg3 = static_cast< int >(val3);
30162 ecode4 = SWIG_AsVal_int(obj3, &val4);
30163 if (!SWIG_IsOK(ecode4)) {
30164 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetDimensions" "', expected argument " "4"" of type '" "int""'");
30165 }
30166 arg4 = static_cast< int >(val4);
30167 ecode5 = SWIG_AsVal_int(obj4, &val5);
30168 if (!SWIG_IsOK(ecode5)) {
30169 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetDimensions" "', expected argument " "5"" of type '" "int""'");
30170 }
30171 arg5 = static_cast< int >(val5);
30172 if (obj5) {
30173 ecode6 = SWIG_AsVal_int(obj5, &val6);
30174 if (!SWIG_IsOK(ecode6)) {
30175 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetDimensions" "', expected argument " "6"" of type '" "int""'");
30176 }
30177 arg6 = static_cast< int >(val6);
30178 }
30179 {
30180 PyThreadState* __tstate = wxPyBeginAllowThreads();
30181 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
30182 wxPyEndAllowThreads(__tstate);
30183 if (PyErr_Occurred()) SWIG_fail;
30184 }
30185 resultobj = SWIG_Py_Void();
30186 return resultobj;
30187 fail:
30188 return NULL;
30189 }
30190
30191
30192 SWIGINTERN PyObject *_wrap_Window_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30193 PyObject *resultobj = 0;
30194 wxWindow *arg1 = (wxWindow *) 0 ;
30195 wxRect *arg2 = 0 ;
30196 int arg3 = (int) wxSIZE_AUTO ;
30197 void *argp1 = 0 ;
30198 int res1 = 0 ;
30199 wxRect temp2 ;
30200 int val3 ;
30201 int ecode3 = 0 ;
30202 PyObject * obj0 = 0 ;
30203 PyObject * obj1 = 0 ;
30204 PyObject * obj2 = 0 ;
30205 char * kwnames[] = {
30206 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
30207 };
30208
30209 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30210 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30211 if (!SWIG_IsOK(res1)) {
30212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetRect" "', expected argument " "1"" of type '" "wxWindow *""'");
30213 }
30214 arg1 = reinterpret_cast< wxWindow * >(argp1);
30215 {
30216 arg2 = &temp2;
30217 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30218 }
30219 if (obj2) {
30220 ecode3 = SWIG_AsVal_int(obj2, &val3);
30221 if (!SWIG_IsOK(ecode3)) {
30222 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetRect" "', expected argument " "3"" of type '" "int""'");
30223 }
30224 arg3 = static_cast< int >(val3);
30225 }
30226 {
30227 PyThreadState* __tstate = wxPyBeginAllowThreads();
30228 (arg1)->SetSize((wxRect const &)*arg2,arg3);
30229 wxPyEndAllowThreads(__tstate);
30230 if (PyErr_Occurred()) SWIG_fail;
30231 }
30232 resultobj = SWIG_Py_Void();
30233 return resultobj;
30234 fail:
30235 return NULL;
30236 }
30237
30238
30239 SWIGINTERN PyObject *_wrap_Window_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30240 PyObject *resultobj = 0;
30241 wxWindow *arg1 = (wxWindow *) 0 ;
30242 int arg2 ;
30243 int arg3 ;
30244 void *argp1 = 0 ;
30245 int res1 = 0 ;
30246 int val2 ;
30247 int ecode2 = 0 ;
30248 int val3 ;
30249 int ecode3 = 0 ;
30250 PyObject * obj0 = 0 ;
30251 PyObject * obj1 = 0 ;
30252 PyObject * obj2 = 0 ;
30253 char * kwnames[] = {
30254 (char *) "self",(char *) "width",(char *) "height", NULL
30255 };
30256
30257 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30258 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30259 if (!SWIG_IsOK(res1)) {
30260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
30261 }
30262 arg1 = reinterpret_cast< wxWindow * >(argp1);
30263 ecode2 = SWIG_AsVal_int(obj1, &val2);
30264 if (!SWIG_IsOK(ecode2)) {
30265 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
30266 }
30267 arg2 = static_cast< int >(val2);
30268 ecode3 = SWIG_AsVal_int(obj2, &val3);
30269 if (!SWIG_IsOK(ecode3)) {
30270 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
30271 }
30272 arg3 = static_cast< int >(val3);
30273 {
30274 PyThreadState* __tstate = wxPyBeginAllowThreads();
30275 (arg1)->SetSize(arg2,arg3);
30276 wxPyEndAllowThreads(__tstate);
30277 if (PyErr_Occurred()) SWIG_fail;
30278 }
30279 resultobj = SWIG_Py_Void();
30280 return resultobj;
30281 fail:
30282 return NULL;
30283 }
30284
30285
30286 SWIGINTERN PyObject *_wrap_Window_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30287 PyObject *resultobj = 0;
30288 wxWindow *arg1 = (wxWindow *) 0 ;
30289 wxPoint *arg2 = 0 ;
30290 int arg3 = (int) wxSIZE_USE_EXISTING ;
30291 void *argp1 = 0 ;
30292 int res1 = 0 ;
30293 wxPoint temp2 ;
30294 int val3 ;
30295 int ecode3 = 0 ;
30296 PyObject * obj0 = 0 ;
30297 PyObject * obj1 = 0 ;
30298 PyObject * obj2 = 0 ;
30299 char * kwnames[] = {
30300 (char *) "self",(char *) "pt",(char *) "flags", NULL
30301 };
30302
30303 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30304 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30305 if (!SWIG_IsOK(res1)) {
30306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Move" "', expected argument " "1"" of type '" "wxWindow *""'");
30307 }
30308 arg1 = reinterpret_cast< wxWindow * >(argp1);
30309 {
30310 arg2 = &temp2;
30311 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30312 }
30313 if (obj2) {
30314 ecode3 = SWIG_AsVal_int(obj2, &val3);
30315 if (!SWIG_IsOK(ecode3)) {
30316 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Move" "', expected argument " "3"" of type '" "int""'");
30317 }
30318 arg3 = static_cast< int >(val3);
30319 }
30320 {
30321 PyThreadState* __tstate = wxPyBeginAllowThreads();
30322 (arg1)->Move((wxPoint const &)*arg2,arg3);
30323 wxPyEndAllowThreads(__tstate);
30324 if (PyErr_Occurred()) SWIG_fail;
30325 }
30326 resultobj = SWIG_Py_Void();
30327 return resultobj;
30328 fail:
30329 return NULL;
30330 }
30331
30332
30333 SWIGINTERN PyObject *_wrap_Window_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30334 PyObject *resultobj = 0;
30335 wxWindow *arg1 = (wxWindow *) 0 ;
30336 int arg2 ;
30337 int arg3 ;
30338 int arg4 = (int) wxSIZE_USE_EXISTING ;
30339 void *argp1 = 0 ;
30340 int res1 = 0 ;
30341 int val2 ;
30342 int ecode2 = 0 ;
30343 int val3 ;
30344 int ecode3 = 0 ;
30345 int val4 ;
30346 int ecode4 = 0 ;
30347 PyObject * obj0 = 0 ;
30348 PyObject * obj1 = 0 ;
30349 PyObject * obj2 = 0 ;
30350 PyObject * obj3 = 0 ;
30351 char * kwnames[] = {
30352 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
30353 };
30354
30355 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30356 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30357 if (!SWIG_IsOK(res1)) {
30358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveXY" "', expected argument " "1"" of type '" "wxWindow *""'");
30359 }
30360 arg1 = reinterpret_cast< wxWindow * >(argp1);
30361 ecode2 = SWIG_AsVal_int(obj1, &val2);
30362 if (!SWIG_IsOK(ecode2)) {
30363 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MoveXY" "', expected argument " "2"" of type '" "int""'");
30364 }
30365 arg2 = static_cast< int >(val2);
30366 ecode3 = SWIG_AsVal_int(obj2, &val3);
30367 if (!SWIG_IsOK(ecode3)) {
30368 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_MoveXY" "', expected argument " "3"" of type '" "int""'");
30369 }
30370 arg3 = static_cast< int >(val3);
30371 if (obj3) {
30372 ecode4 = SWIG_AsVal_int(obj3, &val4);
30373 if (!SWIG_IsOK(ecode4)) {
30374 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_MoveXY" "', expected argument " "4"" of type '" "int""'");
30375 }
30376 arg4 = static_cast< int >(val4);
30377 }
30378 {
30379 PyThreadState* __tstate = wxPyBeginAllowThreads();
30380 (arg1)->Move(arg2,arg3,arg4);
30381 wxPyEndAllowThreads(__tstate);
30382 if (PyErr_Occurred()) SWIG_fail;
30383 }
30384 resultobj = SWIG_Py_Void();
30385 return resultobj;
30386 fail:
30387 return NULL;
30388 }
30389
30390
30391 SWIGINTERN PyObject *_wrap_Window_SetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30392 PyObject *resultobj = 0;
30393 wxWindow *arg1 = (wxWindow *) 0 ;
30394 wxSize const &arg2_defvalue = wxDefaultSize ;
30395 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
30396 void *argp1 = 0 ;
30397 int res1 = 0 ;
30398 wxSize temp2 ;
30399 PyObject * obj0 = 0 ;
30400 PyObject * obj1 = 0 ;
30401 char * kwnames[] = {
30402 (char *) "self",(char *) "size", NULL
30403 };
30404
30405 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) SWIG_fail;
30406 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30407 if (!SWIG_IsOK(res1)) {
30408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30409 }
30410 arg1 = reinterpret_cast< wxWindow * >(argp1);
30411 if (obj1) {
30412 {
30413 arg2 = &temp2;
30414 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30415 }
30416 }
30417 {
30418 PyThreadState* __tstate = wxPyBeginAllowThreads();
30419 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
30420 wxPyEndAllowThreads(__tstate);
30421 if (PyErr_Occurred()) SWIG_fail;
30422 }
30423 resultobj = SWIG_Py_Void();
30424 return resultobj;
30425 fail:
30426 return NULL;
30427 }
30428
30429
30430 SWIGINTERN PyObject *_wrap_Window_Raise(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30431 PyObject *resultobj = 0;
30432 wxWindow *arg1 = (wxWindow *) 0 ;
30433 void *argp1 = 0 ;
30434 int res1 = 0 ;
30435 PyObject *swig_obj[1] ;
30436
30437 if (!args) SWIG_fail;
30438 swig_obj[0] = args;
30439 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30440 if (!SWIG_IsOK(res1)) {
30441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Raise" "', expected argument " "1"" of type '" "wxWindow *""'");
30442 }
30443 arg1 = reinterpret_cast< wxWindow * >(argp1);
30444 {
30445 PyThreadState* __tstate = wxPyBeginAllowThreads();
30446 (arg1)->Raise();
30447 wxPyEndAllowThreads(__tstate);
30448 if (PyErr_Occurred()) SWIG_fail;
30449 }
30450 resultobj = SWIG_Py_Void();
30451 return resultobj;
30452 fail:
30453 return NULL;
30454 }
30455
30456
30457 SWIGINTERN PyObject *_wrap_Window_Lower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30458 PyObject *resultobj = 0;
30459 wxWindow *arg1 = (wxWindow *) 0 ;
30460 void *argp1 = 0 ;
30461 int res1 = 0 ;
30462 PyObject *swig_obj[1] ;
30463
30464 if (!args) SWIG_fail;
30465 swig_obj[0] = args;
30466 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30467 if (!SWIG_IsOK(res1)) {
30468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Lower" "', expected argument " "1"" of type '" "wxWindow *""'");
30469 }
30470 arg1 = reinterpret_cast< wxWindow * >(argp1);
30471 {
30472 PyThreadState* __tstate = wxPyBeginAllowThreads();
30473 (arg1)->Lower();
30474 wxPyEndAllowThreads(__tstate);
30475 if (PyErr_Occurred()) SWIG_fail;
30476 }
30477 resultobj = SWIG_Py_Void();
30478 return resultobj;
30479 fail:
30480 return NULL;
30481 }
30482
30483
30484 SWIGINTERN PyObject *_wrap_Window_SetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30485 PyObject *resultobj = 0;
30486 wxWindow *arg1 = (wxWindow *) 0 ;
30487 wxSize *arg2 = 0 ;
30488 void *argp1 = 0 ;
30489 int res1 = 0 ;
30490 wxSize temp2 ;
30491 PyObject * obj0 = 0 ;
30492 PyObject * obj1 = 0 ;
30493 char * kwnames[] = {
30494 (char *) "self",(char *) "size", NULL
30495 };
30496
30497 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) SWIG_fail;
30498 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30499 if (!SWIG_IsOK(res1)) {
30500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30501 }
30502 arg1 = reinterpret_cast< wxWindow * >(argp1);
30503 {
30504 arg2 = &temp2;
30505 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30506 }
30507 {
30508 PyThreadState* __tstate = wxPyBeginAllowThreads();
30509 (arg1)->SetClientSize((wxSize const &)*arg2);
30510 wxPyEndAllowThreads(__tstate);
30511 if (PyErr_Occurred()) SWIG_fail;
30512 }
30513 resultobj = SWIG_Py_Void();
30514 return resultobj;
30515 fail:
30516 return NULL;
30517 }
30518
30519
30520 SWIGINTERN PyObject *_wrap_Window_SetClientSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30521 PyObject *resultobj = 0;
30522 wxWindow *arg1 = (wxWindow *) 0 ;
30523 int arg2 ;
30524 int arg3 ;
30525 void *argp1 = 0 ;
30526 int res1 = 0 ;
30527 int val2 ;
30528 int ecode2 = 0 ;
30529 int val3 ;
30530 int ecode3 = 0 ;
30531 PyObject * obj0 = 0 ;
30532 PyObject * obj1 = 0 ;
30533 PyObject * obj2 = 0 ;
30534 char * kwnames[] = {
30535 (char *) "self",(char *) "width",(char *) "height", NULL
30536 };
30537
30538 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30539 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30540 if (!SWIG_IsOK(res1)) {
30541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
30542 }
30543 arg1 = reinterpret_cast< wxWindow * >(argp1);
30544 ecode2 = SWIG_AsVal_int(obj1, &val2);
30545 if (!SWIG_IsOK(ecode2)) {
30546 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetClientSizeWH" "', expected argument " "2"" of type '" "int""'");
30547 }
30548 arg2 = static_cast< int >(val2);
30549 ecode3 = SWIG_AsVal_int(obj2, &val3);
30550 if (!SWIG_IsOK(ecode3)) {
30551 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetClientSizeWH" "', expected argument " "3"" of type '" "int""'");
30552 }
30553 arg3 = static_cast< int >(val3);
30554 {
30555 PyThreadState* __tstate = wxPyBeginAllowThreads();
30556 (arg1)->SetClientSize(arg2,arg3);
30557 wxPyEndAllowThreads(__tstate);
30558 if (PyErr_Occurred()) SWIG_fail;
30559 }
30560 resultobj = SWIG_Py_Void();
30561 return resultobj;
30562 fail:
30563 return NULL;
30564 }
30565
30566
30567 SWIGINTERN PyObject *_wrap_Window_SetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30568 PyObject *resultobj = 0;
30569 wxWindow *arg1 = (wxWindow *) 0 ;
30570 wxRect *arg2 = 0 ;
30571 void *argp1 = 0 ;
30572 int res1 = 0 ;
30573 wxRect temp2 ;
30574 PyObject * obj0 = 0 ;
30575 PyObject * obj1 = 0 ;
30576 char * kwnames[] = {
30577 (char *) "self",(char *) "rect", NULL
30578 };
30579
30580 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) SWIG_fail;
30581 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30582 if (!SWIG_IsOK(res1)) {
30583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientRect" "', expected argument " "1"" of type '" "wxWindow *""'");
30584 }
30585 arg1 = reinterpret_cast< wxWindow * >(argp1);
30586 {
30587 arg2 = &temp2;
30588 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30589 }
30590 {
30591 PyThreadState* __tstate = wxPyBeginAllowThreads();
30592 (arg1)->SetClientSize((wxRect const &)*arg2);
30593 wxPyEndAllowThreads(__tstate);
30594 if (PyErr_Occurred()) SWIG_fail;
30595 }
30596 resultobj = SWIG_Py_Void();
30597 return resultobj;
30598 fail:
30599 return NULL;
30600 }
30601
30602
30603 SWIGINTERN PyObject *_wrap_Window_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30604 PyObject *resultobj = 0;
30605 wxWindow *arg1 = (wxWindow *) 0 ;
30606 wxPoint result;
30607 void *argp1 = 0 ;
30608 int res1 = 0 ;
30609 PyObject *swig_obj[1] ;
30610
30611 if (!args) SWIG_fail;
30612 swig_obj[0] = args;
30613 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30614 if (!SWIG_IsOK(res1)) {
30615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
30616 }
30617 arg1 = reinterpret_cast< wxWindow * >(argp1);
30618 {
30619 PyThreadState* __tstate = wxPyBeginAllowThreads();
30620 result = ((wxWindow const *)arg1)->GetPosition();
30621 wxPyEndAllowThreads(__tstate);
30622 if (PyErr_Occurred()) SWIG_fail;
30623 }
30624 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
30625 return resultobj;
30626 fail:
30627 return NULL;
30628 }
30629
30630
30631 SWIGINTERN PyObject *_wrap_Window_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30632 PyObject *resultobj = 0;
30633 wxWindow *arg1 = (wxWindow *) 0 ;
30634 int *arg2 = (int *) 0 ;
30635 int *arg3 = (int *) 0 ;
30636 void *argp1 = 0 ;
30637 int res1 = 0 ;
30638 int temp2 ;
30639 int res2 = SWIG_TMPOBJ ;
30640 int temp3 ;
30641 int res3 = SWIG_TMPOBJ ;
30642 PyObject *swig_obj[1] ;
30643
30644 arg2 = &temp2;
30645 arg3 = &temp3;
30646 if (!args) SWIG_fail;
30647 swig_obj[0] = args;
30648 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30649 if (!SWIG_IsOK(res1)) {
30650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30651 }
30652 arg1 = reinterpret_cast< wxWindow * >(argp1);
30653 {
30654 PyThreadState* __tstate = wxPyBeginAllowThreads();
30655 ((wxWindow const *)arg1)->GetPosition(arg2,arg3);
30656 wxPyEndAllowThreads(__tstate);
30657 if (PyErr_Occurred()) SWIG_fail;
30658 }
30659 resultobj = SWIG_Py_Void();
30660 if (SWIG_IsTmpObj(res2)) {
30661 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30662 } else {
30663 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30664 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30665 }
30666 if (SWIG_IsTmpObj(res3)) {
30667 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30668 } else {
30669 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30670 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30671 }
30672 return resultobj;
30673 fail:
30674 return NULL;
30675 }
30676
30677
30678 SWIGINTERN PyObject *_wrap_Window_GetScreenPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30679 PyObject *resultobj = 0;
30680 wxWindow *arg1 = (wxWindow *) 0 ;
30681 wxPoint result;
30682 void *argp1 = 0 ;
30683 int res1 = 0 ;
30684 PyObject *swig_obj[1] ;
30685
30686 if (!args) SWIG_fail;
30687 swig_obj[0] = args;
30688 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30689 if (!SWIG_IsOK(res1)) {
30690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
30691 }
30692 arg1 = reinterpret_cast< wxWindow * >(argp1);
30693 {
30694 PyThreadState* __tstate = wxPyBeginAllowThreads();
30695 result = ((wxWindow const *)arg1)->GetScreenPosition();
30696 wxPyEndAllowThreads(__tstate);
30697 if (PyErr_Occurred()) SWIG_fail;
30698 }
30699 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
30700 return resultobj;
30701 fail:
30702 return NULL;
30703 }
30704
30705
30706 SWIGINTERN PyObject *_wrap_Window_GetScreenPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30707 PyObject *resultobj = 0;
30708 wxWindow *arg1 = (wxWindow *) 0 ;
30709 int *arg2 = (int *) 0 ;
30710 int *arg3 = (int *) 0 ;
30711 void *argp1 = 0 ;
30712 int res1 = 0 ;
30713 int temp2 ;
30714 int res2 = SWIG_TMPOBJ ;
30715 int temp3 ;
30716 int res3 = SWIG_TMPOBJ ;
30717 PyObject *swig_obj[1] ;
30718
30719 arg2 = &temp2;
30720 arg3 = &temp3;
30721 if (!args) SWIG_fail;
30722 swig_obj[0] = args;
30723 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30724 if (!SWIG_IsOK(res1)) {
30725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30726 }
30727 arg1 = reinterpret_cast< wxWindow * >(argp1);
30728 {
30729 PyThreadState* __tstate = wxPyBeginAllowThreads();
30730 ((wxWindow const *)arg1)->GetScreenPosition(arg2,arg3);
30731 wxPyEndAllowThreads(__tstate);
30732 if (PyErr_Occurred()) SWIG_fail;
30733 }
30734 resultobj = SWIG_Py_Void();
30735 if (SWIG_IsTmpObj(res2)) {
30736 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30737 } else {
30738 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30739 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30740 }
30741 if (SWIG_IsTmpObj(res3)) {
30742 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30743 } else {
30744 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30745 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30746 }
30747 return resultobj;
30748 fail:
30749 return NULL;
30750 }
30751
30752
30753 SWIGINTERN PyObject *_wrap_Window_GetScreenRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30754 PyObject *resultobj = 0;
30755 wxWindow *arg1 = (wxWindow *) 0 ;
30756 wxRect result;
30757 void *argp1 = 0 ;
30758 int res1 = 0 ;
30759 PyObject *swig_obj[1] ;
30760
30761 if (!args) SWIG_fail;
30762 swig_obj[0] = args;
30763 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30764 if (!SWIG_IsOK(res1)) {
30765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
30766 }
30767 arg1 = reinterpret_cast< wxWindow * >(argp1);
30768 {
30769 PyThreadState* __tstate = wxPyBeginAllowThreads();
30770 result = ((wxWindow const *)arg1)->GetScreenRect();
30771 wxPyEndAllowThreads(__tstate);
30772 if (PyErr_Occurred()) SWIG_fail;
30773 }
30774 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
30775 return resultobj;
30776 fail:
30777 return NULL;
30778 }
30779
30780
30781 SWIGINTERN PyObject *_wrap_Window_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30782 PyObject *resultobj = 0;
30783 wxWindow *arg1 = (wxWindow *) 0 ;
30784 wxSize result;
30785 void *argp1 = 0 ;
30786 int res1 = 0 ;
30787 PyObject *swig_obj[1] ;
30788
30789 if (!args) SWIG_fail;
30790 swig_obj[0] = args;
30791 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30792 if (!SWIG_IsOK(res1)) {
30793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
30794 }
30795 arg1 = reinterpret_cast< wxWindow * >(argp1);
30796 {
30797 PyThreadState* __tstate = wxPyBeginAllowThreads();
30798 result = ((wxWindow const *)arg1)->GetSize();
30799 wxPyEndAllowThreads(__tstate);
30800 if (PyErr_Occurred()) SWIG_fail;
30801 }
30802 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
30803 return resultobj;
30804 fail:
30805 return NULL;
30806 }
30807
30808
30809 SWIGINTERN PyObject *_wrap_Window_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30810 PyObject *resultobj = 0;
30811 wxWindow *arg1 = (wxWindow *) 0 ;
30812 int *arg2 = (int *) 0 ;
30813 int *arg3 = (int *) 0 ;
30814 void *argp1 = 0 ;
30815 int res1 = 0 ;
30816 int temp2 ;
30817 int res2 = SWIG_TMPOBJ ;
30818 int temp3 ;
30819 int res3 = SWIG_TMPOBJ ;
30820 PyObject *swig_obj[1] ;
30821
30822 arg2 = &temp2;
30823 arg3 = &temp3;
30824 if (!args) SWIG_fail;
30825 swig_obj[0] = args;
30826 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30827 if (!SWIG_IsOK(res1)) {
30828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30829 }
30830 arg1 = reinterpret_cast< wxWindow * >(argp1);
30831 {
30832 PyThreadState* __tstate = wxPyBeginAllowThreads();
30833 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
30834 wxPyEndAllowThreads(__tstate);
30835 if (PyErr_Occurred()) SWIG_fail;
30836 }
30837 resultobj = SWIG_Py_Void();
30838 if (SWIG_IsTmpObj(res2)) {
30839 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30840 } else {
30841 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30842 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30843 }
30844 if (SWIG_IsTmpObj(res3)) {
30845 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30846 } else {
30847 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30848 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30849 }
30850 return resultobj;
30851 fail:
30852 return NULL;
30853 }
30854
30855
30856 SWIGINTERN PyObject *_wrap_Window_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30857 PyObject *resultobj = 0;
30858 wxWindow *arg1 = (wxWindow *) 0 ;
30859 wxRect result;
30860 void *argp1 = 0 ;
30861 int res1 = 0 ;
30862 PyObject *swig_obj[1] ;
30863
30864 if (!args) SWIG_fail;
30865 swig_obj[0] = args;
30866 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30867 if (!SWIG_IsOK(res1)) {
30868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
30869 }
30870 arg1 = reinterpret_cast< wxWindow * >(argp1);
30871 {
30872 PyThreadState* __tstate = wxPyBeginAllowThreads();
30873 result = ((wxWindow const *)arg1)->GetRect();
30874 wxPyEndAllowThreads(__tstate);
30875 if (PyErr_Occurred()) SWIG_fail;
30876 }
30877 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
30878 return resultobj;
30879 fail:
30880 return NULL;
30881 }
30882
30883
30884 SWIGINTERN PyObject *_wrap_Window_GetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30885 PyObject *resultobj = 0;
30886 wxWindow *arg1 = (wxWindow *) 0 ;
30887 wxSize result;
30888 void *argp1 = 0 ;
30889 int res1 = 0 ;
30890 PyObject *swig_obj[1] ;
30891
30892 if (!args) SWIG_fail;
30893 swig_obj[0] = args;
30894 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30895 if (!SWIG_IsOK(res1)) {
30896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
30897 }
30898 arg1 = reinterpret_cast< wxWindow * >(argp1);
30899 {
30900 PyThreadState* __tstate = wxPyBeginAllowThreads();
30901 result = ((wxWindow const *)arg1)->GetClientSize();
30902 wxPyEndAllowThreads(__tstate);
30903 if (PyErr_Occurred()) SWIG_fail;
30904 }
30905 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
30906 return resultobj;
30907 fail:
30908 return NULL;
30909 }
30910
30911
30912 SWIGINTERN PyObject *_wrap_Window_GetClientSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30913 PyObject *resultobj = 0;
30914 wxWindow *arg1 = (wxWindow *) 0 ;
30915 int *arg2 = (int *) 0 ;
30916 int *arg3 = (int *) 0 ;
30917 void *argp1 = 0 ;
30918 int res1 = 0 ;
30919 int temp2 ;
30920 int res2 = SWIG_TMPOBJ ;
30921 int temp3 ;
30922 int res3 = SWIG_TMPOBJ ;
30923 PyObject *swig_obj[1] ;
30924
30925 arg2 = &temp2;
30926 arg3 = &temp3;
30927 if (!args) SWIG_fail;
30928 swig_obj[0] = args;
30929 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30930 if (!SWIG_IsOK(res1)) {
30931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30932 }
30933 arg1 = reinterpret_cast< wxWindow * >(argp1);
30934 {
30935 PyThreadState* __tstate = wxPyBeginAllowThreads();
30936 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
30937 wxPyEndAllowThreads(__tstate);
30938 if (PyErr_Occurred()) SWIG_fail;
30939 }
30940 resultobj = SWIG_Py_Void();
30941 if (SWIG_IsTmpObj(res2)) {
30942 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30943 } else {
30944 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30945 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30946 }
30947 if (SWIG_IsTmpObj(res3)) {
30948 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30949 } else {
30950 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30951 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30952 }
30953 return resultobj;
30954 fail:
30955 return NULL;
30956 }
30957
30958
30959 SWIGINTERN PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30960 PyObject *resultobj = 0;
30961 wxWindow *arg1 = (wxWindow *) 0 ;
30962 wxPoint result;
30963 void *argp1 = 0 ;
30964 int res1 = 0 ;
30965 PyObject *swig_obj[1] ;
30966
30967 if (!args) SWIG_fail;
30968 swig_obj[0] = args;
30969 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30970 if (!SWIG_IsOK(res1)) {
30971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientAreaOrigin" "', expected argument " "1"" of type '" "wxWindow const *""'");
30972 }
30973 arg1 = reinterpret_cast< wxWindow * >(argp1);
30974 {
30975 PyThreadState* __tstate = wxPyBeginAllowThreads();
30976 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
30977 wxPyEndAllowThreads(__tstate);
30978 if (PyErr_Occurred()) SWIG_fail;
30979 }
30980 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
30981 return resultobj;
30982 fail:
30983 return NULL;
30984 }
30985
30986
30987 SWIGINTERN PyObject *_wrap_Window_GetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30988 PyObject *resultobj = 0;
30989 wxWindow *arg1 = (wxWindow *) 0 ;
30990 wxRect result;
30991 void *argp1 = 0 ;
30992 int res1 = 0 ;
30993 PyObject *swig_obj[1] ;
30994
30995 if (!args) SWIG_fail;
30996 swig_obj[0] = args;
30997 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30998 if (!SWIG_IsOK(res1)) {
30999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
31000 }
31001 arg1 = reinterpret_cast< wxWindow * >(argp1);
31002 {
31003 PyThreadState* __tstate = wxPyBeginAllowThreads();
31004 result = ((wxWindow const *)arg1)->GetClientRect();
31005 wxPyEndAllowThreads(__tstate);
31006 if (PyErr_Occurred()) SWIG_fail;
31007 }
31008 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
31009 return resultobj;
31010 fail:
31011 return NULL;
31012 }
31013
31014
31015 SWIGINTERN PyObject *_wrap_Window_GetBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31016 PyObject *resultobj = 0;
31017 wxWindow *arg1 = (wxWindow *) 0 ;
31018 wxSize result;
31019 void *argp1 = 0 ;
31020 int res1 = 0 ;
31021 PyObject *swig_obj[1] ;
31022
31023 if (!args) SWIG_fail;
31024 swig_obj[0] = args;
31025 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31026 if (!SWIG_IsOK(res1)) {
31027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31028 }
31029 arg1 = reinterpret_cast< wxWindow * >(argp1);
31030 {
31031 PyThreadState* __tstate = wxPyBeginAllowThreads();
31032 result = ((wxWindow const *)arg1)->GetBestSize();
31033 wxPyEndAllowThreads(__tstate);
31034 if (PyErr_Occurred()) SWIG_fail;
31035 }
31036 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31037 return resultobj;
31038 fail:
31039 return NULL;
31040 }
31041
31042
31043 SWIGINTERN PyObject *_wrap_Window_GetBestSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31044 PyObject *resultobj = 0;
31045 wxWindow *arg1 = (wxWindow *) 0 ;
31046 int *arg2 = (int *) 0 ;
31047 int *arg3 = (int *) 0 ;
31048 void *argp1 = 0 ;
31049 int res1 = 0 ;
31050 int temp2 ;
31051 int res2 = SWIG_TMPOBJ ;
31052 int temp3 ;
31053 int res3 = SWIG_TMPOBJ ;
31054 PyObject *swig_obj[1] ;
31055
31056 arg2 = &temp2;
31057 arg3 = &temp3;
31058 if (!args) SWIG_fail;
31059 swig_obj[0] = args;
31060 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31061 if (!SWIG_IsOK(res1)) {
31062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31063 }
31064 arg1 = reinterpret_cast< wxWindow * >(argp1);
31065 {
31066 PyThreadState* __tstate = wxPyBeginAllowThreads();
31067 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
31068 wxPyEndAllowThreads(__tstate);
31069 if (PyErr_Occurred()) SWIG_fail;
31070 }
31071 resultobj = SWIG_Py_Void();
31072 if (SWIG_IsTmpObj(res2)) {
31073 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31074 } else {
31075 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31076 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31077 }
31078 if (SWIG_IsTmpObj(res3)) {
31079 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31080 } else {
31081 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31082 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31083 }
31084 return resultobj;
31085 fail:
31086 return NULL;
31087 }
31088
31089
31090 SWIGINTERN PyObject *_wrap_Window_InvalidateBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31091 PyObject *resultobj = 0;
31092 wxWindow *arg1 = (wxWindow *) 0 ;
31093 void *argp1 = 0 ;
31094 int res1 = 0 ;
31095 PyObject *swig_obj[1] ;
31096
31097 if (!args) SWIG_fail;
31098 swig_obj[0] = args;
31099 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31100 if (!SWIG_IsOK(res1)) {
31101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InvalidateBestSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31102 }
31103 arg1 = reinterpret_cast< wxWindow * >(argp1);
31104 {
31105 PyThreadState* __tstate = wxPyBeginAllowThreads();
31106 (arg1)->InvalidateBestSize();
31107 wxPyEndAllowThreads(__tstate);
31108 if (PyErr_Occurred()) SWIG_fail;
31109 }
31110 resultobj = SWIG_Py_Void();
31111 return resultobj;
31112 fail:
31113 return NULL;
31114 }
31115
31116
31117 SWIGINTERN PyObject *_wrap_Window_CacheBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31118 PyObject *resultobj = 0;
31119 wxWindow *arg1 = (wxWindow *) 0 ;
31120 wxSize *arg2 = 0 ;
31121 void *argp1 = 0 ;
31122 int res1 = 0 ;
31123 wxSize temp2 ;
31124 PyObject * obj0 = 0 ;
31125 PyObject * obj1 = 0 ;
31126 char * kwnames[] = {
31127 (char *) "self",(char *) "size", NULL
31128 };
31129
31130 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) SWIG_fail;
31131 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31132 if (!SWIG_IsOK(res1)) {
31133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CacheBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31134 }
31135 arg1 = reinterpret_cast< wxWindow * >(argp1);
31136 {
31137 arg2 = &temp2;
31138 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31139 }
31140 {
31141 PyThreadState* __tstate = wxPyBeginAllowThreads();
31142 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
31143 wxPyEndAllowThreads(__tstate);
31144 if (PyErr_Occurred()) SWIG_fail;
31145 }
31146 resultobj = SWIG_Py_Void();
31147 return resultobj;
31148 fail:
31149 return NULL;
31150 }
31151
31152
31153 SWIGINTERN PyObject *_wrap_Window_GetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31154 PyObject *resultobj = 0;
31155 wxWindow *arg1 = (wxWindow *) 0 ;
31156 wxSize result;
31157 void *argp1 = 0 ;
31158 int res1 = 0 ;
31159 PyObject *swig_obj[1] ;
31160
31161 if (!args) SWIG_fail;
31162 swig_obj[0] = args;
31163 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31164 if (!SWIG_IsOK(res1)) {
31165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31166 }
31167 arg1 = reinterpret_cast< wxWindow * >(argp1);
31168 {
31169 PyThreadState* __tstate = wxPyBeginAllowThreads();
31170 result = ((wxWindow const *)arg1)->GetBestFittingSize();
31171 wxPyEndAllowThreads(__tstate);
31172 if (PyErr_Occurred()) SWIG_fail;
31173 }
31174 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31175 return resultobj;
31176 fail:
31177 return NULL;
31178 }
31179
31180
31181 SWIGINTERN PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31182 PyObject *resultobj = 0;
31183 wxWindow *arg1 = (wxWindow *) 0 ;
31184 wxSize result;
31185 void *argp1 = 0 ;
31186 int res1 = 0 ;
31187 PyObject *swig_obj[1] ;
31188
31189 if (!args) SWIG_fail;
31190 swig_obj[0] = args;
31191 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31192 if (!SWIG_IsOK(res1)) {
31193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAdjustedBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31194 }
31195 arg1 = reinterpret_cast< wxWindow * >(argp1);
31196 {
31197 PyThreadState* __tstate = wxPyBeginAllowThreads();
31198 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
31199 wxPyEndAllowThreads(__tstate);
31200 if (PyErr_Occurred()) SWIG_fail;
31201 }
31202 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31203 return resultobj;
31204 fail:
31205 return NULL;
31206 }
31207
31208
31209 SWIGINTERN PyObject *_wrap_Window_Center(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31210 PyObject *resultobj = 0;
31211 wxWindow *arg1 = (wxWindow *) 0 ;
31212 int arg2 = (int) wxBOTH ;
31213 void *argp1 = 0 ;
31214 int res1 = 0 ;
31215 int val2 ;
31216 int ecode2 = 0 ;
31217 PyObject * obj0 = 0 ;
31218 PyObject * obj1 = 0 ;
31219 char * kwnames[] = {
31220 (char *) "self",(char *) "direction", NULL
31221 };
31222
31223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) SWIG_fail;
31224 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31225 if (!SWIG_IsOK(res1)) {
31226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Center" "', expected argument " "1"" of type '" "wxWindow *""'");
31227 }
31228 arg1 = reinterpret_cast< wxWindow * >(argp1);
31229 if (obj1) {
31230 ecode2 = SWIG_AsVal_int(obj1, &val2);
31231 if (!SWIG_IsOK(ecode2)) {
31232 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Center" "', expected argument " "2"" of type '" "int""'");
31233 }
31234 arg2 = static_cast< int >(val2);
31235 }
31236 {
31237 PyThreadState* __tstate = wxPyBeginAllowThreads();
31238 (arg1)->Center(arg2);
31239 wxPyEndAllowThreads(__tstate);
31240 if (PyErr_Occurred()) SWIG_fail;
31241 }
31242 resultobj = SWIG_Py_Void();
31243 return resultobj;
31244 fail:
31245 return NULL;
31246 }
31247
31248
31249 SWIGINTERN PyObject *_wrap_Window_CenterOnParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31250 PyObject *resultobj = 0;
31251 wxWindow *arg1 = (wxWindow *) 0 ;
31252 int arg2 = (int) wxBOTH ;
31253 void *argp1 = 0 ;
31254 int res1 = 0 ;
31255 int val2 ;
31256 int ecode2 = 0 ;
31257 PyObject * obj0 = 0 ;
31258 PyObject * obj1 = 0 ;
31259 char * kwnames[] = {
31260 (char *) "self",(char *) "dir", NULL
31261 };
31262
31263 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) SWIG_fail;
31264 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31265 if (!SWIG_IsOK(res1)) {
31266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CenterOnParent" "', expected argument " "1"" of type '" "wxWindow *""'");
31267 }
31268 arg1 = reinterpret_cast< wxWindow * >(argp1);
31269 if (obj1) {
31270 ecode2 = SWIG_AsVal_int(obj1, &val2);
31271 if (!SWIG_IsOK(ecode2)) {
31272 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_CenterOnParent" "', expected argument " "2"" of type '" "int""'");
31273 }
31274 arg2 = static_cast< int >(val2);
31275 }
31276 {
31277 PyThreadState* __tstate = wxPyBeginAllowThreads();
31278 (arg1)->CenterOnParent(arg2);
31279 wxPyEndAllowThreads(__tstate);
31280 if (PyErr_Occurred()) SWIG_fail;
31281 }
31282 resultobj = SWIG_Py_Void();
31283 return resultobj;
31284 fail:
31285 return NULL;
31286 }
31287
31288
31289 SWIGINTERN PyObject *_wrap_Window_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31290 PyObject *resultobj = 0;
31291 wxWindow *arg1 = (wxWindow *) 0 ;
31292 void *argp1 = 0 ;
31293 int res1 = 0 ;
31294 PyObject *swig_obj[1] ;
31295
31296 if (!args) SWIG_fail;
31297 swig_obj[0] = args;
31298 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31299 if (!SWIG_IsOK(res1)) {
31300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Fit" "', expected argument " "1"" of type '" "wxWindow *""'");
31301 }
31302 arg1 = reinterpret_cast< wxWindow * >(argp1);
31303 {
31304 PyThreadState* __tstate = wxPyBeginAllowThreads();
31305 (arg1)->Fit();
31306 wxPyEndAllowThreads(__tstate);
31307 if (PyErr_Occurred()) SWIG_fail;
31308 }
31309 resultobj = SWIG_Py_Void();
31310 return resultobj;
31311 fail:
31312 return NULL;
31313 }
31314
31315
31316 SWIGINTERN PyObject *_wrap_Window_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31317 PyObject *resultobj = 0;
31318 wxWindow *arg1 = (wxWindow *) 0 ;
31319 void *argp1 = 0 ;
31320 int res1 = 0 ;
31321 PyObject *swig_obj[1] ;
31322
31323 if (!args) SWIG_fail;
31324 swig_obj[0] = args;
31325 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31326 if (!SWIG_IsOK(res1)) {
31327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FitInside" "', expected argument " "1"" of type '" "wxWindow *""'");
31328 }
31329 arg1 = reinterpret_cast< wxWindow * >(argp1);
31330 {
31331 PyThreadState* __tstate = wxPyBeginAllowThreads();
31332 (arg1)->FitInside();
31333 wxPyEndAllowThreads(__tstate);
31334 if (PyErr_Occurred()) SWIG_fail;
31335 }
31336 resultobj = SWIG_Py_Void();
31337 return resultobj;
31338 fail:
31339 return NULL;
31340 }
31341
31342
31343 SWIGINTERN PyObject *_wrap_Window_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31344 PyObject *resultobj = 0;
31345 wxWindow *arg1 = (wxWindow *) 0 ;
31346 int arg2 ;
31347 int arg3 ;
31348 int arg4 = (int) -1 ;
31349 int arg5 = (int) -1 ;
31350 int arg6 = (int) -1 ;
31351 int arg7 = (int) -1 ;
31352 void *argp1 = 0 ;
31353 int res1 = 0 ;
31354 int val2 ;
31355 int ecode2 = 0 ;
31356 int val3 ;
31357 int ecode3 = 0 ;
31358 int val4 ;
31359 int ecode4 = 0 ;
31360 int val5 ;
31361 int ecode5 = 0 ;
31362 int val6 ;
31363 int ecode6 = 0 ;
31364 int val7 ;
31365 int ecode7 = 0 ;
31366 PyObject * obj0 = 0 ;
31367 PyObject * obj1 = 0 ;
31368 PyObject * obj2 = 0 ;
31369 PyObject * obj3 = 0 ;
31370 PyObject * obj4 = 0 ;
31371 PyObject * obj5 = 0 ;
31372 PyObject * obj6 = 0 ;
31373 char * kwnames[] = {
31374 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
31375 };
31376
31377 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
31378 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31379 if (!SWIG_IsOK(res1)) {
31380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
31381 }
31382 arg1 = reinterpret_cast< wxWindow * >(argp1);
31383 ecode2 = SWIG_AsVal_int(obj1, &val2);
31384 if (!SWIG_IsOK(ecode2)) {
31385 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeHints" "', expected argument " "2"" of type '" "int""'");
31386 }
31387 arg2 = static_cast< int >(val2);
31388 ecode3 = SWIG_AsVal_int(obj2, &val3);
31389 if (!SWIG_IsOK(ecode3)) {
31390 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeHints" "', expected argument " "3"" of type '" "int""'");
31391 }
31392 arg3 = static_cast< int >(val3);
31393 if (obj3) {
31394 ecode4 = SWIG_AsVal_int(obj3, &val4);
31395 if (!SWIG_IsOK(ecode4)) {
31396 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetSizeHints" "', expected argument " "4"" of type '" "int""'");
31397 }
31398 arg4 = static_cast< int >(val4);
31399 }
31400 if (obj4) {
31401 ecode5 = SWIG_AsVal_int(obj4, &val5);
31402 if (!SWIG_IsOK(ecode5)) {
31403 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetSizeHints" "', expected argument " "5"" of type '" "int""'");
31404 }
31405 arg5 = static_cast< int >(val5);
31406 }
31407 if (obj5) {
31408 ecode6 = SWIG_AsVal_int(obj5, &val6);
31409 if (!SWIG_IsOK(ecode6)) {
31410 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetSizeHints" "', expected argument " "6"" of type '" "int""'");
31411 }
31412 arg6 = static_cast< int >(val6);
31413 }
31414 if (obj6) {
31415 ecode7 = SWIG_AsVal_int(obj6, &val7);
31416 if (!SWIG_IsOK(ecode7)) {
31417 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Window_SetSizeHints" "', expected argument " "7"" of type '" "int""'");
31418 }
31419 arg7 = static_cast< int >(val7);
31420 }
31421 {
31422 PyThreadState* __tstate = wxPyBeginAllowThreads();
31423 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
31424 wxPyEndAllowThreads(__tstate);
31425 if (PyErr_Occurred()) SWIG_fail;
31426 }
31427 resultobj = SWIG_Py_Void();
31428 return resultobj;
31429 fail:
31430 return NULL;
31431 }
31432
31433
31434 SWIGINTERN PyObject *_wrap_Window_SetSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31435 PyObject *resultobj = 0;
31436 wxWindow *arg1 = (wxWindow *) 0 ;
31437 wxSize *arg2 = 0 ;
31438 wxSize const &arg3_defvalue = wxDefaultSize ;
31439 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
31440 wxSize const &arg4_defvalue = wxDefaultSize ;
31441 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
31442 void *argp1 = 0 ;
31443 int res1 = 0 ;
31444 wxSize temp2 ;
31445 wxSize temp3 ;
31446 wxSize temp4 ;
31447 PyObject * obj0 = 0 ;
31448 PyObject * obj1 = 0 ;
31449 PyObject * obj2 = 0 ;
31450 PyObject * obj3 = 0 ;
31451 char * kwnames[] = {
31452 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
31453 };
31454
31455 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
31456 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31457 if (!SWIG_IsOK(res1)) {
31458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
31459 }
31460 arg1 = reinterpret_cast< wxWindow * >(argp1);
31461 {
31462 arg2 = &temp2;
31463 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31464 }
31465 if (obj2) {
31466 {
31467 arg3 = &temp3;
31468 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
31469 }
31470 }
31471 if (obj3) {
31472 {
31473 arg4 = &temp4;
31474 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
31475 }
31476 }
31477 {
31478 PyThreadState* __tstate = wxPyBeginAllowThreads();
31479 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
31480 wxPyEndAllowThreads(__tstate);
31481 if (PyErr_Occurred()) SWIG_fail;
31482 }
31483 resultobj = SWIG_Py_Void();
31484 return resultobj;
31485 fail:
31486 return NULL;
31487 }
31488
31489
31490 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31491 PyObject *resultobj = 0;
31492 wxWindow *arg1 = (wxWindow *) 0 ;
31493 int arg2 ;
31494 int arg3 ;
31495 int arg4 = (int) -1 ;
31496 int arg5 = (int) -1 ;
31497 void *argp1 = 0 ;
31498 int res1 = 0 ;
31499 int val2 ;
31500 int ecode2 = 0 ;
31501 int val3 ;
31502 int ecode3 = 0 ;
31503 int val4 ;
31504 int ecode4 = 0 ;
31505 int val5 ;
31506 int ecode5 = 0 ;
31507 PyObject * obj0 = 0 ;
31508 PyObject * obj1 = 0 ;
31509 PyObject * obj2 = 0 ;
31510 PyObject * obj3 = 0 ;
31511 PyObject * obj4 = 0 ;
31512 char * kwnames[] = {
31513 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
31514 };
31515
31516 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
31517 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31518 if (!SWIG_IsOK(res1)) {
31519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
31520 }
31521 arg1 = reinterpret_cast< wxWindow * >(argp1);
31522 ecode2 = SWIG_AsVal_int(obj1, &val2);
31523 if (!SWIG_IsOK(ecode2)) {
31524 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "2"" of type '" "int""'");
31525 }
31526 arg2 = static_cast< int >(val2);
31527 ecode3 = SWIG_AsVal_int(obj2, &val3);
31528 if (!SWIG_IsOK(ecode3)) {
31529 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "3"" of type '" "int""'");
31530 }
31531 arg3 = static_cast< int >(val3);
31532 if (obj3) {
31533 ecode4 = SWIG_AsVal_int(obj3, &val4);
31534 if (!SWIG_IsOK(ecode4)) {
31535 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "4"" of type '" "int""'");
31536 }
31537 arg4 = static_cast< int >(val4);
31538 }
31539 if (obj4) {
31540 ecode5 = SWIG_AsVal_int(obj4, &val5);
31541 if (!SWIG_IsOK(ecode5)) {
31542 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "5"" of type '" "int""'");
31543 }
31544 arg5 = static_cast< int >(val5);
31545 }
31546 {
31547 PyThreadState* __tstate = wxPyBeginAllowThreads();
31548 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
31549 wxPyEndAllowThreads(__tstate);
31550 if (PyErr_Occurred()) SWIG_fail;
31551 }
31552 resultobj = SWIG_Py_Void();
31553 return resultobj;
31554 fail:
31555 return NULL;
31556 }
31557
31558
31559 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31560 PyObject *resultobj = 0;
31561 wxWindow *arg1 = (wxWindow *) 0 ;
31562 wxSize *arg2 = 0 ;
31563 wxSize const &arg3_defvalue = wxDefaultSize ;
31564 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
31565 void *argp1 = 0 ;
31566 int res1 = 0 ;
31567 wxSize temp2 ;
31568 wxSize temp3 ;
31569 PyObject * obj0 = 0 ;
31570 PyObject * obj1 = 0 ;
31571 PyObject * obj2 = 0 ;
31572 char * kwnames[] = {
31573 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
31574 };
31575
31576 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31577 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31578 if (!SWIG_IsOK(res1)) {
31579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
31580 }
31581 arg1 = reinterpret_cast< wxWindow * >(argp1);
31582 {
31583 arg2 = &temp2;
31584 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31585 }
31586 if (obj2) {
31587 {
31588 arg3 = &temp3;
31589 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
31590 }
31591 }
31592 {
31593 PyThreadState* __tstate = wxPyBeginAllowThreads();
31594 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
31595 wxPyEndAllowThreads(__tstate);
31596 if (PyErr_Occurred()) SWIG_fail;
31597 }
31598 resultobj = SWIG_Py_Void();
31599 return resultobj;
31600 fail:
31601 return NULL;
31602 }
31603
31604
31605 SWIGINTERN PyObject *_wrap_Window_GetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31606 PyObject *resultobj = 0;
31607 wxWindow *arg1 = (wxWindow *) 0 ;
31608 wxSize result;
31609 void *argp1 = 0 ;
31610 int res1 = 0 ;
31611 PyObject *swig_obj[1] ;
31612
31613 if (!args) SWIG_fail;
31614 swig_obj[0] = args;
31615 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31616 if (!SWIG_IsOK(res1)) {
31617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31618 }
31619 arg1 = reinterpret_cast< wxWindow * >(argp1);
31620 {
31621 PyThreadState* __tstate = wxPyBeginAllowThreads();
31622 result = ((wxWindow const *)arg1)->GetMaxSize();
31623 wxPyEndAllowThreads(__tstate);
31624 if (PyErr_Occurred()) SWIG_fail;
31625 }
31626 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31627 return resultobj;
31628 fail:
31629 return NULL;
31630 }
31631
31632
31633 SWIGINTERN PyObject *_wrap_Window_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31634 PyObject *resultobj = 0;
31635 wxWindow *arg1 = (wxWindow *) 0 ;
31636 wxSize result;
31637 void *argp1 = 0 ;
31638 int res1 = 0 ;
31639 PyObject *swig_obj[1] ;
31640
31641 if (!args) SWIG_fail;
31642 swig_obj[0] = args;
31643 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31644 if (!SWIG_IsOK(res1)) {
31645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31646 }
31647 arg1 = reinterpret_cast< wxWindow * >(argp1);
31648 {
31649 PyThreadState* __tstate = wxPyBeginAllowThreads();
31650 result = ((wxWindow const *)arg1)->GetMinSize();
31651 wxPyEndAllowThreads(__tstate);
31652 if (PyErr_Occurred()) SWIG_fail;
31653 }
31654 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31655 return resultobj;
31656 fail:
31657 return NULL;
31658 }
31659
31660
31661 SWIGINTERN PyObject *_wrap_Window_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31662 PyObject *resultobj = 0;
31663 wxWindow *arg1 = (wxWindow *) 0 ;
31664 wxSize *arg2 = 0 ;
31665 void *argp1 = 0 ;
31666 int res1 = 0 ;
31667 wxSize temp2 ;
31668 PyObject * obj0 = 0 ;
31669 PyObject * obj1 = 0 ;
31670 char * kwnames[] = {
31671 (char *) "self",(char *) "minSize", NULL
31672 };
31673
31674 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
31675 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31676 if (!SWIG_IsOK(res1)) {
31677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMinSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31678 }
31679 arg1 = reinterpret_cast< wxWindow * >(argp1);
31680 {
31681 arg2 = &temp2;
31682 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31683 }
31684 {
31685 PyThreadState* __tstate = wxPyBeginAllowThreads();
31686 (arg1)->SetMinSize((wxSize const &)*arg2);
31687 wxPyEndAllowThreads(__tstate);
31688 if (PyErr_Occurred()) SWIG_fail;
31689 }
31690 resultobj = SWIG_Py_Void();
31691 return resultobj;
31692 fail:
31693 return NULL;
31694 }
31695
31696
31697 SWIGINTERN PyObject *_wrap_Window_SetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31698 PyObject *resultobj = 0;
31699 wxWindow *arg1 = (wxWindow *) 0 ;
31700 wxSize *arg2 = 0 ;
31701 void *argp1 = 0 ;
31702 int res1 = 0 ;
31703 wxSize temp2 ;
31704 PyObject * obj0 = 0 ;
31705 PyObject * obj1 = 0 ;
31706 char * kwnames[] = {
31707 (char *) "self",(char *) "maxSize", NULL
31708 };
31709
31710 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) SWIG_fail;
31711 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31712 if (!SWIG_IsOK(res1)) {
31713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMaxSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31714 }
31715 arg1 = reinterpret_cast< wxWindow * >(argp1);
31716 {
31717 arg2 = &temp2;
31718 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31719 }
31720 {
31721 PyThreadState* __tstate = wxPyBeginAllowThreads();
31722 (arg1)->SetMaxSize((wxSize const &)*arg2);
31723 wxPyEndAllowThreads(__tstate);
31724 if (PyErr_Occurred()) SWIG_fail;
31725 }
31726 resultobj = SWIG_Py_Void();
31727 return resultobj;
31728 fail:
31729 return NULL;
31730 }
31731
31732
31733 SWIGINTERN PyObject *_wrap_Window_GetMinWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31734 PyObject *resultobj = 0;
31735 wxWindow *arg1 = (wxWindow *) 0 ;
31736 int result;
31737 void *argp1 = 0 ;
31738 int res1 = 0 ;
31739 PyObject *swig_obj[1] ;
31740
31741 if (!args) SWIG_fail;
31742 swig_obj[0] = args;
31743 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31744 if (!SWIG_IsOK(res1)) {
31745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
31746 }
31747 arg1 = reinterpret_cast< wxWindow * >(argp1);
31748 {
31749 PyThreadState* __tstate = wxPyBeginAllowThreads();
31750 result = (int)((wxWindow const *)arg1)->GetMinWidth();
31751 wxPyEndAllowThreads(__tstate);
31752 if (PyErr_Occurred()) SWIG_fail;
31753 }
31754 resultobj = SWIG_From_int(static_cast< int >(result));
31755 return resultobj;
31756 fail:
31757 return NULL;
31758 }
31759
31760
31761 SWIGINTERN PyObject *_wrap_Window_GetMinHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31762 PyObject *resultobj = 0;
31763 wxWindow *arg1 = (wxWindow *) 0 ;
31764 int result;
31765 void *argp1 = 0 ;
31766 int res1 = 0 ;
31767 PyObject *swig_obj[1] ;
31768
31769 if (!args) SWIG_fail;
31770 swig_obj[0] = args;
31771 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31772 if (!SWIG_IsOK(res1)) {
31773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
31774 }
31775 arg1 = reinterpret_cast< wxWindow * >(argp1);
31776 {
31777 PyThreadState* __tstate = wxPyBeginAllowThreads();
31778 result = (int)((wxWindow const *)arg1)->GetMinHeight();
31779 wxPyEndAllowThreads(__tstate);
31780 if (PyErr_Occurred()) SWIG_fail;
31781 }
31782 resultobj = SWIG_From_int(static_cast< int >(result));
31783 return resultobj;
31784 fail:
31785 return NULL;
31786 }
31787
31788
31789 SWIGINTERN PyObject *_wrap_Window_GetMaxWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31790 PyObject *resultobj = 0;
31791 wxWindow *arg1 = (wxWindow *) 0 ;
31792 int result;
31793 void *argp1 = 0 ;
31794 int res1 = 0 ;
31795 PyObject *swig_obj[1] ;
31796
31797 if (!args) SWIG_fail;
31798 swig_obj[0] = args;
31799 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31800 if (!SWIG_IsOK(res1)) {
31801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
31802 }
31803 arg1 = reinterpret_cast< wxWindow * >(argp1);
31804 {
31805 PyThreadState* __tstate = wxPyBeginAllowThreads();
31806 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
31807 wxPyEndAllowThreads(__tstate);
31808 if (PyErr_Occurred()) SWIG_fail;
31809 }
31810 resultobj = SWIG_From_int(static_cast< int >(result));
31811 return resultobj;
31812 fail:
31813 return NULL;
31814 }
31815
31816
31817 SWIGINTERN PyObject *_wrap_Window_GetMaxHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31818 PyObject *resultobj = 0;
31819 wxWindow *arg1 = (wxWindow *) 0 ;
31820 int result;
31821 void *argp1 = 0 ;
31822 int res1 = 0 ;
31823 PyObject *swig_obj[1] ;
31824
31825 if (!args) SWIG_fail;
31826 swig_obj[0] = args;
31827 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31828 if (!SWIG_IsOK(res1)) {
31829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
31830 }
31831 arg1 = reinterpret_cast< wxWindow * >(argp1);
31832 {
31833 PyThreadState* __tstate = wxPyBeginAllowThreads();
31834 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
31835 wxPyEndAllowThreads(__tstate);
31836 if (PyErr_Occurred()) SWIG_fail;
31837 }
31838 resultobj = SWIG_From_int(static_cast< int >(result));
31839 return resultobj;
31840 fail:
31841 return NULL;
31842 }
31843
31844
31845 SWIGINTERN PyObject *_wrap_Window_SetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31846 PyObject *resultobj = 0;
31847 wxWindow *arg1 = (wxWindow *) 0 ;
31848 wxSize *arg2 = 0 ;
31849 void *argp1 = 0 ;
31850 int res1 = 0 ;
31851 wxSize temp2 ;
31852 PyObject * obj0 = 0 ;
31853 PyObject * obj1 = 0 ;
31854 char * kwnames[] = {
31855 (char *) "self",(char *) "size", NULL
31856 };
31857
31858 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) SWIG_fail;
31859 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31860 if (!SWIG_IsOK(res1)) {
31861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31862 }
31863 arg1 = reinterpret_cast< wxWindow * >(argp1);
31864 {
31865 arg2 = &temp2;
31866 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31867 }
31868 {
31869 PyThreadState* __tstate = wxPyBeginAllowThreads();
31870 (arg1)->SetVirtualSize((wxSize const &)*arg2);
31871 wxPyEndAllowThreads(__tstate);
31872 if (PyErr_Occurred()) SWIG_fail;
31873 }
31874 resultobj = SWIG_Py_Void();
31875 return resultobj;
31876 fail:
31877 return NULL;
31878 }
31879
31880
31881 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31882 PyObject *resultobj = 0;
31883 wxWindow *arg1 = (wxWindow *) 0 ;
31884 int arg2 ;
31885 int arg3 ;
31886 void *argp1 = 0 ;
31887 int res1 = 0 ;
31888 int val2 ;
31889 int ecode2 = 0 ;
31890 int val3 ;
31891 int ecode3 = 0 ;
31892 PyObject * obj0 = 0 ;
31893 PyObject * obj1 = 0 ;
31894 PyObject * obj2 = 0 ;
31895 char * kwnames[] = {
31896 (char *) "self",(char *) "w",(char *) "h", NULL
31897 };
31898
31899 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31900 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31901 if (!SWIG_IsOK(res1)) {
31902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
31903 }
31904 arg1 = reinterpret_cast< wxWindow * >(argp1);
31905 ecode2 = SWIG_AsVal_int(obj1, &val2);
31906 if (!SWIG_IsOK(ecode2)) {
31907 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "2"" of type '" "int""'");
31908 }
31909 arg2 = static_cast< int >(val2);
31910 ecode3 = SWIG_AsVal_int(obj2, &val3);
31911 if (!SWIG_IsOK(ecode3)) {
31912 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "3"" of type '" "int""'");
31913 }
31914 arg3 = static_cast< int >(val3);
31915 {
31916 PyThreadState* __tstate = wxPyBeginAllowThreads();
31917 (arg1)->SetVirtualSize(arg2,arg3);
31918 wxPyEndAllowThreads(__tstate);
31919 if (PyErr_Occurred()) SWIG_fail;
31920 }
31921 resultobj = SWIG_Py_Void();
31922 return resultobj;
31923 fail:
31924 return NULL;
31925 }
31926
31927
31928 SWIGINTERN PyObject *_wrap_Window_GetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31929 PyObject *resultobj = 0;
31930 wxWindow *arg1 = (wxWindow *) 0 ;
31931 wxSize result;
31932 void *argp1 = 0 ;
31933 int res1 = 0 ;
31934 PyObject *swig_obj[1] ;
31935
31936 if (!args) SWIG_fail;
31937 swig_obj[0] = args;
31938 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31939 if (!SWIG_IsOK(res1)) {
31940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31941 }
31942 arg1 = reinterpret_cast< wxWindow * >(argp1);
31943 {
31944 PyThreadState* __tstate = wxPyBeginAllowThreads();
31945 result = ((wxWindow const *)arg1)->GetVirtualSize();
31946 wxPyEndAllowThreads(__tstate);
31947 if (PyErr_Occurred()) SWIG_fail;
31948 }
31949 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31950 return resultobj;
31951 fail:
31952 return NULL;
31953 }
31954
31955
31956 SWIGINTERN PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31957 PyObject *resultobj = 0;
31958 wxWindow *arg1 = (wxWindow *) 0 ;
31959 int *arg2 = (int *) 0 ;
31960 int *arg3 = (int *) 0 ;
31961 void *argp1 = 0 ;
31962 int res1 = 0 ;
31963 int temp2 ;
31964 int res2 = SWIG_TMPOBJ ;
31965 int temp3 ;
31966 int res3 = SWIG_TMPOBJ ;
31967 PyObject *swig_obj[1] ;
31968
31969 arg2 = &temp2;
31970 arg3 = &temp3;
31971 if (!args) SWIG_fail;
31972 swig_obj[0] = args;
31973 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31974 if (!SWIG_IsOK(res1)) {
31975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31976 }
31977 arg1 = reinterpret_cast< wxWindow * >(argp1);
31978 {
31979 PyThreadState* __tstate = wxPyBeginAllowThreads();
31980 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
31981 wxPyEndAllowThreads(__tstate);
31982 if (PyErr_Occurred()) SWIG_fail;
31983 }
31984 resultobj = SWIG_Py_Void();
31985 if (SWIG_IsTmpObj(res2)) {
31986 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31987 } else {
31988 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31989 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31990 }
31991 if (SWIG_IsTmpObj(res3)) {
31992 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31993 } else {
31994 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31995 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31996 }
31997 return resultobj;
31998 fail:
31999 return NULL;
32000 }
32001
32002
32003 SWIGINTERN PyObject *_wrap_Window_GetBestVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32004 PyObject *resultobj = 0;
32005 wxWindow *arg1 = (wxWindow *) 0 ;
32006 wxSize result;
32007 void *argp1 = 0 ;
32008 int res1 = 0 ;
32009 PyObject *swig_obj[1] ;
32010
32011 if (!args) SWIG_fail;
32012 swig_obj[0] = args;
32013 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32014 if (!SWIG_IsOK(res1)) {
32015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32016 }
32017 arg1 = reinterpret_cast< wxWindow * >(argp1);
32018 {
32019 PyThreadState* __tstate = wxPyBeginAllowThreads();
32020 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
32021 wxPyEndAllowThreads(__tstate);
32022 if (PyErr_Occurred()) SWIG_fail;
32023 }
32024 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32025 return resultobj;
32026 fail:
32027 return NULL;
32028 }
32029
32030
32031 SWIGINTERN PyObject *_wrap_Window_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32032 PyObject *resultobj = 0;
32033 wxWindow *arg1 = (wxWindow *) 0 ;
32034 bool arg2 = (bool) true ;
32035 bool result;
32036 void *argp1 = 0 ;
32037 int res1 = 0 ;
32038 bool val2 ;
32039 int ecode2 = 0 ;
32040 PyObject * obj0 = 0 ;
32041 PyObject * obj1 = 0 ;
32042 char * kwnames[] = {
32043 (char *) "self",(char *) "show", NULL
32044 };
32045
32046 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) SWIG_fail;
32047 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32048 if (!SWIG_IsOK(res1)) {
32049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Show" "', expected argument " "1"" of type '" "wxWindow *""'");
32050 }
32051 arg1 = reinterpret_cast< wxWindow * >(argp1);
32052 if (obj1) {
32053 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32054 if (!SWIG_IsOK(ecode2)) {
32055 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Show" "', expected argument " "2"" of type '" "bool""'");
32056 }
32057 arg2 = static_cast< bool >(val2);
32058 }
32059 {
32060 PyThreadState* __tstate = wxPyBeginAllowThreads();
32061 result = (bool)(arg1)->Show(arg2);
32062 wxPyEndAllowThreads(__tstate);
32063 if (PyErr_Occurred()) SWIG_fail;
32064 }
32065 {
32066 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32067 }
32068 return resultobj;
32069 fail:
32070 return NULL;
32071 }
32072
32073
32074 SWIGINTERN PyObject *_wrap_Window_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32075 PyObject *resultobj = 0;
32076 wxWindow *arg1 = (wxWindow *) 0 ;
32077 bool result;
32078 void *argp1 = 0 ;
32079 int res1 = 0 ;
32080 PyObject *swig_obj[1] ;
32081
32082 if (!args) SWIG_fail;
32083 swig_obj[0] = args;
32084 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32085 if (!SWIG_IsOK(res1)) {
32086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Hide" "', expected argument " "1"" of type '" "wxWindow *""'");
32087 }
32088 arg1 = reinterpret_cast< wxWindow * >(argp1);
32089 {
32090 PyThreadState* __tstate = wxPyBeginAllowThreads();
32091 result = (bool)(arg1)->Hide();
32092 wxPyEndAllowThreads(__tstate);
32093 if (PyErr_Occurred()) SWIG_fail;
32094 }
32095 {
32096 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32097 }
32098 return resultobj;
32099 fail:
32100 return NULL;
32101 }
32102
32103
32104 SWIGINTERN PyObject *_wrap_Window_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32105 PyObject *resultobj = 0;
32106 wxWindow *arg1 = (wxWindow *) 0 ;
32107 bool arg2 = (bool) true ;
32108 bool result;
32109 void *argp1 = 0 ;
32110 int res1 = 0 ;
32111 bool val2 ;
32112 int ecode2 = 0 ;
32113 PyObject * obj0 = 0 ;
32114 PyObject * obj1 = 0 ;
32115 char * kwnames[] = {
32116 (char *) "self",(char *) "enable", NULL
32117 };
32118
32119 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
32120 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32121 if (!SWIG_IsOK(res1)) {
32122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Enable" "', expected argument " "1"" of type '" "wxWindow *""'");
32123 }
32124 arg1 = reinterpret_cast< wxWindow * >(argp1);
32125 if (obj1) {
32126 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32127 if (!SWIG_IsOK(ecode2)) {
32128 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Enable" "', expected argument " "2"" of type '" "bool""'");
32129 }
32130 arg2 = static_cast< bool >(val2);
32131 }
32132 {
32133 PyThreadState* __tstate = wxPyBeginAllowThreads();
32134 result = (bool)(arg1)->Enable(arg2);
32135 wxPyEndAllowThreads(__tstate);
32136 if (PyErr_Occurred()) SWIG_fail;
32137 }
32138 {
32139 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32140 }
32141 return resultobj;
32142 fail:
32143 return NULL;
32144 }
32145
32146
32147 SWIGINTERN PyObject *_wrap_Window_Disable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32148 PyObject *resultobj = 0;
32149 wxWindow *arg1 = (wxWindow *) 0 ;
32150 bool result;
32151 void *argp1 = 0 ;
32152 int res1 = 0 ;
32153 PyObject *swig_obj[1] ;
32154
32155 if (!args) SWIG_fail;
32156 swig_obj[0] = args;
32157 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32158 if (!SWIG_IsOK(res1)) {
32159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Disable" "', expected argument " "1"" of type '" "wxWindow *""'");
32160 }
32161 arg1 = reinterpret_cast< wxWindow * >(argp1);
32162 {
32163 PyThreadState* __tstate = wxPyBeginAllowThreads();
32164 result = (bool)(arg1)->Disable();
32165 wxPyEndAllowThreads(__tstate);
32166 if (PyErr_Occurred()) SWIG_fail;
32167 }
32168 {
32169 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32170 }
32171 return resultobj;
32172 fail:
32173 return NULL;
32174 }
32175
32176
32177 SWIGINTERN PyObject *_wrap_Window_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32178 PyObject *resultobj = 0;
32179 wxWindow *arg1 = (wxWindow *) 0 ;
32180 bool result;
32181 void *argp1 = 0 ;
32182 int res1 = 0 ;
32183 PyObject *swig_obj[1] ;
32184
32185 if (!args) SWIG_fail;
32186 swig_obj[0] = args;
32187 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32188 if (!SWIG_IsOK(res1)) {
32189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShown" "', expected argument " "1"" of type '" "wxWindow const *""'");
32190 }
32191 arg1 = reinterpret_cast< wxWindow * >(argp1);
32192 {
32193 PyThreadState* __tstate = wxPyBeginAllowThreads();
32194 result = (bool)((wxWindow const *)arg1)->IsShown();
32195 wxPyEndAllowThreads(__tstate);
32196 if (PyErr_Occurred()) SWIG_fail;
32197 }
32198 {
32199 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32200 }
32201 return resultobj;
32202 fail:
32203 return NULL;
32204 }
32205
32206
32207 SWIGINTERN PyObject *_wrap_Window_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32208 PyObject *resultobj = 0;
32209 wxWindow *arg1 = (wxWindow *) 0 ;
32210 bool result;
32211 void *argp1 = 0 ;
32212 int res1 = 0 ;
32213 PyObject *swig_obj[1] ;
32214
32215 if (!args) SWIG_fail;
32216 swig_obj[0] = args;
32217 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32218 if (!SWIG_IsOK(res1)) {
32219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
32220 }
32221 arg1 = reinterpret_cast< wxWindow * >(argp1);
32222 {
32223 PyThreadState* __tstate = wxPyBeginAllowThreads();
32224 result = (bool)((wxWindow const *)arg1)->IsEnabled();
32225 wxPyEndAllowThreads(__tstate);
32226 if (PyErr_Occurred()) SWIG_fail;
32227 }
32228 {
32229 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32230 }
32231 return resultobj;
32232 fail:
32233 return NULL;
32234 }
32235
32236
32237 SWIGINTERN PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32238 PyObject *resultobj = 0;
32239 wxWindow *arg1 = (wxWindow *) 0 ;
32240 long arg2 ;
32241 void *argp1 = 0 ;
32242 int res1 = 0 ;
32243 long val2 ;
32244 int ecode2 = 0 ;
32245 PyObject * obj0 = 0 ;
32246 PyObject * obj1 = 0 ;
32247 char * kwnames[] = {
32248 (char *) "self",(char *) "style", NULL
32249 };
32250
32251 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) SWIG_fail;
32252 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32253 if (!SWIG_IsOK(res1)) {
32254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow *""'");
32255 }
32256 arg1 = reinterpret_cast< wxWindow * >(argp1);
32257 ecode2 = SWIG_AsVal_long(obj1, &val2);
32258 if (!SWIG_IsOK(ecode2)) {
32259 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "2"" of type '" "long""'");
32260 }
32261 arg2 = static_cast< long >(val2);
32262 {
32263 PyThreadState* __tstate = wxPyBeginAllowThreads();
32264 (arg1)->SetWindowStyleFlag(arg2);
32265 wxPyEndAllowThreads(__tstate);
32266 if (PyErr_Occurred()) SWIG_fail;
32267 }
32268 resultobj = SWIG_Py_Void();
32269 return resultobj;
32270 fail:
32271 return NULL;
32272 }
32273
32274
32275 SWIGINTERN PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32276 PyObject *resultobj = 0;
32277 wxWindow *arg1 = (wxWindow *) 0 ;
32278 long result;
32279 void *argp1 = 0 ;
32280 int res1 = 0 ;
32281 PyObject *swig_obj[1] ;
32282
32283 if (!args) SWIG_fail;
32284 swig_obj[0] = args;
32285 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32286 if (!SWIG_IsOK(res1)) {
32287 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
32288 }
32289 arg1 = reinterpret_cast< wxWindow * >(argp1);
32290 {
32291 PyThreadState* __tstate = wxPyBeginAllowThreads();
32292 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
32293 wxPyEndAllowThreads(__tstate);
32294 if (PyErr_Occurred()) SWIG_fail;
32295 }
32296 resultobj = SWIG_From_long(static_cast< long >(result));
32297 return resultobj;
32298 fail:
32299 return NULL;
32300 }
32301
32302
32303 SWIGINTERN PyObject *_wrap_Window_HasFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32304 PyObject *resultobj = 0;
32305 wxWindow *arg1 = (wxWindow *) 0 ;
32306 int arg2 ;
32307 bool result;
32308 void *argp1 = 0 ;
32309 int res1 = 0 ;
32310 int val2 ;
32311 int ecode2 = 0 ;
32312 PyObject * obj0 = 0 ;
32313 PyObject * obj1 = 0 ;
32314 char * kwnames[] = {
32315 (char *) "self",(char *) "flag", NULL
32316 };
32317
32318 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) SWIG_fail;
32319 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32320 if (!SWIG_IsOK(res1)) {
32321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
32322 }
32323 arg1 = reinterpret_cast< wxWindow * >(argp1);
32324 ecode2 = SWIG_AsVal_int(obj1, &val2);
32325 if (!SWIG_IsOK(ecode2)) {
32326 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasFlag" "', expected argument " "2"" of type '" "int""'");
32327 }
32328 arg2 = static_cast< int >(val2);
32329 {
32330 PyThreadState* __tstate = wxPyBeginAllowThreads();
32331 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
32332 wxPyEndAllowThreads(__tstate);
32333 if (PyErr_Occurred()) SWIG_fail;
32334 }
32335 {
32336 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32337 }
32338 return resultobj;
32339 fail:
32340 return NULL;
32341 }
32342
32343
32344 SWIGINTERN PyObject *_wrap_Window_IsRetained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32345 PyObject *resultobj = 0;
32346 wxWindow *arg1 = (wxWindow *) 0 ;
32347 bool result;
32348 void *argp1 = 0 ;
32349 int res1 = 0 ;
32350 PyObject *swig_obj[1] ;
32351
32352 if (!args) SWIG_fail;
32353 swig_obj[0] = args;
32354 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32355 if (!SWIG_IsOK(res1)) {
32356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsRetained" "', expected argument " "1"" of type '" "wxWindow const *""'");
32357 }
32358 arg1 = reinterpret_cast< wxWindow * >(argp1);
32359 {
32360 PyThreadState* __tstate = wxPyBeginAllowThreads();
32361 result = (bool)((wxWindow const *)arg1)->IsRetained();
32362 wxPyEndAllowThreads(__tstate);
32363 if (PyErr_Occurred()) SWIG_fail;
32364 }
32365 {
32366 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32367 }
32368 return resultobj;
32369 fail:
32370 return NULL;
32371 }
32372
32373
32374 SWIGINTERN PyObject *_wrap_Window_SetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32375 PyObject *resultobj = 0;
32376 wxWindow *arg1 = (wxWindow *) 0 ;
32377 long arg2 ;
32378 void *argp1 = 0 ;
32379 int res1 = 0 ;
32380 long val2 ;
32381 int ecode2 = 0 ;
32382 PyObject * obj0 = 0 ;
32383 PyObject * obj1 = 0 ;
32384 char * kwnames[] = {
32385 (char *) "self",(char *) "exStyle", NULL
32386 };
32387
32388 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) SWIG_fail;
32389 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32390 if (!SWIG_IsOK(res1)) {
32391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetExtraStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
32392 }
32393 arg1 = reinterpret_cast< wxWindow * >(argp1);
32394 ecode2 = SWIG_AsVal_long(obj1, &val2);
32395 if (!SWIG_IsOK(ecode2)) {
32396 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetExtraStyle" "', expected argument " "2"" of type '" "long""'");
32397 }
32398 arg2 = static_cast< long >(val2);
32399 {
32400 PyThreadState* __tstate = wxPyBeginAllowThreads();
32401 (arg1)->SetExtraStyle(arg2);
32402 wxPyEndAllowThreads(__tstate);
32403 if (PyErr_Occurred()) SWIG_fail;
32404 }
32405 resultobj = SWIG_Py_Void();
32406 return resultobj;
32407 fail:
32408 return NULL;
32409 }
32410
32411
32412 SWIGINTERN PyObject *_wrap_Window_GetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32413 PyObject *resultobj = 0;
32414 wxWindow *arg1 = (wxWindow *) 0 ;
32415 long result;
32416 void *argp1 = 0 ;
32417 int res1 = 0 ;
32418 PyObject *swig_obj[1] ;
32419
32420 if (!args) SWIG_fail;
32421 swig_obj[0] = args;
32422 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32423 if (!SWIG_IsOK(res1)) {
32424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetExtraStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
32425 }
32426 arg1 = reinterpret_cast< wxWindow * >(argp1);
32427 {
32428 PyThreadState* __tstate = wxPyBeginAllowThreads();
32429 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
32430 wxPyEndAllowThreads(__tstate);
32431 if (PyErr_Occurred()) SWIG_fail;
32432 }
32433 resultobj = SWIG_From_long(static_cast< long >(result));
32434 return resultobj;
32435 fail:
32436 return NULL;
32437 }
32438
32439
32440 SWIGINTERN PyObject *_wrap_Window_MakeModal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32441 PyObject *resultobj = 0;
32442 wxWindow *arg1 = (wxWindow *) 0 ;
32443 bool arg2 = (bool) true ;
32444 void *argp1 = 0 ;
32445 int res1 = 0 ;
32446 bool val2 ;
32447 int ecode2 = 0 ;
32448 PyObject * obj0 = 0 ;
32449 PyObject * obj1 = 0 ;
32450 char * kwnames[] = {
32451 (char *) "self",(char *) "modal", NULL
32452 };
32453
32454 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) SWIG_fail;
32455 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32456 if (!SWIG_IsOK(res1)) {
32457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MakeModal" "', expected argument " "1"" of type '" "wxWindow *""'");
32458 }
32459 arg1 = reinterpret_cast< wxWindow * >(argp1);
32460 if (obj1) {
32461 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32462 if (!SWIG_IsOK(ecode2)) {
32463 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MakeModal" "', expected argument " "2"" of type '" "bool""'");
32464 }
32465 arg2 = static_cast< bool >(val2);
32466 }
32467 {
32468 PyThreadState* __tstate = wxPyBeginAllowThreads();
32469 (arg1)->MakeModal(arg2);
32470 wxPyEndAllowThreads(__tstate);
32471 if (PyErr_Occurred()) SWIG_fail;
32472 }
32473 resultobj = SWIG_Py_Void();
32474 return resultobj;
32475 fail:
32476 return NULL;
32477 }
32478
32479
32480 SWIGINTERN PyObject *_wrap_Window_SetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32481 PyObject *resultobj = 0;
32482 wxWindow *arg1 = (wxWindow *) 0 ;
32483 bool arg2 ;
32484 void *argp1 = 0 ;
32485 int res1 = 0 ;
32486 bool val2 ;
32487 int ecode2 = 0 ;
32488 PyObject * obj0 = 0 ;
32489 PyObject * obj1 = 0 ;
32490 char * kwnames[] = {
32491 (char *) "self",(char *) "enableTheme", NULL
32492 };
32493
32494 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
32495 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32496 if (!SWIG_IsOK(res1)) {
32497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow *""'");
32498 }
32499 arg1 = reinterpret_cast< wxWindow * >(argp1);
32500 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32501 if (!SWIG_IsOK(ecode2)) {
32502 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetThemeEnabled" "', expected argument " "2"" of type '" "bool""'");
32503 }
32504 arg2 = static_cast< bool >(val2);
32505 {
32506 PyThreadState* __tstate = wxPyBeginAllowThreads();
32507 (arg1)->SetThemeEnabled(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_GetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32519 PyObject *resultobj = 0;
32520 wxWindow *arg1 = (wxWindow *) 0 ;
32521 bool result;
32522 void *argp1 = 0 ;
32523 int res1 = 0 ;
32524 PyObject *swig_obj[1] ;
32525
32526 if (!args) SWIG_fail;
32527 swig_obj[0] = args;
32528 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32529 if (!SWIG_IsOK(res1)) {
32530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
32531 }
32532 arg1 = reinterpret_cast< wxWindow * >(argp1);
32533 {
32534 PyThreadState* __tstate = wxPyBeginAllowThreads();
32535 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
32536 wxPyEndAllowThreads(__tstate);
32537 if (PyErr_Occurred()) SWIG_fail;
32538 }
32539 {
32540 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32541 }
32542 return resultobj;
32543 fail:
32544 return NULL;
32545 }
32546
32547
32548 SWIGINTERN PyObject *_wrap_Window_SetFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32549 PyObject *resultobj = 0;
32550 wxWindow *arg1 = (wxWindow *) 0 ;
32551 void *argp1 = 0 ;
32552 int res1 = 0 ;
32553 PyObject *swig_obj[1] ;
32554
32555 if (!args) SWIG_fail;
32556 swig_obj[0] = args;
32557 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32558 if (!SWIG_IsOK(res1)) {
32559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocus" "', expected argument " "1"" of type '" "wxWindow *""'");
32560 }
32561 arg1 = reinterpret_cast< wxWindow * >(argp1);
32562 {
32563 PyThreadState* __tstate = wxPyBeginAllowThreads();
32564 (arg1)->SetFocus();
32565 wxPyEndAllowThreads(__tstate);
32566 if (PyErr_Occurred()) SWIG_fail;
32567 }
32568 resultobj = SWIG_Py_Void();
32569 return resultobj;
32570 fail:
32571 return NULL;
32572 }
32573
32574
32575 SWIGINTERN PyObject *_wrap_Window_SetFocusFromKbd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32576 PyObject *resultobj = 0;
32577 wxWindow *arg1 = (wxWindow *) 0 ;
32578 void *argp1 = 0 ;
32579 int res1 = 0 ;
32580 PyObject *swig_obj[1] ;
32581
32582 if (!args) SWIG_fail;
32583 swig_obj[0] = args;
32584 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32585 if (!SWIG_IsOK(res1)) {
32586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocusFromKbd" "', expected argument " "1"" of type '" "wxWindow *""'");
32587 }
32588 arg1 = reinterpret_cast< wxWindow * >(argp1);
32589 {
32590 PyThreadState* __tstate = wxPyBeginAllowThreads();
32591 (arg1)->SetFocusFromKbd();
32592 wxPyEndAllowThreads(__tstate);
32593 if (PyErr_Occurred()) SWIG_fail;
32594 }
32595 resultobj = SWIG_Py_Void();
32596 return resultobj;
32597 fail:
32598 return NULL;
32599 }
32600
32601
32602 SWIGINTERN PyObject *_wrap_Window_FindFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32603 PyObject *resultobj = 0;
32604 wxWindow *result = 0 ;
32605
32606 if (!SWIG_Python_UnpackTuple(args,"Window_FindFocus",0,0,0)) SWIG_fail;
32607 {
32608 if (!wxPyCheckForApp()) SWIG_fail;
32609 PyThreadState* __tstate = wxPyBeginAllowThreads();
32610 result = (wxWindow *)wxWindow::FindFocus();
32611 wxPyEndAllowThreads(__tstate);
32612 if (PyErr_Occurred()) SWIG_fail;
32613 }
32614 {
32615 resultobj = wxPyMake_wxObject(result, 0);
32616 }
32617 return resultobj;
32618 fail:
32619 return NULL;
32620 }
32621
32622
32623 SWIGINTERN PyObject *_wrap_Window_AcceptsFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32624 PyObject *resultobj = 0;
32625 wxWindow *arg1 = (wxWindow *) 0 ;
32626 bool result;
32627 void *argp1 = 0 ;
32628 int res1 = 0 ;
32629 PyObject *swig_obj[1] ;
32630
32631 if (!args) SWIG_fail;
32632 swig_obj[0] = args;
32633 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32634 if (!SWIG_IsOK(res1)) {
32635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
32636 }
32637 arg1 = reinterpret_cast< wxWindow * >(argp1);
32638 {
32639 PyThreadState* __tstate = wxPyBeginAllowThreads();
32640 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
32641 wxPyEndAllowThreads(__tstate);
32642 if (PyErr_Occurred()) SWIG_fail;
32643 }
32644 {
32645 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32646 }
32647 return resultobj;
32648 fail:
32649 return NULL;
32650 }
32651
32652
32653 SWIGINTERN PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32654 PyObject *resultobj = 0;
32655 wxWindow *arg1 = (wxWindow *) 0 ;
32656 bool result;
32657 void *argp1 = 0 ;
32658 int res1 = 0 ;
32659 PyObject *swig_obj[1] ;
32660
32661 if (!args) SWIG_fail;
32662 swig_obj[0] = args;
32663 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32664 if (!SWIG_IsOK(res1)) {
32665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
32666 }
32667 arg1 = reinterpret_cast< wxWindow * >(argp1);
32668 {
32669 PyThreadState* __tstate = wxPyBeginAllowThreads();
32670 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
32671 wxPyEndAllowThreads(__tstate);
32672 if (PyErr_Occurred()) SWIG_fail;
32673 }
32674 {
32675 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32676 }
32677 return resultobj;
32678 fail:
32679 return NULL;
32680 }
32681
32682
32683 SWIGINTERN PyObject *_wrap_Window_GetDefaultItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32684 PyObject *resultobj = 0;
32685 wxWindow *arg1 = (wxWindow *) 0 ;
32686 wxWindow *result = 0 ;
32687 void *argp1 = 0 ;
32688 int res1 = 0 ;
32689 PyObject *swig_obj[1] ;
32690
32691 if (!args) SWIG_fail;
32692 swig_obj[0] = args;
32693 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32694 if (!SWIG_IsOK(res1)) {
32695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultItem" "', expected argument " "1"" of type '" "wxWindow const *""'");
32696 }
32697 arg1 = reinterpret_cast< wxWindow * >(argp1);
32698 {
32699 PyThreadState* __tstate = wxPyBeginAllowThreads();
32700 result = (wxWindow *)((wxWindow const *)arg1)->GetDefaultItem();
32701 wxPyEndAllowThreads(__tstate);
32702 if (PyErr_Occurred()) SWIG_fail;
32703 }
32704 {
32705 resultobj = wxPyMake_wxObject(result, 0);
32706 }
32707 return resultobj;
32708 fail:
32709 return NULL;
32710 }
32711
32712
32713 SWIGINTERN PyObject *_wrap_Window_SetDefaultItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32714 PyObject *resultobj = 0;
32715 wxWindow *arg1 = (wxWindow *) 0 ;
32716 wxWindow *arg2 = (wxWindow *) 0 ;
32717 wxWindow *result = 0 ;
32718 void *argp1 = 0 ;
32719 int res1 = 0 ;
32720 void *argp2 = 0 ;
32721 int res2 = 0 ;
32722 PyObject * obj0 = 0 ;
32723 PyObject * obj1 = 0 ;
32724 char * kwnames[] = {
32725 (char *) "self",(char *) "child", NULL
32726 };
32727
32728 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDefaultItem",kwnames,&obj0,&obj1)) SWIG_fail;
32729 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32730 if (!SWIG_IsOK(res1)) {
32731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDefaultItem" "', expected argument " "1"" of type '" "wxWindow *""'");
32732 }
32733 arg1 = reinterpret_cast< wxWindow * >(argp1);
32734 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32735 if (!SWIG_IsOK(res2)) {
32736 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDefaultItem" "', expected argument " "2"" of type '" "wxWindow *""'");
32737 }
32738 arg2 = reinterpret_cast< wxWindow * >(argp2);
32739 {
32740 PyThreadState* __tstate = wxPyBeginAllowThreads();
32741 result = (wxWindow *)(arg1)->SetDefaultItem(arg2);
32742 wxPyEndAllowThreads(__tstate);
32743 if (PyErr_Occurred()) SWIG_fail;
32744 }
32745 {
32746 resultobj = wxPyMake_wxObject(result, 0);
32747 }
32748 return resultobj;
32749 fail:
32750 return NULL;
32751 }
32752
32753
32754 SWIGINTERN PyObject *_wrap_Window_SetTmpDefaultItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32755 PyObject *resultobj = 0;
32756 wxWindow *arg1 = (wxWindow *) 0 ;
32757 wxWindow *arg2 = (wxWindow *) 0 ;
32758 void *argp1 = 0 ;
32759 int res1 = 0 ;
32760 void *argp2 = 0 ;
32761 int res2 = 0 ;
32762 PyObject * obj0 = 0 ;
32763 PyObject * obj1 = 0 ;
32764 char * kwnames[] = {
32765 (char *) "self",(char *) "win", NULL
32766 };
32767
32768 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTmpDefaultItem",kwnames,&obj0,&obj1)) SWIG_fail;
32769 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32770 if (!SWIG_IsOK(res1)) {
32771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetTmpDefaultItem" "', expected argument " "1"" of type '" "wxWindow *""'");
32772 }
32773 arg1 = reinterpret_cast< wxWindow * >(argp1);
32774 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32775 if (!SWIG_IsOK(res2)) {
32776 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetTmpDefaultItem" "', expected argument " "2"" of type '" "wxWindow *""'");
32777 }
32778 arg2 = reinterpret_cast< wxWindow * >(argp2);
32779 {
32780 PyThreadState* __tstate = wxPyBeginAllowThreads();
32781 (arg1)->SetTmpDefaultItem(arg2);
32782 wxPyEndAllowThreads(__tstate);
32783 if (PyErr_Occurred()) SWIG_fail;
32784 }
32785 resultobj = SWIG_Py_Void();
32786 return resultobj;
32787 fail:
32788 return NULL;
32789 }
32790
32791
32792 SWIGINTERN PyObject *_wrap_Window_Navigate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32793 PyObject *resultobj = 0;
32794 wxWindow *arg1 = (wxWindow *) 0 ;
32795 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
32796 bool result;
32797 void *argp1 = 0 ;
32798 int res1 = 0 ;
32799 int val2 ;
32800 int ecode2 = 0 ;
32801 PyObject * obj0 = 0 ;
32802 PyObject * obj1 = 0 ;
32803 char * kwnames[] = {
32804 (char *) "self",(char *) "flags", NULL
32805 };
32806
32807 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) SWIG_fail;
32808 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32809 if (!SWIG_IsOK(res1)) {
32810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Navigate" "', expected argument " "1"" of type '" "wxWindow *""'");
32811 }
32812 arg1 = reinterpret_cast< wxWindow * >(argp1);
32813 if (obj1) {
32814 ecode2 = SWIG_AsVal_int(obj1, &val2);
32815 if (!SWIG_IsOK(ecode2)) {
32816 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Navigate" "', expected argument " "2"" of type '" "int""'");
32817 }
32818 arg2 = static_cast< int >(val2);
32819 }
32820 {
32821 PyThreadState* __tstate = wxPyBeginAllowThreads();
32822 result = (bool)(arg1)->Navigate(arg2);
32823 wxPyEndAllowThreads(__tstate);
32824 if (PyErr_Occurred()) SWIG_fail;
32825 }
32826 {
32827 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32828 }
32829 return resultobj;
32830 fail:
32831 return NULL;
32832 }
32833
32834
32835 SWIGINTERN PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32836 PyObject *resultobj = 0;
32837 wxWindow *arg1 = (wxWindow *) 0 ;
32838 wxWindow *arg2 = (wxWindow *) 0 ;
32839 void *argp1 = 0 ;
32840 int res1 = 0 ;
32841 void *argp2 = 0 ;
32842 int res2 = 0 ;
32843 PyObject * obj0 = 0 ;
32844 PyObject * obj1 = 0 ;
32845 char * kwnames[] = {
32846 (char *) "self",(char *) "win", NULL
32847 };
32848
32849 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
32850 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32851 if (!SWIG_IsOK(res1)) {
32852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
32853 }
32854 arg1 = reinterpret_cast< wxWindow * >(argp1);
32855 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32856 if (!SWIG_IsOK(res2)) {
32857 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
32858 }
32859 arg2 = reinterpret_cast< wxWindow * >(argp2);
32860 {
32861 PyThreadState* __tstate = wxPyBeginAllowThreads();
32862 (arg1)->MoveAfterInTabOrder(arg2);
32863 wxPyEndAllowThreads(__tstate);
32864 if (PyErr_Occurred()) SWIG_fail;
32865 }
32866 resultobj = SWIG_Py_Void();
32867 return resultobj;
32868 fail:
32869 return NULL;
32870 }
32871
32872
32873 SWIGINTERN PyObject *_wrap_Window_MoveBeforeInTabOrder(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_MoveBeforeInTabOrder",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_MoveBeforeInTabOrder" "', 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_MoveBeforeInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
32896 }
32897 arg2 = reinterpret_cast< wxWindow * >(argp2);
32898 {
32899 PyThreadState* __tstate = wxPyBeginAllowThreads();
32900 (arg1)->MoveBeforeInTabOrder(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_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32912 PyObject *resultobj = 0;
32913 wxWindow *arg1 = (wxWindow *) 0 ;
32914 PyObject *result = 0 ;
32915 void *argp1 = 0 ;
32916 int res1 = 0 ;
32917 PyObject *swig_obj[1] ;
32918
32919 if (!args) SWIG_fail;
32920 swig_obj[0] = args;
32921 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32922 if (!SWIG_IsOK(res1)) {
32923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
32924 }
32925 arg1 = reinterpret_cast< wxWindow * >(argp1);
32926 {
32927 PyThreadState* __tstate = wxPyBeginAllowThreads();
32928 result = (PyObject *)wxWindow_GetChildren(arg1);
32929 wxPyEndAllowThreads(__tstate);
32930 if (PyErr_Occurred()) SWIG_fail;
32931 }
32932 resultobj = result;
32933 return resultobj;
32934 fail:
32935 return NULL;
32936 }
32937
32938
32939 SWIGINTERN PyObject *_wrap_Window_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32940 PyObject *resultobj = 0;
32941 wxWindow *arg1 = (wxWindow *) 0 ;
32942 wxWindow *result = 0 ;
32943 void *argp1 = 0 ;
32944 int res1 = 0 ;
32945 PyObject *swig_obj[1] ;
32946
32947 if (!args) SWIG_fail;
32948 swig_obj[0] = args;
32949 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32950 if (!SWIG_IsOK(res1)) {
32951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
32952 }
32953 arg1 = reinterpret_cast< wxWindow * >(argp1);
32954 {
32955 PyThreadState* __tstate = wxPyBeginAllowThreads();
32956 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
32957 wxPyEndAllowThreads(__tstate);
32958 if (PyErr_Occurred()) SWIG_fail;
32959 }
32960 {
32961 resultobj = wxPyMake_wxObject(result, 0);
32962 }
32963 return resultobj;
32964 fail:
32965 return NULL;
32966 }
32967
32968
32969 SWIGINTERN PyObject *_wrap_Window_GetGrandParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32970 PyObject *resultobj = 0;
32971 wxWindow *arg1 = (wxWindow *) 0 ;
32972 wxWindow *result = 0 ;
32973 void *argp1 = 0 ;
32974 int res1 = 0 ;
32975 PyObject *swig_obj[1] ;
32976
32977 if (!args) SWIG_fail;
32978 swig_obj[0] = args;
32979 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32980 if (!SWIG_IsOK(res1)) {
32981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetGrandParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
32982 }
32983 arg1 = reinterpret_cast< wxWindow * >(argp1);
32984 {
32985 PyThreadState* __tstate = wxPyBeginAllowThreads();
32986 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
32987 wxPyEndAllowThreads(__tstate);
32988 if (PyErr_Occurred()) SWIG_fail;
32989 }
32990 {
32991 resultobj = wxPyMake_wxObject(result, 0);
32992 }
32993 return resultobj;
32994 fail:
32995 return NULL;
32996 }
32997
32998
32999 SWIGINTERN PyObject *_wrap_Window_IsTopLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33000 PyObject *resultobj = 0;
33001 wxWindow *arg1 = (wxWindow *) 0 ;
33002 bool result;
33003 void *argp1 = 0 ;
33004 int res1 = 0 ;
33005 PyObject *swig_obj[1] ;
33006
33007 if (!args) SWIG_fail;
33008 swig_obj[0] = args;
33009 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33010 if (!SWIG_IsOK(res1)) {
33011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsTopLevel" "', expected argument " "1"" of type '" "wxWindow const *""'");
33012 }
33013 arg1 = reinterpret_cast< wxWindow * >(argp1);
33014 {
33015 PyThreadState* __tstate = wxPyBeginAllowThreads();
33016 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
33017 wxPyEndAllowThreads(__tstate);
33018 if (PyErr_Occurred()) SWIG_fail;
33019 }
33020 {
33021 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33022 }
33023 return resultobj;
33024 fail:
33025 return NULL;
33026 }
33027
33028
33029 SWIGINTERN PyObject *_wrap_Window_Reparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33030 PyObject *resultobj = 0;
33031 wxWindow *arg1 = (wxWindow *) 0 ;
33032 wxWindow *arg2 = (wxWindow *) 0 ;
33033 bool result;
33034 void *argp1 = 0 ;
33035 int res1 = 0 ;
33036 void *argp2 = 0 ;
33037 int res2 = 0 ;
33038 PyObject * obj0 = 0 ;
33039 PyObject * obj1 = 0 ;
33040 char * kwnames[] = {
33041 (char *) "self",(char *) "newParent", NULL
33042 };
33043
33044 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) SWIG_fail;
33045 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33046 if (!SWIG_IsOK(res1)) {
33047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Reparent" "', expected argument " "1"" of type '" "wxWindow *""'");
33048 }
33049 arg1 = reinterpret_cast< wxWindow * >(argp1);
33050 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33051 if (!SWIG_IsOK(res2)) {
33052 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Reparent" "', expected argument " "2"" of type '" "wxWindow *""'");
33053 }
33054 arg2 = reinterpret_cast< wxWindow * >(argp2);
33055 {
33056 PyThreadState* __tstate = wxPyBeginAllowThreads();
33057 result = (bool)(arg1)->Reparent(arg2);
33058 wxPyEndAllowThreads(__tstate);
33059 if (PyErr_Occurred()) SWIG_fail;
33060 }
33061 {
33062 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33063 }
33064 return resultobj;
33065 fail:
33066 return NULL;
33067 }
33068
33069
33070 SWIGINTERN PyObject *_wrap_Window_AddChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33071 PyObject *resultobj = 0;
33072 wxWindow *arg1 = (wxWindow *) 0 ;
33073 wxWindow *arg2 = (wxWindow *) 0 ;
33074 void *argp1 = 0 ;
33075 int res1 = 0 ;
33076 void *argp2 = 0 ;
33077 int res2 = 0 ;
33078 PyObject * obj0 = 0 ;
33079 PyObject * obj1 = 0 ;
33080 char * kwnames[] = {
33081 (char *) "self",(char *) "child", NULL
33082 };
33083
33084 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) SWIG_fail;
33085 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33086 if (!SWIG_IsOK(res1)) {
33087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AddChild" "', expected argument " "1"" of type '" "wxWindow *""'");
33088 }
33089 arg1 = reinterpret_cast< wxWindow * >(argp1);
33090 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33091 if (!SWIG_IsOK(res2)) {
33092 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_AddChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33093 }
33094 arg2 = reinterpret_cast< wxWindow * >(argp2);
33095 {
33096 PyThreadState* __tstate = wxPyBeginAllowThreads();
33097 (arg1)->AddChild(arg2);
33098 wxPyEndAllowThreads(__tstate);
33099 if (PyErr_Occurred()) SWIG_fail;
33100 }
33101 resultobj = SWIG_Py_Void();
33102 return resultobj;
33103 fail:
33104 return NULL;
33105 }
33106
33107
33108 SWIGINTERN PyObject *_wrap_Window_RemoveChild(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_RemoveChild",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_RemoveChild" "', 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_RemoveChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33131 }
33132 arg2 = reinterpret_cast< wxWindow * >(argp2);
33133 {
33134 PyThreadState* __tstate = wxPyBeginAllowThreads();
33135 (arg1)->RemoveChild(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_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33147 PyObject *resultobj = 0;
33148 wxWindow *arg1 = (wxWindow *) 0 ;
33149 long arg2 ;
33150 wxWindow *result = 0 ;
33151 void *argp1 = 0 ;
33152 int res1 = 0 ;
33153 long val2 ;
33154 int ecode2 = 0 ;
33155 PyObject * obj0 = 0 ;
33156 PyObject * obj1 = 0 ;
33157 char * kwnames[] = {
33158 (char *) "self",(char *) "winid", NULL
33159 };
33160
33161 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
33162 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33163 if (!SWIG_IsOK(res1)) {
33164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowById" "', expected argument " "1"" of type '" "wxWindow *""'");
33165 }
33166 arg1 = reinterpret_cast< wxWindow * >(argp1);
33167 ecode2 = SWIG_AsVal_long(obj1, &val2);
33168 if (!SWIG_IsOK(ecode2)) {
33169 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FindWindowById" "', expected argument " "2"" of type '" "long""'");
33170 }
33171 arg2 = static_cast< long >(val2);
33172 {
33173 PyThreadState* __tstate = wxPyBeginAllowThreads();
33174 result = (wxWindow *)(arg1)->FindWindow(arg2);
33175 wxPyEndAllowThreads(__tstate);
33176 if (PyErr_Occurred()) SWIG_fail;
33177 }
33178 {
33179 resultobj = wxPyMake_wxObject(result, 0);
33180 }
33181 return resultobj;
33182 fail:
33183 return NULL;
33184 }
33185
33186
33187 SWIGINTERN PyObject *_wrap_Window_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33188 PyObject *resultobj = 0;
33189 wxWindow *arg1 = (wxWindow *) 0 ;
33190 wxString *arg2 = 0 ;
33191 wxWindow *result = 0 ;
33192 void *argp1 = 0 ;
33193 int res1 = 0 ;
33194 bool temp2 = false ;
33195 PyObject * obj0 = 0 ;
33196 PyObject * obj1 = 0 ;
33197 char * kwnames[] = {
33198 (char *) "self",(char *) "name", NULL
33199 };
33200
33201 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
33202 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33203 if (!SWIG_IsOK(res1)) {
33204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowByName" "', expected argument " "1"" of type '" "wxWindow *""'");
33205 }
33206 arg1 = reinterpret_cast< wxWindow * >(argp1);
33207 {
33208 arg2 = wxString_in_helper(obj1);
33209 if (arg2 == NULL) SWIG_fail;
33210 temp2 = true;
33211 }
33212 {
33213 PyThreadState* __tstate = wxPyBeginAllowThreads();
33214 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
33215 wxPyEndAllowThreads(__tstate);
33216 if (PyErr_Occurred()) SWIG_fail;
33217 }
33218 {
33219 resultobj = wxPyMake_wxObject(result, 0);
33220 }
33221 {
33222 if (temp2)
33223 delete arg2;
33224 }
33225 return resultobj;
33226 fail:
33227 {
33228 if (temp2)
33229 delete arg2;
33230 }
33231 return NULL;
33232 }
33233
33234
33235 SWIGINTERN PyObject *_wrap_Window_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33236 PyObject *resultobj = 0;
33237 wxWindow *arg1 = (wxWindow *) 0 ;
33238 wxEvtHandler *result = 0 ;
33239 void *argp1 = 0 ;
33240 int res1 = 0 ;
33241 PyObject *swig_obj[1] ;
33242
33243 if (!args) SWIG_fail;
33244 swig_obj[0] = args;
33245 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33246 if (!SWIG_IsOK(res1)) {
33247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEventHandler" "', expected argument " "1"" of type '" "wxWindow const *""'");
33248 }
33249 arg1 = reinterpret_cast< wxWindow * >(argp1);
33250 {
33251 PyThreadState* __tstate = wxPyBeginAllowThreads();
33252 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
33253 wxPyEndAllowThreads(__tstate);
33254 if (PyErr_Occurred()) SWIG_fail;
33255 }
33256 {
33257 resultobj = wxPyMake_wxObject(result, 0);
33258 }
33259 return resultobj;
33260 fail:
33261 return NULL;
33262 }
33263
33264
33265 SWIGINTERN PyObject *_wrap_Window_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33266 PyObject *resultobj = 0;
33267 wxWindow *arg1 = (wxWindow *) 0 ;
33268 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33269 void *argp1 = 0 ;
33270 int res1 = 0 ;
33271 void *argp2 = 0 ;
33272 int res2 = 0 ;
33273 PyObject * obj0 = 0 ;
33274 PyObject * obj1 = 0 ;
33275 char * kwnames[] = {
33276 (char *) "self",(char *) "handler", NULL
33277 };
33278
33279 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33280 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33281 if (!SWIG_IsOK(res1)) {
33282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33283 }
33284 arg1 = reinterpret_cast< wxWindow * >(argp1);
33285 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33286 if (!SWIG_IsOK(res2)) {
33287 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33288 }
33289 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33290 {
33291 PyThreadState* __tstate = wxPyBeginAllowThreads();
33292 (arg1)->SetEventHandler(arg2);
33293 wxPyEndAllowThreads(__tstate);
33294 if (PyErr_Occurred()) SWIG_fail;
33295 }
33296 resultobj = SWIG_Py_Void();
33297 return resultobj;
33298 fail:
33299 return NULL;
33300 }
33301
33302
33303 SWIGINTERN PyObject *_wrap_Window_PushEventHandler(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_PushEventHandler",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_PushEventHandler" "', 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_PushEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33326 }
33327 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33328 {
33329 PyThreadState* __tstate = wxPyBeginAllowThreads();
33330 (arg1)->PushEventHandler(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_PopEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33342 PyObject *resultobj = 0;
33343 wxWindow *arg1 = (wxWindow *) 0 ;
33344 bool arg2 = (bool) false ;
33345 wxEvtHandler *result = 0 ;
33346 void *argp1 = 0 ;
33347 int res1 = 0 ;
33348 bool val2 ;
33349 int ecode2 = 0 ;
33350 PyObject * obj0 = 0 ;
33351 PyObject * obj1 = 0 ;
33352 char * kwnames[] = {
33353 (char *) "self",(char *) "deleteHandler", NULL
33354 };
33355
33356 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33357 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33358 if (!SWIG_IsOK(res1)) {
33359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33360 }
33361 arg1 = reinterpret_cast< wxWindow * >(argp1);
33362 if (obj1) {
33363 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33364 if (!SWIG_IsOK(ecode2)) {
33365 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_PopEventHandler" "', expected argument " "2"" of type '" "bool""'");
33366 }
33367 arg2 = static_cast< bool >(val2);
33368 }
33369 {
33370 PyThreadState* __tstate = wxPyBeginAllowThreads();
33371 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
33372 wxPyEndAllowThreads(__tstate);
33373 if (PyErr_Occurred()) SWIG_fail;
33374 }
33375 {
33376 resultobj = wxPyMake_wxObject(result, 0);
33377 }
33378 return resultobj;
33379 fail:
33380 return NULL;
33381 }
33382
33383
33384 SWIGINTERN PyObject *_wrap_Window_RemoveEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33385 PyObject *resultobj = 0;
33386 wxWindow *arg1 = (wxWindow *) 0 ;
33387 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33388 bool result;
33389 void *argp1 = 0 ;
33390 int res1 = 0 ;
33391 void *argp2 = 0 ;
33392 int res2 = 0 ;
33393 PyObject * obj0 = 0 ;
33394 PyObject * obj1 = 0 ;
33395 char * kwnames[] = {
33396 (char *) "self",(char *) "handler", NULL
33397 };
33398
33399 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33400 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33401 if (!SWIG_IsOK(res1)) {
33402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33403 }
33404 arg1 = reinterpret_cast< wxWindow * >(argp1);
33405 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33406 if (!SWIG_IsOK(res2)) {
33407 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33408 }
33409 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33410 {
33411 PyThreadState* __tstate = wxPyBeginAllowThreads();
33412 result = (bool)(arg1)->RemoveEventHandler(arg2);
33413 wxPyEndAllowThreads(__tstate);
33414 if (PyErr_Occurred()) SWIG_fail;
33415 }
33416 {
33417 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33418 }
33419 return resultobj;
33420 fail:
33421 return NULL;
33422 }
33423
33424
33425 SWIGINTERN PyObject *_wrap_Window_SetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33426 PyObject *resultobj = 0;
33427 wxWindow *arg1 = (wxWindow *) 0 ;
33428 wxValidator *arg2 = 0 ;
33429 void *argp1 = 0 ;
33430 int res1 = 0 ;
33431 void *argp2 = 0 ;
33432 int res2 = 0 ;
33433 PyObject * obj0 = 0 ;
33434 PyObject * obj1 = 0 ;
33435 char * kwnames[] = {
33436 (char *) "self",(char *) "validator", NULL
33437 };
33438
33439 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) SWIG_fail;
33440 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33441 if (!SWIG_IsOK(res1)) {
33442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
33443 }
33444 arg1 = reinterpret_cast< wxWindow * >(argp1);
33445 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxValidator, 0 | 0);
33446 if (!SWIG_IsOK(res2)) {
33447 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
33448 }
33449 if (!argp2) {
33450 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
33451 }
33452 arg2 = reinterpret_cast< wxValidator * >(argp2);
33453 {
33454 PyThreadState* __tstate = wxPyBeginAllowThreads();
33455 (arg1)->SetValidator((wxValidator const &)*arg2);
33456 wxPyEndAllowThreads(__tstate);
33457 if (PyErr_Occurred()) SWIG_fail;
33458 }
33459 resultobj = SWIG_Py_Void();
33460 return resultobj;
33461 fail:
33462 return NULL;
33463 }
33464
33465
33466 SWIGINTERN PyObject *_wrap_Window_GetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33467 PyObject *resultobj = 0;
33468 wxWindow *arg1 = (wxWindow *) 0 ;
33469 wxValidator *result = 0 ;
33470 void *argp1 = 0 ;
33471 int res1 = 0 ;
33472 PyObject *swig_obj[1] ;
33473
33474 if (!args) SWIG_fail;
33475 swig_obj[0] = args;
33476 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33477 if (!SWIG_IsOK(res1)) {
33478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
33479 }
33480 arg1 = reinterpret_cast< wxWindow * >(argp1);
33481 {
33482 PyThreadState* __tstate = wxPyBeginAllowThreads();
33483 result = (wxValidator *)(arg1)->GetValidator();
33484 wxPyEndAllowThreads(__tstate);
33485 if (PyErr_Occurred()) SWIG_fail;
33486 }
33487 {
33488 resultobj = wxPyMake_wxObject(result, (bool)0);
33489 }
33490 return resultobj;
33491 fail:
33492 return NULL;
33493 }
33494
33495
33496 SWIGINTERN PyObject *_wrap_Window_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33497 PyObject *resultobj = 0;
33498 wxWindow *arg1 = (wxWindow *) 0 ;
33499 bool result;
33500 void *argp1 = 0 ;
33501 int res1 = 0 ;
33502 PyObject *swig_obj[1] ;
33503
33504 if (!args) SWIG_fail;
33505 swig_obj[0] = args;
33506 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33507 if (!SWIG_IsOK(res1)) {
33508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Validate" "', expected argument " "1"" of type '" "wxWindow *""'");
33509 }
33510 arg1 = reinterpret_cast< wxWindow * >(argp1);
33511 {
33512 PyThreadState* __tstate = wxPyBeginAllowThreads();
33513 result = (bool)(arg1)->Validate();
33514 wxPyEndAllowThreads(__tstate);
33515 if (PyErr_Occurred()) SWIG_fail;
33516 }
33517 {
33518 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33519 }
33520 return resultobj;
33521 fail:
33522 return NULL;
33523 }
33524
33525
33526 SWIGINTERN PyObject *_wrap_Window_TransferDataToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33527 PyObject *resultobj = 0;
33528 wxWindow *arg1 = (wxWindow *) 0 ;
33529 bool result;
33530 void *argp1 = 0 ;
33531 int res1 = 0 ;
33532 PyObject *swig_obj[1] ;
33533
33534 if (!args) SWIG_fail;
33535 swig_obj[0] = args;
33536 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33537 if (!SWIG_IsOK(res1)) {
33538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataToWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
33539 }
33540 arg1 = reinterpret_cast< wxWindow * >(argp1);
33541 {
33542 PyThreadState* __tstate = wxPyBeginAllowThreads();
33543 result = (bool)(arg1)->TransferDataToWindow();
33544 wxPyEndAllowThreads(__tstate);
33545 if (PyErr_Occurred()) SWIG_fail;
33546 }
33547 {
33548 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33549 }
33550 return resultobj;
33551 fail:
33552 return NULL;
33553 }
33554
33555
33556 SWIGINTERN PyObject *_wrap_Window_TransferDataFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33557 PyObject *resultobj = 0;
33558 wxWindow *arg1 = (wxWindow *) 0 ;
33559 bool result;
33560 void *argp1 = 0 ;
33561 int res1 = 0 ;
33562 PyObject *swig_obj[1] ;
33563
33564 if (!args) SWIG_fail;
33565 swig_obj[0] = args;
33566 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33567 if (!SWIG_IsOK(res1)) {
33568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
33569 }
33570 arg1 = reinterpret_cast< wxWindow * >(argp1);
33571 {
33572 PyThreadState* __tstate = wxPyBeginAllowThreads();
33573 result = (bool)(arg1)->TransferDataFromWindow();
33574 wxPyEndAllowThreads(__tstate);
33575 if (PyErr_Occurred()) SWIG_fail;
33576 }
33577 {
33578 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33579 }
33580 return resultobj;
33581 fail:
33582 return NULL;
33583 }
33584
33585
33586 SWIGINTERN PyObject *_wrap_Window_InitDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33587 PyObject *resultobj = 0;
33588 wxWindow *arg1 = (wxWindow *) 0 ;
33589 void *argp1 = 0 ;
33590 int res1 = 0 ;
33591 PyObject *swig_obj[1] ;
33592
33593 if (!args) SWIG_fail;
33594 swig_obj[0] = args;
33595 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33596 if (!SWIG_IsOK(res1)) {
33597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InitDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
33598 }
33599 arg1 = reinterpret_cast< wxWindow * >(argp1);
33600 {
33601 PyThreadState* __tstate = wxPyBeginAllowThreads();
33602 (arg1)->InitDialog();
33603 wxPyEndAllowThreads(__tstate);
33604 if (PyErr_Occurred()) SWIG_fail;
33605 }
33606 resultobj = SWIG_Py_Void();
33607 return resultobj;
33608 fail:
33609 return NULL;
33610 }
33611
33612
33613 SWIGINTERN PyObject *_wrap_Window_SetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33614 PyObject *resultobj = 0;
33615 wxWindow *arg1 = (wxWindow *) 0 ;
33616 wxAcceleratorTable *arg2 = 0 ;
33617 void *argp1 = 0 ;
33618 int res1 = 0 ;
33619 void *argp2 = 0 ;
33620 int res2 = 0 ;
33621 PyObject * obj0 = 0 ;
33622 PyObject * obj1 = 0 ;
33623 char * kwnames[] = {
33624 (char *) "self",(char *) "accel", NULL
33625 };
33626
33627 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) SWIG_fail;
33628 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33629 if (!SWIG_IsOK(res1)) {
33630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
33631 }
33632 arg1 = reinterpret_cast< wxWindow * >(argp1);
33633 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAcceleratorTable, 0 | 0);
33634 if (!SWIG_IsOK(res2)) {
33635 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
33636 }
33637 if (!argp2) {
33638 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
33639 }
33640 arg2 = reinterpret_cast< wxAcceleratorTable * >(argp2);
33641 {
33642 PyThreadState* __tstate = wxPyBeginAllowThreads();
33643 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
33644 wxPyEndAllowThreads(__tstate);
33645 if (PyErr_Occurred()) SWIG_fail;
33646 }
33647 resultobj = SWIG_Py_Void();
33648 return resultobj;
33649 fail:
33650 return NULL;
33651 }
33652
33653
33654 SWIGINTERN PyObject *_wrap_Window_GetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33655 PyObject *resultobj = 0;
33656 wxWindow *arg1 = (wxWindow *) 0 ;
33657 wxAcceleratorTable *result = 0 ;
33658 void *argp1 = 0 ;
33659 int res1 = 0 ;
33660 PyObject *swig_obj[1] ;
33661
33662 if (!args) SWIG_fail;
33663 swig_obj[0] = args;
33664 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33665 if (!SWIG_IsOK(res1)) {
33666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
33667 }
33668 arg1 = reinterpret_cast< wxWindow * >(argp1);
33669 {
33670 PyThreadState* __tstate = wxPyBeginAllowThreads();
33671 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
33672 wxPyEndAllowThreads(__tstate);
33673 if (PyErr_Occurred()) SWIG_fail;
33674 }
33675 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
33676 return resultobj;
33677 fail:
33678 return NULL;
33679 }
33680
33681
33682 SWIGINTERN PyObject *_wrap_Window_RegisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33683 PyObject *resultobj = 0;
33684 wxWindow *arg1 = (wxWindow *) 0 ;
33685 int arg2 ;
33686 int arg3 ;
33687 int arg4 ;
33688 bool result;
33689 void *argp1 = 0 ;
33690 int res1 = 0 ;
33691 int val2 ;
33692 int ecode2 = 0 ;
33693 int val3 ;
33694 int ecode3 = 0 ;
33695 int val4 ;
33696 int ecode4 = 0 ;
33697 PyObject * obj0 = 0 ;
33698 PyObject * obj1 = 0 ;
33699 PyObject * obj2 = 0 ;
33700 PyObject * obj3 = 0 ;
33701 char * kwnames[] = {
33702 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
33703 };
33704
33705 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33706 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33707 if (!SWIG_IsOK(res1)) {
33708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RegisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
33709 }
33710 arg1 = reinterpret_cast< wxWindow * >(argp1);
33711 ecode2 = SWIG_AsVal_int(obj1, &val2);
33712 if (!SWIG_IsOK(ecode2)) {
33713 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_RegisterHotKey" "', expected argument " "2"" of type '" "int""'");
33714 }
33715 arg2 = static_cast< int >(val2);
33716 ecode3 = SWIG_AsVal_int(obj2, &val3);
33717 if (!SWIG_IsOK(ecode3)) {
33718 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RegisterHotKey" "', expected argument " "3"" of type '" "int""'");
33719 }
33720 arg3 = static_cast< int >(val3);
33721 ecode4 = SWIG_AsVal_int(obj3, &val4);
33722 if (!SWIG_IsOK(ecode4)) {
33723 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_RegisterHotKey" "', expected argument " "4"" of type '" "int""'");
33724 }
33725 arg4 = static_cast< int >(val4);
33726 {
33727 PyThreadState* __tstate = wxPyBeginAllowThreads();
33728 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
33729 wxPyEndAllowThreads(__tstate);
33730 if (PyErr_Occurred()) SWIG_fail;
33731 }
33732 {
33733 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33734 }
33735 return resultobj;
33736 fail:
33737 return NULL;
33738 }
33739
33740
33741 SWIGINTERN PyObject *_wrap_Window_UnregisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33742 PyObject *resultobj = 0;
33743 wxWindow *arg1 = (wxWindow *) 0 ;
33744 int arg2 ;
33745 bool result;
33746 void *argp1 = 0 ;
33747 int res1 = 0 ;
33748 int val2 ;
33749 int ecode2 = 0 ;
33750 PyObject * obj0 = 0 ;
33751 PyObject * obj1 = 0 ;
33752 char * kwnames[] = {
33753 (char *) "self",(char *) "hotkeyId", NULL
33754 };
33755
33756 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) SWIG_fail;
33757 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33758 if (!SWIG_IsOK(res1)) {
33759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UnregisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
33760 }
33761 arg1 = reinterpret_cast< wxWindow * >(argp1);
33762 ecode2 = SWIG_AsVal_int(obj1, &val2);
33763 if (!SWIG_IsOK(ecode2)) {
33764 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UnregisterHotKey" "', expected argument " "2"" of type '" "int""'");
33765 }
33766 arg2 = static_cast< int >(val2);
33767 {
33768 PyThreadState* __tstate = wxPyBeginAllowThreads();
33769 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
33770 wxPyEndAllowThreads(__tstate);
33771 if (PyErr_Occurred()) SWIG_fail;
33772 }
33773 {
33774 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33775 }
33776 return resultobj;
33777 fail:
33778 return NULL;
33779 }
33780
33781
33782 SWIGINTERN PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33783 PyObject *resultobj = 0;
33784 wxWindow *arg1 = (wxWindow *) 0 ;
33785 wxPoint *arg2 = 0 ;
33786 wxPoint result;
33787 void *argp1 = 0 ;
33788 int res1 = 0 ;
33789 wxPoint temp2 ;
33790 PyObject * obj0 = 0 ;
33791 PyObject * obj1 = 0 ;
33792 char * kwnames[] = {
33793 (char *) "self",(char *) "pt", NULL
33794 };
33795
33796 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
33797 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33798 if (!SWIG_IsOK(res1)) {
33799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogPointToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
33800 }
33801 arg1 = reinterpret_cast< wxWindow * >(argp1);
33802 {
33803 arg2 = &temp2;
33804 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
33805 }
33806 {
33807 PyThreadState* __tstate = wxPyBeginAllowThreads();
33808 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
33809 wxPyEndAllowThreads(__tstate);
33810 if (PyErr_Occurred()) SWIG_fail;
33811 }
33812 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
33813 return resultobj;
33814 fail:
33815 return NULL;
33816 }
33817
33818
33819 SWIGINTERN PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33820 PyObject *resultobj = 0;
33821 wxWindow *arg1 = (wxWindow *) 0 ;
33822 wxSize *arg2 = 0 ;
33823 wxSize result;
33824 void *argp1 = 0 ;
33825 int res1 = 0 ;
33826 wxSize temp2 ;
33827 PyObject * obj0 = 0 ;
33828 PyObject * obj1 = 0 ;
33829 char * kwnames[] = {
33830 (char *) "self",(char *) "sz", NULL
33831 };
33832
33833 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
33834 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33835 if (!SWIG_IsOK(res1)) {
33836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogSizeToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
33837 }
33838 arg1 = reinterpret_cast< wxWindow * >(argp1);
33839 {
33840 arg2 = &temp2;
33841 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33842 }
33843 {
33844 PyThreadState* __tstate = wxPyBeginAllowThreads();
33845 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
33846 wxPyEndAllowThreads(__tstate);
33847 if (PyErr_Occurred()) SWIG_fail;
33848 }
33849 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
33850 return resultobj;
33851 fail:
33852 return NULL;
33853 }
33854
33855
33856 SWIGINTERN PyObject *_wrap_Window_DLG_PNT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33857 PyObject *resultobj = 0;
33858 wxWindow *arg1 = (wxWindow *) 0 ;
33859 wxPoint *arg2 = 0 ;
33860 wxPoint result;
33861 void *argp1 = 0 ;
33862 int res1 = 0 ;
33863 wxPoint temp2 ;
33864 PyObject * obj0 = 0 ;
33865 PyObject * obj1 = 0 ;
33866 char * kwnames[] = {
33867 (char *) "self",(char *) "pt", NULL
33868 };
33869
33870 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) SWIG_fail;
33871 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33872 if (!SWIG_IsOK(res1)) {
33873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_PNT" "', expected argument " "1"" of type '" "wxWindow *""'");
33874 }
33875 arg1 = reinterpret_cast< wxWindow * >(argp1);
33876 {
33877 arg2 = &temp2;
33878 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
33879 }
33880 {
33881 PyThreadState* __tstate = wxPyBeginAllowThreads();
33882 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
33883 wxPyEndAllowThreads(__tstate);
33884 if (PyErr_Occurred()) SWIG_fail;
33885 }
33886 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
33887 return resultobj;
33888 fail:
33889 return NULL;
33890 }
33891
33892
33893 SWIGINTERN PyObject *_wrap_Window_DLG_SZE(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33894 PyObject *resultobj = 0;
33895 wxWindow *arg1 = (wxWindow *) 0 ;
33896 wxSize *arg2 = 0 ;
33897 wxSize result;
33898 void *argp1 = 0 ;
33899 int res1 = 0 ;
33900 wxSize temp2 ;
33901 PyObject * obj0 = 0 ;
33902 PyObject * obj1 = 0 ;
33903 char * kwnames[] = {
33904 (char *) "self",(char *) "sz", NULL
33905 };
33906
33907 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) SWIG_fail;
33908 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33909 if (!SWIG_IsOK(res1)) {
33910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_SZE" "', expected argument " "1"" of type '" "wxWindow *""'");
33911 }
33912 arg1 = reinterpret_cast< wxWindow * >(argp1);
33913 {
33914 arg2 = &temp2;
33915 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33916 }
33917 {
33918 PyThreadState* __tstate = wxPyBeginAllowThreads();
33919 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
33920 wxPyEndAllowThreads(__tstate);
33921 if (PyErr_Occurred()) SWIG_fail;
33922 }
33923 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
33924 return resultobj;
33925 fail:
33926 return NULL;
33927 }
33928
33929
33930 SWIGINTERN PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33931 PyObject *resultobj = 0;
33932 wxWindow *arg1 = (wxWindow *) 0 ;
33933 wxPoint *arg2 = 0 ;
33934 wxPoint result;
33935 void *argp1 = 0 ;
33936 int res1 = 0 ;
33937 wxPoint temp2 ;
33938 PyObject * obj0 = 0 ;
33939 PyObject * obj1 = 0 ;
33940 char * kwnames[] = {
33941 (char *) "self",(char *) "pt", NULL
33942 };
33943
33944 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
33945 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33946 if (!SWIG_IsOK(res1)) {
33947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelPointToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
33948 }
33949 arg1 = reinterpret_cast< wxWindow * >(argp1);
33950 {
33951 arg2 = &temp2;
33952 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
33953 }
33954 {
33955 PyThreadState* __tstate = wxPyBeginAllowThreads();
33956 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
33957 wxPyEndAllowThreads(__tstate);
33958 if (PyErr_Occurred()) SWIG_fail;
33959 }
33960 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
33961 return resultobj;
33962 fail:
33963 return NULL;
33964 }
33965
33966
33967 SWIGINTERN PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33968 PyObject *resultobj = 0;
33969 wxWindow *arg1 = (wxWindow *) 0 ;
33970 wxSize *arg2 = 0 ;
33971 wxSize result;
33972 void *argp1 = 0 ;
33973 int res1 = 0 ;
33974 wxSize temp2 ;
33975 PyObject * obj0 = 0 ;
33976 PyObject * obj1 = 0 ;
33977 char * kwnames[] = {
33978 (char *) "self",(char *) "sz", NULL
33979 };
33980
33981 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
33982 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33983 if (!SWIG_IsOK(res1)) {
33984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelSizeToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
33985 }
33986 arg1 = reinterpret_cast< wxWindow * >(argp1);
33987 {
33988 arg2 = &temp2;
33989 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33990 }
33991 {
33992 PyThreadState* __tstate = wxPyBeginAllowThreads();
33993 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
33994 wxPyEndAllowThreads(__tstate);
33995 if (PyErr_Occurred()) SWIG_fail;
33996 }
33997 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
33998 return resultobj;
33999 fail:
34000 return NULL;
34001 }
34002
34003
34004 SWIGINTERN PyObject *_wrap_Window_WarpPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34005 PyObject *resultobj = 0;
34006 wxWindow *arg1 = (wxWindow *) 0 ;
34007 int arg2 ;
34008 int arg3 ;
34009 void *argp1 = 0 ;
34010 int res1 = 0 ;
34011 int val2 ;
34012 int ecode2 = 0 ;
34013 int val3 ;
34014 int ecode3 = 0 ;
34015 PyObject * obj0 = 0 ;
34016 PyObject * obj1 = 0 ;
34017 PyObject * obj2 = 0 ;
34018 char * kwnames[] = {
34019 (char *) "self",(char *) "x",(char *) "y", NULL
34020 };
34021
34022 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34023 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34024 if (!SWIG_IsOK(res1)) {
34025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_WarpPointer" "', expected argument " "1"" of type '" "wxWindow *""'");
34026 }
34027 arg1 = reinterpret_cast< wxWindow * >(argp1);
34028 ecode2 = SWIG_AsVal_int(obj1, &val2);
34029 if (!SWIG_IsOK(ecode2)) {
34030 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_WarpPointer" "', expected argument " "2"" of type '" "int""'");
34031 }
34032 arg2 = static_cast< int >(val2);
34033 ecode3 = SWIG_AsVal_int(obj2, &val3);
34034 if (!SWIG_IsOK(ecode3)) {
34035 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_WarpPointer" "', expected argument " "3"" of type '" "int""'");
34036 }
34037 arg3 = static_cast< int >(val3);
34038 {
34039 PyThreadState* __tstate = wxPyBeginAllowThreads();
34040 (arg1)->WarpPointer(arg2,arg3);
34041 wxPyEndAllowThreads(__tstate);
34042 if (PyErr_Occurred()) SWIG_fail;
34043 }
34044 resultobj = SWIG_Py_Void();
34045 return resultobj;
34046 fail:
34047 return NULL;
34048 }
34049
34050
34051 SWIGINTERN PyObject *_wrap_Window_CaptureMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34052 PyObject *resultobj = 0;
34053 wxWindow *arg1 = (wxWindow *) 0 ;
34054 void *argp1 = 0 ;
34055 int res1 = 0 ;
34056 PyObject *swig_obj[1] ;
34057
34058 if (!args) SWIG_fail;
34059 swig_obj[0] = args;
34060 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34061 if (!SWIG_IsOK(res1)) {
34062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CaptureMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
34063 }
34064 arg1 = reinterpret_cast< wxWindow * >(argp1);
34065 {
34066 PyThreadState* __tstate = wxPyBeginAllowThreads();
34067 (arg1)->CaptureMouse();
34068 wxPyEndAllowThreads(__tstate);
34069 if (PyErr_Occurred()) SWIG_fail;
34070 }
34071 resultobj = SWIG_Py_Void();
34072 return resultobj;
34073 fail:
34074 return NULL;
34075 }
34076
34077
34078 SWIGINTERN PyObject *_wrap_Window_ReleaseMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34079 PyObject *resultobj = 0;
34080 wxWindow *arg1 = (wxWindow *) 0 ;
34081 void *argp1 = 0 ;
34082 int res1 = 0 ;
34083 PyObject *swig_obj[1] ;
34084
34085 if (!args) SWIG_fail;
34086 swig_obj[0] = args;
34087 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34088 if (!SWIG_IsOK(res1)) {
34089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ReleaseMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
34090 }
34091 arg1 = reinterpret_cast< wxWindow * >(argp1);
34092 {
34093 PyThreadState* __tstate = wxPyBeginAllowThreads();
34094 (arg1)->ReleaseMouse();
34095 wxPyEndAllowThreads(__tstate);
34096 if (PyErr_Occurred()) SWIG_fail;
34097 }
34098 resultobj = SWIG_Py_Void();
34099 return resultobj;
34100 fail:
34101 return NULL;
34102 }
34103
34104
34105 SWIGINTERN PyObject *_wrap_Window_GetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34106 PyObject *resultobj = 0;
34107 wxWindow *result = 0 ;
34108
34109 if (!SWIG_Python_UnpackTuple(args,"Window_GetCapture",0,0,0)) SWIG_fail;
34110 {
34111 if (!wxPyCheckForApp()) SWIG_fail;
34112 PyThreadState* __tstate = wxPyBeginAllowThreads();
34113 result = (wxWindow *)wxWindow::GetCapture();
34114 wxPyEndAllowThreads(__tstate);
34115 if (PyErr_Occurred()) SWIG_fail;
34116 }
34117 {
34118 resultobj = wxPyMake_wxObject(result, 0);
34119 }
34120 return resultobj;
34121 fail:
34122 return NULL;
34123 }
34124
34125
34126 SWIGINTERN PyObject *_wrap_Window_HasCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34127 PyObject *resultobj = 0;
34128 wxWindow *arg1 = (wxWindow *) 0 ;
34129 bool result;
34130 void *argp1 = 0 ;
34131 int res1 = 0 ;
34132 PyObject *swig_obj[1] ;
34133
34134 if (!args) SWIG_fail;
34135 swig_obj[0] = args;
34136 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34137 if (!SWIG_IsOK(res1)) {
34138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasCapture" "', expected argument " "1"" of type '" "wxWindow const *""'");
34139 }
34140 arg1 = reinterpret_cast< wxWindow * >(argp1);
34141 {
34142 PyThreadState* __tstate = wxPyBeginAllowThreads();
34143 result = (bool)((wxWindow const *)arg1)->HasCapture();
34144 wxPyEndAllowThreads(__tstate);
34145 if (PyErr_Occurred()) SWIG_fail;
34146 }
34147 {
34148 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34149 }
34150 return resultobj;
34151 fail:
34152 return NULL;
34153 }
34154
34155
34156 SWIGINTERN PyObject *_wrap_Window_Refresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34157 PyObject *resultobj = 0;
34158 wxWindow *arg1 = (wxWindow *) 0 ;
34159 bool arg2 = (bool) true ;
34160 wxRect *arg3 = (wxRect *) NULL ;
34161 void *argp1 = 0 ;
34162 int res1 = 0 ;
34163 bool val2 ;
34164 int ecode2 = 0 ;
34165 void *argp3 = 0 ;
34166 int res3 = 0 ;
34167 PyObject * obj0 = 0 ;
34168 PyObject * obj1 = 0 ;
34169 PyObject * obj2 = 0 ;
34170 char * kwnames[] = {
34171 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
34172 };
34173
34174 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34175 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34176 if (!SWIG_IsOK(res1)) {
34177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Refresh" "', expected argument " "1"" of type '" "wxWindow *""'");
34178 }
34179 arg1 = reinterpret_cast< wxWindow * >(argp1);
34180 if (obj1) {
34181 ecode2 = SWIG_AsVal_bool(obj1, &val2);
34182 if (!SWIG_IsOK(ecode2)) {
34183 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Refresh" "', expected argument " "2"" of type '" "bool""'");
34184 }
34185 arg2 = static_cast< bool >(val2);
34186 }
34187 if (obj2) {
34188 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxRect, 0 | 0 );
34189 if (!SWIG_IsOK(res3)) {
34190 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_Refresh" "', expected argument " "3"" of type '" "wxRect const *""'");
34191 }
34192 arg3 = reinterpret_cast< wxRect * >(argp3);
34193 }
34194 {
34195 PyThreadState* __tstate = wxPyBeginAllowThreads();
34196 (arg1)->Refresh(arg2,(wxRect const *)arg3);
34197 wxPyEndAllowThreads(__tstate);
34198 if (PyErr_Occurred()) SWIG_fail;
34199 }
34200 resultobj = SWIG_Py_Void();
34201 return resultobj;
34202 fail:
34203 return NULL;
34204 }
34205
34206
34207 SWIGINTERN PyObject *_wrap_Window_RefreshRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34208 PyObject *resultobj = 0;
34209 wxWindow *arg1 = (wxWindow *) 0 ;
34210 wxRect *arg2 = 0 ;
34211 bool arg3 = (bool) true ;
34212 void *argp1 = 0 ;
34213 int res1 = 0 ;
34214 wxRect temp2 ;
34215 bool val3 ;
34216 int ecode3 = 0 ;
34217 PyObject * obj0 = 0 ;
34218 PyObject * obj1 = 0 ;
34219 PyObject * obj2 = 0 ;
34220 char * kwnames[] = {
34221 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
34222 };
34223
34224 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34225 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34226 if (!SWIG_IsOK(res1)) {
34227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RefreshRect" "', expected argument " "1"" of type '" "wxWindow *""'");
34228 }
34229 arg1 = reinterpret_cast< wxWindow * >(argp1);
34230 {
34231 arg2 = &temp2;
34232 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34233 }
34234 if (obj2) {
34235 ecode3 = SWIG_AsVal_bool(obj2, &val3);
34236 if (!SWIG_IsOK(ecode3)) {
34237 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RefreshRect" "', expected argument " "3"" of type '" "bool""'");
34238 }
34239 arg3 = static_cast< bool >(val3);
34240 }
34241 {
34242 PyThreadState* __tstate = wxPyBeginAllowThreads();
34243 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
34244 wxPyEndAllowThreads(__tstate);
34245 if (PyErr_Occurred()) SWIG_fail;
34246 }
34247 resultobj = SWIG_Py_Void();
34248 return resultobj;
34249 fail:
34250 return NULL;
34251 }
34252
34253
34254 SWIGINTERN PyObject *_wrap_Window_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34255 PyObject *resultobj = 0;
34256 wxWindow *arg1 = (wxWindow *) 0 ;
34257 void *argp1 = 0 ;
34258 int res1 = 0 ;
34259 PyObject *swig_obj[1] ;
34260
34261 if (!args) SWIG_fail;
34262 swig_obj[0] = args;
34263 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34264 if (!SWIG_IsOK(res1)) {
34265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Update" "', expected argument " "1"" of type '" "wxWindow *""'");
34266 }
34267 arg1 = reinterpret_cast< wxWindow * >(argp1);
34268 {
34269 PyThreadState* __tstate = wxPyBeginAllowThreads();
34270 (arg1)->Update();
34271 wxPyEndAllowThreads(__tstate);
34272 if (PyErr_Occurred()) SWIG_fail;
34273 }
34274 resultobj = SWIG_Py_Void();
34275 return resultobj;
34276 fail:
34277 return NULL;
34278 }
34279
34280
34281 SWIGINTERN PyObject *_wrap_Window_ClearBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34282 PyObject *resultobj = 0;
34283 wxWindow *arg1 = (wxWindow *) 0 ;
34284 void *argp1 = 0 ;
34285 int res1 = 0 ;
34286 PyObject *swig_obj[1] ;
34287
34288 if (!args) SWIG_fail;
34289 swig_obj[0] = args;
34290 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34291 if (!SWIG_IsOK(res1)) {
34292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClearBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
34293 }
34294 arg1 = reinterpret_cast< wxWindow * >(argp1);
34295 {
34296 PyThreadState* __tstate = wxPyBeginAllowThreads();
34297 (arg1)->ClearBackground();
34298 wxPyEndAllowThreads(__tstate);
34299 if (PyErr_Occurred()) SWIG_fail;
34300 }
34301 resultobj = SWIG_Py_Void();
34302 return resultobj;
34303 fail:
34304 return NULL;
34305 }
34306
34307
34308 SWIGINTERN PyObject *_wrap_Window_Freeze(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34309 PyObject *resultobj = 0;
34310 wxWindow *arg1 = (wxWindow *) 0 ;
34311 void *argp1 = 0 ;
34312 int res1 = 0 ;
34313 PyObject *swig_obj[1] ;
34314
34315 if (!args) SWIG_fail;
34316 swig_obj[0] = args;
34317 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34318 if (!SWIG_IsOK(res1)) {
34319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Freeze" "', expected argument " "1"" of type '" "wxWindow *""'");
34320 }
34321 arg1 = reinterpret_cast< wxWindow * >(argp1);
34322 {
34323 PyThreadState* __tstate = wxPyBeginAllowThreads();
34324 (arg1)->Freeze();
34325 wxPyEndAllowThreads(__tstate);
34326 if (PyErr_Occurred()) SWIG_fail;
34327 }
34328 resultobj = SWIG_Py_Void();
34329 return resultobj;
34330 fail:
34331 return NULL;
34332 }
34333
34334
34335 SWIGINTERN PyObject *_wrap_Window_Thaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34336 PyObject *resultobj = 0;
34337 wxWindow *arg1 = (wxWindow *) 0 ;
34338 void *argp1 = 0 ;
34339 int res1 = 0 ;
34340 PyObject *swig_obj[1] ;
34341
34342 if (!args) SWIG_fail;
34343 swig_obj[0] = args;
34344 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34345 if (!SWIG_IsOK(res1)) {
34346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Thaw" "', expected argument " "1"" of type '" "wxWindow *""'");
34347 }
34348 arg1 = reinterpret_cast< wxWindow * >(argp1);
34349 {
34350 PyThreadState* __tstate = wxPyBeginAllowThreads();
34351 (arg1)->Thaw();
34352 wxPyEndAllowThreads(__tstate);
34353 if (PyErr_Occurred()) SWIG_fail;
34354 }
34355 resultobj = SWIG_Py_Void();
34356 return resultobj;
34357 fail:
34358 return NULL;
34359 }
34360
34361
34362 SWIGINTERN PyObject *_wrap_Window_PrepareDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34363 PyObject *resultobj = 0;
34364 wxWindow *arg1 = (wxWindow *) 0 ;
34365 wxDC *arg2 = 0 ;
34366 void *argp1 = 0 ;
34367 int res1 = 0 ;
34368 void *argp2 = 0 ;
34369 int res2 = 0 ;
34370 PyObject * obj0 = 0 ;
34371 PyObject * obj1 = 0 ;
34372 char * kwnames[] = {
34373 (char *) "self",(char *) "dc", NULL
34374 };
34375
34376 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) SWIG_fail;
34377 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34378 if (!SWIG_IsOK(res1)) {
34379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PrepareDC" "', expected argument " "1"" of type '" "wxWindow *""'");
34380 }
34381 arg1 = reinterpret_cast< wxWindow * >(argp1);
34382 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
34383 if (!SWIG_IsOK(res2)) {
34384 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
34385 }
34386 if (!argp2) {
34387 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
34388 }
34389 arg2 = reinterpret_cast< wxDC * >(argp2);
34390 {
34391 PyThreadState* __tstate = wxPyBeginAllowThreads();
34392 (arg1)->PrepareDC(*arg2);
34393 wxPyEndAllowThreads(__tstate);
34394 if (PyErr_Occurred()) SWIG_fail;
34395 }
34396 resultobj = SWIG_Py_Void();
34397 return resultobj;
34398 fail:
34399 return NULL;
34400 }
34401
34402
34403 SWIGINTERN PyObject *_wrap_Window_GetUpdateRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34404 PyObject *resultobj = 0;
34405 wxWindow *arg1 = (wxWindow *) 0 ;
34406 wxRegion *result = 0 ;
34407 void *argp1 = 0 ;
34408 int res1 = 0 ;
34409 PyObject *swig_obj[1] ;
34410
34411 if (!args) SWIG_fail;
34412 swig_obj[0] = args;
34413 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34414 if (!SWIG_IsOK(res1)) {
34415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateRegion" "', expected argument " "1"" of type '" "wxWindow *""'");
34416 }
34417 arg1 = reinterpret_cast< wxWindow * >(argp1);
34418 {
34419 PyThreadState* __tstate = wxPyBeginAllowThreads();
34420 {
34421 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
34422 result = (wxRegion *) &_result_ref;
34423 }
34424 wxPyEndAllowThreads(__tstate);
34425 if (PyErr_Occurred()) SWIG_fail;
34426 }
34427 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, 0 | 0 );
34428 return resultobj;
34429 fail:
34430 return NULL;
34431 }
34432
34433
34434 SWIGINTERN PyObject *_wrap_Window_GetUpdateClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34435 PyObject *resultobj = 0;
34436 wxWindow *arg1 = (wxWindow *) 0 ;
34437 wxRect result;
34438 void *argp1 = 0 ;
34439 int res1 = 0 ;
34440 PyObject *swig_obj[1] ;
34441
34442 if (!args) SWIG_fail;
34443 swig_obj[0] = args;
34444 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34445 if (!SWIG_IsOK(res1)) {
34446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34447 }
34448 arg1 = reinterpret_cast< wxWindow * >(argp1);
34449 {
34450 PyThreadState* __tstate = wxPyBeginAllowThreads();
34451 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
34452 wxPyEndAllowThreads(__tstate);
34453 if (PyErr_Occurred()) SWIG_fail;
34454 }
34455 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34456 return resultobj;
34457 fail:
34458 return NULL;
34459 }
34460
34461
34462 SWIGINTERN PyObject *_wrap_Window_IsExposed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34463 PyObject *resultobj = 0;
34464 wxWindow *arg1 = (wxWindow *) 0 ;
34465 int arg2 ;
34466 int arg3 ;
34467 int arg4 = (int) 1 ;
34468 int arg5 = (int) 1 ;
34469 bool result;
34470 void *argp1 = 0 ;
34471 int res1 = 0 ;
34472 int val2 ;
34473 int ecode2 = 0 ;
34474 int val3 ;
34475 int ecode3 = 0 ;
34476 int val4 ;
34477 int ecode4 = 0 ;
34478 int val5 ;
34479 int ecode5 = 0 ;
34480 PyObject * obj0 = 0 ;
34481 PyObject * obj1 = 0 ;
34482 PyObject * obj2 = 0 ;
34483 PyObject * obj3 = 0 ;
34484 PyObject * obj4 = 0 ;
34485 char * kwnames[] = {
34486 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
34487 };
34488
34489 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
34490 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34491 if (!SWIG_IsOK(res1)) {
34492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposed" "', expected argument " "1"" of type '" "wxWindow const *""'");
34493 }
34494 arg1 = reinterpret_cast< wxWindow * >(argp1);
34495 ecode2 = SWIG_AsVal_int(obj1, &val2);
34496 if (!SWIG_IsOK(ecode2)) {
34497 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_IsExposed" "', expected argument " "2"" of type '" "int""'");
34498 }
34499 arg2 = static_cast< int >(val2);
34500 ecode3 = SWIG_AsVal_int(obj2, &val3);
34501 if (!SWIG_IsOK(ecode3)) {
34502 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_IsExposed" "', expected argument " "3"" of type '" "int""'");
34503 }
34504 arg3 = static_cast< int >(val3);
34505 if (obj3) {
34506 ecode4 = SWIG_AsVal_int(obj3, &val4);
34507 if (!SWIG_IsOK(ecode4)) {
34508 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_IsExposed" "', expected argument " "4"" of type '" "int""'");
34509 }
34510 arg4 = static_cast< int >(val4);
34511 }
34512 if (obj4) {
34513 ecode5 = SWIG_AsVal_int(obj4, &val5);
34514 if (!SWIG_IsOK(ecode5)) {
34515 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_IsExposed" "', expected argument " "5"" of type '" "int""'");
34516 }
34517 arg5 = static_cast< int >(val5);
34518 }
34519 {
34520 PyThreadState* __tstate = wxPyBeginAllowThreads();
34521 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
34522 wxPyEndAllowThreads(__tstate);
34523 if (PyErr_Occurred()) SWIG_fail;
34524 }
34525 {
34526 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34527 }
34528 return resultobj;
34529 fail:
34530 return NULL;
34531 }
34532
34533
34534 SWIGINTERN PyObject *_wrap_Window_IsExposedPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34535 PyObject *resultobj = 0;
34536 wxWindow *arg1 = (wxWindow *) 0 ;
34537 wxPoint *arg2 = 0 ;
34538 bool result;
34539 void *argp1 = 0 ;
34540 int res1 = 0 ;
34541 wxPoint temp2 ;
34542 PyObject * obj0 = 0 ;
34543 PyObject * obj1 = 0 ;
34544 char * kwnames[] = {
34545 (char *) "self",(char *) "pt", NULL
34546 };
34547
34548 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) SWIG_fail;
34549 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34550 if (!SWIG_IsOK(res1)) {
34551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
34552 }
34553 arg1 = reinterpret_cast< wxWindow * >(argp1);
34554 {
34555 arg2 = &temp2;
34556 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34557 }
34558 {
34559 PyThreadState* __tstate = wxPyBeginAllowThreads();
34560 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
34561 wxPyEndAllowThreads(__tstate);
34562 if (PyErr_Occurred()) SWIG_fail;
34563 }
34564 {
34565 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34566 }
34567 return resultobj;
34568 fail:
34569 return NULL;
34570 }
34571
34572
34573 SWIGINTERN PyObject *_wrap_Window_IsExposedRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34574 PyObject *resultobj = 0;
34575 wxWindow *arg1 = (wxWindow *) 0 ;
34576 wxRect *arg2 = 0 ;
34577 bool result;
34578 void *argp1 = 0 ;
34579 int res1 = 0 ;
34580 wxRect temp2 ;
34581 PyObject * obj0 = 0 ;
34582 PyObject * obj1 = 0 ;
34583 char * kwnames[] = {
34584 (char *) "self",(char *) "rect", NULL
34585 };
34586
34587 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) SWIG_fail;
34588 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34589 if (!SWIG_IsOK(res1)) {
34590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34591 }
34592 arg1 = reinterpret_cast< wxWindow * >(argp1);
34593 {
34594 arg2 = &temp2;
34595 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34596 }
34597 {
34598 PyThreadState* __tstate = wxPyBeginAllowThreads();
34599 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
34600 wxPyEndAllowThreads(__tstate);
34601 if (PyErr_Occurred()) SWIG_fail;
34602 }
34603 {
34604 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34605 }
34606 return resultobj;
34607 fail:
34608 return NULL;
34609 }
34610
34611
34612 SWIGINTERN PyObject *_wrap_Window_GetDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34613 PyObject *resultobj = 0;
34614 wxWindow *arg1 = (wxWindow *) 0 ;
34615 SwigValueWrapper<wxVisualAttributes > result;
34616 void *argp1 = 0 ;
34617 int res1 = 0 ;
34618 PyObject *swig_obj[1] ;
34619
34620 if (!args) SWIG_fail;
34621 swig_obj[0] = args;
34622 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34623 if (!SWIG_IsOK(res1)) {
34624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultAttributes" "', expected argument " "1"" of type '" "wxWindow const *""'");
34625 }
34626 arg1 = reinterpret_cast< wxWindow * >(argp1);
34627 {
34628 PyThreadState* __tstate = wxPyBeginAllowThreads();
34629 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
34630 wxPyEndAllowThreads(__tstate);
34631 if (PyErr_Occurred()) SWIG_fail;
34632 }
34633 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
34634 return resultobj;
34635 fail:
34636 return NULL;
34637 }
34638
34639
34640 SWIGINTERN PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34641 PyObject *resultobj = 0;
34642 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
34643 SwigValueWrapper<wxVisualAttributes > result;
34644 int val1 ;
34645 int ecode1 = 0 ;
34646 PyObject * obj0 = 0 ;
34647 char * kwnames[] = {
34648 (char *) "variant", NULL
34649 };
34650
34651 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
34652 if (obj0) {
34653 ecode1 = SWIG_AsVal_int(obj0, &val1);
34654 if (!SWIG_IsOK(ecode1)) {
34655 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
34656 }
34657 arg1 = static_cast< wxWindowVariant >(val1);
34658 }
34659 {
34660 if (!wxPyCheckForApp()) SWIG_fail;
34661 PyThreadState* __tstate = wxPyBeginAllowThreads();
34662 result = wxWindow::GetClassDefaultAttributes(arg1);
34663 wxPyEndAllowThreads(__tstate);
34664 if (PyErr_Occurred()) SWIG_fail;
34665 }
34666 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
34667 return resultobj;
34668 fail:
34669 return NULL;
34670 }
34671
34672
34673 SWIGINTERN PyObject *_wrap_Window_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34674 PyObject *resultobj = 0;
34675 wxWindow *arg1 = (wxWindow *) 0 ;
34676 wxColour *arg2 = 0 ;
34677 bool result;
34678 void *argp1 = 0 ;
34679 int res1 = 0 ;
34680 wxColour temp2 ;
34681 PyObject * obj0 = 0 ;
34682 PyObject * obj1 = 0 ;
34683 char * kwnames[] = {
34684 (char *) "self",(char *) "colour", NULL
34685 };
34686
34687 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34688 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34689 if (!SWIG_IsOK(res1)) {
34690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34691 }
34692 arg1 = reinterpret_cast< wxWindow * >(argp1);
34693 {
34694 arg2 = &temp2;
34695 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34696 }
34697 {
34698 PyThreadState* __tstate = wxPyBeginAllowThreads();
34699 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
34700 wxPyEndAllowThreads(__tstate);
34701 if (PyErr_Occurred()) SWIG_fail;
34702 }
34703 {
34704 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34705 }
34706 return resultobj;
34707 fail:
34708 return NULL;
34709 }
34710
34711
34712 SWIGINTERN PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34713 PyObject *resultobj = 0;
34714 wxWindow *arg1 = (wxWindow *) 0 ;
34715 wxColour *arg2 = 0 ;
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_SetOwnBackgroundColour",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_SetOwnBackgroundColour" "', 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 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
34738 wxPyEndAllowThreads(__tstate);
34739 if (PyErr_Occurred()) SWIG_fail;
34740 }
34741 resultobj = SWIG_Py_Void();
34742 return resultobj;
34743 fail:
34744 return NULL;
34745 }
34746
34747
34748 SWIGINTERN PyObject *_wrap_Window_SetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34749 PyObject *resultobj = 0;
34750 wxWindow *arg1 = (wxWindow *) 0 ;
34751 wxColour *arg2 = 0 ;
34752 bool result;
34753 void *argp1 = 0 ;
34754 int res1 = 0 ;
34755 wxColour temp2 ;
34756 PyObject * obj0 = 0 ;
34757 PyObject * obj1 = 0 ;
34758 char * kwnames[] = {
34759 (char *) "self",(char *) "colour", NULL
34760 };
34761
34762 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34763 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34764 if (!SWIG_IsOK(res1)) {
34765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34766 }
34767 arg1 = reinterpret_cast< wxWindow * >(argp1);
34768 {
34769 arg2 = &temp2;
34770 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34771 }
34772 {
34773 PyThreadState* __tstate = wxPyBeginAllowThreads();
34774 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
34775 wxPyEndAllowThreads(__tstate);
34776 if (PyErr_Occurred()) SWIG_fail;
34777 }
34778 {
34779 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34780 }
34781 return resultobj;
34782 fail:
34783 return NULL;
34784 }
34785
34786
34787 SWIGINTERN PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34788 PyObject *resultobj = 0;
34789 wxWindow *arg1 = (wxWindow *) 0 ;
34790 wxColour *arg2 = 0 ;
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_SetOwnForegroundColour",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_SetOwnForegroundColour" "', 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 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
34813 wxPyEndAllowThreads(__tstate);
34814 if (PyErr_Occurred()) SWIG_fail;
34815 }
34816 resultobj = SWIG_Py_Void();
34817 return resultobj;
34818 fail:
34819 return NULL;
34820 }
34821
34822
34823 SWIGINTERN PyObject *_wrap_Window_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34824 PyObject *resultobj = 0;
34825 wxWindow *arg1 = (wxWindow *) 0 ;
34826 wxColour result;
34827 void *argp1 = 0 ;
34828 int res1 = 0 ;
34829 PyObject *swig_obj[1] ;
34830
34831 if (!args) SWIG_fail;
34832 swig_obj[0] = args;
34833 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34834 if (!SWIG_IsOK(res1)) {
34835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
34836 }
34837 arg1 = reinterpret_cast< wxWindow * >(argp1);
34838 {
34839 PyThreadState* __tstate = wxPyBeginAllowThreads();
34840 result = ((wxWindow const *)arg1)->GetBackgroundColour();
34841 wxPyEndAllowThreads(__tstate);
34842 if (PyErr_Occurred()) SWIG_fail;
34843 }
34844 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
34845 return resultobj;
34846 fail:
34847 return NULL;
34848 }
34849
34850
34851 SWIGINTERN PyObject *_wrap_Window_GetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34852 PyObject *resultobj = 0;
34853 wxWindow *arg1 = (wxWindow *) 0 ;
34854 wxColour result;
34855 void *argp1 = 0 ;
34856 int res1 = 0 ;
34857 PyObject *swig_obj[1] ;
34858
34859 if (!args) SWIG_fail;
34860 swig_obj[0] = args;
34861 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34862 if (!SWIG_IsOK(res1)) {
34863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetForegroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
34864 }
34865 arg1 = reinterpret_cast< wxWindow * >(argp1);
34866 {
34867 PyThreadState* __tstate = wxPyBeginAllowThreads();
34868 result = ((wxWindow const *)arg1)->GetForegroundColour();
34869 wxPyEndAllowThreads(__tstate);
34870 if (PyErr_Occurred()) SWIG_fail;
34871 }
34872 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
34873 return resultobj;
34874 fail:
34875 return NULL;
34876 }
34877
34878
34879 SWIGINTERN PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34880 PyObject *resultobj = 0;
34881 wxWindow *arg1 = (wxWindow *) 0 ;
34882 bool result;
34883 void *argp1 = 0 ;
34884 int res1 = 0 ;
34885 PyObject *swig_obj[1] ;
34886
34887 if (!args) SWIG_fail;
34888 swig_obj[0] = args;
34889 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34890 if (!SWIG_IsOK(res1)) {
34891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritsBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
34892 }
34893 arg1 = reinterpret_cast< wxWindow * >(argp1);
34894 {
34895 PyThreadState* __tstate = wxPyBeginAllowThreads();
34896 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
34897 wxPyEndAllowThreads(__tstate);
34898 if (PyErr_Occurred()) SWIG_fail;
34899 }
34900 {
34901 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34902 }
34903 return resultobj;
34904 fail:
34905 return NULL;
34906 }
34907
34908
34909 SWIGINTERN PyObject *_wrap_Window_UseBgCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34910 PyObject *resultobj = 0;
34911 wxWindow *arg1 = (wxWindow *) 0 ;
34912 bool result;
34913 void *argp1 = 0 ;
34914 int res1 = 0 ;
34915 PyObject *swig_obj[1] ;
34916
34917 if (!args) SWIG_fail;
34918 swig_obj[0] = args;
34919 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34920 if (!SWIG_IsOK(res1)) {
34921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UseBgCol" "', expected argument " "1"" of type '" "wxWindow const *""'");
34922 }
34923 arg1 = reinterpret_cast< wxWindow * >(argp1);
34924 {
34925 PyThreadState* __tstate = wxPyBeginAllowThreads();
34926 result = (bool)((wxWindow const *)arg1)->UseBgCol();
34927 wxPyEndAllowThreads(__tstate);
34928 if (PyErr_Occurred()) SWIG_fail;
34929 }
34930 {
34931 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34932 }
34933 return resultobj;
34934 fail:
34935 return NULL;
34936 }
34937
34938
34939 SWIGINTERN PyObject *_wrap_Window_SetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34940 PyObject *resultobj = 0;
34941 wxWindow *arg1 = (wxWindow *) 0 ;
34942 wxBackgroundStyle arg2 ;
34943 bool result;
34944 void *argp1 = 0 ;
34945 int res1 = 0 ;
34946 int val2 ;
34947 int ecode2 = 0 ;
34948 PyObject * obj0 = 0 ;
34949 PyObject * obj1 = 0 ;
34950 char * kwnames[] = {
34951 (char *) "self",(char *) "style", NULL
34952 };
34953
34954 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) SWIG_fail;
34955 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34956 if (!SWIG_IsOK(res1)) {
34957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
34958 }
34959 arg1 = reinterpret_cast< wxWindow * >(argp1);
34960 ecode2 = SWIG_AsVal_int(obj1, &val2);
34961 if (!SWIG_IsOK(ecode2)) {
34962 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetBackgroundStyle" "', expected argument " "2"" of type '" "wxBackgroundStyle""'");
34963 }
34964 arg2 = static_cast< wxBackgroundStyle >(val2);
34965 {
34966 PyThreadState* __tstate = wxPyBeginAllowThreads();
34967 result = (bool)(arg1)->SetBackgroundStyle(arg2);
34968 wxPyEndAllowThreads(__tstate);
34969 if (PyErr_Occurred()) SWIG_fail;
34970 }
34971 {
34972 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34973 }
34974 return resultobj;
34975 fail:
34976 return NULL;
34977 }
34978
34979
34980 SWIGINTERN PyObject *_wrap_Window_GetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34981 PyObject *resultobj = 0;
34982 wxWindow *arg1 = (wxWindow *) 0 ;
34983 wxBackgroundStyle result;
34984 void *argp1 = 0 ;
34985 int res1 = 0 ;
34986 PyObject *swig_obj[1] ;
34987
34988 if (!args) SWIG_fail;
34989 swig_obj[0] = args;
34990 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34991 if (!SWIG_IsOK(res1)) {
34992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
34993 }
34994 arg1 = reinterpret_cast< wxWindow * >(argp1);
34995 {
34996 PyThreadState* __tstate = wxPyBeginAllowThreads();
34997 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
34998 wxPyEndAllowThreads(__tstate);
34999 if (PyErr_Occurred()) SWIG_fail;
35000 }
35001 resultobj = SWIG_From_int(static_cast< int >(result));
35002 return resultobj;
35003 fail:
35004 return NULL;
35005 }
35006
35007
35008 SWIGINTERN PyObject *_wrap_Window_HasTransparentBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35009 PyObject *resultobj = 0;
35010 wxWindow *arg1 = (wxWindow *) 0 ;
35011 bool result;
35012 void *argp1 = 0 ;
35013 int res1 = 0 ;
35014 PyObject *swig_obj[1] ;
35015
35016 if (!args) SWIG_fail;
35017 swig_obj[0] = args;
35018 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35019 if (!SWIG_IsOK(res1)) {
35020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasTransparentBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
35021 }
35022 arg1 = reinterpret_cast< wxWindow * >(argp1);
35023 {
35024 PyThreadState* __tstate = wxPyBeginAllowThreads();
35025 result = (bool)(arg1)->HasTransparentBackground();
35026 wxPyEndAllowThreads(__tstate);
35027 if (PyErr_Occurred()) SWIG_fail;
35028 }
35029 {
35030 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35031 }
35032 return resultobj;
35033 fail:
35034 return NULL;
35035 }
35036
35037
35038 SWIGINTERN PyObject *_wrap_Window_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35039 PyObject *resultobj = 0;
35040 wxWindow *arg1 = (wxWindow *) 0 ;
35041 wxCursor *arg2 = 0 ;
35042 bool result;
35043 void *argp1 = 0 ;
35044 int res1 = 0 ;
35045 void *argp2 = 0 ;
35046 int res2 = 0 ;
35047 PyObject * obj0 = 0 ;
35048 PyObject * obj1 = 0 ;
35049 char * kwnames[] = {
35050 (char *) "self",(char *) "cursor", NULL
35051 };
35052
35053 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
35054 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35055 if (!SWIG_IsOK(res1)) {
35056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
35057 }
35058 arg1 = reinterpret_cast< wxWindow * >(argp1);
35059 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
35060 if (!SWIG_IsOK(res2)) {
35061 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
35062 }
35063 if (!argp2) {
35064 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
35065 }
35066 arg2 = reinterpret_cast< wxCursor * >(argp2);
35067 {
35068 PyThreadState* __tstate = wxPyBeginAllowThreads();
35069 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
35070 wxPyEndAllowThreads(__tstate);
35071 if (PyErr_Occurred()) SWIG_fail;
35072 }
35073 {
35074 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35075 }
35076 return resultobj;
35077 fail:
35078 return NULL;
35079 }
35080
35081
35082 SWIGINTERN PyObject *_wrap_Window_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35083 PyObject *resultobj = 0;
35084 wxWindow *arg1 = (wxWindow *) 0 ;
35085 wxCursor result;
35086 void *argp1 = 0 ;
35087 int res1 = 0 ;
35088 PyObject *swig_obj[1] ;
35089
35090 if (!args) SWIG_fail;
35091 swig_obj[0] = args;
35092 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35093 if (!SWIG_IsOK(res1)) {
35094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
35095 }
35096 arg1 = reinterpret_cast< wxWindow * >(argp1);
35097 {
35098 PyThreadState* __tstate = wxPyBeginAllowThreads();
35099 result = (arg1)->GetCursor();
35100 wxPyEndAllowThreads(__tstate);
35101 if (PyErr_Occurred()) SWIG_fail;
35102 }
35103 resultobj = SWIG_NewPointerObj((new wxCursor(static_cast< const wxCursor& >(result))), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );
35104 return resultobj;
35105 fail:
35106 return NULL;
35107 }
35108
35109
35110 SWIGINTERN PyObject *_wrap_Window_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35111 PyObject *resultobj = 0;
35112 wxWindow *arg1 = (wxWindow *) 0 ;
35113 wxFont *arg2 = 0 ;
35114 bool result;
35115 void *argp1 = 0 ;
35116 int res1 = 0 ;
35117 void *argp2 = 0 ;
35118 int res2 = 0 ;
35119 PyObject * obj0 = 0 ;
35120 PyObject * obj1 = 0 ;
35121 char * kwnames[] = {
35122 (char *) "self",(char *) "font", NULL
35123 };
35124
35125 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
35126 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35127 if (!SWIG_IsOK(res1)) {
35128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35129 }
35130 arg1 = reinterpret_cast< wxWindow * >(argp1);
35131 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
35132 if (!SWIG_IsOK(res2)) {
35133 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35134 }
35135 if (!argp2) {
35136 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35137 }
35138 arg2 = reinterpret_cast< wxFont * >(argp2);
35139 {
35140 PyThreadState* __tstate = wxPyBeginAllowThreads();
35141 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
35142 wxPyEndAllowThreads(__tstate);
35143 if (PyErr_Occurred()) SWIG_fail;
35144 }
35145 {
35146 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35147 }
35148 return resultobj;
35149 fail:
35150 return NULL;
35151 }
35152
35153
35154 SWIGINTERN PyObject *_wrap_Window_SetOwnFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35155 PyObject *resultobj = 0;
35156 wxWindow *arg1 = (wxWindow *) 0 ;
35157 wxFont *arg2 = 0 ;
35158 void *argp1 = 0 ;
35159 int res1 = 0 ;
35160 void *argp2 = 0 ;
35161 int res2 = 0 ;
35162 PyObject * obj0 = 0 ;
35163 PyObject * obj1 = 0 ;
35164 char * kwnames[] = {
35165 (char *) "self",(char *) "font", NULL
35166 };
35167
35168 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) SWIG_fail;
35169 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35170 if (!SWIG_IsOK(res1)) {
35171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35172 }
35173 arg1 = reinterpret_cast< wxWindow * >(argp1);
35174 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
35175 if (!SWIG_IsOK(res2)) {
35176 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35177 }
35178 if (!argp2) {
35179 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35180 }
35181 arg2 = reinterpret_cast< wxFont * >(argp2);
35182 {
35183 PyThreadState* __tstate = wxPyBeginAllowThreads();
35184 (arg1)->SetOwnFont((wxFont const &)*arg2);
35185 wxPyEndAllowThreads(__tstate);
35186 if (PyErr_Occurred()) SWIG_fail;
35187 }
35188 resultobj = SWIG_Py_Void();
35189 return resultobj;
35190 fail:
35191 return NULL;
35192 }
35193
35194
35195 SWIGINTERN PyObject *_wrap_Window_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35196 PyObject *resultobj = 0;
35197 wxWindow *arg1 = (wxWindow *) 0 ;
35198 wxFont result;
35199 void *argp1 = 0 ;
35200 int res1 = 0 ;
35201 PyObject *swig_obj[1] ;
35202
35203 if (!args) SWIG_fail;
35204 swig_obj[0] = args;
35205 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35206 if (!SWIG_IsOK(res1)) {
35207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35208 }
35209 arg1 = reinterpret_cast< wxWindow * >(argp1);
35210 {
35211 PyThreadState* __tstate = wxPyBeginAllowThreads();
35212 result = (arg1)->GetFont();
35213 wxPyEndAllowThreads(__tstate);
35214 if (PyErr_Occurred()) SWIG_fail;
35215 }
35216 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
35217 return resultobj;
35218 fail:
35219 return NULL;
35220 }
35221
35222
35223 SWIGINTERN PyObject *_wrap_Window_SetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35224 PyObject *resultobj = 0;
35225 wxWindow *arg1 = (wxWindow *) 0 ;
35226 wxCaret *arg2 = (wxCaret *) 0 ;
35227 void *argp1 = 0 ;
35228 int res1 = 0 ;
35229 int res2 = 0 ;
35230 PyObject * obj0 = 0 ;
35231 PyObject * obj1 = 0 ;
35232 char * kwnames[] = {
35233 (char *) "self",(char *) "caret", NULL
35234 };
35235
35236 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) SWIG_fail;
35237 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35238 if (!SWIG_IsOK(res1)) {
35239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCaret" "', expected argument " "1"" of type '" "wxWindow *""'");
35240 }
35241 arg1 = reinterpret_cast< wxWindow * >(argp1);
35242 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
35243 if (!SWIG_IsOK(res2)) {
35244 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCaret" "', expected argument " "2"" of type '" "wxCaret *""'");
35245 }
35246 {
35247 PyThreadState* __tstate = wxPyBeginAllowThreads();
35248 (arg1)->SetCaret(arg2);
35249 wxPyEndAllowThreads(__tstate);
35250 if (PyErr_Occurred()) SWIG_fail;
35251 }
35252 resultobj = SWIG_Py_Void();
35253 return resultobj;
35254 fail:
35255 return NULL;
35256 }
35257
35258
35259 SWIGINTERN PyObject *_wrap_Window_GetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35260 PyObject *resultobj = 0;
35261 wxWindow *arg1 = (wxWindow *) 0 ;
35262 wxCaret *result = 0 ;
35263 void *argp1 = 0 ;
35264 int res1 = 0 ;
35265 PyObject *swig_obj[1] ;
35266
35267 if (!args) SWIG_fail;
35268 swig_obj[0] = args;
35269 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35270 if (!SWIG_IsOK(res1)) {
35271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCaret" "', expected argument " "1"" of type '" "wxWindow const *""'");
35272 }
35273 arg1 = reinterpret_cast< wxWindow * >(argp1);
35274 {
35275 PyThreadState* __tstate = wxPyBeginAllowThreads();
35276 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
35277 wxPyEndAllowThreads(__tstate);
35278 if (PyErr_Occurred()) SWIG_fail;
35279 }
35280 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, 0 | 0 );
35281 return resultobj;
35282 fail:
35283 return NULL;
35284 }
35285
35286
35287 SWIGINTERN PyObject *_wrap_Window_GetCharHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35288 PyObject *resultobj = 0;
35289 wxWindow *arg1 = (wxWindow *) 0 ;
35290 int result;
35291 void *argp1 = 0 ;
35292 int res1 = 0 ;
35293 PyObject *swig_obj[1] ;
35294
35295 if (!args) SWIG_fail;
35296 swig_obj[0] = args;
35297 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35298 if (!SWIG_IsOK(res1)) {
35299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
35300 }
35301 arg1 = reinterpret_cast< wxWindow * >(argp1);
35302 {
35303 PyThreadState* __tstate = wxPyBeginAllowThreads();
35304 result = (int)((wxWindow const *)arg1)->GetCharHeight();
35305 wxPyEndAllowThreads(__tstate);
35306 if (PyErr_Occurred()) SWIG_fail;
35307 }
35308 resultobj = SWIG_From_int(static_cast< int >(result));
35309 return resultobj;
35310 fail:
35311 return NULL;
35312 }
35313
35314
35315 SWIGINTERN PyObject *_wrap_Window_GetCharWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35316 PyObject *resultobj = 0;
35317 wxWindow *arg1 = (wxWindow *) 0 ;
35318 int result;
35319 void *argp1 = 0 ;
35320 int res1 = 0 ;
35321 PyObject *swig_obj[1] ;
35322
35323 if (!args) SWIG_fail;
35324 swig_obj[0] = args;
35325 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35326 if (!SWIG_IsOK(res1)) {
35327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
35328 }
35329 arg1 = reinterpret_cast< wxWindow * >(argp1);
35330 {
35331 PyThreadState* __tstate = wxPyBeginAllowThreads();
35332 result = (int)((wxWindow const *)arg1)->GetCharWidth();
35333 wxPyEndAllowThreads(__tstate);
35334 if (PyErr_Occurred()) SWIG_fail;
35335 }
35336 resultobj = SWIG_From_int(static_cast< int >(result));
35337 return resultobj;
35338 fail:
35339 return NULL;
35340 }
35341
35342
35343 SWIGINTERN PyObject *_wrap_Window_GetTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35344 PyObject *resultobj = 0;
35345 wxWindow *arg1 = (wxWindow *) 0 ;
35346 wxString *arg2 = 0 ;
35347 int *arg3 = (int *) 0 ;
35348 int *arg4 = (int *) 0 ;
35349 void *argp1 = 0 ;
35350 int res1 = 0 ;
35351 bool temp2 = false ;
35352 int temp3 ;
35353 int res3 = SWIG_TMPOBJ ;
35354 int temp4 ;
35355 int res4 = SWIG_TMPOBJ ;
35356 PyObject * obj0 = 0 ;
35357 PyObject * obj1 = 0 ;
35358 char * kwnames[] = {
35359 (char *) "self",(char *) "string", NULL
35360 };
35361
35362 arg3 = &temp3;
35363 arg4 = &temp4;
35364 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) SWIG_fail;
35365 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35366 if (!SWIG_IsOK(res1)) {
35367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
35368 }
35369 arg1 = reinterpret_cast< wxWindow * >(argp1);
35370 {
35371 arg2 = wxString_in_helper(obj1);
35372 if (arg2 == NULL) SWIG_fail;
35373 temp2 = true;
35374 }
35375 {
35376 PyThreadState* __tstate = wxPyBeginAllowThreads();
35377 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
35378 wxPyEndAllowThreads(__tstate);
35379 if (PyErr_Occurred()) SWIG_fail;
35380 }
35381 resultobj = SWIG_Py_Void();
35382 if (SWIG_IsTmpObj(res3)) {
35383 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35384 } else {
35385 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35386 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35387 }
35388 if (SWIG_IsTmpObj(res4)) {
35389 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
35390 } else {
35391 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35392 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
35393 }
35394 {
35395 if (temp2)
35396 delete arg2;
35397 }
35398 return resultobj;
35399 fail:
35400 {
35401 if (temp2)
35402 delete arg2;
35403 }
35404 return NULL;
35405 }
35406
35407
35408 SWIGINTERN PyObject *_wrap_Window_GetFullTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35409 PyObject *resultobj = 0;
35410 wxWindow *arg1 = (wxWindow *) 0 ;
35411 wxString *arg2 = 0 ;
35412 int *arg3 = (int *) 0 ;
35413 int *arg4 = (int *) 0 ;
35414 int *arg5 = (int *) 0 ;
35415 int *arg6 = (int *) 0 ;
35416 wxFont *arg7 = (wxFont *) NULL ;
35417 void *argp1 = 0 ;
35418 int res1 = 0 ;
35419 bool temp2 = false ;
35420 int temp3 ;
35421 int res3 = SWIG_TMPOBJ ;
35422 int temp4 ;
35423 int res4 = SWIG_TMPOBJ ;
35424 int temp5 ;
35425 int res5 = SWIG_TMPOBJ ;
35426 int temp6 ;
35427 int res6 = SWIG_TMPOBJ ;
35428 void *argp7 = 0 ;
35429 int res7 = 0 ;
35430 PyObject * obj0 = 0 ;
35431 PyObject * obj1 = 0 ;
35432 PyObject * obj2 = 0 ;
35433 char * kwnames[] = {
35434 (char *) "self",(char *) "string",(char *) "font", NULL
35435 };
35436
35437 arg3 = &temp3;
35438 arg4 = &temp4;
35439 arg5 = &temp5;
35440 arg6 = &temp6;
35441 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35442 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35443 if (!SWIG_IsOK(res1)) {
35444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFullTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
35445 }
35446 arg1 = reinterpret_cast< wxWindow * >(argp1);
35447 {
35448 arg2 = wxString_in_helper(obj1);
35449 if (arg2 == NULL) SWIG_fail;
35450 temp2 = true;
35451 }
35452 if (obj2) {
35453 res7 = SWIG_ConvertPtr(obj2, &argp7,SWIGTYPE_p_wxFont, 0 | 0 );
35454 if (!SWIG_IsOK(res7)) {
35455 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Window_GetFullTextExtent" "', expected argument " "7"" of type '" "wxFont const *""'");
35456 }
35457 arg7 = reinterpret_cast< wxFont * >(argp7);
35458 }
35459 {
35460 PyThreadState* __tstate = wxPyBeginAllowThreads();
35461 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
35462 wxPyEndAllowThreads(__tstate);
35463 if (PyErr_Occurred()) SWIG_fail;
35464 }
35465 resultobj = SWIG_Py_Void();
35466 if (SWIG_IsTmpObj(res3)) {
35467 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35468 } else {
35469 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35470 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35471 }
35472 if (SWIG_IsTmpObj(res4)) {
35473 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
35474 } else {
35475 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35476 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
35477 }
35478 if (SWIG_IsTmpObj(res5)) {
35479 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
35480 } else {
35481 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35482 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
35483 }
35484 if (SWIG_IsTmpObj(res6)) {
35485 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
35486 } else {
35487 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35488 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
35489 }
35490 {
35491 if (temp2)
35492 delete arg2;
35493 }
35494 return resultobj;
35495 fail:
35496 {
35497 if (temp2)
35498 delete arg2;
35499 }
35500 return NULL;
35501 }
35502
35503
35504 SWIGINTERN PyObject *_wrap_Window_ClientToScreenXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35505 PyObject *resultobj = 0;
35506 wxWindow *arg1 = (wxWindow *) 0 ;
35507 int *arg2 = (int *) 0 ;
35508 int *arg3 = (int *) 0 ;
35509 void *argp1 = 0 ;
35510 int res1 = 0 ;
35511 int temp2 ;
35512 int res2 = 0 ;
35513 int temp3 ;
35514 int res3 = 0 ;
35515 PyObject * obj0 = 0 ;
35516 PyObject * obj1 = 0 ;
35517 PyObject * obj2 = 0 ;
35518 char * kwnames[] = {
35519 (char *) "self",(char *) "x",(char *) "y", NULL
35520 };
35521
35522 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35523 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35524 if (!SWIG_IsOK(res1)) {
35525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreenXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35526 }
35527 arg1 = reinterpret_cast< wxWindow * >(argp1);
35528 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
35529 int val;
35530 int ecode = SWIG_AsVal_int(obj1, &val);
35531 if (!SWIG_IsOK(ecode)) {
35532 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "2"" of type '" "int""'");
35533 }
35534 temp2 = static_cast< int >(val);
35535 arg2 = &temp2;
35536 res2 = SWIG_AddTmpMask(ecode);
35537 }
35538 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
35539 int val;
35540 int ecode = SWIG_AsVal_int(obj2, &val);
35541 if (!SWIG_IsOK(ecode)) {
35542 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "3"" of type '" "int""'");
35543 }
35544 temp3 = static_cast< int >(val);
35545 arg3 = &temp3;
35546 res3 = SWIG_AddTmpMask(ecode);
35547 }
35548 {
35549 PyThreadState* __tstate = wxPyBeginAllowThreads();
35550 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
35551 wxPyEndAllowThreads(__tstate);
35552 if (PyErr_Occurred()) SWIG_fail;
35553 }
35554 resultobj = SWIG_Py_Void();
35555 if (SWIG_IsTmpObj(res2)) {
35556 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35557 } else {
35558 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35559 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35560 }
35561 if (SWIG_IsTmpObj(res3)) {
35562 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35563 } else {
35564 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35565 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35566 }
35567 return resultobj;
35568 fail:
35569 return NULL;
35570 }
35571
35572
35573 SWIGINTERN PyObject *_wrap_Window_ScreenToClientXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35574 PyObject *resultobj = 0;
35575 wxWindow *arg1 = (wxWindow *) 0 ;
35576 int *arg2 = (int *) 0 ;
35577 int *arg3 = (int *) 0 ;
35578 void *argp1 = 0 ;
35579 int res1 = 0 ;
35580 int temp2 ;
35581 int res2 = 0 ;
35582 int temp3 ;
35583 int res3 = 0 ;
35584 PyObject * obj0 = 0 ;
35585 PyObject * obj1 = 0 ;
35586 PyObject * obj2 = 0 ;
35587 char * kwnames[] = {
35588 (char *) "self",(char *) "x",(char *) "y", NULL
35589 };
35590
35591 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35592 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35593 if (!SWIG_IsOK(res1)) {
35594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClientXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35595 }
35596 arg1 = reinterpret_cast< wxWindow * >(argp1);
35597 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
35598 int val;
35599 int ecode = SWIG_AsVal_int(obj1, &val);
35600 if (!SWIG_IsOK(ecode)) {
35601 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "2"" of type '" "int""'");
35602 }
35603 temp2 = static_cast< int >(val);
35604 arg2 = &temp2;
35605 res2 = SWIG_AddTmpMask(ecode);
35606 }
35607 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
35608 int val;
35609 int ecode = SWIG_AsVal_int(obj2, &val);
35610 if (!SWIG_IsOK(ecode)) {
35611 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "3"" of type '" "int""'");
35612 }
35613 temp3 = static_cast< int >(val);
35614 arg3 = &temp3;
35615 res3 = SWIG_AddTmpMask(ecode);
35616 }
35617 {
35618 PyThreadState* __tstate = wxPyBeginAllowThreads();
35619 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
35620 wxPyEndAllowThreads(__tstate);
35621 if (PyErr_Occurred()) SWIG_fail;
35622 }
35623 resultobj = SWIG_Py_Void();
35624 if (SWIG_IsTmpObj(res2)) {
35625 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35626 } else {
35627 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35628 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35629 }
35630 if (SWIG_IsTmpObj(res3)) {
35631 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35632 } else {
35633 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35634 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35635 }
35636 return resultobj;
35637 fail:
35638 return NULL;
35639 }
35640
35641
35642 SWIGINTERN PyObject *_wrap_Window_ClientToScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35643 PyObject *resultobj = 0;
35644 wxWindow *arg1 = (wxWindow *) 0 ;
35645 wxPoint *arg2 = 0 ;
35646 wxPoint result;
35647 void *argp1 = 0 ;
35648 int res1 = 0 ;
35649 wxPoint temp2 ;
35650 PyObject * obj0 = 0 ;
35651 PyObject * obj1 = 0 ;
35652 char * kwnames[] = {
35653 (char *) "self",(char *) "pt", NULL
35654 };
35655
35656 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) SWIG_fail;
35657 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35658 if (!SWIG_IsOK(res1)) {
35659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
35660 }
35661 arg1 = reinterpret_cast< wxWindow * >(argp1);
35662 {
35663 arg2 = &temp2;
35664 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35665 }
35666 {
35667 PyThreadState* __tstate = wxPyBeginAllowThreads();
35668 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
35669 wxPyEndAllowThreads(__tstate);
35670 if (PyErr_Occurred()) SWIG_fail;
35671 }
35672 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35673 return resultobj;
35674 fail:
35675 return NULL;
35676 }
35677
35678
35679 SWIGINTERN PyObject *_wrap_Window_ScreenToClient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35680 PyObject *resultobj = 0;
35681 wxWindow *arg1 = (wxWindow *) 0 ;
35682 wxPoint *arg2 = 0 ;
35683 wxPoint result;
35684 void *argp1 = 0 ;
35685 int res1 = 0 ;
35686 wxPoint temp2 ;
35687 PyObject * obj0 = 0 ;
35688 PyObject * obj1 = 0 ;
35689 char * kwnames[] = {
35690 (char *) "self",(char *) "pt", NULL
35691 };
35692
35693 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) SWIG_fail;
35694 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35695 if (!SWIG_IsOK(res1)) {
35696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClient" "', expected argument " "1"" of type '" "wxWindow const *""'");
35697 }
35698 arg1 = reinterpret_cast< wxWindow * >(argp1);
35699 {
35700 arg2 = &temp2;
35701 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35702 }
35703 {
35704 PyThreadState* __tstate = wxPyBeginAllowThreads();
35705 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
35706 wxPyEndAllowThreads(__tstate);
35707 if (PyErr_Occurred()) SWIG_fail;
35708 }
35709 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35710 return resultobj;
35711 fail:
35712 return NULL;
35713 }
35714
35715
35716 SWIGINTERN PyObject *_wrap_Window_HitTestXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35717 PyObject *resultobj = 0;
35718 wxWindow *arg1 = (wxWindow *) 0 ;
35719 int arg2 ;
35720 int arg3 ;
35721 wxHitTest result;
35722 void *argp1 = 0 ;
35723 int res1 = 0 ;
35724 int val2 ;
35725 int ecode2 = 0 ;
35726 int val3 ;
35727 int ecode3 = 0 ;
35728 PyObject * obj0 = 0 ;
35729 PyObject * obj1 = 0 ;
35730 PyObject * obj2 = 0 ;
35731 char * kwnames[] = {
35732 (char *) "self",(char *) "x",(char *) "y", NULL
35733 };
35734
35735 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35736 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35737 if (!SWIG_IsOK(res1)) {
35738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTestXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35739 }
35740 arg1 = reinterpret_cast< wxWindow * >(argp1);
35741 ecode2 = SWIG_AsVal_int(obj1, &val2);
35742 if (!SWIG_IsOK(ecode2)) {
35743 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HitTestXY" "', expected argument " "2"" of type '" "int""'");
35744 }
35745 arg2 = static_cast< int >(val2);
35746 ecode3 = SWIG_AsVal_int(obj2, &val3);
35747 if (!SWIG_IsOK(ecode3)) {
35748 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_HitTestXY" "', expected argument " "3"" of type '" "int""'");
35749 }
35750 arg3 = static_cast< int >(val3);
35751 {
35752 PyThreadState* __tstate = wxPyBeginAllowThreads();
35753 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
35754 wxPyEndAllowThreads(__tstate);
35755 if (PyErr_Occurred()) SWIG_fail;
35756 }
35757 resultobj = SWIG_From_int(static_cast< int >(result));
35758 return resultobj;
35759 fail:
35760 return NULL;
35761 }
35762
35763
35764 SWIGINTERN PyObject *_wrap_Window_HitTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35765 PyObject *resultobj = 0;
35766 wxWindow *arg1 = (wxWindow *) 0 ;
35767 wxPoint *arg2 = 0 ;
35768 wxHitTest result;
35769 void *argp1 = 0 ;
35770 int res1 = 0 ;
35771 wxPoint temp2 ;
35772 PyObject * obj0 = 0 ;
35773 PyObject * obj1 = 0 ;
35774 char * kwnames[] = {
35775 (char *) "self",(char *) "pt", NULL
35776 };
35777
35778 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) SWIG_fail;
35779 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35780 if (!SWIG_IsOK(res1)) {
35781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTest" "', expected argument " "1"" of type '" "wxWindow const *""'");
35782 }
35783 arg1 = reinterpret_cast< wxWindow * >(argp1);
35784 {
35785 arg2 = &temp2;
35786 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35787 }
35788 {
35789 PyThreadState* __tstate = wxPyBeginAllowThreads();
35790 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
35791 wxPyEndAllowThreads(__tstate);
35792 if (PyErr_Occurred()) SWIG_fail;
35793 }
35794 resultobj = SWIG_From_int(static_cast< int >(result));
35795 return resultobj;
35796 fail:
35797 return NULL;
35798 }
35799
35800
35801 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
35802 PyObject *resultobj = 0;
35803 wxWindow *arg1 = (wxWindow *) 0 ;
35804 long arg2 ;
35805 wxBorder result;
35806 void *argp1 = 0 ;
35807 int res1 = 0 ;
35808 long val2 ;
35809 int ecode2 = 0 ;
35810
35811 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
35812 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35813 if (!SWIG_IsOK(res1)) {
35814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
35815 }
35816 arg1 = reinterpret_cast< wxWindow * >(argp1);
35817 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
35818 if (!SWIG_IsOK(ecode2)) {
35819 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetBorder" "', expected argument " "2"" of type '" "long""'");
35820 }
35821 arg2 = static_cast< long >(val2);
35822 {
35823 PyThreadState* __tstate = wxPyBeginAllowThreads();
35824 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
35825 wxPyEndAllowThreads(__tstate);
35826 if (PyErr_Occurred()) SWIG_fail;
35827 }
35828 resultobj = SWIG_From_int(static_cast< int >(result));
35829 return resultobj;
35830 fail:
35831 return NULL;
35832 }
35833
35834
35835 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
35836 PyObject *resultobj = 0;
35837 wxWindow *arg1 = (wxWindow *) 0 ;
35838 wxBorder result;
35839 void *argp1 = 0 ;
35840 int res1 = 0 ;
35841
35842 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
35843 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35844 if (!SWIG_IsOK(res1)) {
35845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
35846 }
35847 arg1 = reinterpret_cast< wxWindow * >(argp1);
35848 {
35849 PyThreadState* __tstate = wxPyBeginAllowThreads();
35850 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
35851 wxPyEndAllowThreads(__tstate);
35852 if (PyErr_Occurred()) SWIG_fail;
35853 }
35854 resultobj = SWIG_From_int(static_cast< int >(result));
35855 return resultobj;
35856 fail:
35857 return NULL;
35858 }
35859
35860
35861 SWIGINTERN PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
35862 int argc;
35863 PyObject *argv[3];
35864
35865 if (!(argc = SWIG_Python_UnpackTuple(args,"Window_GetBorder",0,2,argv))) SWIG_fail;
35866 --argc;
35867 if (argc == 1) {
35868 return _wrap_Window_GetBorder__SWIG_1(self, argc, argv);
35869 }
35870 if (argc == 2) {
35871 return _wrap_Window_GetBorder__SWIG_0(self, argc, argv);
35872 }
35873
35874 fail:
35875 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
35876 return NULL;
35877 }
35878
35879
35880 SWIGINTERN PyObject *_wrap_Window_UpdateWindowUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35881 PyObject *resultobj = 0;
35882 wxWindow *arg1 = (wxWindow *) 0 ;
35883 long arg2 = (long) wxUPDATE_UI_NONE ;
35884 void *argp1 = 0 ;
35885 int res1 = 0 ;
35886 long val2 ;
35887 int ecode2 = 0 ;
35888 PyObject * obj0 = 0 ;
35889 PyObject * obj1 = 0 ;
35890 char * kwnames[] = {
35891 (char *) "self",(char *) "flags", NULL
35892 };
35893
35894 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) SWIG_fail;
35895 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35896 if (!SWIG_IsOK(res1)) {
35897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UpdateWindowUI" "', expected argument " "1"" of type '" "wxWindow *""'");
35898 }
35899 arg1 = reinterpret_cast< wxWindow * >(argp1);
35900 if (obj1) {
35901 ecode2 = SWIG_AsVal_long(obj1, &val2);
35902 if (!SWIG_IsOK(ecode2)) {
35903 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UpdateWindowUI" "', expected argument " "2"" of type '" "long""'");
35904 }
35905 arg2 = static_cast< long >(val2);
35906 }
35907 {
35908 PyThreadState* __tstate = wxPyBeginAllowThreads();
35909 (arg1)->UpdateWindowUI(arg2);
35910 wxPyEndAllowThreads(__tstate);
35911 if (PyErr_Occurred()) SWIG_fail;
35912 }
35913 resultobj = SWIG_Py_Void();
35914 return resultobj;
35915 fail:
35916 return NULL;
35917 }
35918
35919
35920 SWIGINTERN PyObject *_wrap_Window_PopupMenuXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35921 PyObject *resultobj = 0;
35922 wxWindow *arg1 = (wxWindow *) 0 ;
35923 wxMenu *arg2 = (wxMenu *) 0 ;
35924 int arg3 = (int) -1 ;
35925 int arg4 = (int) -1 ;
35926 bool result;
35927 void *argp1 = 0 ;
35928 int res1 = 0 ;
35929 void *argp2 = 0 ;
35930 int res2 = 0 ;
35931 int val3 ;
35932 int ecode3 = 0 ;
35933 int val4 ;
35934 int ecode4 = 0 ;
35935 PyObject * obj0 = 0 ;
35936 PyObject * obj1 = 0 ;
35937 PyObject * obj2 = 0 ;
35938 PyObject * obj3 = 0 ;
35939 char * kwnames[] = {
35940 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
35941 };
35942
35943 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35944 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35945 if (!SWIG_IsOK(res1)) {
35946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenuXY" "', expected argument " "1"" of type '" "wxWindow *""'");
35947 }
35948 arg1 = reinterpret_cast< wxWindow * >(argp1);
35949 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
35950 if (!SWIG_IsOK(res2)) {
35951 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenuXY" "', expected argument " "2"" of type '" "wxMenu *""'");
35952 }
35953 arg2 = reinterpret_cast< wxMenu * >(argp2);
35954 if (obj2) {
35955 ecode3 = SWIG_AsVal_int(obj2, &val3);
35956 if (!SWIG_IsOK(ecode3)) {
35957 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_PopupMenuXY" "', expected argument " "3"" of type '" "int""'");
35958 }
35959 arg3 = static_cast< int >(val3);
35960 }
35961 if (obj3) {
35962 ecode4 = SWIG_AsVal_int(obj3, &val4);
35963 if (!SWIG_IsOK(ecode4)) {
35964 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_PopupMenuXY" "', expected argument " "4"" of type '" "int""'");
35965 }
35966 arg4 = static_cast< int >(val4);
35967 }
35968 {
35969 PyThreadState* __tstate = wxPyBeginAllowThreads();
35970 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
35971 wxPyEndAllowThreads(__tstate);
35972 if (PyErr_Occurred()) SWIG_fail;
35973 }
35974 {
35975 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35976 }
35977 return resultobj;
35978 fail:
35979 return NULL;
35980 }
35981
35982
35983 SWIGINTERN PyObject *_wrap_Window_PopupMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35984 PyObject *resultobj = 0;
35985 wxWindow *arg1 = (wxWindow *) 0 ;
35986 wxMenu *arg2 = (wxMenu *) 0 ;
35987 wxPoint const &arg3_defvalue = wxDefaultPosition ;
35988 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
35989 bool result;
35990 void *argp1 = 0 ;
35991 int res1 = 0 ;
35992 void *argp2 = 0 ;
35993 int res2 = 0 ;
35994 wxPoint temp3 ;
35995 PyObject * obj0 = 0 ;
35996 PyObject * obj1 = 0 ;
35997 PyObject * obj2 = 0 ;
35998 char * kwnames[] = {
35999 (char *) "self",(char *) "menu",(char *) "pos", NULL
36000 };
36001
36002 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36003 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36004 if (!SWIG_IsOK(res1)) {
36005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenu" "', expected argument " "1"" of type '" "wxWindow *""'");
36006 }
36007 arg1 = reinterpret_cast< wxWindow * >(argp1);
36008 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
36009 if (!SWIG_IsOK(res2)) {
36010 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
36011 }
36012 arg2 = reinterpret_cast< wxMenu * >(argp2);
36013 if (obj2) {
36014 {
36015 arg3 = &temp3;
36016 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
36017 }
36018 }
36019 {
36020 PyThreadState* __tstate = wxPyBeginAllowThreads();
36021 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
36022 wxPyEndAllowThreads(__tstate);
36023 if (PyErr_Occurred()) SWIG_fail;
36024 }
36025 {
36026 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36027 }
36028 return resultobj;
36029 fail:
36030 return NULL;
36031 }
36032
36033
36034 SWIGINTERN PyObject *_wrap_Window_GetHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36035 PyObject *resultobj = 0;
36036 wxWindow *arg1 = (wxWindow *) 0 ;
36037 long result;
36038 void *argp1 = 0 ;
36039 int res1 = 0 ;
36040 PyObject *swig_obj[1] ;
36041
36042 if (!args) SWIG_fail;
36043 swig_obj[0] = args;
36044 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36045 if (!SWIG_IsOK(res1)) {
36046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36047 }
36048 arg1 = reinterpret_cast< wxWindow * >(argp1);
36049 {
36050 PyThreadState* __tstate = wxPyBeginAllowThreads();
36051 result = (long)wxWindow_GetHandle(arg1);
36052 wxPyEndAllowThreads(__tstate);
36053 if (PyErr_Occurred()) SWIG_fail;
36054 }
36055 resultobj = SWIG_From_long(static_cast< long >(result));
36056 return resultobj;
36057 fail:
36058 return NULL;
36059 }
36060
36061
36062 SWIGINTERN PyObject *_wrap_Window_AssociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36063 PyObject *resultobj = 0;
36064 wxWindow *arg1 = (wxWindow *) 0 ;
36065 long arg2 ;
36066 void *argp1 = 0 ;
36067 int res1 = 0 ;
36068 long val2 ;
36069 int ecode2 = 0 ;
36070 PyObject * obj0 = 0 ;
36071 PyObject * obj1 = 0 ;
36072 char * kwnames[] = {
36073 (char *) "self",(char *) "handle", NULL
36074 };
36075
36076 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) SWIG_fail;
36077 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36078 if (!SWIG_IsOK(res1)) {
36079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AssociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36080 }
36081 arg1 = reinterpret_cast< wxWindow * >(argp1);
36082 ecode2 = SWIG_AsVal_long(obj1, &val2);
36083 if (!SWIG_IsOK(ecode2)) {
36084 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AssociateHandle" "', expected argument " "2"" of type '" "long""'");
36085 }
36086 arg2 = static_cast< long >(val2);
36087 {
36088 PyThreadState* __tstate = wxPyBeginAllowThreads();
36089 wxWindow_AssociateHandle(arg1,arg2);
36090 wxPyEndAllowThreads(__tstate);
36091 if (PyErr_Occurred()) SWIG_fail;
36092 }
36093 resultobj = SWIG_Py_Void();
36094 return resultobj;
36095 fail:
36096 return NULL;
36097 }
36098
36099
36100 SWIGINTERN PyObject *_wrap_Window_DissociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36101 PyObject *resultobj = 0;
36102 wxWindow *arg1 = (wxWindow *) 0 ;
36103 void *argp1 = 0 ;
36104 int res1 = 0 ;
36105 PyObject *swig_obj[1] ;
36106
36107 if (!args) SWIG_fail;
36108 swig_obj[0] = args;
36109 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36110 if (!SWIG_IsOK(res1)) {
36111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DissociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36112 }
36113 arg1 = reinterpret_cast< wxWindow * >(argp1);
36114 {
36115 PyThreadState* __tstate = wxPyBeginAllowThreads();
36116 (arg1)->DissociateHandle();
36117 wxPyEndAllowThreads(__tstate);
36118 if (PyErr_Occurred()) SWIG_fail;
36119 }
36120 resultobj = SWIG_Py_Void();
36121 return resultobj;
36122 fail:
36123 return NULL;
36124 }
36125
36126
36127 SWIGINTERN PyObject *_wrap_Window_HasScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36128 PyObject *resultobj = 0;
36129 wxWindow *arg1 = (wxWindow *) 0 ;
36130 int arg2 ;
36131 bool result;
36132 void *argp1 = 0 ;
36133 int res1 = 0 ;
36134 int val2 ;
36135 int ecode2 = 0 ;
36136 PyObject * obj0 = 0 ;
36137 PyObject * obj1 = 0 ;
36138 char * kwnames[] = {
36139 (char *) "self",(char *) "orient", NULL
36140 };
36141
36142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) SWIG_fail;
36143 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36144 if (!SWIG_IsOK(res1)) {
36145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasScrollbar" "', expected argument " "1"" of type '" "wxWindow const *""'");
36146 }
36147 arg1 = reinterpret_cast< wxWindow * >(argp1);
36148 ecode2 = SWIG_AsVal_int(obj1, &val2);
36149 if (!SWIG_IsOK(ecode2)) {
36150 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasScrollbar" "', expected argument " "2"" of type '" "int""'");
36151 }
36152 arg2 = static_cast< int >(val2);
36153 {
36154 PyThreadState* __tstate = wxPyBeginAllowThreads();
36155 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
36156 wxPyEndAllowThreads(__tstate);
36157 if (PyErr_Occurred()) SWIG_fail;
36158 }
36159 {
36160 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36161 }
36162 return resultobj;
36163 fail:
36164 return NULL;
36165 }
36166
36167
36168 SWIGINTERN PyObject *_wrap_Window_SetScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36169 PyObject *resultobj = 0;
36170 wxWindow *arg1 = (wxWindow *) 0 ;
36171 int arg2 ;
36172 int arg3 ;
36173 int arg4 ;
36174 int arg5 ;
36175 bool arg6 = (bool) true ;
36176 void *argp1 = 0 ;
36177 int res1 = 0 ;
36178 int val2 ;
36179 int ecode2 = 0 ;
36180 int val3 ;
36181 int ecode3 = 0 ;
36182 int val4 ;
36183 int ecode4 = 0 ;
36184 int val5 ;
36185 int ecode5 = 0 ;
36186 bool val6 ;
36187 int ecode6 = 0 ;
36188 PyObject * obj0 = 0 ;
36189 PyObject * obj1 = 0 ;
36190 PyObject * obj2 = 0 ;
36191 PyObject * obj3 = 0 ;
36192 PyObject * obj4 = 0 ;
36193 PyObject * obj5 = 0 ;
36194 char * kwnames[] = {
36195 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
36196 };
36197
36198 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
36199 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36200 if (!SWIG_IsOK(res1)) {
36201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollbar" "', expected argument " "1"" of type '" "wxWindow *""'");
36202 }
36203 arg1 = reinterpret_cast< wxWindow * >(argp1);
36204 ecode2 = SWIG_AsVal_int(obj1, &val2);
36205 if (!SWIG_IsOK(ecode2)) {
36206 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollbar" "', expected argument " "2"" of type '" "int""'");
36207 }
36208 arg2 = static_cast< int >(val2);
36209 ecode3 = SWIG_AsVal_int(obj2, &val3);
36210 if (!SWIG_IsOK(ecode3)) {
36211 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollbar" "', expected argument " "3"" of type '" "int""'");
36212 }
36213 arg3 = static_cast< int >(val3);
36214 ecode4 = SWIG_AsVal_int(obj3, &val4);
36215 if (!SWIG_IsOK(ecode4)) {
36216 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollbar" "', expected argument " "4"" of type '" "int""'");
36217 }
36218 arg4 = static_cast< int >(val4);
36219 ecode5 = SWIG_AsVal_int(obj4, &val5);
36220 if (!SWIG_IsOK(ecode5)) {
36221 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetScrollbar" "', expected argument " "5"" of type '" "int""'");
36222 }
36223 arg5 = static_cast< int >(val5);
36224 if (obj5) {
36225 ecode6 = SWIG_AsVal_bool(obj5, &val6);
36226 if (!SWIG_IsOK(ecode6)) {
36227 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetScrollbar" "', expected argument " "6"" of type '" "bool""'");
36228 }
36229 arg6 = static_cast< bool >(val6);
36230 }
36231 {
36232 PyThreadState* __tstate = wxPyBeginAllowThreads();
36233 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
36234 wxPyEndAllowThreads(__tstate);
36235 if (PyErr_Occurred()) SWIG_fail;
36236 }
36237 resultobj = SWIG_Py_Void();
36238 return resultobj;
36239 fail:
36240 return NULL;
36241 }
36242
36243
36244 SWIGINTERN PyObject *_wrap_Window_SetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36245 PyObject *resultobj = 0;
36246 wxWindow *arg1 = (wxWindow *) 0 ;
36247 int arg2 ;
36248 int arg3 ;
36249 bool arg4 = (bool) true ;
36250 void *argp1 = 0 ;
36251 int res1 = 0 ;
36252 int val2 ;
36253 int ecode2 = 0 ;
36254 int val3 ;
36255 int ecode3 = 0 ;
36256 bool val4 ;
36257 int ecode4 = 0 ;
36258 PyObject * obj0 = 0 ;
36259 PyObject * obj1 = 0 ;
36260 PyObject * obj2 = 0 ;
36261 PyObject * obj3 = 0 ;
36262 char * kwnames[] = {
36263 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
36264 };
36265
36266 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36267 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36268 if (!SWIG_IsOK(res1)) {
36269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollPos" "', expected argument " "1"" of type '" "wxWindow *""'");
36270 }
36271 arg1 = reinterpret_cast< wxWindow * >(argp1);
36272 ecode2 = SWIG_AsVal_int(obj1, &val2);
36273 if (!SWIG_IsOK(ecode2)) {
36274 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollPos" "', expected argument " "2"" of type '" "int""'");
36275 }
36276 arg2 = static_cast< int >(val2);
36277 ecode3 = SWIG_AsVal_int(obj2, &val3);
36278 if (!SWIG_IsOK(ecode3)) {
36279 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollPos" "', expected argument " "3"" of type '" "int""'");
36280 }
36281 arg3 = static_cast< int >(val3);
36282 if (obj3) {
36283 ecode4 = SWIG_AsVal_bool(obj3, &val4);
36284 if (!SWIG_IsOK(ecode4)) {
36285 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollPos" "', expected argument " "4"" of type '" "bool""'");
36286 }
36287 arg4 = static_cast< bool >(val4);
36288 }
36289 {
36290 PyThreadState* __tstate = wxPyBeginAllowThreads();
36291 (arg1)->SetScrollPos(arg2,arg3,arg4);
36292 wxPyEndAllowThreads(__tstate);
36293 if (PyErr_Occurred()) SWIG_fail;
36294 }
36295 resultobj = SWIG_Py_Void();
36296 return resultobj;
36297 fail:
36298 return NULL;
36299 }
36300
36301
36302 SWIGINTERN PyObject *_wrap_Window_GetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36303 PyObject *resultobj = 0;
36304 wxWindow *arg1 = (wxWindow *) 0 ;
36305 int arg2 ;
36306 int result;
36307 void *argp1 = 0 ;
36308 int res1 = 0 ;
36309 int val2 ;
36310 int ecode2 = 0 ;
36311 PyObject * obj0 = 0 ;
36312 PyObject * obj1 = 0 ;
36313 char * kwnames[] = {
36314 (char *) "self",(char *) "orientation", NULL
36315 };
36316
36317 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) SWIG_fail;
36318 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36319 if (!SWIG_IsOK(res1)) {
36320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollPos" "', expected argument " "1"" of type '" "wxWindow const *""'");
36321 }
36322 arg1 = reinterpret_cast< wxWindow * >(argp1);
36323 ecode2 = SWIG_AsVal_int(obj1, &val2);
36324 if (!SWIG_IsOK(ecode2)) {
36325 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollPos" "', expected argument " "2"" of type '" "int""'");
36326 }
36327 arg2 = static_cast< int >(val2);
36328 {
36329 PyThreadState* __tstate = wxPyBeginAllowThreads();
36330 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
36331 wxPyEndAllowThreads(__tstate);
36332 if (PyErr_Occurred()) SWIG_fail;
36333 }
36334 resultobj = SWIG_From_int(static_cast< int >(result));
36335 return resultobj;
36336 fail:
36337 return NULL;
36338 }
36339
36340
36341 SWIGINTERN PyObject *_wrap_Window_GetScrollThumb(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36342 PyObject *resultobj = 0;
36343 wxWindow *arg1 = (wxWindow *) 0 ;
36344 int arg2 ;
36345 int result;
36346 void *argp1 = 0 ;
36347 int res1 = 0 ;
36348 int val2 ;
36349 int ecode2 = 0 ;
36350 PyObject * obj0 = 0 ;
36351 PyObject * obj1 = 0 ;
36352 char * kwnames[] = {
36353 (char *) "self",(char *) "orientation", NULL
36354 };
36355
36356 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) SWIG_fail;
36357 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36358 if (!SWIG_IsOK(res1)) {
36359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollThumb" "', expected argument " "1"" of type '" "wxWindow const *""'");
36360 }
36361 arg1 = reinterpret_cast< wxWindow * >(argp1);
36362 ecode2 = SWIG_AsVal_int(obj1, &val2);
36363 if (!SWIG_IsOK(ecode2)) {
36364 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollThumb" "', expected argument " "2"" of type '" "int""'");
36365 }
36366 arg2 = static_cast< int >(val2);
36367 {
36368 PyThreadState* __tstate = wxPyBeginAllowThreads();
36369 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
36370 wxPyEndAllowThreads(__tstate);
36371 if (PyErr_Occurred()) SWIG_fail;
36372 }
36373 resultobj = SWIG_From_int(static_cast< int >(result));
36374 return resultobj;
36375 fail:
36376 return NULL;
36377 }
36378
36379
36380 SWIGINTERN PyObject *_wrap_Window_GetScrollRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36381 PyObject *resultobj = 0;
36382 wxWindow *arg1 = (wxWindow *) 0 ;
36383 int arg2 ;
36384 int result;
36385 void *argp1 = 0 ;
36386 int res1 = 0 ;
36387 int val2 ;
36388 int ecode2 = 0 ;
36389 PyObject * obj0 = 0 ;
36390 PyObject * obj1 = 0 ;
36391 char * kwnames[] = {
36392 (char *) "self",(char *) "orientation", NULL
36393 };
36394
36395 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) SWIG_fail;
36396 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36397 if (!SWIG_IsOK(res1)) {
36398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollRange" "', expected argument " "1"" of type '" "wxWindow const *""'");
36399 }
36400 arg1 = reinterpret_cast< wxWindow * >(argp1);
36401 ecode2 = SWIG_AsVal_int(obj1, &val2);
36402 if (!SWIG_IsOK(ecode2)) {
36403 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollRange" "', expected argument " "2"" of type '" "int""'");
36404 }
36405 arg2 = static_cast< int >(val2);
36406 {
36407 PyThreadState* __tstate = wxPyBeginAllowThreads();
36408 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
36409 wxPyEndAllowThreads(__tstate);
36410 if (PyErr_Occurred()) SWIG_fail;
36411 }
36412 resultobj = SWIG_From_int(static_cast< int >(result));
36413 return resultobj;
36414 fail:
36415 return NULL;
36416 }
36417
36418
36419 SWIGINTERN PyObject *_wrap_Window_ScrollWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36420 PyObject *resultobj = 0;
36421 wxWindow *arg1 = (wxWindow *) 0 ;
36422 int arg2 ;
36423 int arg3 ;
36424 wxRect *arg4 = (wxRect *) NULL ;
36425 void *argp1 = 0 ;
36426 int res1 = 0 ;
36427 int val2 ;
36428 int ecode2 = 0 ;
36429 int val3 ;
36430 int ecode3 = 0 ;
36431 void *argp4 = 0 ;
36432 int res4 = 0 ;
36433 PyObject * obj0 = 0 ;
36434 PyObject * obj1 = 0 ;
36435 PyObject * obj2 = 0 ;
36436 PyObject * obj3 = 0 ;
36437 char * kwnames[] = {
36438 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
36439 };
36440
36441 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36442 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36443 if (!SWIG_IsOK(res1)) {
36444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
36445 }
36446 arg1 = reinterpret_cast< wxWindow * >(argp1);
36447 ecode2 = SWIG_AsVal_int(obj1, &val2);
36448 if (!SWIG_IsOK(ecode2)) {
36449 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollWindow" "', expected argument " "2"" of type '" "int""'");
36450 }
36451 arg2 = static_cast< int >(val2);
36452 ecode3 = SWIG_AsVal_int(obj2, &val3);
36453 if (!SWIG_IsOK(ecode3)) {
36454 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_ScrollWindow" "', expected argument " "3"" of type '" "int""'");
36455 }
36456 arg3 = static_cast< int >(val3);
36457 if (obj3) {
36458 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxRect, 0 | 0 );
36459 if (!SWIG_IsOK(res4)) {
36460 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Window_ScrollWindow" "', expected argument " "4"" of type '" "wxRect const *""'");
36461 }
36462 arg4 = reinterpret_cast< wxRect * >(argp4);
36463 }
36464 {
36465 PyThreadState* __tstate = wxPyBeginAllowThreads();
36466 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
36467 wxPyEndAllowThreads(__tstate);
36468 if (PyErr_Occurred()) SWIG_fail;
36469 }
36470 resultobj = SWIG_Py_Void();
36471 return resultobj;
36472 fail:
36473 return NULL;
36474 }
36475
36476
36477 SWIGINTERN PyObject *_wrap_Window_ScrollLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36478 PyObject *resultobj = 0;
36479 wxWindow *arg1 = (wxWindow *) 0 ;
36480 int arg2 ;
36481 bool result;
36482 void *argp1 = 0 ;
36483 int res1 = 0 ;
36484 int val2 ;
36485 int ecode2 = 0 ;
36486 PyObject * obj0 = 0 ;
36487 PyObject * obj1 = 0 ;
36488 char * kwnames[] = {
36489 (char *) "self",(char *) "lines", NULL
36490 };
36491
36492 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) SWIG_fail;
36493 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36494 if (!SWIG_IsOK(res1)) {
36495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollLines" "', expected argument " "1"" of type '" "wxWindow *""'");
36496 }
36497 arg1 = reinterpret_cast< wxWindow * >(argp1);
36498 ecode2 = SWIG_AsVal_int(obj1, &val2);
36499 if (!SWIG_IsOK(ecode2)) {
36500 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollLines" "', expected argument " "2"" of type '" "int""'");
36501 }
36502 arg2 = static_cast< int >(val2);
36503 {
36504 PyThreadState* __tstate = wxPyBeginAllowThreads();
36505 result = (bool)(arg1)->ScrollLines(arg2);
36506 wxPyEndAllowThreads(__tstate);
36507 if (PyErr_Occurred()) SWIG_fail;
36508 }
36509 {
36510 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36511 }
36512 return resultobj;
36513 fail:
36514 return NULL;
36515 }
36516
36517
36518 SWIGINTERN PyObject *_wrap_Window_ScrollPages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36519 PyObject *resultobj = 0;
36520 wxWindow *arg1 = (wxWindow *) 0 ;
36521 int arg2 ;
36522 bool result;
36523 void *argp1 = 0 ;
36524 int res1 = 0 ;
36525 int val2 ;
36526 int ecode2 = 0 ;
36527 PyObject * obj0 = 0 ;
36528 PyObject * obj1 = 0 ;
36529 char * kwnames[] = {
36530 (char *) "self",(char *) "pages", NULL
36531 };
36532
36533 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) SWIG_fail;
36534 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36535 if (!SWIG_IsOK(res1)) {
36536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollPages" "', expected argument " "1"" of type '" "wxWindow *""'");
36537 }
36538 arg1 = reinterpret_cast< wxWindow * >(argp1);
36539 ecode2 = SWIG_AsVal_int(obj1, &val2);
36540 if (!SWIG_IsOK(ecode2)) {
36541 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollPages" "', expected argument " "2"" of type '" "int""'");
36542 }
36543 arg2 = static_cast< int >(val2);
36544 {
36545 PyThreadState* __tstate = wxPyBeginAllowThreads();
36546 result = (bool)(arg1)->ScrollPages(arg2);
36547 wxPyEndAllowThreads(__tstate);
36548 if (PyErr_Occurred()) SWIG_fail;
36549 }
36550 {
36551 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36552 }
36553 return resultobj;
36554 fail:
36555 return NULL;
36556 }
36557
36558
36559 SWIGINTERN PyObject *_wrap_Window_LineUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36560 PyObject *resultobj = 0;
36561 wxWindow *arg1 = (wxWindow *) 0 ;
36562 bool result;
36563 void *argp1 = 0 ;
36564 int res1 = 0 ;
36565 PyObject *swig_obj[1] ;
36566
36567 if (!args) SWIG_fail;
36568 swig_obj[0] = args;
36569 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36570 if (!SWIG_IsOK(res1)) {
36571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineUp" "', expected argument " "1"" of type '" "wxWindow *""'");
36572 }
36573 arg1 = reinterpret_cast< wxWindow * >(argp1);
36574 {
36575 PyThreadState* __tstate = wxPyBeginAllowThreads();
36576 result = (bool)(arg1)->LineUp();
36577 wxPyEndAllowThreads(__tstate);
36578 if (PyErr_Occurred()) SWIG_fail;
36579 }
36580 {
36581 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36582 }
36583 return resultobj;
36584 fail:
36585 return NULL;
36586 }
36587
36588
36589 SWIGINTERN PyObject *_wrap_Window_LineDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36590 PyObject *resultobj = 0;
36591 wxWindow *arg1 = (wxWindow *) 0 ;
36592 bool result;
36593 void *argp1 = 0 ;
36594 int res1 = 0 ;
36595 PyObject *swig_obj[1] ;
36596
36597 if (!args) SWIG_fail;
36598 swig_obj[0] = args;
36599 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36600 if (!SWIG_IsOK(res1)) {
36601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineDown" "', expected argument " "1"" of type '" "wxWindow *""'");
36602 }
36603 arg1 = reinterpret_cast< wxWindow * >(argp1);
36604 {
36605 PyThreadState* __tstate = wxPyBeginAllowThreads();
36606 result = (bool)(arg1)->LineDown();
36607 wxPyEndAllowThreads(__tstate);
36608 if (PyErr_Occurred()) SWIG_fail;
36609 }
36610 {
36611 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36612 }
36613 return resultobj;
36614 fail:
36615 return NULL;
36616 }
36617
36618
36619 SWIGINTERN PyObject *_wrap_Window_PageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36620 PyObject *resultobj = 0;
36621 wxWindow *arg1 = (wxWindow *) 0 ;
36622 bool result;
36623 void *argp1 = 0 ;
36624 int res1 = 0 ;
36625 PyObject *swig_obj[1] ;
36626
36627 if (!args) SWIG_fail;
36628 swig_obj[0] = args;
36629 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36630 if (!SWIG_IsOK(res1)) {
36631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageUp" "', expected argument " "1"" of type '" "wxWindow *""'");
36632 }
36633 arg1 = reinterpret_cast< wxWindow * >(argp1);
36634 {
36635 PyThreadState* __tstate = wxPyBeginAllowThreads();
36636 result = (bool)(arg1)->PageUp();
36637 wxPyEndAllowThreads(__tstate);
36638 if (PyErr_Occurred()) SWIG_fail;
36639 }
36640 {
36641 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36642 }
36643 return resultobj;
36644 fail:
36645 return NULL;
36646 }
36647
36648
36649 SWIGINTERN PyObject *_wrap_Window_PageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36650 PyObject *resultobj = 0;
36651 wxWindow *arg1 = (wxWindow *) 0 ;
36652 bool result;
36653 void *argp1 = 0 ;
36654 int res1 = 0 ;
36655 PyObject *swig_obj[1] ;
36656
36657 if (!args) SWIG_fail;
36658 swig_obj[0] = args;
36659 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36660 if (!SWIG_IsOK(res1)) {
36661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageDown" "', expected argument " "1"" of type '" "wxWindow *""'");
36662 }
36663 arg1 = reinterpret_cast< wxWindow * >(argp1);
36664 {
36665 PyThreadState* __tstate = wxPyBeginAllowThreads();
36666 result = (bool)(arg1)->PageDown();
36667 wxPyEndAllowThreads(__tstate);
36668 if (PyErr_Occurred()) SWIG_fail;
36669 }
36670 {
36671 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36672 }
36673 return resultobj;
36674 fail:
36675 return NULL;
36676 }
36677
36678
36679 SWIGINTERN PyObject *_wrap_Window_SetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36680 PyObject *resultobj = 0;
36681 wxWindow *arg1 = (wxWindow *) 0 ;
36682 wxString *arg2 = 0 ;
36683 void *argp1 = 0 ;
36684 int res1 = 0 ;
36685 bool temp2 = false ;
36686 PyObject * obj0 = 0 ;
36687 PyObject * obj1 = 0 ;
36688 char * kwnames[] = {
36689 (char *) "self",(char *) "text", NULL
36690 };
36691
36692 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) SWIG_fail;
36693 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36694 if (!SWIG_IsOK(res1)) {
36695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpText" "', expected argument " "1"" of type '" "wxWindow *""'");
36696 }
36697 arg1 = reinterpret_cast< wxWindow * >(argp1);
36698 {
36699 arg2 = wxString_in_helper(obj1);
36700 if (arg2 == NULL) SWIG_fail;
36701 temp2 = true;
36702 }
36703 {
36704 PyThreadState* __tstate = wxPyBeginAllowThreads();
36705 (arg1)->SetHelpText((wxString const &)*arg2);
36706 wxPyEndAllowThreads(__tstate);
36707 if (PyErr_Occurred()) SWIG_fail;
36708 }
36709 resultobj = SWIG_Py_Void();
36710 {
36711 if (temp2)
36712 delete arg2;
36713 }
36714 return resultobj;
36715 fail:
36716 {
36717 if (temp2)
36718 delete arg2;
36719 }
36720 return NULL;
36721 }
36722
36723
36724 SWIGINTERN PyObject *_wrap_Window_SetHelpTextForId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36725 PyObject *resultobj = 0;
36726 wxWindow *arg1 = (wxWindow *) 0 ;
36727 wxString *arg2 = 0 ;
36728 void *argp1 = 0 ;
36729 int res1 = 0 ;
36730 bool temp2 = false ;
36731 PyObject * obj0 = 0 ;
36732 PyObject * obj1 = 0 ;
36733 char * kwnames[] = {
36734 (char *) "self",(char *) "text", NULL
36735 };
36736
36737 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) SWIG_fail;
36738 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36739 if (!SWIG_IsOK(res1)) {
36740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpTextForId" "', expected argument " "1"" of type '" "wxWindow *""'");
36741 }
36742 arg1 = reinterpret_cast< wxWindow * >(argp1);
36743 {
36744 arg2 = wxString_in_helper(obj1);
36745 if (arg2 == NULL) SWIG_fail;
36746 temp2 = true;
36747 }
36748 {
36749 PyThreadState* __tstate = wxPyBeginAllowThreads();
36750 (arg1)->SetHelpTextForId((wxString const &)*arg2);
36751 wxPyEndAllowThreads(__tstate);
36752 if (PyErr_Occurred()) SWIG_fail;
36753 }
36754 resultobj = SWIG_Py_Void();
36755 {
36756 if (temp2)
36757 delete arg2;
36758 }
36759 return resultobj;
36760 fail:
36761 {
36762 if (temp2)
36763 delete arg2;
36764 }
36765 return NULL;
36766 }
36767
36768
36769 SWIGINTERN PyObject *_wrap_Window_GetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36770 PyObject *resultobj = 0;
36771 wxWindow *arg1 = (wxWindow *) 0 ;
36772 wxString result;
36773 void *argp1 = 0 ;
36774 int res1 = 0 ;
36775 PyObject *swig_obj[1] ;
36776
36777 if (!args) SWIG_fail;
36778 swig_obj[0] = args;
36779 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36780 if (!SWIG_IsOK(res1)) {
36781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpText" "', expected argument " "1"" of type '" "wxWindow const *""'");
36782 }
36783 arg1 = reinterpret_cast< wxWindow * >(argp1);
36784 {
36785 PyThreadState* __tstate = wxPyBeginAllowThreads();
36786 result = ((wxWindow const *)arg1)->GetHelpText();
36787 wxPyEndAllowThreads(__tstate);
36788 if (PyErr_Occurred()) SWIG_fail;
36789 }
36790 {
36791 #if wxUSE_UNICODE
36792 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36793 #else
36794 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36795 #endif
36796 }
36797 return resultobj;
36798 fail:
36799 return NULL;
36800 }
36801
36802
36803 SWIGINTERN PyObject *_wrap_Window_SetToolTipString(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 *) "tip", NULL
36814 };
36815
36816 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",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_SetToolTipString" "', 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)->SetToolTip((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_SetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36849 PyObject *resultobj = 0;
36850 wxWindow *arg1 = (wxWindow *) 0 ;
36851 wxToolTip *arg2 = (wxToolTip *) 0 ;
36852 void *argp1 = 0 ;
36853 int res1 = 0 ;
36854 int res2 = 0 ;
36855 PyObject * obj0 = 0 ;
36856 PyObject * obj1 = 0 ;
36857 char * kwnames[] = {
36858 (char *) "self",(char *) "tip", NULL
36859 };
36860
36861 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) SWIG_fail;
36862 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36863 if (!SWIG_IsOK(res1)) {
36864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTip" "', expected argument " "1"" of type '" "wxWindow *""'");
36865 }
36866 arg1 = reinterpret_cast< wxWindow * >(argp1);
36867 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
36868 if (!SWIG_IsOK(res2)) {
36869 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetToolTip" "', expected argument " "2"" of type '" "wxToolTip *""'");
36870 }
36871 {
36872 PyThreadState* __tstate = wxPyBeginAllowThreads();
36873 (arg1)->SetToolTip(arg2);
36874 wxPyEndAllowThreads(__tstate);
36875 if (PyErr_Occurred()) SWIG_fail;
36876 }
36877 resultobj = SWIG_Py_Void();
36878 return resultobj;
36879 fail:
36880 return NULL;
36881 }
36882
36883
36884 SWIGINTERN PyObject *_wrap_Window_GetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36885 PyObject *resultobj = 0;
36886 wxWindow *arg1 = (wxWindow *) 0 ;
36887 wxToolTip *result = 0 ;
36888 void *argp1 = 0 ;
36889 int res1 = 0 ;
36890 PyObject *swig_obj[1] ;
36891
36892 if (!args) SWIG_fail;
36893 swig_obj[0] = args;
36894 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36895 if (!SWIG_IsOK(res1)) {
36896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetToolTip" "', expected argument " "1"" of type '" "wxWindow const *""'");
36897 }
36898 arg1 = reinterpret_cast< wxWindow * >(argp1);
36899 {
36900 PyThreadState* __tstate = wxPyBeginAllowThreads();
36901 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
36902 wxPyEndAllowThreads(__tstate);
36903 if (PyErr_Occurred()) SWIG_fail;
36904 }
36905 {
36906 resultobj = wxPyMake_wxObject(result, (bool)0);
36907 }
36908 return resultobj;
36909 fail:
36910 return NULL;
36911 }
36912
36913
36914 SWIGINTERN PyObject *_wrap_Window_SetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36915 PyObject *resultobj = 0;
36916 wxWindow *arg1 = (wxWindow *) 0 ;
36917 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
36918 void *argp1 = 0 ;
36919 int res1 = 0 ;
36920 int res2 = 0 ;
36921 PyObject * obj0 = 0 ;
36922 PyObject * obj1 = 0 ;
36923 char * kwnames[] = {
36924 (char *) "self",(char *) "dropTarget", NULL
36925 };
36926
36927 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) SWIG_fail;
36928 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36929 if (!SWIG_IsOK(res1)) {
36930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDropTarget" "', expected argument " "1"" of type '" "wxWindow *""'");
36931 }
36932 arg1 = reinterpret_cast< wxWindow * >(argp1);
36933 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
36934 if (!SWIG_IsOK(res2)) {
36935 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDropTarget" "', expected argument " "2"" of type '" "wxPyDropTarget *""'");
36936 }
36937 {
36938 PyThreadState* __tstate = wxPyBeginAllowThreads();
36939 (arg1)->SetDropTarget(arg2);
36940 wxPyEndAllowThreads(__tstate);
36941 if (PyErr_Occurred()) SWIG_fail;
36942 }
36943 resultobj = SWIG_Py_Void();
36944 return resultobj;
36945 fail:
36946 return NULL;
36947 }
36948
36949
36950 SWIGINTERN PyObject *_wrap_Window_GetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36951 PyObject *resultobj = 0;
36952 wxWindow *arg1 = (wxWindow *) 0 ;
36953 wxPyDropTarget *result = 0 ;
36954 void *argp1 = 0 ;
36955 int res1 = 0 ;
36956 PyObject *swig_obj[1] ;
36957
36958 if (!args) SWIG_fail;
36959 swig_obj[0] = args;
36960 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36961 if (!SWIG_IsOK(res1)) {
36962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDropTarget" "', expected argument " "1"" of type '" "wxWindow const *""'");
36963 }
36964 arg1 = reinterpret_cast< wxWindow * >(argp1);
36965 {
36966 PyThreadState* __tstate = wxPyBeginAllowThreads();
36967 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
36968 wxPyEndAllowThreads(__tstate);
36969 if (PyErr_Occurred()) SWIG_fail;
36970 }
36971 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
36972 return resultobj;
36973 fail:
36974 return NULL;
36975 }
36976
36977
36978 SWIGINTERN PyObject *_wrap_Window_DragAcceptFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36979 PyObject *resultobj = 0;
36980 wxWindow *arg1 = (wxWindow *) 0 ;
36981 bool arg2 ;
36982 void *argp1 = 0 ;
36983 int res1 = 0 ;
36984 bool val2 ;
36985 int ecode2 = 0 ;
36986 PyObject * obj0 = 0 ;
36987 PyObject * obj1 = 0 ;
36988 char * kwnames[] = {
36989 (char *) "self",(char *) "accept", NULL
36990 };
36991
36992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) SWIG_fail;
36993 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36994 if (!SWIG_IsOK(res1)) {
36995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DragAcceptFiles" "', expected argument " "1"" of type '" "wxWindow *""'");
36996 }
36997 arg1 = reinterpret_cast< wxWindow * >(argp1);
36998 ecode2 = SWIG_AsVal_bool(obj1, &val2);
36999 if (!SWIG_IsOK(ecode2)) {
37000 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_DragAcceptFiles" "', expected argument " "2"" of type '" "bool""'");
37001 }
37002 arg2 = static_cast< bool >(val2);
37003 {
37004 PyThreadState* __tstate = wxPyBeginAllowThreads();
37005 wxWindow_DragAcceptFiles(arg1,arg2);
37006 wxPyEndAllowThreads(__tstate);
37007 if (PyErr_Occurred()) SWIG_fail;
37008 }
37009 resultobj = SWIG_Py_Void();
37010 return resultobj;
37011 fail:
37012 return NULL;
37013 }
37014
37015
37016 SWIGINTERN PyObject *_wrap_Window_SetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37017 PyObject *resultobj = 0;
37018 wxWindow *arg1 = (wxWindow *) 0 ;
37019 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
37020 void *argp1 = 0 ;
37021 int res1 = 0 ;
37022 int res2 = 0 ;
37023 PyObject * obj0 = 0 ;
37024 PyObject * obj1 = 0 ;
37025 char * kwnames[] = {
37026 (char *) "self",(char *) "constraints", NULL
37027 };
37028
37029 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
37030 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37031 if (!SWIG_IsOK(res1)) {
37032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetConstraints" "', expected argument " "1"" of type '" "wxWindow *""'");
37033 }
37034 arg1 = reinterpret_cast< wxWindow * >(argp1);
37035 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
37036 if (!SWIG_IsOK(res2)) {
37037 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetConstraints" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
37038 }
37039 {
37040 PyThreadState* __tstate = wxPyBeginAllowThreads();
37041 (arg1)->SetConstraints(arg2);
37042 wxPyEndAllowThreads(__tstate);
37043 if (PyErr_Occurred()) SWIG_fail;
37044 }
37045 resultobj = SWIG_Py_Void();
37046 return resultobj;
37047 fail:
37048 return NULL;
37049 }
37050
37051
37052 SWIGINTERN PyObject *_wrap_Window_GetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37053 PyObject *resultobj = 0;
37054 wxWindow *arg1 = (wxWindow *) 0 ;
37055 wxLayoutConstraints *result = 0 ;
37056 void *argp1 = 0 ;
37057 int res1 = 0 ;
37058 PyObject *swig_obj[1] ;
37059
37060 if (!args) SWIG_fail;
37061 swig_obj[0] = args;
37062 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37063 if (!SWIG_IsOK(res1)) {
37064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetConstraints" "', expected argument " "1"" of type '" "wxWindow const *""'");
37065 }
37066 arg1 = reinterpret_cast< wxWindow * >(argp1);
37067 {
37068 PyThreadState* __tstate = wxPyBeginAllowThreads();
37069 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
37070 wxPyEndAllowThreads(__tstate);
37071 if (PyErr_Occurred()) SWIG_fail;
37072 }
37073 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
37074 return resultobj;
37075 fail:
37076 return NULL;
37077 }
37078
37079
37080 SWIGINTERN PyObject *_wrap_Window_SetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37081 PyObject *resultobj = 0;
37082 wxWindow *arg1 = (wxWindow *) 0 ;
37083 bool arg2 ;
37084 void *argp1 = 0 ;
37085 int res1 = 0 ;
37086 bool val2 ;
37087 int ecode2 = 0 ;
37088 PyObject * obj0 = 0 ;
37089 PyObject * obj1 = 0 ;
37090 char * kwnames[] = {
37091 (char *) "self",(char *) "autoLayout", NULL
37092 };
37093
37094 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) SWIG_fail;
37095 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37096 if (!SWIG_IsOK(res1)) {
37097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAutoLayout" "', expected argument " "1"" of type '" "wxWindow *""'");
37098 }
37099 arg1 = reinterpret_cast< wxWindow * >(argp1);
37100 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37101 if (!SWIG_IsOK(ecode2)) {
37102 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetAutoLayout" "', expected argument " "2"" of type '" "bool""'");
37103 }
37104 arg2 = static_cast< bool >(val2);
37105 {
37106 PyThreadState* __tstate = wxPyBeginAllowThreads();
37107 (arg1)->SetAutoLayout(arg2);
37108 wxPyEndAllowThreads(__tstate);
37109 if (PyErr_Occurred()) SWIG_fail;
37110 }
37111 resultobj = SWIG_Py_Void();
37112 return resultobj;
37113 fail:
37114 return NULL;
37115 }
37116
37117
37118 SWIGINTERN PyObject *_wrap_Window_GetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37119 PyObject *resultobj = 0;
37120 wxWindow *arg1 = (wxWindow *) 0 ;
37121 bool result;
37122 void *argp1 = 0 ;
37123 int res1 = 0 ;
37124 PyObject *swig_obj[1] ;
37125
37126 if (!args) SWIG_fail;
37127 swig_obj[0] = args;
37128 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37129 if (!SWIG_IsOK(res1)) {
37130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAutoLayout" "', expected argument " "1"" of type '" "wxWindow const *""'");
37131 }
37132 arg1 = reinterpret_cast< wxWindow * >(argp1);
37133 {
37134 PyThreadState* __tstate = wxPyBeginAllowThreads();
37135 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
37136 wxPyEndAllowThreads(__tstate);
37137 if (PyErr_Occurred()) SWIG_fail;
37138 }
37139 {
37140 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37141 }
37142 return resultobj;
37143 fail:
37144 return NULL;
37145 }
37146
37147
37148 SWIGINTERN PyObject *_wrap_Window_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37149 PyObject *resultobj = 0;
37150 wxWindow *arg1 = (wxWindow *) 0 ;
37151 bool result;
37152 void *argp1 = 0 ;
37153 int res1 = 0 ;
37154 PyObject *swig_obj[1] ;
37155
37156 if (!args) SWIG_fail;
37157 swig_obj[0] = args;
37158 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37159 if (!SWIG_IsOK(res1)) {
37160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Layout" "', expected argument " "1"" of type '" "wxWindow *""'");
37161 }
37162 arg1 = reinterpret_cast< wxWindow * >(argp1);
37163 {
37164 PyThreadState* __tstate = wxPyBeginAllowThreads();
37165 result = (bool)(arg1)->Layout();
37166 wxPyEndAllowThreads(__tstate);
37167 if (PyErr_Occurred()) SWIG_fail;
37168 }
37169 {
37170 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37171 }
37172 return resultobj;
37173 fail:
37174 return NULL;
37175 }
37176
37177
37178 SWIGINTERN PyObject *_wrap_Window_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37179 PyObject *resultobj = 0;
37180 wxWindow *arg1 = (wxWindow *) 0 ;
37181 wxSizer *arg2 = (wxSizer *) 0 ;
37182 bool arg3 = (bool) true ;
37183 void *argp1 = 0 ;
37184 int res1 = 0 ;
37185 int res2 = 0 ;
37186 bool val3 ;
37187 int ecode3 = 0 ;
37188 PyObject * obj0 = 0 ;
37189 PyObject * obj1 = 0 ;
37190 PyObject * obj2 = 0 ;
37191 char * kwnames[] = {
37192 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
37193 };
37194
37195 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37196 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37197 if (!SWIG_IsOK(res1)) {
37198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
37199 }
37200 arg1 = reinterpret_cast< wxWindow * >(argp1);
37201 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
37202 if (!SWIG_IsOK(res2)) {
37203 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
37204 }
37205 if (obj2) {
37206 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37207 if (!SWIG_IsOK(ecode3)) {
37208 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizer" "', expected argument " "3"" of type '" "bool""'");
37209 }
37210 arg3 = static_cast< bool >(val3);
37211 }
37212 {
37213 PyThreadState* __tstate = wxPyBeginAllowThreads();
37214 (arg1)->SetSizer(arg2,arg3);
37215 wxPyEndAllowThreads(__tstate);
37216 if (PyErr_Occurred()) SWIG_fail;
37217 }
37218 resultobj = SWIG_Py_Void();
37219 return resultobj;
37220 fail:
37221 return NULL;
37222 }
37223
37224
37225 SWIGINTERN PyObject *_wrap_Window_SetSizerAndFit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37226 PyObject *resultobj = 0;
37227 wxWindow *arg1 = (wxWindow *) 0 ;
37228 wxSizer *arg2 = (wxSizer *) 0 ;
37229 bool arg3 = (bool) true ;
37230 void *argp1 = 0 ;
37231 int res1 = 0 ;
37232 int res2 = 0 ;
37233 bool val3 ;
37234 int ecode3 = 0 ;
37235 PyObject * obj0 = 0 ;
37236 PyObject * obj1 = 0 ;
37237 PyObject * obj2 = 0 ;
37238 char * kwnames[] = {
37239 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
37240 };
37241
37242 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37243 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37244 if (!SWIG_IsOK(res1)) {
37245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizerAndFit" "', expected argument " "1"" of type '" "wxWindow *""'");
37246 }
37247 arg1 = reinterpret_cast< wxWindow * >(argp1);
37248 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
37249 if (!SWIG_IsOK(res2)) {
37250 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizerAndFit" "', expected argument " "2"" of type '" "wxSizer *""'");
37251 }
37252 if (obj2) {
37253 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37254 if (!SWIG_IsOK(ecode3)) {
37255 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizerAndFit" "', expected argument " "3"" of type '" "bool""'");
37256 }
37257 arg3 = static_cast< bool >(val3);
37258 }
37259 {
37260 PyThreadState* __tstate = wxPyBeginAllowThreads();
37261 (arg1)->SetSizerAndFit(arg2,arg3);
37262 wxPyEndAllowThreads(__tstate);
37263 if (PyErr_Occurred()) SWIG_fail;
37264 }
37265 resultobj = SWIG_Py_Void();
37266 return resultobj;
37267 fail:
37268 return NULL;
37269 }
37270
37271
37272 SWIGINTERN PyObject *_wrap_Window_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37273 PyObject *resultobj = 0;
37274 wxWindow *arg1 = (wxWindow *) 0 ;
37275 wxSizer *result = 0 ;
37276 void *argp1 = 0 ;
37277 int res1 = 0 ;
37278 PyObject *swig_obj[1] ;
37279
37280 if (!args) SWIG_fail;
37281 swig_obj[0] = args;
37282 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37283 if (!SWIG_IsOK(res1)) {
37284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
37285 }
37286 arg1 = reinterpret_cast< wxWindow * >(argp1);
37287 {
37288 PyThreadState* __tstate = wxPyBeginAllowThreads();
37289 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
37290 wxPyEndAllowThreads(__tstate);
37291 if (PyErr_Occurred()) SWIG_fail;
37292 }
37293 {
37294 resultobj = wxPyMake_wxObject(result, (bool)0);
37295 }
37296 return resultobj;
37297 fail:
37298 return NULL;
37299 }
37300
37301
37302 SWIGINTERN PyObject *_wrap_Window_SetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37303 PyObject *resultobj = 0;
37304 wxWindow *arg1 = (wxWindow *) 0 ;
37305 wxSizer *arg2 = (wxSizer *) 0 ;
37306 void *argp1 = 0 ;
37307 int res1 = 0 ;
37308 void *argp2 = 0 ;
37309 int res2 = 0 ;
37310 PyObject * obj0 = 0 ;
37311 PyObject * obj1 = 0 ;
37312 char * kwnames[] = {
37313 (char *) "self",(char *) "sizer", NULL
37314 };
37315
37316 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) SWIG_fail;
37317 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37318 if (!SWIG_IsOK(res1)) {
37319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetContainingSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
37320 }
37321 arg1 = reinterpret_cast< wxWindow * >(argp1);
37322 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
37323 if (!SWIG_IsOK(res2)) {
37324 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetContainingSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
37325 }
37326 arg2 = reinterpret_cast< wxSizer * >(argp2);
37327 {
37328 PyThreadState* __tstate = wxPyBeginAllowThreads();
37329 (arg1)->SetContainingSizer(arg2);
37330 wxPyEndAllowThreads(__tstate);
37331 if (PyErr_Occurred()) SWIG_fail;
37332 }
37333 resultobj = SWIG_Py_Void();
37334 return resultobj;
37335 fail:
37336 return NULL;
37337 }
37338
37339
37340 SWIGINTERN PyObject *_wrap_Window_GetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37341 PyObject *resultobj = 0;
37342 wxWindow *arg1 = (wxWindow *) 0 ;
37343 wxSizer *result = 0 ;
37344 void *argp1 = 0 ;
37345 int res1 = 0 ;
37346 PyObject *swig_obj[1] ;
37347
37348 if (!args) SWIG_fail;
37349 swig_obj[0] = args;
37350 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37351 if (!SWIG_IsOK(res1)) {
37352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetContainingSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
37353 }
37354 arg1 = reinterpret_cast< wxWindow * >(argp1);
37355 {
37356 PyThreadState* __tstate = wxPyBeginAllowThreads();
37357 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
37358 wxPyEndAllowThreads(__tstate);
37359 if (PyErr_Occurred()) SWIG_fail;
37360 }
37361 {
37362 resultobj = wxPyMake_wxObject(result, (bool)0);
37363 }
37364 return resultobj;
37365 fail:
37366 return NULL;
37367 }
37368
37369
37370 SWIGINTERN PyObject *_wrap_Window_InheritAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37371 PyObject *resultobj = 0;
37372 wxWindow *arg1 = (wxWindow *) 0 ;
37373 void *argp1 = 0 ;
37374 int res1 = 0 ;
37375 PyObject *swig_obj[1] ;
37376
37377 if (!args) SWIG_fail;
37378 swig_obj[0] = args;
37379 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37380 if (!SWIG_IsOK(res1)) {
37381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritAttributes" "', expected argument " "1"" of type '" "wxWindow *""'");
37382 }
37383 arg1 = reinterpret_cast< wxWindow * >(argp1);
37384 {
37385 PyThreadState* __tstate = wxPyBeginAllowThreads();
37386 (arg1)->InheritAttributes();
37387 wxPyEndAllowThreads(__tstate);
37388 if (PyErr_Occurred()) SWIG_fail;
37389 }
37390 resultobj = SWIG_Py_Void();
37391 return resultobj;
37392 fail:
37393 return NULL;
37394 }
37395
37396
37397 SWIGINTERN PyObject *_wrap_Window_ShouldInheritColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37398 PyObject *resultobj = 0;
37399 wxWindow *arg1 = (wxWindow *) 0 ;
37400 bool result;
37401 void *argp1 = 0 ;
37402 int res1 = 0 ;
37403 PyObject *swig_obj[1] ;
37404
37405 if (!args) SWIG_fail;
37406 swig_obj[0] = args;
37407 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37408 if (!SWIG_IsOK(res1)) {
37409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ShouldInheritColours" "', expected argument " "1"" of type '" "wxWindow const *""'");
37410 }
37411 arg1 = reinterpret_cast< wxWindow * >(argp1);
37412 {
37413 PyThreadState* __tstate = wxPyBeginAllowThreads();
37414 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
37415 wxPyEndAllowThreads(__tstate);
37416 if (PyErr_Occurred()) SWIG_fail;
37417 }
37418 {
37419 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37420 }
37421 return resultobj;
37422 fail:
37423 return NULL;
37424 }
37425
37426
37427 SWIGINTERN PyObject *Window_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37428 PyObject *obj;
37429 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37430 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindow, SWIG_NewClientData(obj));
37431 return SWIG_Py_Void();
37432 }
37433
37434 SWIGINTERN PyObject *Window_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37435 return SWIG_Python_InitShadowInstance(args);
37436 }
37437
37438 SWIGINTERN PyObject *_wrap_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37439 PyObject *resultobj = 0;
37440 long arg1 ;
37441 wxWindow *arg2 = (wxWindow *) NULL ;
37442 wxWindow *result = 0 ;
37443 long val1 ;
37444 int ecode1 = 0 ;
37445 void *argp2 = 0 ;
37446 int res2 = 0 ;
37447 PyObject * obj0 = 0 ;
37448 PyObject * obj1 = 0 ;
37449 char * kwnames[] = {
37450 (char *) "id",(char *) "parent", NULL
37451 };
37452
37453 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
37454 ecode1 = SWIG_AsVal_long(obj0, &val1);
37455 if (!SWIG_IsOK(ecode1)) {
37456 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FindWindowById" "', expected argument " "1"" of type '" "long""'");
37457 }
37458 arg1 = static_cast< long >(val1);
37459 if (obj1) {
37460 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37461 if (!SWIG_IsOK(res2)) {
37462 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowById" "', expected argument " "2"" of type '" "wxWindow const *""'");
37463 }
37464 arg2 = reinterpret_cast< wxWindow * >(argp2);
37465 }
37466 {
37467 if (!wxPyCheckForApp()) SWIG_fail;
37468 PyThreadState* __tstate = wxPyBeginAllowThreads();
37469 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
37470 wxPyEndAllowThreads(__tstate);
37471 if (PyErr_Occurred()) SWIG_fail;
37472 }
37473 {
37474 resultobj = wxPyMake_wxObject(result, 0);
37475 }
37476 return resultobj;
37477 fail:
37478 return NULL;
37479 }
37480
37481
37482 SWIGINTERN PyObject *_wrap_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37483 PyObject *resultobj = 0;
37484 wxString *arg1 = 0 ;
37485 wxWindow *arg2 = (wxWindow *) NULL ;
37486 wxWindow *result = 0 ;
37487 bool temp1 = false ;
37488 void *argp2 = 0 ;
37489 int res2 = 0 ;
37490 PyObject * obj0 = 0 ;
37491 PyObject * obj1 = 0 ;
37492 char * kwnames[] = {
37493 (char *) "name",(char *) "parent", NULL
37494 };
37495
37496 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
37497 {
37498 arg1 = wxString_in_helper(obj0);
37499 if (arg1 == NULL) SWIG_fail;
37500 temp1 = true;
37501 }
37502 if (obj1) {
37503 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37504 if (!SWIG_IsOK(res2)) {
37505 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByName" "', expected argument " "2"" of type '" "wxWindow const *""'");
37506 }
37507 arg2 = reinterpret_cast< wxWindow * >(argp2);
37508 }
37509 {
37510 if (!wxPyCheckForApp()) SWIG_fail;
37511 PyThreadState* __tstate = wxPyBeginAllowThreads();
37512 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
37513 wxPyEndAllowThreads(__tstate);
37514 if (PyErr_Occurred()) SWIG_fail;
37515 }
37516 {
37517 resultobj = wxPyMake_wxObject(result, 0);
37518 }
37519 {
37520 if (temp1)
37521 delete arg1;
37522 }
37523 return resultobj;
37524 fail:
37525 {
37526 if (temp1)
37527 delete arg1;
37528 }
37529 return NULL;
37530 }
37531
37532
37533 SWIGINTERN PyObject *_wrap_FindWindowByLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37534 PyObject *resultobj = 0;
37535 wxString *arg1 = 0 ;
37536 wxWindow *arg2 = (wxWindow *) NULL ;
37537 wxWindow *result = 0 ;
37538 bool temp1 = false ;
37539 void *argp2 = 0 ;
37540 int res2 = 0 ;
37541 PyObject * obj0 = 0 ;
37542 PyObject * obj1 = 0 ;
37543 char * kwnames[] = {
37544 (char *) "label",(char *) "parent", NULL
37545 };
37546
37547 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) SWIG_fail;
37548 {
37549 arg1 = wxString_in_helper(obj0);
37550 if (arg1 == NULL) SWIG_fail;
37551 temp1 = true;
37552 }
37553 if (obj1) {
37554 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37555 if (!SWIG_IsOK(res2)) {
37556 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByLabel" "', expected argument " "2"" of type '" "wxWindow const *""'");
37557 }
37558 arg2 = reinterpret_cast< wxWindow * >(argp2);
37559 }
37560 {
37561 if (!wxPyCheckForApp()) SWIG_fail;
37562 PyThreadState* __tstate = wxPyBeginAllowThreads();
37563 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
37564 wxPyEndAllowThreads(__tstate);
37565 if (PyErr_Occurred()) SWIG_fail;
37566 }
37567 {
37568 resultobj = wxPyMake_wxObject(result, 0);
37569 }
37570 {
37571 if (temp1)
37572 delete arg1;
37573 }
37574 return resultobj;
37575 fail:
37576 {
37577 if (temp1)
37578 delete arg1;
37579 }
37580 return NULL;
37581 }
37582
37583
37584 SWIGINTERN PyObject *_wrap_Window_FromHWND(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37585 PyObject *resultobj = 0;
37586 wxWindow *arg1 = (wxWindow *) 0 ;
37587 unsigned long arg2 ;
37588 wxWindow *result = 0 ;
37589 void *argp1 = 0 ;
37590 int res1 = 0 ;
37591 unsigned long val2 ;
37592 int ecode2 = 0 ;
37593 PyObject * obj0 = 0 ;
37594 PyObject * obj1 = 0 ;
37595 char * kwnames[] = {
37596 (char *) "parent",(char *) "_hWnd", NULL
37597 };
37598
37599 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) SWIG_fail;
37600 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37601 if (!SWIG_IsOK(res1)) {
37602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FromHWND" "', expected argument " "1"" of type '" "wxWindow *""'");
37603 }
37604 arg1 = reinterpret_cast< wxWindow * >(argp1);
37605 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
37606 if (!SWIG_IsOK(ecode2)) {
37607 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FromHWND" "', expected argument " "2"" of type '" "unsigned long""'");
37608 }
37609 arg2 = static_cast< unsigned long >(val2);
37610 {
37611 PyThreadState* __tstate = wxPyBeginAllowThreads();
37612 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
37613 wxPyEndAllowThreads(__tstate);
37614 if (PyErr_Occurred()) SWIG_fail;
37615 }
37616 {
37617 resultobj = wxPyMake_wxObject(result, 0);
37618 }
37619 return resultobj;
37620 fail:
37621 return NULL;
37622 }
37623
37624
37625 SWIGINTERN PyObject *_wrap_GetTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37626 PyObject *resultobj = 0;
37627 PyObject *result = 0 ;
37628
37629 if (!SWIG_Python_UnpackTuple(args,"GetTopLevelWindows",0,0,0)) SWIG_fail;
37630 {
37631 PyThreadState* __tstate = wxPyBeginAllowThreads();
37632 result = (PyObject *)GetTopLevelWindows();
37633 wxPyEndAllowThreads(__tstate);
37634 if (PyErr_Occurred()) SWIG_fail;
37635 }
37636 resultobj = result;
37637 return resultobj;
37638 fail:
37639 return NULL;
37640 }
37641
37642
37643 SWIGINTERN PyObject *_wrap_new_Validator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37644 PyObject *resultobj = 0;
37645 wxValidator *result = 0 ;
37646
37647 if (!SWIG_Python_UnpackTuple(args,"new_Validator",0,0,0)) SWIG_fail;
37648 {
37649 PyThreadState* __tstate = wxPyBeginAllowThreads();
37650 result = (wxValidator *)new wxValidator();
37651 wxPyEndAllowThreads(__tstate);
37652 if (PyErr_Occurred()) SWIG_fail;
37653 }
37654 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxValidator, SWIG_POINTER_NEW | 0 );
37655 return resultobj;
37656 fail:
37657 return NULL;
37658 }
37659
37660
37661 SWIGINTERN PyObject *_wrap_Validator_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37662 PyObject *resultobj = 0;
37663 wxValidator *arg1 = (wxValidator *) 0 ;
37664 wxValidator *result = 0 ;
37665 void *argp1 = 0 ;
37666 int res1 = 0 ;
37667 PyObject *swig_obj[1] ;
37668
37669 if (!args) SWIG_fail;
37670 swig_obj[0] = args;
37671 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37672 if (!SWIG_IsOK(res1)) {
37673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Clone" "', expected argument " "1"" of type '" "wxValidator *""'");
37674 }
37675 arg1 = reinterpret_cast< wxValidator * >(argp1);
37676 {
37677 PyThreadState* __tstate = wxPyBeginAllowThreads();
37678 result = (wxValidator *)(arg1)->Clone();
37679 wxPyEndAllowThreads(__tstate);
37680 if (PyErr_Occurred()) SWIG_fail;
37681 }
37682 {
37683 resultobj = wxPyMake_wxObject(result, 0);
37684 }
37685 return resultobj;
37686 fail:
37687 return NULL;
37688 }
37689
37690
37691 SWIGINTERN PyObject *_wrap_Validator_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37692 PyObject *resultobj = 0;
37693 wxValidator *arg1 = (wxValidator *) 0 ;
37694 wxWindow *arg2 = (wxWindow *) 0 ;
37695 bool result;
37696 void *argp1 = 0 ;
37697 int res1 = 0 ;
37698 void *argp2 = 0 ;
37699 int res2 = 0 ;
37700 PyObject * obj0 = 0 ;
37701 PyObject * obj1 = 0 ;
37702 char * kwnames[] = {
37703 (char *) "self",(char *) "parent", NULL
37704 };
37705
37706 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) SWIG_fail;
37707 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37708 if (!SWIG_IsOK(res1)) {
37709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Validate" "', expected argument " "1"" of type '" "wxValidator *""'");
37710 }
37711 arg1 = reinterpret_cast< wxValidator * >(argp1);
37712 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37713 if (!SWIG_IsOK(res2)) {
37714 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_Validate" "', expected argument " "2"" of type '" "wxWindow *""'");
37715 }
37716 arg2 = reinterpret_cast< wxWindow * >(argp2);
37717 {
37718 PyThreadState* __tstate = wxPyBeginAllowThreads();
37719 result = (bool)(arg1)->Validate(arg2);
37720 wxPyEndAllowThreads(__tstate);
37721 if (PyErr_Occurred()) SWIG_fail;
37722 }
37723 {
37724 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37725 }
37726 return resultobj;
37727 fail:
37728 return NULL;
37729 }
37730
37731
37732 SWIGINTERN PyObject *_wrap_Validator_TransferToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37733 PyObject *resultobj = 0;
37734 wxValidator *arg1 = (wxValidator *) 0 ;
37735 bool result;
37736 void *argp1 = 0 ;
37737 int res1 = 0 ;
37738 PyObject *swig_obj[1] ;
37739
37740 if (!args) SWIG_fail;
37741 swig_obj[0] = args;
37742 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37743 if (!SWIG_IsOK(res1)) {
37744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferToWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
37745 }
37746 arg1 = reinterpret_cast< wxValidator * >(argp1);
37747 {
37748 PyThreadState* __tstate = wxPyBeginAllowThreads();
37749 result = (bool)(arg1)->TransferToWindow();
37750 wxPyEndAllowThreads(__tstate);
37751 if (PyErr_Occurred()) SWIG_fail;
37752 }
37753 {
37754 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37755 }
37756 return resultobj;
37757 fail:
37758 return NULL;
37759 }
37760
37761
37762 SWIGINTERN PyObject *_wrap_Validator_TransferFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37763 PyObject *resultobj = 0;
37764 wxValidator *arg1 = (wxValidator *) 0 ;
37765 bool result;
37766 void *argp1 = 0 ;
37767 int res1 = 0 ;
37768 PyObject *swig_obj[1] ;
37769
37770 if (!args) SWIG_fail;
37771 swig_obj[0] = args;
37772 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37773 if (!SWIG_IsOK(res1)) {
37774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferFromWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
37775 }
37776 arg1 = reinterpret_cast< wxValidator * >(argp1);
37777 {
37778 PyThreadState* __tstate = wxPyBeginAllowThreads();
37779 result = (bool)(arg1)->TransferFromWindow();
37780 wxPyEndAllowThreads(__tstate);
37781 if (PyErr_Occurred()) SWIG_fail;
37782 }
37783 {
37784 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37785 }
37786 return resultobj;
37787 fail:
37788 return NULL;
37789 }
37790
37791
37792 SWIGINTERN PyObject *_wrap_Validator_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37793 PyObject *resultobj = 0;
37794 wxValidator *arg1 = (wxValidator *) 0 ;
37795 wxWindow *result = 0 ;
37796 void *argp1 = 0 ;
37797 int res1 = 0 ;
37798 PyObject *swig_obj[1] ;
37799
37800 if (!args) SWIG_fail;
37801 swig_obj[0] = args;
37802 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37803 if (!SWIG_IsOK(res1)) {
37804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_GetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
37805 }
37806 arg1 = reinterpret_cast< wxValidator * >(argp1);
37807 {
37808 PyThreadState* __tstate = wxPyBeginAllowThreads();
37809 result = (wxWindow *)(arg1)->GetWindow();
37810 wxPyEndAllowThreads(__tstate);
37811 if (PyErr_Occurred()) SWIG_fail;
37812 }
37813 {
37814 resultobj = wxPyMake_wxObject(result, 0);
37815 }
37816 return resultobj;
37817 fail:
37818 return NULL;
37819 }
37820
37821
37822 SWIGINTERN PyObject *_wrap_Validator_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37823 PyObject *resultobj = 0;
37824 wxValidator *arg1 = (wxValidator *) 0 ;
37825 wxWindow *arg2 = (wxWindow *) 0 ;
37826 void *argp1 = 0 ;
37827 int res1 = 0 ;
37828 void *argp2 = 0 ;
37829 int res2 = 0 ;
37830 PyObject * obj0 = 0 ;
37831 PyObject * obj1 = 0 ;
37832 char * kwnames[] = {
37833 (char *) "self",(char *) "window", NULL
37834 };
37835
37836 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
37837 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37838 if (!SWIG_IsOK(res1)) {
37839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_SetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
37840 }
37841 arg1 = reinterpret_cast< wxValidator * >(argp1);
37842 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37843 if (!SWIG_IsOK(res2)) {
37844 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
37845 }
37846 arg2 = reinterpret_cast< wxWindow * >(argp2);
37847 {
37848 PyThreadState* __tstate = wxPyBeginAllowThreads();
37849 (arg1)->SetWindow(arg2);
37850 wxPyEndAllowThreads(__tstate);
37851 if (PyErr_Occurred()) SWIG_fail;
37852 }
37853 resultobj = SWIG_Py_Void();
37854 return resultobj;
37855 fail:
37856 return NULL;
37857 }
37858
37859
37860 SWIGINTERN PyObject *_wrap_Validator_IsSilent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37861 PyObject *resultobj = 0;
37862 bool result;
37863
37864 if (!SWIG_Python_UnpackTuple(args,"Validator_IsSilent",0,0,0)) SWIG_fail;
37865 {
37866 PyThreadState* __tstate = wxPyBeginAllowThreads();
37867 result = (bool)wxValidator::IsSilent();
37868 wxPyEndAllowThreads(__tstate);
37869 if (PyErr_Occurred()) SWIG_fail;
37870 }
37871 {
37872 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37873 }
37874 return resultobj;
37875 fail:
37876 return NULL;
37877 }
37878
37879
37880 SWIGINTERN PyObject *_wrap_Validator_SetBellOnError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37881 PyObject *resultobj = 0;
37882 int arg1 = (int) true ;
37883 int val1 ;
37884 int ecode1 = 0 ;
37885 PyObject * obj0 = 0 ;
37886 char * kwnames[] = {
37887 (char *) "doIt", NULL
37888 };
37889
37890 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) SWIG_fail;
37891 if (obj0) {
37892 ecode1 = SWIG_AsVal_int(obj0, &val1);
37893 if (!SWIG_IsOK(ecode1)) {
37894 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Validator_SetBellOnError" "', expected argument " "1"" of type '" "int""'");
37895 }
37896 arg1 = static_cast< int >(val1);
37897 }
37898 {
37899 PyThreadState* __tstate = wxPyBeginAllowThreads();
37900 wxValidator::SetBellOnError(arg1);
37901 wxPyEndAllowThreads(__tstate);
37902 if (PyErr_Occurred()) SWIG_fail;
37903 }
37904 resultobj = SWIG_Py_Void();
37905 return resultobj;
37906 fail:
37907 return NULL;
37908 }
37909
37910
37911 SWIGINTERN PyObject *Validator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37912 PyObject *obj;
37913 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37914 SWIG_TypeNewClientData(SWIGTYPE_p_wxValidator, SWIG_NewClientData(obj));
37915 return SWIG_Py_Void();
37916 }
37917
37918 SWIGINTERN PyObject *Validator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37919 return SWIG_Python_InitShadowInstance(args);
37920 }
37921
37922 SWIGINTERN PyObject *_wrap_new_PyValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37923 PyObject *resultobj = 0;
37924 wxPyValidator *result = 0 ;
37925
37926 if (!SWIG_Python_UnpackTuple(args,"new_PyValidator",0,0,0)) SWIG_fail;
37927 {
37928 PyThreadState* __tstate = wxPyBeginAllowThreads();
37929 result = (wxPyValidator *)new wxPyValidator();
37930 wxPyEndAllowThreads(__tstate);
37931 if (PyErr_Occurred()) SWIG_fail;
37932 }
37933 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyValidator, SWIG_POINTER_NEW | 0 );
37934 return resultobj;
37935 fail:
37936 return NULL;
37937 }
37938
37939
37940 SWIGINTERN PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37941 PyObject *resultobj = 0;
37942 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
37943 PyObject *arg2 = (PyObject *) 0 ;
37944 PyObject *arg3 = (PyObject *) 0 ;
37945 int arg4 = (int) true ;
37946 void *argp1 = 0 ;
37947 int res1 = 0 ;
37948 int val4 ;
37949 int ecode4 = 0 ;
37950 PyObject * obj0 = 0 ;
37951 PyObject * obj1 = 0 ;
37952 PyObject * obj2 = 0 ;
37953 PyObject * obj3 = 0 ;
37954 char * kwnames[] = {
37955 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
37956 };
37957
37958 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
37959 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyValidator, 0 | 0 );
37960 if (!SWIG_IsOK(res1)) {
37961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyValidator *""'");
37962 }
37963 arg1 = reinterpret_cast< wxPyValidator * >(argp1);
37964 arg2 = obj1;
37965 arg3 = obj2;
37966 if (obj3) {
37967 ecode4 = SWIG_AsVal_int(obj3, &val4);
37968 if (!SWIG_IsOK(ecode4)) {
37969 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
37970 }
37971 arg4 = static_cast< int >(val4);
37972 }
37973 {
37974 PyThreadState* __tstate = wxPyBeginAllowThreads();
37975 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
37976 wxPyEndAllowThreads(__tstate);
37977 if (PyErr_Occurred()) SWIG_fail;
37978 }
37979 resultobj = SWIG_Py_Void();
37980 return resultobj;
37981 fail:
37982 return NULL;
37983 }
37984
37985
37986 SWIGINTERN PyObject *PyValidator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37987 PyObject *obj;
37988 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37989 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyValidator, SWIG_NewClientData(obj));
37990 return SWIG_Py_Void();
37991 }
37992
37993 SWIGINTERN PyObject *PyValidator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37994 return SWIG_Python_InitShadowInstance(args);
37995 }
37996
37997 SWIGINTERN int DefaultValidator_set(PyObject *) {
37998 SWIG_Error(SWIG_AttributeError,"Variable DefaultValidator is read-only.");
37999 return 1;
38000 }
38001
38002
38003 SWIGINTERN PyObject *DefaultValidator_get(void) {
38004 PyObject *pyobj = 0;
38005
38006 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0 );
38007 return pyobj;
38008 }
38009
38010
38011 SWIGINTERN PyObject *_wrap_new_Menu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38012 PyObject *resultobj = 0;
38013 wxString const &arg1_defvalue = wxPyEmptyString ;
38014 wxString *arg1 = (wxString *) &arg1_defvalue ;
38015 long arg2 = (long) 0 ;
38016 wxMenu *result = 0 ;
38017 bool temp1 = false ;
38018 long val2 ;
38019 int ecode2 = 0 ;
38020 PyObject * obj0 = 0 ;
38021 PyObject * obj1 = 0 ;
38022 char * kwnames[] = {
38023 (char *) "title",(char *) "style", NULL
38024 };
38025
38026 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) SWIG_fail;
38027 if (obj0) {
38028 {
38029 arg1 = wxString_in_helper(obj0);
38030 if (arg1 == NULL) SWIG_fail;
38031 temp1 = true;
38032 }
38033 }
38034 if (obj1) {
38035 ecode2 = SWIG_AsVal_long(obj1, &val2);
38036 if (!SWIG_IsOK(ecode2)) {
38037 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Menu" "', expected argument " "2"" of type '" "long""'");
38038 }
38039 arg2 = static_cast< long >(val2);
38040 }
38041 {
38042 if (!wxPyCheckForApp()) SWIG_fail;
38043 PyThreadState* __tstate = wxPyBeginAllowThreads();
38044 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
38045 wxPyEndAllowThreads(__tstate);
38046 if (PyErr_Occurred()) SWIG_fail;
38047 }
38048 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenu, SWIG_POINTER_NEW | 0 );
38049 {
38050 if (temp1)
38051 delete arg1;
38052 }
38053 return resultobj;
38054 fail:
38055 {
38056 if (temp1)
38057 delete arg1;
38058 }
38059 return NULL;
38060 }
38061
38062
38063 SWIGINTERN PyObject *_wrap_Menu_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38064 PyObject *resultobj = 0;
38065 wxMenu *arg1 = (wxMenu *) 0 ;
38066 int arg2 ;
38067 wxString *arg3 = 0 ;
38068 wxString const &arg4_defvalue = wxPyEmptyString ;
38069 wxString *arg4 = (wxString *) &arg4_defvalue ;
38070 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
38071 wxMenuItem *result = 0 ;
38072 void *argp1 = 0 ;
38073 int res1 = 0 ;
38074 int val2 ;
38075 int ecode2 = 0 ;
38076 bool temp3 = false ;
38077 bool temp4 = false ;
38078 int val5 ;
38079 int ecode5 = 0 ;
38080 PyObject * obj0 = 0 ;
38081 PyObject * obj1 = 0 ;
38082 PyObject * obj2 = 0 ;
38083 PyObject * obj3 = 0 ;
38084 PyObject * obj4 = 0 ;
38085 char * kwnames[] = {
38086 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
38087 };
38088
38089 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38090 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38091 if (!SWIG_IsOK(res1)) {
38092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Append" "', expected argument " "1"" of type '" "wxMenu *""'");
38093 }
38094 arg1 = reinterpret_cast< wxMenu * >(argp1);
38095 ecode2 = SWIG_AsVal_int(obj1, &val2);
38096 if (!SWIG_IsOK(ecode2)) {
38097 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Append" "', expected argument " "2"" of type '" "int""'");
38098 }
38099 arg2 = static_cast< int >(val2);
38100 {
38101 arg3 = wxString_in_helper(obj2);
38102 if (arg3 == NULL) SWIG_fail;
38103 temp3 = true;
38104 }
38105 if (obj3) {
38106 {
38107 arg4 = wxString_in_helper(obj3);
38108 if (arg4 == NULL) SWIG_fail;
38109 temp4 = true;
38110 }
38111 }
38112 if (obj4) {
38113 ecode5 = SWIG_AsVal_int(obj4, &val5);
38114 if (!SWIG_IsOK(ecode5)) {
38115 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Append" "', expected argument " "5"" of type '" "wxItemKind""'");
38116 }
38117 arg5 = static_cast< wxItemKind >(val5);
38118 }
38119 {
38120 PyThreadState* __tstate = wxPyBeginAllowThreads();
38121 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
38122 wxPyEndAllowThreads(__tstate);
38123 if (PyErr_Occurred()) SWIG_fail;
38124 }
38125 {
38126 resultobj = wxPyMake_wxObject(result, (bool)0);
38127 }
38128 {
38129 if (temp3)
38130 delete arg3;
38131 }
38132 {
38133 if (temp4)
38134 delete arg4;
38135 }
38136 return resultobj;
38137 fail:
38138 {
38139 if (temp3)
38140 delete arg3;
38141 }
38142 {
38143 if (temp4)
38144 delete arg4;
38145 }
38146 return NULL;
38147 }
38148
38149
38150 SWIGINTERN PyObject *_wrap_Menu_AppendSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38151 PyObject *resultobj = 0;
38152 wxMenu *arg1 = (wxMenu *) 0 ;
38153 wxMenuItem *result = 0 ;
38154 void *argp1 = 0 ;
38155 int res1 = 0 ;
38156 PyObject *swig_obj[1] ;
38157
38158 if (!args) SWIG_fail;
38159 swig_obj[0] = args;
38160 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38161 if (!SWIG_IsOK(res1)) {
38162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
38163 }
38164 arg1 = reinterpret_cast< wxMenu * >(argp1);
38165 {
38166 PyThreadState* __tstate = wxPyBeginAllowThreads();
38167 result = (wxMenuItem *)(arg1)->AppendSeparator();
38168 wxPyEndAllowThreads(__tstate);
38169 if (PyErr_Occurred()) SWIG_fail;
38170 }
38171 {
38172 resultobj = wxPyMake_wxObject(result, (bool)0);
38173 }
38174 return resultobj;
38175 fail:
38176 return NULL;
38177 }
38178
38179
38180 SWIGINTERN PyObject *_wrap_Menu_AppendCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38181 PyObject *resultobj = 0;
38182 wxMenu *arg1 = (wxMenu *) 0 ;
38183 int arg2 ;
38184 wxString *arg3 = 0 ;
38185 wxString const &arg4_defvalue = wxPyEmptyString ;
38186 wxString *arg4 = (wxString *) &arg4_defvalue ;
38187 wxMenuItem *result = 0 ;
38188 void *argp1 = 0 ;
38189 int res1 = 0 ;
38190 int val2 ;
38191 int ecode2 = 0 ;
38192 bool temp3 = false ;
38193 bool temp4 = false ;
38194 PyObject * obj0 = 0 ;
38195 PyObject * obj1 = 0 ;
38196 PyObject * obj2 = 0 ;
38197 PyObject * obj3 = 0 ;
38198 char * kwnames[] = {
38199 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
38200 };
38201
38202 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38203 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38204 if (!SWIG_IsOK(res1)) {
38205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38206 }
38207 arg1 = reinterpret_cast< wxMenu * >(argp1);
38208 ecode2 = SWIG_AsVal_int(obj1, &val2);
38209 if (!SWIG_IsOK(ecode2)) {
38210 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendCheckItem" "', expected argument " "2"" of type '" "int""'");
38211 }
38212 arg2 = static_cast< int >(val2);
38213 {
38214 arg3 = wxString_in_helper(obj2);
38215 if (arg3 == NULL) SWIG_fail;
38216 temp3 = true;
38217 }
38218 if (obj3) {
38219 {
38220 arg4 = wxString_in_helper(obj3);
38221 if (arg4 == NULL) SWIG_fail;
38222 temp4 = true;
38223 }
38224 }
38225 {
38226 PyThreadState* __tstate = wxPyBeginAllowThreads();
38227 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38228 wxPyEndAllowThreads(__tstate);
38229 if (PyErr_Occurred()) SWIG_fail;
38230 }
38231 {
38232 resultobj = wxPyMake_wxObject(result, (bool)0);
38233 }
38234 {
38235 if (temp3)
38236 delete arg3;
38237 }
38238 {
38239 if (temp4)
38240 delete arg4;
38241 }
38242 return resultobj;
38243 fail:
38244 {
38245 if (temp3)
38246 delete arg3;
38247 }
38248 {
38249 if (temp4)
38250 delete arg4;
38251 }
38252 return NULL;
38253 }
38254
38255
38256 SWIGINTERN PyObject *_wrap_Menu_AppendRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38257 PyObject *resultobj = 0;
38258 wxMenu *arg1 = (wxMenu *) 0 ;
38259 int arg2 ;
38260 wxString *arg3 = 0 ;
38261 wxString const &arg4_defvalue = wxPyEmptyString ;
38262 wxString *arg4 = (wxString *) &arg4_defvalue ;
38263 wxMenuItem *result = 0 ;
38264 void *argp1 = 0 ;
38265 int res1 = 0 ;
38266 int val2 ;
38267 int ecode2 = 0 ;
38268 bool temp3 = false ;
38269 bool temp4 = false ;
38270 PyObject * obj0 = 0 ;
38271 PyObject * obj1 = 0 ;
38272 PyObject * obj2 = 0 ;
38273 PyObject * obj3 = 0 ;
38274 char * kwnames[] = {
38275 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
38276 };
38277
38278 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38279 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38280 if (!SWIG_IsOK(res1)) {
38281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38282 }
38283 arg1 = reinterpret_cast< wxMenu * >(argp1);
38284 ecode2 = SWIG_AsVal_int(obj1, &val2);
38285 if (!SWIG_IsOK(ecode2)) {
38286 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendRadioItem" "', expected argument " "2"" of type '" "int""'");
38287 }
38288 arg2 = static_cast< int >(val2);
38289 {
38290 arg3 = wxString_in_helper(obj2);
38291 if (arg3 == NULL) SWIG_fail;
38292 temp3 = true;
38293 }
38294 if (obj3) {
38295 {
38296 arg4 = wxString_in_helper(obj3);
38297 if (arg4 == NULL) SWIG_fail;
38298 temp4 = true;
38299 }
38300 }
38301 {
38302 PyThreadState* __tstate = wxPyBeginAllowThreads();
38303 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38304 wxPyEndAllowThreads(__tstate);
38305 if (PyErr_Occurred()) SWIG_fail;
38306 }
38307 {
38308 resultobj = wxPyMake_wxObject(result, (bool)0);
38309 }
38310 {
38311 if (temp3)
38312 delete arg3;
38313 }
38314 {
38315 if (temp4)
38316 delete arg4;
38317 }
38318 return resultobj;
38319 fail:
38320 {
38321 if (temp3)
38322 delete arg3;
38323 }
38324 {
38325 if (temp4)
38326 delete arg4;
38327 }
38328 return NULL;
38329 }
38330
38331
38332 SWIGINTERN PyObject *_wrap_Menu_AppendMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38333 PyObject *resultobj = 0;
38334 wxMenu *arg1 = (wxMenu *) 0 ;
38335 int arg2 ;
38336 wxString *arg3 = 0 ;
38337 wxMenu *arg4 = (wxMenu *) 0 ;
38338 wxString const &arg5_defvalue = wxPyEmptyString ;
38339 wxString *arg5 = (wxString *) &arg5_defvalue ;
38340 wxMenuItem *result = 0 ;
38341 void *argp1 = 0 ;
38342 int res1 = 0 ;
38343 int val2 ;
38344 int ecode2 = 0 ;
38345 bool temp3 = false ;
38346 void *argp4 = 0 ;
38347 int res4 = 0 ;
38348 bool temp5 = false ;
38349 PyObject * obj0 = 0 ;
38350 PyObject * obj1 = 0 ;
38351 PyObject * obj2 = 0 ;
38352 PyObject * obj3 = 0 ;
38353 PyObject * obj4 = 0 ;
38354 char * kwnames[] = {
38355 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
38356 };
38357
38358 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38359 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38360 if (!SWIG_IsOK(res1)) {
38361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
38362 }
38363 arg1 = reinterpret_cast< wxMenu * >(argp1);
38364 ecode2 = SWIG_AsVal_int(obj1, &val2);
38365 if (!SWIG_IsOK(ecode2)) {
38366 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendMenu" "', expected argument " "2"" of type '" "int""'");
38367 }
38368 arg2 = static_cast< int >(val2);
38369 {
38370 arg3 = wxString_in_helper(obj2);
38371 if (arg3 == NULL) SWIG_fail;
38372 temp3 = true;
38373 }
38374 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
38375 if (!SWIG_IsOK(res4)) {
38376 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_AppendMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
38377 }
38378 arg4 = reinterpret_cast< wxMenu * >(argp4);
38379 if (obj4) {
38380 {
38381 arg5 = wxString_in_helper(obj4);
38382 if (arg5 == NULL) SWIG_fail;
38383 temp5 = true;
38384 }
38385 }
38386 {
38387 PyThreadState* __tstate = wxPyBeginAllowThreads();
38388 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
38389 wxPyEndAllowThreads(__tstate);
38390 if (PyErr_Occurred()) SWIG_fail;
38391 }
38392 {
38393 resultobj = wxPyMake_wxObject(result, (bool)0);
38394 }
38395 {
38396 if (temp3)
38397 delete arg3;
38398 }
38399 {
38400 if (temp5)
38401 delete arg5;
38402 }
38403 return resultobj;
38404 fail:
38405 {
38406 if (temp3)
38407 delete arg3;
38408 }
38409 {
38410 if (temp5)
38411 delete arg5;
38412 }
38413 return NULL;
38414 }
38415
38416
38417 SWIGINTERN PyObject *_wrap_Menu_AppendSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38418 PyObject *resultobj = 0;
38419 wxMenu *arg1 = (wxMenu *) 0 ;
38420 wxMenu *arg2 = (wxMenu *) 0 ;
38421 wxString *arg3 = 0 ;
38422 wxString const &arg4_defvalue = wxPyEmptyString ;
38423 wxString *arg4 = (wxString *) &arg4_defvalue ;
38424 wxMenuItem *result = 0 ;
38425 void *argp1 = 0 ;
38426 int res1 = 0 ;
38427 void *argp2 = 0 ;
38428 int res2 = 0 ;
38429 bool temp3 = false ;
38430 bool temp4 = false ;
38431 PyObject * obj0 = 0 ;
38432 PyObject * obj1 = 0 ;
38433 PyObject * obj2 = 0 ;
38434 PyObject * obj3 = 0 ;
38435 char * kwnames[] = {
38436 (char *) "self",(char *) "submenu",(char *) "text",(char *) "help", NULL
38437 };
38438
38439 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendSubMenu",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38440 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38441 if (!SWIG_IsOK(res1)) {
38442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSubMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
38443 }
38444 arg1 = reinterpret_cast< wxMenu * >(argp1);
38445 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
38446 if (!SWIG_IsOK(res2)) {
38447 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
38448 }
38449 arg2 = reinterpret_cast< wxMenu * >(argp2);
38450 {
38451 arg3 = wxString_in_helper(obj2);
38452 if (arg3 == NULL) SWIG_fail;
38453 temp3 = true;
38454 }
38455 if (obj3) {
38456 {
38457 arg4 = wxString_in_helper(obj3);
38458 if (arg4 == NULL) SWIG_fail;
38459 temp4 = true;
38460 }
38461 }
38462 {
38463 PyThreadState* __tstate = wxPyBeginAllowThreads();
38464 result = (wxMenuItem *)(arg1)->AppendSubMenu(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38465 wxPyEndAllowThreads(__tstate);
38466 if (PyErr_Occurred()) SWIG_fail;
38467 }
38468 {
38469 resultobj = wxPyMake_wxObject(result, (bool)0);
38470 }
38471 {
38472 if (temp3)
38473 delete arg3;
38474 }
38475 {
38476 if (temp4)
38477 delete arg4;
38478 }
38479 return resultobj;
38480 fail:
38481 {
38482 if (temp3)
38483 delete arg3;
38484 }
38485 {
38486 if (temp4)
38487 delete arg4;
38488 }
38489 return NULL;
38490 }
38491
38492
38493 SWIGINTERN PyObject *_wrap_Menu_AppendItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38494 PyObject *resultobj = 0;
38495 wxMenu *arg1 = (wxMenu *) 0 ;
38496 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
38497 wxMenuItem *result = 0 ;
38498 void *argp1 = 0 ;
38499 int res1 = 0 ;
38500 int res2 = 0 ;
38501 PyObject * obj0 = 0 ;
38502 PyObject * obj1 = 0 ;
38503 char * kwnames[] = {
38504 (char *) "self",(char *) "item", NULL
38505 };
38506
38507 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) SWIG_fail;
38508 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38509 if (!SWIG_IsOK(res1)) {
38510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38511 }
38512 arg1 = reinterpret_cast< wxMenu * >(argp1);
38513 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38514 if (!SWIG_IsOK(res2)) {
38515 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
38516 }
38517 {
38518 PyThreadState* __tstate = wxPyBeginAllowThreads();
38519 result = (wxMenuItem *)(arg1)->Append(arg2);
38520 wxPyEndAllowThreads(__tstate);
38521 if (PyErr_Occurred()) SWIG_fail;
38522 }
38523 {
38524 resultobj = wxPyMake_wxObject(result, (bool)0);
38525 }
38526 return resultobj;
38527 fail:
38528 return NULL;
38529 }
38530
38531
38532 SWIGINTERN PyObject *_wrap_Menu_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38533 PyObject *resultobj = 0;
38534 wxMenu *arg1 = (wxMenu *) 0 ;
38535 size_t arg2 ;
38536 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
38537 wxMenuItem *result = 0 ;
38538 void *argp1 = 0 ;
38539 int res1 = 0 ;
38540 size_t val2 ;
38541 int ecode2 = 0 ;
38542 int res3 = 0 ;
38543 PyObject * obj0 = 0 ;
38544 PyObject * obj1 = 0 ;
38545 PyObject * obj2 = 0 ;
38546 char * kwnames[] = {
38547 (char *) "self",(char *) "pos",(char *) "item", NULL
38548 };
38549
38550 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38551 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38552 if (!SWIG_IsOK(res1)) {
38553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38554 }
38555 arg1 = reinterpret_cast< wxMenu * >(argp1);
38556 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38557 if (!SWIG_IsOK(ecode2)) {
38558 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
38559 }
38560 arg2 = static_cast< size_t >(val2);
38561 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38562 if (!SWIG_IsOK(res3)) {
38563 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Menu_InsertItem" "', expected argument " "3"" of type '" "wxMenuItem *""'");
38564 }
38565 {
38566 PyThreadState* __tstate = wxPyBeginAllowThreads();
38567 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
38568 wxPyEndAllowThreads(__tstate);
38569 if (PyErr_Occurred()) SWIG_fail;
38570 }
38571 {
38572 resultobj = wxPyMake_wxObject(result, (bool)0);
38573 }
38574 return resultobj;
38575 fail:
38576 return NULL;
38577 }
38578
38579
38580 SWIGINTERN PyObject *_wrap_Menu_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38581 PyObject *resultobj = 0;
38582 wxMenu *arg1 = (wxMenu *) 0 ;
38583 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
38584 wxMenuItem *result = 0 ;
38585 void *argp1 = 0 ;
38586 int res1 = 0 ;
38587 int res2 = 0 ;
38588 PyObject * obj0 = 0 ;
38589 PyObject * obj1 = 0 ;
38590 char * kwnames[] = {
38591 (char *) "self",(char *) "item", NULL
38592 };
38593
38594 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
38595 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38596 if (!SWIG_IsOK(res1)) {
38597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38598 }
38599 arg1 = reinterpret_cast< wxMenu * >(argp1);
38600 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38601 if (!SWIG_IsOK(res2)) {
38602 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_PrependItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
38603 }
38604 {
38605 PyThreadState* __tstate = wxPyBeginAllowThreads();
38606 result = (wxMenuItem *)(arg1)->Prepend(arg2);
38607 wxPyEndAllowThreads(__tstate);
38608 if (PyErr_Occurred()) SWIG_fail;
38609 }
38610 {
38611 resultobj = wxPyMake_wxObject(result, (bool)0);
38612 }
38613 return resultobj;
38614 fail:
38615 return NULL;
38616 }
38617
38618
38619 SWIGINTERN PyObject *_wrap_Menu_Break(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38620 PyObject *resultobj = 0;
38621 wxMenu *arg1 = (wxMenu *) 0 ;
38622 void *argp1 = 0 ;
38623 int res1 = 0 ;
38624 PyObject *swig_obj[1] ;
38625
38626 if (!args) SWIG_fail;
38627 swig_obj[0] = args;
38628 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38629 if (!SWIG_IsOK(res1)) {
38630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Break" "', expected argument " "1"" of type '" "wxMenu *""'");
38631 }
38632 arg1 = reinterpret_cast< wxMenu * >(argp1);
38633 {
38634 PyThreadState* __tstate = wxPyBeginAllowThreads();
38635 (arg1)->Break();
38636 wxPyEndAllowThreads(__tstate);
38637 if (PyErr_Occurred()) SWIG_fail;
38638 }
38639 resultobj = SWIG_Py_Void();
38640 return resultobj;
38641 fail:
38642 return NULL;
38643 }
38644
38645
38646 SWIGINTERN PyObject *_wrap_Menu_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38647 PyObject *resultobj = 0;
38648 wxMenu *arg1 = (wxMenu *) 0 ;
38649 size_t arg2 ;
38650 int arg3 ;
38651 wxString *arg4 = 0 ;
38652 wxString const &arg5_defvalue = wxPyEmptyString ;
38653 wxString *arg5 = (wxString *) &arg5_defvalue ;
38654 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
38655 wxMenuItem *result = 0 ;
38656 void *argp1 = 0 ;
38657 int res1 = 0 ;
38658 size_t val2 ;
38659 int ecode2 = 0 ;
38660 int val3 ;
38661 int ecode3 = 0 ;
38662 bool temp4 = false ;
38663 bool temp5 = false ;
38664 int val6 ;
38665 int ecode6 = 0 ;
38666 PyObject * obj0 = 0 ;
38667 PyObject * obj1 = 0 ;
38668 PyObject * obj2 = 0 ;
38669 PyObject * obj3 = 0 ;
38670 PyObject * obj4 = 0 ;
38671 PyObject * obj5 = 0 ;
38672 char * kwnames[] = {
38673 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
38674 };
38675
38676 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
38677 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38678 if (!SWIG_IsOK(res1)) {
38679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Insert" "', expected argument " "1"" of type '" "wxMenu *""'");
38680 }
38681 arg1 = reinterpret_cast< wxMenu * >(argp1);
38682 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38683 if (!SWIG_IsOK(ecode2)) {
38684 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Insert" "', expected argument " "2"" of type '" "size_t""'");
38685 }
38686 arg2 = static_cast< size_t >(val2);
38687 ecode3 = SWIG_AsVal_int(obj2, &val3);
38688 if (!SWIG_IsOK(ecode3)) {
38689 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Insert" "', expected argument " "3"" of type '" "int""'");
38690 }
38691 arg3 = static_cast< int >(val3);
38692 {
38693 arg4 = wxString_in_helper(obj3);
38694 if (arg4 == NULL) SWIG_fail;
38695 temp4 = true;
38696 }
38697 if (obj4) {
38698 {
38699 arg5 = wxString_in_helper(obj4);
38700 if (arg5 == NULL) SWIG_fail;
38701 temp5 = true;
38702 }
38703 }
38704 if (obj5) {
38705 ecode6 = SWIG_AsVal_int(obj5, &val6);
38706 if (!SWIG_IsOK(ecode6)) {
38707 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Menu_Insert" "', expected argument " "6"" of type '" "wxItemKind""'");
38708 }
38709 arg6 = static_cast< wxItemKind >(val6);
38710 }
38711 {
38712 PyThreadState* __tstate = wxPyBeginAllowThreads();
38713 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6);
38714 wxPyEndAllowThreads(__tstate);
38715 if (PyErr_Occurred()) SWIG_fail;
38716 }
38717 {
38718 resultobj = wxPyMake_wxObject(result, (bool)0);
38719 }
38720 {
38721 if (temp4)
38722 delete arg4;
38723 }
38724 {
38725 if (temp5)
38726 delete arg5;
38727 }
38728 return resultobj;
38729 fail:
38730 {
38731 if (temp4)
38732 delete arg4;
38733 }
38734 {
38735 if (temp5)
38736 delete arg5;
38737 }
38738 return NULL;
38739 }
38740
38741
38742 SWIGINTERN PyObject *_wrap_Menu_InsertSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38743 PyObject *resultobj = 0;
38744 wxMenu *arg1 = (wxMenu *) 0 ;
38745 size_t arg2 ;
38746 wxMenuItem *result = 0 ;
38747 void *argp1 = 0 ;
38748 int res1 = 0 ;
38749 size_t val2 ;
38750 int ecode2 = 0 ;
38751 PyObject * obj0 = 0 ;
38752 PyObject * obj1 = 0 ;
38753 char * kwnames[] = {
38754 (char *) "self",(char *) "pos", NULL
38755 };
38756
38757 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) SWIG_fail;
38758 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38759 if (!SWIG_IsOK(res1)) {
38760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
38761 }
38762 arg1 = reinterpret_cast< wxMenu * >(argp1);
38763 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38764 if (!SWIG_IsOK(ecode2)) {
38765 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertSeparator" "', expected argument " "2"" of type '" "size_t""'");
38766 }
38767 arg2 = static_cast< size_t >(val2);
38768 {
38769 PyThreadState* __tstate = wxPyBeginAllowThreads();
38770 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
38771 wxPyEndAllowThreads(__tstate);
38772 if (PyErr_Occurred()) SWIG_fail;
38773 }
38774 {
38775 resultobj = wxPyMake_wxObject(result, (bool)0);
38776 }
38777 return resultobj;
38778 fail:
38779 return NULL;
38780 }
38781
38782
38783 SWIGINTERN PyObject *_wrap_Menu_InsertCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38784 PyObject *resultobj = 0;
38785 wxMenu *arg1 = (wxMenu *) 0 ;
38786 size_t arg2 ;
38787 int arg3 ;
38788 wxString *arg4 = 0 ;
38789 wxString const &arg5_defvalue = wxPyEmptyString ;
38790 wxString *arg5 = (wxString *) &arg5_defvalue ;
38791 wxMenuItem *result = 0 ;
38792 void *argp1 = 0 ;
38793 int res1 = 0 ;
38794 size_t val2 ;
38795 int ecode2 = 0 ;
38796 int val3 ;
38797 int ecode3 = 0 ;
38798 bool temp4 = false ;
38799 bool temp5 = false ;
38800 PyObject * obj0 = 0 ;
38801 PyObject * obj1 = 0 ;
38802 PyObject * obj2 = 0 ;
38803 PyObject * obj3 = 0 ;
38804 PyObject * obj4 = 0 ;
38805 char * kwnames[] = {
38806 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
38807 };
38808
38809 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38810 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38811 if (!SWIG_IsOK(res1)) {
38812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38813 }
38814 arg1 = reinterpret_cast< wxMenu * >(argp1);
38815 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38816 if (!SWIG_IsOK(ecode2)) {
38817 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertCheckItem" "', expected argument " "2"" of type '" "size_t""'");
38818 }
38819 arg2 = static_cast< size_t >(val2);
38820 ecode3 = SWIG_AsVal_int(obj2, &val3);
38821 if (!SWIG_IsOK(ecode3)) {
38822 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertCheckItem" "', expected argument " "3"" of type '" "int""'");
38823 }
38824 arg3 = static_cast< int >(val3);
38825 {
38826 arg4 = wxString_in_helper(obj3);
38827 if (arg4 == NULL) SWIG_fail;
38828 temp4 = true;
38829 }
38830 if (obj4) {
38831 {
38832 arg5 = wxString_in_helper(obj4);
38833 if (arg5 == NULL) SWIG_fail;
38834 temp5 = true;
38835 }
38836 }
38837 {
38838 PyThreadState* __tstate = wxPyBeginAllowThreads();
38839 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
38840 wxPyEndAllowThreads(__tstate);
38841 if (PyErr_Occurred()) SWIG_fail;
38842 }
38843 {
38844 resultobj = wxPyMake_wxObject(result, (bool)0);
38845 }
38846 {
38847 if (temp4)
38848 delete arg4;
38849 }
38850 {
38851 if (temp5)
38852 delete arg5;
38853 }
38854 return resultobj;
38855 fail:
38856 {
38857 if (temp4)
38858 delete arg4;
38859 }
38860 {
38861 if (temp5)
38862 delete arg5;
38863 }
38864 return NULL;
38865 }
38866
38867
38868 SWIGINTERN PyObject *_wrap_Menu_InsertRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38869 PyObject *resultobj = 0;
38870 wxMenu *arg1 = (wxMenu *) 0 ;
38871 size_t arg2 ;
38872 int arg3 ;
38873 wxString *arg4 = 0 ;
38874 wxString const &arg5_defvalue = wxPyEmptyString ;
38875 wxString *arg5 = (wxString *) &arg5_defvalue ;
38876 wxMenuItem *result = 0 ;
38877 void *argp1 = 0 ;
38878 int res1 = 0 ;
38879 size_t val2 ;
38880 int ecode2 = 0 ;
38881 int val3 ;
38882 int ecode3 = 0 ;
38883 bool temp4 = false ;
38884 bool temp5 = false ;
38885 PyObject * obj0 = 0 ;
38886 PyObject * obj1 = 0 ;
38887 PyObject * obj2 = 0 ;
38888 PyObject * obj3 = 0 ;
38889 PyObject * obj4 = 0 ;
38890 char * kwnames[] = {
38891 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
38892 };
38893
38894 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38895 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38896 if (!SWIG_IsOK(res1)) {
38897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38898 }
38899 arg1 = reinterpret_cast< wxMenu * >(argp1);
38900 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38901 if (!SWIG_IsOK(ecode2)) {
38902 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertRadioItem" "', expected argument " "2"" of type '" "size_t""'");
38903 }
38904 arg2 = static_cast< size_t >(val2);
38905 ecode3 = SWIG_AsVal_int(obj2, &val3);
38906 if (!SWIG_IsOK(ecode3)) {
38907 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertRadioItem" "', expected argument " "3"" of type '" "int""'");
38908 }
38909 arg3 = static_cast< int >(val3);
38910 {
38911 arg4 = wxString_in_helper(obj3);
38912 if (arg4 == NULL) SWIG_fail;
38913 temp4 = true;
38914 }
38915 if (obj4) {
38916 {
38917 arg5 = wxString_in_helper(obj4);
38918 if (arg5 == NULL) SWIG_fail;
38919 temp5 = true;
38920 }
38921 }
38922 {
38923 PyThreadState* __tstate = wxPyBeginAllowThreads();
38924 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
38925 wxPyEndAllowThreads(__tstate);
38926 if (PyErr_Occurred()) SWIG_fail;
38927 }
38928 {
38929 resultobj = wxPyMake_wxObject(result, (bool)0);
38930 }
38931 {
38932 if (temp4)
38933 delete arg4;
38934 }
38935 {
38936 if (temp5)
38937 delete arg5;
38938 }
38939 return resultobj;
38940 fail:
38941 {
38942 if (temp4)
38943 delete arg4;
38944 }
38945 {
38946 if (temp5)
38947 delete arg5;
38948 }
38949 return NULL;
38950 }
38951
38952
38953 SWIGINTERN PyObject *_wrap_Menu_InsertMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38954 PyObject *resultobj = 0;
38955 wxMenu *arg1 = (wxMenu *) 0 ;
38956 size_t arg2 ;
38957 int arg3 ;
38958 wxString *arg4 = 0 ;
38959 wxMenu *arg5 = (wxMenu *) 0 ;
38960 wxString const &arg6_defvalue = wxPyEmptyString ;
38961 wxString *arg6 = (wxString *) &arg6_defvalue ;
38962 wxMenuItem *result = 0 ;
38963 void *argp1 = 0 ;
38964 int res1 = 0 ;
38965 size_t val2 ;
38966 int ecode2 = 0 ;
38967 int val3 ;
38968 int ecode3 = 0 ;
38969 bool temp4 = false ;
38970 void *argp5 = 0 ;
38971 int res5 = 0 ;
38972 bool temp6 = false ;
38973 PyObject * obj0 = 0 ;
38974 PyObject * obj1 = 0 ;
38975 PyObject * obj2 = 0 ;
38976 PyObject * obj3 = 0 ;
38977 PyObject * obj4 = 0 ;
38978 PyObject * obj5 = 0 ;
38979 char * kwnames[] = {
38980 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
38981 };
38982
38983 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
38984 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38985 if (!SWIG_IsOK(res1)) {
38986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
38987 }
38988 arg1 = reinterpret_cast< wxMenu * >(argp1);
38989 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38990 if (!SWIG_IsOK(ecode2)) {
38991 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertMenu" "', expected argument " "2"" of type '" "size_t""'");
38992 }
38993 arg2 = static_cast< size_t >(val2);
38994 ecode3 = SWIG_AsVal_int(obj2, &val3);
38995 if (!SWIG_IsOK(ecode3)) {
38996 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertMenu" "', expected argument " "3"" of type '" "int""'");
38997 }
38998 arg3 = static_cast< int >(val3);
38999 {
39000 arg4 = wxString_in_helper(obj3);
39001 if (arg4 == NULL) SWIG_fail;
39002 temp4 = true;
39003 }
39004 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxMenu, 0 | 0 );
39005 if (!SWIG_IsOK(res5)) {
39006 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Menu_InsertMenu" "', expected argument " "5"" of type '" "wxMenu *""'");
39007 }
39008 arg5 = reinterpret_cast< wxMenu * >(argp5);
39009 if (obj5) {
39010 {
39011 arg6 = wxString_in_helper(obj5);
39012 if (arg6 == NULL) SWIG_fail;
39013 temp6 = true;
39014 }
39015 }
39016 {
39017 PyThreadState* __tstate = wxPyBeginAllowThreads();
39018 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
39019 wxPyEndAllowThreads(__tstate);
39020 if (PyErr_Occurred()) SWIG_fail;
39021 }
39022 {
39023 resultobj = wxPyMake_wxObject(result, (bool)0);
39024 }
39025 {
39026 if (temp4)
39027 delete arg4;
39028 }
39029 {
39030 if (temp6)
39031 delete arg6;
39032 }
39033 return resultobj;
39034 fail:
39035 {
39036 if (temp4)
39037 delete arg4;
39038 }
39039 {
39040 if (temp6)
39041 delete arg6;
39042 }
39043 return NULL;
39044 }
39045
39046
39047 SWIGINTERN PyObject *_wrap_Menu_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39048 PyObject *resultobj = 0;
39049 wxMenu *arg1 = (wxMenu *) 0 ;
39050 int arg2 ;
39051 wxString *arg3 = 0 ;
39052 wxString const &arg4_defvalue = wxPyEmptyString ;
39053 wxString *arg4 = (wxString *) &arg4_defvalue ;
39054 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
39055 wxMenuItem *result = 0 ;
39056 void *argp1 = 0 ;
39057 int res1 = 0 ;
39058 int val2 ;
39059 int ecode2 = 0 ;
39060 bool temp3 = false ;
39061 bool temp4 = false ;
39062 int val5 ;
39063 int ecode5 = 0 ;
39064 PyObject * obj0 = 0 ;
39065 PyObject * obj1 = 0 ;
39066 PyObject * obj2 = 0 ;
39067 PyObject * obj3 = 0 ;
39068 PyObject * obj4 = 0 ;
39069 char * kwnames[] = {
39070 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
39071 };
39072
39073 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39074 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39075 if (!SWIG_IsOK(res1)) {
39076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Prepend" "', expected argument " "1"" of type '" "wxMenu *""'");
39077 }
39078 arg1 = reinterpret_cast< wxMenu * >(argp1);
39079 ecode2 = SWIG_AsVal_int(obj1, &val2);
39080 if (!SWIG_IsOK(ecode2)) {
39081 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Prepend" "', expected argument " "2"" of type '" "int""'");
39082 }
39083 arg2 = static_cast< int >(val2);
39084 {
39085 arg3 = wxString_in_helper(obj2);
39086 if (arg3 == NULL) SWIG_fail;
39087 temp3 = true;
39088 }
39089 if (obj3) {
39090 {
39091 arg4 = wxString_in_helper(obj3);
39092 if (arg4 == NULL) SWIG_fail;
39093 temp4 = true;
39094 }
39095 }
39096 if (obj4) {
39097 ecode5 = SWIG_AsVal_int(obj4, &val5);
39098 if (!SWIG_IsOK(ecode5)) {
39099 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Prepend" "', expected argument " "5"" of type '" "wxItemKind""'");
39100 }
39101 arg5 = static_cast< wxItemKind >(val5);
39102 }
39103 {
39104 PyThreadState* __tstate = wxPyBeginAllowThreads();
39105 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
39106 wxPyEndAllowThreads(__tstate);
39107 if (PyErr_Occurred()) SWIG_fail;
39108 }
39109 {
39110 resultobj = wxPyMake_wxObject(result, (bool)0);
39111 }
39112 {
39113 if (temp3)
39114 delete arg3;
39115 }
39116 {
39117 if (temp4)
39118 delete arg4;
39119 }
39120 return resultobj;
39121 fail:
39122 {
39123 if (temp3)
39124 delete arg3;
39125 }
39126 {
39127 if (temp4)
39128 delete arg4;
39129 }
39130 return NULL;
39131 }
39132
39133
39134 SWIGINTERN PyObject *_wrap_Menu_PrependSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39135 PyObject *resultobj = 0;
39136 wxMenu *arg1 = (wxMenu *) 0 ;
39137 wxMenuItem *result = 0 ;
39138 void *argp1 = 0 ;
39139 int res1 = 0 ;
39140 PyObject *swig_obj[1] ;
39141
39142 if (!args) SWIG_fail;
39143 swig_obj[0] = args;
39144 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39145 if (!SWIG_IsOK(res1)) {
39146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
39147 }
39148 arg1 = reinterpret_cast< wxMenu * >(argp1);
39149 {
39150 PyThreadState* __tstate = wxPyBeginAllowThreads();
39151 result = (wxMenuItem *)(arg1)->PrependSeparator();
39152 wxPyEndAllowThreads(__tstate);
39153 if (PyErr_Occurred()) SWIG_fail;
39154 }
39155 {
39156 resultobj = wxPyMake_wxObject(result, (bool)0);
39157 }
39158 return resultobj;
39159 fail:
39160 return NULL;
39161 }
39162
39163
39164 SWIGINTERN PyObject *_wrap_Menu_PrependCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39165 PyObject *resultobj = 0;
39166 wxMenu *arg1 = (wxMenu *) 0 ;
39167 int arg2 ;
39168 wxString *arg3 = 0 ;
39169 wxString const &arg4_defvalue = wxPyEmptyString ;
39170 wxString *arg4 = (wxString *) &arg4_defvalue ;
39171 wxMenuItem *result = 0 ;
39172 void *argp1 = 0 ;
39173 int res1 = 0 ;
39174 int val2 ;
39175 int ecode2 = 0 ;
39176 bool temp3 = false ;
39177 bool temp4 = false ;
39178 PyObject * obj0 = 0 ;
39179 PyObject * obj1 = 0 ;
39180 PyObject * obj2 = 0 ;
39181 PyObject * obj3 = 0 ;
39182 char * kwnames[] = {
39183 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39184 };
39185
39186 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39187 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39188 if (!SWIG_IsOK(res1)) {
39189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39190 }
39191 arg1 = reinterpret_cast< wxMenu * >(argp1);
39192 ecode2 = SWIG_AsVal_int(obj1, &val2);
39193 if (!SWIG_IsOK(ecode2)) {
39194 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependCheckItem" "', expected argument " "2"" of type '" "int""'");
39195 }
39196 arg2 = static_cast< int >(val2);
39197 {
39198 arg3 = wxString_in_helper(obj2);
39199 if (arg3 == NULL) SWIG_fail;
39200 temp3 = true;
39201 }
39202 if (obj3) {
39203 {
39204 arg4 = wxString_in_helper(obj3);
39205 if (arg4 == NULL) SWIG_fail;
39206 temp4 = true;
39207 }
39208 }
39209 {
39210 PyThreadState* __tstate = wxPyBeginAllowThreads();
39211 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39212 wxPyEndAllowThreads(__tstate);
39213 if (PyErr_Occurred()) SWIG_fail;
39214 }
39215 {
39216 resultobj = wxPyMake_wxObject(result, (bool)0);
39217 }
39218 {
39219 if (temp3)
39220 delete arg3;
39221 }
39222 {
39223 if (temp4)
39224 delete arg4;
39225 }
39226 return resultobj;
39227 fail:
39228 {
39229 if (temp3)
39230 delete arg3;
39231 }
39232 {
39233 if (temp4)
39234 delete arg4;
39235 }
39236 return NULL;
39237 }
39238
39239
39240 SWIGINTERN PyObject *_wrap_Menu_PrependRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39241 PyObject *resultobj = 0;
39242 wxMenu *arg1 = (wxMenu *) 0 ;
39243 int arg2 ;
39244 wxString *arg3 = 0 ;
39245 wxString const &arg4_defvalue = wxPyEmptyString ;
39246 wxString *arg4 = (wxString *) &arg4_defvalue ;
39247 wxMenuItem *result = 0 ;
39248 void *argp1 = 0 ;
39249 int res1 = 0 ;
39250 int val2 ;
39251 int ecode2 = 0 ;
39252 bool temp3 = false ;
39253 bool temp4 = false ;
39254 PyObject * obj0 = 0 ;
39255 PyObject * obj1 = 0 ;
39256 PyObject * obj2 = 0 ;
39257 PyObject * obj3 = 0 ;
39258 char * kwnames[] = {
39259 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39260 };
39261
39262 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39263 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39264 if (!SWIG_IsOK(res1)) {
39265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39266 }
39267 arg1 = reinterpret_cast< wxMenu * >(argp1);
39268 ecode2 = SWIG_AsVal_int(obj1, &val2);
39269 if (!SWIG_IsOK(ecode2)) {
39270 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependRadioItem" "', expected argument " "2"" of type '" "int""'");
39271 }
39272 arg2 = static_cast< int >(val2);
39273 {
39274 arg3 = wxString_in_helper(obj2);
39275 if (arg3 == NULL) SWIG_fail;
39276 temp3 = true;
39277 }
39278 if (obj3) {
39279 {
39280 arg4 = wxString_in_helper(obj3);
39281 if (arg4 == NULL) SWIG_fail;
39282 temp4 = true;
39283 }
39284 }
39285 {
39286 PyThreadState* __tstate = wxPyBeginAllowThreads();
39287 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39288 wxPyEndAllowThreads(__tstate);
39289 if (PyErr_Occurred()) SWIG_fail;
39290 }
39291 {
39292 resultobj = wxPyMake_wxObject(result, (bool)0);
39293 }
39294 {
39295 if (temp3)
39296 delete arg3;
39297 }
39298 {
39299 if (temp4)
39300 delete arg4;
39301 }
39302 return resultobj;
39303 fail:
39304 {
39305 if (temp3)
39306 delete arg3;
39307 }
39308 {
39309 if (temp4)
39310 delete arg4;
39311 }
39312 return NULL;
39313 }
39314
39315
39316 SWIGINTERN PyObject *_wrap_Menu_PrependMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39317 PyObject *resultobj = 0;
39318 wxMenu *arg1 = (wxMenu *) 0 ;
39319 int arg2 ;
39320 wxString *arg3 = 0 ;
39321 wxMenu *arg4 = (wxMenu *) 0 ;
39322 wxString const &arg5_defvalue = wxPyEmptyString ;
39323 wxString *arg5 = (wxString *) &arg5_defvalue ;
39324 wxMenuItem *result = 0 ;
39325 void *argp1 = 0 ;
39326 int res1 = 0 ;
39327 int val2 ;
39328 int ecode2 = 0 ;
39329 bool temp3 = false ;
39330 void *argp4 = 0 ;
39331 int res4 = 0 ;
39332 bool temp5 = false ;
39333 PyObject * obj0 = 0 ;
39334 PyObject * obj1 = 0 ;
39335 PyObject * obj2 = 0 ;
39336 PyObject * obj3 = 0 ;
39337 PyObject * obj4 = 0 ;
39338 char * kwnames[] = {
39339 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39340 };
39341
39342 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39343 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39344 if (!SWIG_IsOK(res1)) {
39345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39346 }
39347 arg1 = reinterpret_cast< wxMenu * >(argp1);
39348 ecode2 = SWIG_AsVal_int(obj1, &val2);
39349 if (!SWIG_IsOK(ecode2)) {
39350 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependMenu" "', expected argument " "2"" of type '" "int""'");
39351 }
39352 arg2 = static_cast< int >(val2);
39353 {
39354 arg3 = wxString_in_helper(obj2);
39355 if (arg3 == NULL) SWIG_fail;
39356 temp3 = true;
39357 }
39358 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
39359 if (!SWIG_IsOK(res4)) {
39360 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_PrependMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
39361 }
39362 arg4 = reinterpret_cast< wxMenu * >(argp4);
39363 if (obj4) {
39364 {
39365 arg5 = wxString_in_helper(obj4);
39366 if (arg5 == NULL) SWIG_fail;
39367 temp5 = true;
39368 }
39369 }
39370 {
39371 PyThreadState* __tstate = wxPyBeginAllowThreads();
39372 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
39373 wxPyEndAllowThreads(__tstate);
39374 if (PyErr_Occurred()) SWIG_fail;
39375 }
39376 {
39377 resultobj = wxPyMake_wxObject(result, (bool)0);
39378 }
39379 {
39380 if (temp3)
39381 delete arg3;
39382 }
39383 {
39384 if (temp5)
39385 delete arg5;
39386 }
39387 return resultobj;
39388 fail:
39389 {
39390 if (temp3)
39391 delete arg3;
39392 }
39393 {
39394 if (temp5)
39395 delete arg5;
39396 }
39397 return NULL;
39398 }
39399
39400
39401 SWIGINTERN PyObject *_wrap_Menu_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39402 PyObject *resultobj = 0;
39403 wxMenu *arg1 = (wxMenu *) 0 ;
39404 int arg2 ;
39405 wxMenuItem *result = 0 ;
39406 void *argp1 = 0 ;
39407 int res1 = 0 ;
39408 int val2 ;
39409 int ecode2 = 0 ;
39410 PyObject * obj0 = 0 ;
39411 PyObject * obj1 = 0 ;
39412 char * kwnames[] = {
39413 (char *) "self",(char *) "id", NULL
39414 };
39415
39416 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
39417 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39418 if (!SWIG_IsOK(res1)) {
39419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Remove" "', expected argument " "1"" of type '" "wxMenu *""'");
39420 }
39421 arg1 = reinterpret_cast< wxMenu * >(argp1);
39422 ecode2 = SWIG_AsVal_int(obj1, &val2);
39423 if (!SWIG_IsOK(ecode2)) {
39424 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Remove" "', expected argument " "2"" of type '" "int""'");
39425 }
39426 arg2 = static_cast< int >(val2);
39427 {
39428 PyThreadState* __tstate = wxPyBeginAllowThreads();
39429 result = (wxMenuItem *)(arg1)->Remove(arg2);
39430 wxPyEndAllowThreads(__tstate);
39431 if (PyErr_Occurred()) SWIG_fail;
39432 }
39433 {
39434 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
39435 }
39436 return resultobj;
39437 fail:
39438 return NULL;
39439 }
39440
39441
39442 SWIGINTERN PyObject *_wrap_Menu_RemoveItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39443 PyObject *resultobj = 0;
39444 wxMenu *arg1 = (wxMenu *) 0 ;
39445 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39446 wxMenuItem *result = 0 ;
39447 void *argp1 = 0 ;
39448 int res1 = 0 ;
39449 void *argp2 = 0 ;
39450 int res2 = 0 ;
39451 PyObject * obj0 = 0 ;
39452 PyObject * obj1 = 0 ;
39453 char * kwnames[] = {
39454 (char *) "self",(char *) "item", NULL
39455 };
39456
39457 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) SWIG_fail;
39458 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39459 if (!SWIG_IsOK(res1)) {
39460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_RemoveItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39461 }
39462 arg1 = reinterpret_cast< wxMenu * >(argp1);
39463 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39464 if (!SWIG_IsOK(res2)) {
39465 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_RemoveItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39466 }
39467 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39468 {
39469 PyThreadState* __tstate = wxPyBeginAllowThreads();
39470 result = (wxMenuItem *)(arg1)->Remove(arg2);
39471 wxPyEndAllowThreads(__tstate);
39472 if (PyErr_Occurred()) SWIG_fail;
39473 }
39474 {
39475 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
39476 }
39477 return resultobj;
39478 fail:
39479 return NULL;
39480 }
39481
39482
39483 SWIGINTERN PyObject *_wrap_Menu_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39484 PyObject *resultobj = 0;
39485 wxMenu *arg1 = (wxMenu *) 0 ;
39486 int arg2 ;
39487 bool result;
39488 void *argp1 = 0 ;
39489 int res1 = 0 ;
39490 int val2 ;
39491 int ecode2 = 0 ;
39492 PyObject * obj0 = 0 ;
39493 PyObject * obj1 = 0 ;
39494 char * kwnames[] = {
39495 (char *) "self",(char *) "id", NULL
39496 };
39497
39498 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
39499 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39500 if (!SWIG_IsOK(res1)) {
39501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Delete" "', expected argument " "1"" of type '" "wxMenu *""'");
39502 }
39503 arg1 = reinterpret_cast< wxMenu * >(argp1);
39504 ecode2 = SWIG_AsVal_int(obj1, &val2);
39505 if (!SWIG_IsOK(ecode2)) {
39506 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Delete" "', expected argument " "2"" of type '" "int""'");
39507 }
39508 arg2 = static_cast< int >(val2);
39509 {
39510 PyThreadState* __tstate = wxPyBeginAllowThreads();
39511 result = (bool)(arg1)->Delete(arg2);
39512 wxPyEndAllowThreads(__tstate);
39513 if (PyErr_Occurred()) SWIG_fail;
39514 }
39515 {
39516 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39517 }
39518 return resultobj;
39519 fail:
39520 return NULL;
39521 }
39522
39523
39524 SWIGINTERN PyObject *_wrap_Menu_DeleteItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39525 PyObject *resultobj = 0;
39526 wxMenu *arg1 = (wxMenu *) 0 ;
39527 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39528 bool result;
39529 void *argp1 = 0 ;
39530 int res1 = 0 ;
39531 void *argp2 = 0 ;
39532 int res2 = 0 ;
39533 PyObject * obj0 = 0 ;
39534 PyObject * obj1 = 0 ;
39535 char * kwnames[] = {
39536 (char *) "self",(char *) "item", NULL
39537 };
39538
39539 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) SWIG_fail;
39540 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39541 if (!SWIG_IsOK(res1)) {
39542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DeleteItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39543 }
39544 arg1 = reinterpret_cast< wxMenu * >(argp1);
39545 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39546 if (!SWIG_IsOK(res2)) {
39547 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DeleteItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39548 }
39549 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39550 {
39551 PyThreadState* __tstate = wxPyBeginAllowThreads();
39552 result = (bool)(arg1)->Delete(arg2);
39553 wxPyEndAllowThreads(__tstate);
39554 if (PyErr_Occurred()) SWIG_fail;
39555 }
39556 {
39557 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39558 }
39559 return resultobj;
39560 fail:
39561 return NULL;
39562 }
39563
39564
39565 SWIGINTERN PyObject *_wrap_Menu_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39566 PyObject *resultobj = 0;
39567 wxMenu *arg1 = (wxMenu *) 0 ;
39568 void *argp1 = 0 ;
39569 int res1 = 0 ;
39570 PyObject *swig_obj[1] ;
39571
39572 if (!args) SWIG_fail;
39573 swig_obj[0] = args;
39574 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39575 if (!SWIG_IsOK(res1)) {
39576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Destroy" "', expected argument " "1"" of type '" "wxMenu *""'");
39577 }
39578 arg1 = reinterpret_cast< wxMenu * >(argp1);
39579 {
39580 PyThreadState* __tstate = wxPyBeginAllowThreads();
39581 wxMenu_Destroy(arg1);
39582 wxPyEndAllowThreads(__tstate);
39583 if (PyErr_Occurred()) SWIG_fail;
39584 }
39585 resultobj = SWIG_Py_Void();
39586 return resultobj;
39587 fail:
39588 return NULL;
39589 }
39590
39591
39592 SWIGINTERN PyObject *_wrap_Menu_DestroyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39593 PyObject *resultobj = 0;
39594 wxMenu *arg1 = (wxMenu *) 0 ;
39595 int arg2 ;
39596 bool result;
39597 void *argp1 = 0 ;
39598 int res1 = 0 ;
39599 int val2 ;
39600 int ecode2 = 0 ;
39601 PyObject * obj0 = 0 ;
39602 PyObject * obj1 = 0 ;
39603 char * kwnames[] = {
39604 (char *) "self",(char *) "id", NULL
39605 };
39606
39607 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) SWIG_fail;
39608 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39609 if (!SWIG_IsOK(res1)) {
39610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyId" "', expected argument " "1"" of type '" "wxMenu *""'");
39611 }
39612 arg1 = reinterpret_cast< wxMenu * >(argp1);
39613 ecode2 = SWIG_AsVal_int(obj1, &val2);
39614 if (!SWIG_IsOK(ecode2)) {
39615 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_DestroyId" "', expected argument " "2"" of type '" "int""'");
39616 }
39617 arg2 = static_cast< int >(val2);
39618 {
39619 PyThreadState* __tstate = wxPyBeginAllowThreads();
39620 result = (bool)(arg1)->Destroy(arg2);
39621 wxPyEndAllowThreads(__tstate);
39622 if (PyErr_Occurred()) SWIG_fail;
39623 }
39624 {
39625 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39626 }
39627 return resultobj;
39628 fail:
39629 return NULL;
39630 }
39631
39632
39633 SWIGINTERN PyObject *_wrap_Menu_DestroyItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39634 PyObject *resultobj = 0;
39635 wxMenu *arg1 = (wxMenu *) 0 ;
39636 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39637 bool result;
39638 void *argp1 = 0 ;
39639 int res1 = 0 ;
39640 void *argp2 = 0 ;
39641 int res2 = 0 ;
39642 PyObject * obj0 = 0 ;
39643 PyObject * obj1 = 0 ;
39644 char * kwnames[] = {
39645 (char *) "self",(char *) "item", NULL
39646 };
39647
39648 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) SWIG_fail;
39649 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39650 if (!SWIG_IsOK(res1)) {
39651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39652 }
39653 arg1 = reinterpret_cast< wxMenu * >(argp1);
39654 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39655 if (!SWIG_IsOK(res2)) {
39656 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DestroyItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39657 }
39658 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39659 {
39660 PyThreadState* __tstate = wxPyBeginAllowThreads();
39661 result = (bool)(arg1)->Destroy(arg2);
39662 wxPyEndAllowThreads(__tstate);
39663 if (PyErr_Occurred()) SWIG_fail;
39664 }
39665 {
39666 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39667 }
39668 return resultobj;
39669 fail:
39670 return NULL;
39671 }
39672
39673
39674 SWIGINTERN PyObject *_wrap_Menu_GetMenuItemCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39675 PyObject *resultobj = 0;
39676 wxMenu *arg1 = (wxMenu *) 0 ;
39677 size_t result;
39678 void *argp1 = 0 ;
39679 int res1 = 0 ;
39680 PyObject *swig_obj[1] ;
39681
39682 if (!args) SWIG_fail;
39683 swig_obj[0] = args;
39684 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39685 if (!SWIG_IsOK(res1)) {
39686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItemCount" "', expected argument " "1"" of type '" "wxMenu const *""'");
39687 }
39688 arg1 = reinterpret_cast< wxMenu * >(argp1);
39689 {
39690 PyThreadState* __tstate = wxPyBeginAllowThreads();
39691 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
39692 wxPyEndAllowThreads(__tstate);
39693 if (PyErr_Occurred()) SWIG_fail;
39694 }
39695 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
39696 return resultobj;
39697 fail:
39698 return NULL;
39699 }
39700
39701
39702 SWIGINTERN PyObject *_wrap_Menu_GetMenuItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39703 PyObject *resultobj = 0;
39704 wxMenu *arg1 = (wxMenu *) 0 ;
39705 PyObject *result = 0 ;
39706 void *argp1 = 0 ;
39707 int res1 = 0 ;
39708 PyObject *swig_obj[1] ;
39709
39710 if (!args) SWIG_fail;
39711 swig_obj[0] = args;
39712 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39713 if (!SWIG_IsOK(res1)) {
39714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItems" "', expected argument " "1"" of type '" "wxMenu *""'");
39715 }
39716 arg1 = reinterpret_cast< wxMenu * >(argp1);
39717 {
39718 PyThreadState* __tstate = wxPyBeginAllowThreads();
39719 result = (PyObject *)wxMenu_GetMenuItems(arg1);
39720 wxPyEndAllowThreads(__tstate);
39721 if (PyErr_Occurred()) SWIG_fail;
39722 }
39723 resultobj = result;
39724 return resultobj;
39725 fail:
39726 return NULL;
39727 }
39728
39729
39730 SWIGINTERN PyObject *_wrap_Menu_FindItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39731 PyObject *resultobj = 0;
39732 wxMenu *arg1 = (wxMenu *) 0 ;
39733 wxString *arg2 = 0 ;
39734 int result;
39735 void *argp1 = 0 ;
39736 int res1 = 0 ;
39737 bool temp2 = false ;
39738 PyObject * obj0 = 0 ;
39739 PyObject * obj1 = 0 ;
39740 char * kwnames[] = {
39741 (char *) "self",(char *) "item", NULL
39742 };
39743
39744 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) SWIG_fail;
39745 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39746 if (!SWIG_IsOK(res1)) {
39747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItem" "', expected argument " "1"" of type '" "wxMenu const *""'");
39748 }
39749 arg1 = reinterpret_cast< wxMenu * >(argp1);
39750 {
39751 arg2 = wxString_in_helper(obj1);
39752 if (arg2 == NULL) SWIG_fail;
39753 temp2 = true;
39754 }
39755 {
39756 PyThreadState* __tstate = wxPyBeginAllowThreads();
39757 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
39758 wxPyEndAllowThreads(__tstate);
39759 if (PyErr_Occurred()) SWIG_fail;
39760 }
39761 resultobj = SWIG_From_int(static_cast< int >(result));
39762 {
39763 if (temp2)
39764 delete arg2;
39765 }
39766 return resultobj;
39767 fail:
39768 {
39769 if (temp2)
39770 delete arg2;
39771 }
39772 return NULL;
39773 }
39774
39775
39776 SWIGINTERN PyObject *_wrap_Menu_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39777 PyObject *resultobj = 0;
39778 wxMenu *arg1 = (wxMenu *) 0 ;
39779 int arg2 ;
39780 wxMenuItem *result = 0 ;
39781 void *argp1 = 0 ;
39782 int res1 = 0 ;
39783 int val2 ;
39784 int ecode2 = 0 ;
39785 PyObject * obj0 = 0 ;
39786 PyObject * obj1 = 0 ;
39787 char * kwnames[] = {
39788 (char *) "self",(char *) "id", NULL
39789 };
39790
39791 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
39792 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39793 if (!SWIG_IsOK(res1)) {
39794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemById" "', expected argument " "1"" of type '" "wxMenu const *""'");
39795 }
39796 arg1 = reinterpret_cast< wxMenu * >(argp1);
39797 ecode2 = SWIG_AsVal_int(obj1, &val2);
39798 if (!SWIG_IsOK(ecode2)) {
39799 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemById" "', expected argument " "2"" of type '" "int""'");
39800 }
39801 arg2 = static_cast< int >(val2);
39802 {
39803 PyThreadState* __tstate = wxPyBeginAllowThreads();
39804 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
39805 wxPyEndAllowThreads(__tstate);
39806 if (PyErr_Occurred()) SWIG_fail;
39807 }
39808 {
39809 resultobj = wxPyMake_wxObject(result, (bool)0);
39810 }
39811 return resultobj;
39812 fail:
39813 return NULL;
39814 }
39815
39816
39817 SWIGINTERN PyObject *_wrap_Menu_FindItemByPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39818 PyObject *resultobj = 0;
39819 wxMenu *arg1 = (wxMenu *) 0 ;
39820 size_t arg2 ;
39821 wxMenuItem *result = 0 ;
39822 void *argp1 = 0 ;
39823 int res1 = 0 ;
39824 size_t val2 ;
39825 int ecode2 = 0 ;
39826 PyObject * obj0 = 0 ;
39827 PyObject * obj1 = 0 ;
39828 char * kwnames[] = {
39829 (char *) "self",(char *) "position", NULL
39830 };
39831
39832 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) SWIG_fail;
39833 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39834 if (!SWIG_IsOK(res1)) {
39835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemByPosition" "', expected argument " "1"" of type '" "wxMenu const *""'");
39836 }
39837 arg1 = reinterpret_cast< wxMenu * >(argp1);
39838 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39839 if (!SWIG_IsOK(ecode2)) {
39840 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemByPosition" "', expected argument " "2"" of type '" "size_t""'");
39841 }
39842 arg2 = static_cast< size_t >(val2);
39843 {
39844 PyThreadState* __tstate = wxPyBeginAllowThreads();
39845 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
39846 wxPyEndAllowThreads(__tstate);
39847 if (PyErr_Occurred()) SWIG_fail;
39848 }
39849 {
39850 resultobj = wxPyMake_wxObject(result, (bool)0);
39851 }
39852 return resultobj;
39853 fail:
39854 return NULL;
39855 }
39856
39857
39858 SWIGINTERN PyObject *_wrap_Menu_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39859 PyObject *resultobj = 0;
39860 wxMenu *arg1 = (wxMenu *) 0 ;
39861 int arg2 ;
39862 bool arg3 ;
39863 void *argp1 = 0 ;
39864 int res1 = 0 ;
39865 int val2 ;
39866 int ecode2 = 0 ;
39867 bool val3 ;
39868 int ecode3 = 0 ;
39869 PyObject * obj0 = 0 ;
39870 PyObject * obj1 = 0 ;
39871 PyObject * obj2 = 0 ;
39872 char * kwnames[] = {
39873 (char *) "self",(char *) "id",(char *) "enable", NULL
39874 };
39875
39876 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39877 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39878 if (!SWIG_IsOK(res1)) {
39879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Enable" "', expected argument " "1"" of type '" "wxMenu *""'");
39880 }
39881 arg1 = reinterpret_cast< wxMenu * >(argp1);
39882 ecode2 = SWIG_AsVal_int(obj1, &val2);
39883 if (!SWIG_IsOK(ecode2)) {
39884 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Enable" "', expected argument " "2"" of type '" "int""'");
39885 }
39886 arg2 = static_cast< int >(val2);
39887 ecode3 = SWIG_AsVal_bool(obj2, &val3);
39888 if (!SWIG_IsOK(ecode3)) {
39889 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Enable" "', expected argument " "3"" of type '" "bool""'");
39890 }
39891 arg3 = static_cast< bool >(val3);
39892 {
39893 PyThreadState* __tstate = wxPyBeginAllowThreads();
39894 (arg1)->Enable(arg2,arg3);
39895 wxPyEndAllowThreads(__tstate);
39896 if (PyErr_Occurred()) SWIG_fail;
39897 }
39898 resultobj = SWIG_Py_Void();
39899 return resultobj;
39900 fail:
39901 return NULL;
39902 }
39903
39904
39905 SWIGINTERN PyObject *_wrap_Menu_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39906 PyObject *resultobj = 0;
39907 wxMenu *arg1 = (wxMenu *) 0 ;
39908 int arg2 ;
39909 bool result;
39910 void *argp1 = 0 ;
39911 int res1 = 0 ;
39912 int val2 ;
39913 int ecode2 = 0 ;
39914 PyObject * obj0 = 0 ;
39915 PyObject * obj1 = 0 ;
39916 char * kwnames[] = {
39917 (char *) "self",(char *) "id", NULL
39918 };
39919
39920 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
39921 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39922 if (!SWIG_IsOK(res1)) {
39923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsEnabled" "', expected argument " "1"" of type '" "wxMenu const *""'");
39924 }
39925 arg1 = reinterpret_cast< wxMenu * >(argp1);
39926 ecode2 = SWIG_AsVal_int(obj1, &val2);
39927 if (!SWIG_IsOK(ecode2)) {
39928 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsEnabled" "', expected argument " "2"" of type '" "int""'");
39929 }
39930 arg2 = static_cast< int >(val2);
39931 {
39932 PyThreadState* __tstate = wxPyBeginAllowThreads();
39933 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
39934 wxPyEndAllowThreads(__tstate);
39935 if (PyErr_Occurred()) SWIG_fail;
39936 }
39937 {
39938 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39939 }
39940 return resultobj;
39941 fail:
39942 return NULL;
39943 }
39944
39945
39946 SWIGINTERN PyObject *_wrap_Menu_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39947 PyObject *resultobj = 0;
39948 wxMenu *arg1 = (wxMenu *) 0 ;
39949 int arg2 ;
39950 bool arg3 ;
39951 void *argp1 = 0 ;
39952 int res1 = 0 ;
39953 int val2 ;
39954 int ecode2 = 0 ;
39955 bool val3 ;
39956 int ecode3 = 0 ;
39957 PyObject * obj0 = 0 ;
39958 PyObject * obj1 = 0 ;
39959 PyObject * obj2 = 0 ;
39960 char * kwnames[] = {
39961 (char *) "self",(char *) "id",(char *) "check", NULL
39962 };
39963
39964 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39965 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39966 if (!SWIG_IsOK(res1)) {
39967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Check" "', expected argument " "1"" of type '" "wxMenu *""'");
39968 }
39969 arg1 = reinterpret_cast< wxMenu * >(argp1);
39970 ecode2 = SWIG_AsVal_int(obj1, &val2);
39971 if (!SWIG_IsOK(ecode2)) {
39972 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Check" "', expected argument " "2"" of type '" "int""'");
39973 }
39974 arg2 = static_cast< int >(val2);
39975 ecode3 = SWIG_AsVal_bool(obj2, &val3);
39976 if (!SWIG_IsOK(ecode3)) {
39977 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Check" "', expected argument " "3"" of type '" "bool""'");
39978 }
39979 arg3 = static_cast< bool >(val3);
39980 {
39981 PyThreadState* __tstate = wxPyBeginAllowThreads();
39982 (arg1)->Check(arg2,arg3);
39983 wxPyEndAllowThreads(__tstate);
39984 if (PyErr_Occurred()) SWIG_fail;
39985 }
39986 resultobj = SWIG_Py_Void();
39987 return resultobj;
39988 fail:
39989 return NULL;
39990 }
39991
39992
39993 SWIGINTERN PyObject *_wrap_Menu_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39994 PyObject *resultobj = 0;
39995 wxMenu *arg1 = (wxMenu *) 0 ;
39996 int arg2 ;
39997 bool result;
39998 void *argp1 = 0 ;
39999 int res1 = 0 ;
40000 int val2 ;
40001 int ecode2 = 0 ;
40002 PyObject * obj0 = 0 ;
40003 PyObject * obj1 = 0 ;
40004 char * kwnames[] = {
40005 (char *) "self",(char *) "id", NULL
40006 };
40007
40008 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
40009 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40010 if (!SWIG_IsOK(res1)) {
40011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsChecked" "', expected argument " "1"" of type '" "wxMenu const *""'");
40012 }
40013 arg1 = reinterpret_cast< wxMenu * >(argp1);
40014 ecode2 = SWIG_AsVal_int(obj1, &val2);
40015 if (!SWIG_IsOK(ecode2)) {
40016 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsChecked" "', expected argument " "2"" of type '" "int""'");
40017 }
40018 arg2 = static_cast< int >(val2);
40019 {
40020 PyThreadState* __tstate = wxPyBeginAllowThreads();
40021 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
40022 wxPyEndAllowThreads(__tstate);
40023 if (PyErr_Occurred()) SWIG_fail;
40024 }
40025 {
40026 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40027 }
40028 return resultobj;
40029 fail:
40030 return NULL;
40031 }
40032
40033
40034 SWIGINTERN PyObject *_wrap_Menu_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40035 PyObject *resultobj = 0;
40036 wxMenu *arg1 = (wxMenu *) 0 ;
40037 int arg2 ;
40038 wxString *arg3 = 0 ;
40039 void *argp1 = 0 ;
40040 int res1 = 0 ;
40041 int val2 ;
40042 int ecode2 = 0 ;
40043 bool temp3 = false ;
40044 PyObject * obj0 = 0 ;
40045 PyObject * obj1 = 0 ;
40046 PyObject * obj2 = 0 ;
40047 char * kwnames[] = {
40048 (char *) "self",(char *) "id",(char *) "label", NULL
40049 };
40050
40051 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40052 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40053 if (!SWIG_IsOK(res1)) {
40054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetLabel" "', expected argument " "1"" of type '" "wxMenu *""'");
40055 }
40056 arg1 = reinterpret_cast< wxMenu * >(argp1);
40057 ecode2 = SWIG_AsVal_int(obj1, &val2);
40058 if (!SWIG_IsOK(ecode2)) {
40059 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetLabel" "', expected argument " "2"" of type '" "int""'");
40060 }
40061 arg2 = static_cast< int >(val2);
40062 {
40063 arg3 = wxString_in_helper(obj2);
40064 if (arg3 == NULL) SWIG_fail;
40065 temp3 = true;
40066 }
40067 {
40068 PyThreadState* __tstate = wxPyBeginAllowThreads();
40069 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
40070 wxPyEndAllowThreads(__tstate);
40071 if (PyErr_Occurred()) SWIG_fail;
40072 }
40073 resultobj = SWIG_Py_Void();
40074 {
40075 if (temp3)
40076 delete arg3;
40077 }
40078 return resultobj;
40079 fail:
40080 {
40081 if (temp3)
40082 delete arg3;
40083 }
40084 return NULL;
40085 }
40086
40087
40088 SWIGINTERN PyObject *_wrap_Menu_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40089 PyObject *resultobj = 0;
40090 wxMenu *arg1 = (wxMenu *) 0 ;
40091 int arg2 ;
40092 wxString result;
40093 void *argp1 = 0 ;
40094 int res1 = 0 ;
40095 int val2 ;
40096 int ecode2 = 0 ;
40097 PyObject * obj0 = 0 ;
40098 PyObject * obj1 = 0 ;
40099 char * kwnames[] = {
40100 (char *) "self",(char *) "id", NULL
40101 };
40102
40103 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
40104 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40105 if (!SWIG_IsOK(res1)) {
40106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetLabel" "', expected argument " "1"" of type '" "wxMenu const *""'");
40107 }
40108 arg1 = reinterpret_cast< wxMenu * >(argp1);
40109 ecode2 = SWIG_AsVal_int(obj1, &val2);
40110 if (!SWIG_IsOK(ecode2)) {
40111 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetLabel" "', expected argument " "2"" of type '" "int""'");
40112 }
40113 arg2 = static_cast< int >(val2);
40114 {
40115 PyThreadState* __tstate = wxPyBeginAllowThreads();
40116 result = ((wxMenu const *)arg1)->GetLabel(arg2);
40117 wxPyEndAllowThreads(__tstate);
40118 if (PyErr_Occurred()) SWIG_fail;
40119 }
40120 {
40121 #if wxUSE_UNICODE
40122 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40123 #else
40124 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40125 #endif
40126 }
40127 return resultobj;
40128 fail:
40129 return NULL;
40130 }
40131
40132
40133 SWIGINTERN PyObject *_wrap_Menu_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40134 PyObject *resultobj = 0;
40135 wxMenu *arg1 = (wxMenu *) 0 ;
40136 int arg2 ;
40137 wxString *arg3 = 0 ;
40138 void *argp1 = 0 ;
40139 int res1 = 0 ;
40140 int val2 ;
40141 int ecode2 = 0 ;
40142 bool temp3 = false ;
40143 PyObject * obj0 = 0 ;
40144 PyObject * obj1 = 0 ;
40145 PyObject * obj2 = 0 ;
40146 char * kwnames[] = {
40147 (char *) "self",(char *) "id",(char *) "helpString", NULL
40148 };
40149
40150 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40151 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40152 if (!SWIG_IsOK(res1)) {
40153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetHelpString" "', expected argument " "1"" of type '" "wxMenu *""'");
40154 }
40155 arg1 = reinterpret_cast< wxMenu * >(argp1);
40156 ecode2 = SWIG_AsVal_int(obj1, &val2);
40157 if (!SWIG_IsOK(ecode2)) {
40158 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetHelpString" "', expected argument " "2"" of type '" "int""'");
40159 }
40160 arg2 = static_cast< int >(val2);
40161 {
40162 arg3 = wxString_in_helper(obj2);
40163 if (arg3 == NULL) SWIG_fail;
40164 temp3 = true;
40165 }
40166 {
40167 PyThreadState* __tstate = wxPyBeginAllowThreads();
40168 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
40169 wxPyEndAllowThreads(__tstate);
40170 if (PyErr_Occurred()) SWIG_fail;
40171 }
40172 resultobj = SWIG_Py_Void();
40173 {
40174 if (temp3)
40175 delete arg3;
40176 }
40177 return resultobj;
40178 fail:
40179 {
40180 if (temp3)
40181 delete arg3;
40182 }
40183 return NULL;
40184 }
40185
40186
40187 SWIGINTERN PyObject *_wrap_Menu_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40188 PyObject *resultobj = 0;
40189 wxMenu *arg1 = (wxMenu *) 0 ;
40190 int arg2 ;
40191 wxString result;
40192 void *argp1 = 0 ;
40193 int res1 = 0 ;
40194 int val2 ;
40195 int ecode2 = 0 ;
40196 PyObject * obj0 = 0 ;
40197 PyObject * obj1 = 0 ;
40198 char * kwnames[] = {
40199 (char *) "self",(char *) "id", NULL
40200 };
40201
40202 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
40203 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40204 if (!SWIG_IsOK(res1)) {
40205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetHelpString" "', expected argument " "1"" of type '" "wxMenu const *""'");
40206 }
40207 arg1 = reinterpret_cast< wxMenu * >(argp1);
40208 ecode2 = SWIG_AsVal_int(obj1, &val2);
40209 if (!SWIG_IsOK(ecode2)) {
40210 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetHelpString" "', expected argument " "2"" of type '" "int""'");
40211 }
40212 arg2 = static_cast< int >(val2);
40213 {
40214 PyThreadState* __tstate = wxPyBeginAllowThreads();
40215 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
40216 wxPyEndAllowThreads(__tstate);
40217 if (PyErr_Occurred()) SWIG_fail;
40218 }
40219 {
40220 #if wxUSE_UNICODE
40221 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40222 #else
40223 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40224 #endif
40225 }
40226 return resultobj;
40227 fail:
40228 return NULL;
40229 }
40230
40231
40232 SWIGINTERN PyObject *_wrap_Menu_SetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40233 PyObject *resultobj = 0;
40234 wxMenu *arg1 = (wxMenu *) 0 ;
40235 wxString *arg2 = 0 ;
40236 void *argp1 = 0 ;
40237 int res1 = 0 ;
40238 bool temp2 = false ;
40239 PyObject * obj0 = 0 ;
40240 PyObject * obj1 = 0 ;
40241 char * kwnames[] = {
40242 (char *) "self",(char *) "title", NULL
40243 };
40244
40245 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) SWIG_fail;
40246 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40247 if (!SWIG_IsOK(res1)) {
40248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetTitle" "', expected argument " "1"" of type '" "wxMenu *""'");
40249 }
40250 arg1 = reinterpret_cast< wxMenu * >(argp1);
40251 {
40252 arg2 = wxString_in_helper(obj1);
40253 if (arg2 == NULL) SWIG_fail;
40254 temp2 = true;
40255 }
40256 {
40257 PyThreadState* __tstate = wxPyBeginAllowThreads();
40258 (arg1)->SetTitle((wxString const &)*arg2);
40259 wxPyEndAllowThreads(__tstate);
40260 if (PyErr_Occurred()) SWIG_fail;
40261 }
40262 resultobj = SWIG_Py_Void();
40263 {
40264 if (temp2)
40265 delete arg2;
40266 }
40267 return resultobj;
40268 fail:
40269 {
40270 if (temp2)
40271 delete arg2;
40272 }
40273 return NULL;
40274 }
40275
40276
40277 SWIGINTERN PyObject *_wrap_Menu_GetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40278 PyObject *resultobj = 0;
40279 wxMenu *arg1 = (wxMenu *) 0 ;
40280 wxString result;
40281 void *argp1 = 0 ;
40282 int res1 = 0 ;
40283 PyObject *swig_obj[1] ;
40284
40285 if (!args) SWIG_fail;
40286 swig_obj[0] = args;
40287 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40288 if (!SWIG_IsOK(res1)) {
40289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetTitle" "', expected argument " "1"" of type '" "wxMenu const *""'");
40290 }
40291 arg1 = reinterpret_cast< wxMenu * >(argp1);
40292 {
40293 PyThreadState* __tstate = wxPyBeginAllowThreads();
40294 result = ((wxMenu const *)arg1)->GetTitle();
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_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40312 PyObject *resultobj = 0;
40313 wxMenu *arg1 = (wxMenu *) 0 ;
40314 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
40315 void *argp1 = 0 ;
40316 int res1 = 0 ;
40317 void *argp2 = 0 ;
40318 int res2 = 0 ;
40319 PyObject * obj0 = 0 ;
40320 PyObject * obj1 = 0 ;
40321 char * kwnames[] = {
40322 (char *) "self",(char *) "handler", NULL
40323 };
40324
40325 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
40326 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40327 if (!SWIG_IsOK(res1)) {
40328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetEventHandler" "', expected argument " "1"" of type '" "wxMenu *""'");
40329 }
40330 arg1 = reinterpret_cast< wxMenu * >(argp1);
40331 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
40332 if (!SWIG_IsOK(res2)) {
40333 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
40334 }
40335 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
40336 {
40337 PyThreadState* __tstate = wxPyBeginAllowThreads();
40338 (arg1)->SetEventHandler(arg2);
40339 wxPyEndAllowThreads(__tstate);
40340 if (PyErr_Occurred()) SWIG_fail;
40341 }
40342 resultobj = SWIG_Py_Void();
40343 return resultobj;
40344 fail:
40345 return NULL;
40346 }
40347
40348
40349 SWIGINTERN PyObject *_wrap_Menu_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40350 PyObject *resultobj = 0;
40351 wxMenu *arg1 = (wxMenu *) 0 ;
40352 wxEvtHandler *result = 0 ;
40353 void *argp1 = 0 ;
40354 int res1 = 0 ;
40355 PyObject *swig_obj[1] ;
40356
40357 if (!args) SWIG_fail;
40358 swig_obj[0] = args;
40359 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40360 if (!SWIG_IsOK(res1)) {
40361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetEventHandler" "', expected argument " "1"" of type '" "wxMenu const *""'");
40362 }
40363 arg1 = reinterpret_cast< wxMenu * >(argp1);
40364 {
40365 PyThreadState* __tstate = wxPyBeginAllowThreads();
40366 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
40367 wxPyEndAllowThreads(__tstate);
40368 if (PyErr_Occurred()) SWIG_fail;
40369 }
40370 {
40371 resultobj = wxPyMake_wxObject(result, 0);
40372 }
40373 return resultobj;
40374 fail:
40375 return NULL;
40376 }
40377
40378
40379 SWIGINTERN PyObject *_wrap_Menu_SetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40380 PyObject *resultobj = 0;
40381 wxMenu *arg1 = (wxMenu *) 0 ;
40382 wxWindow *arg2 = (wxWindow *) 0 ;
40383 void *argp1 = 0 ;
40384 int res1 = 0 ;
40385 void *argp2 = 0 ;
40386 int res2 = 0 ;
40387 PyObject * obj0 = 0 ;
40388 PyObject * obj1 = 0 ;
40389 char * kwnames[] = {
40390 (char *) "self",(char *) "win", NULL
40391 };
40392
40393 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
40394 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40395 if (!SWIG_IsOK(res1)) {
40396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu *""'");
40397 }
40398 arg1 = reinterpret_cast< wxMenu * >(argp1);
40399 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
40400 if (!SWIG_IsOK(res2)) {
40401 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetInvokingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
40402 }
40403 arg2 = reinterpret_cast< wxWindow * >(argp2);
40404 {
40405 PyThreadState* __tstate = wxPyBeginAllowThreads();
40406 (arg1)->SetInvokingWindow(arg2);
40407 wxPyEndAllowThreads(__tstate);
40408 if (PyErr_Occurred()) SWIG_fail;
40409 }
40410 resultobj = SWIG_Py_Void();
40411 return resultobj;
40412 fail:
40413 return NULL;
40414 }
40415
40416
40417 SWIGINTERN PyObject *_wrap_Menu_GetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40418 PyObject *resultobj = 0;
40419 wxMenu *arg1 = (wxMenu *) 0 ;
40420 wxWindow *result = 0 ;
40421 void *argp1 = 0 ;
40422 int res1 = 0 ;
40423 PyObject *swig_obj[1] ;
40424
40425 if (!args) SWIG_fail;
40426 swig_obj[0] = args;
40427 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40428 if (!SWIG_IsOK(res1)) {
40429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu const *""'");
40430 }
40431 arg1 = reinterpret_cast< wxMenu * >(argp1);
40432 {
40433 PyThreadState* __tstate = wxPyBeginAllowThreads();
40434 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
40435 wxPyEndAllowThreads(__tstate);
40436 if (PyErr_Occurred()) SWIG_fail;
40437 }
40438 {
40439 resultobj = wxPyMake_wxObject(result, 0);
40440 }
40441 return resultobj;
40442 fail:
40443 return NULL;
40444 }
40445
40446
40447 SWIGINTERN PyObject *_wrap_Menu_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40448 PyObject *resultobj = 0;
40449 wxMenu *arg1 = (wxMenu *) 0 ;
40450 long result;
40451 void *argp1 = 0 ;
40452 int res1 = 0 ;
40453 PyObject *swig_obj[1] ;
40454
40455 if (!args) SWIG_fail;
40456 swig_obj[0] = args;
40457 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40458 if (!SWIG_IsOK(res1)) {
40459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetStyle" "', expected argument " "1"" of type '" "wxMenu const *""'");
40460 }
40461 arg1 = reinterpret_cast< wxMenu * >(argp1);
40462 {
40463 PyThreadState* __tstate = wxPyBeginAllowThreads();
40464 result = (long)((wxMenu const *)arg1)->GetStyle();
40465 wxPyEndAllowThreads(__tstate);
40466 if (PyErr_Occurred()) SWIG_fail;
40467 }
40468 resultobj = SWIG_From_long(static_cast< long >(result));
40469 return resultobj;
40470 fail:
40471 return NULL;
40472 }
40473
40474
40475 SWIGINTERN PyObject *_wrap_Menu_UpdateUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40476 PyObject *resultobj = 0;
40477 wxMenu *arg1 = (wxMenu *) 0 ;
40478 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
40479 void *argp1 = 0 ;
40480 int res1 = 0 ;
40481 void *argp2 = 0 ;
40482 int res2 = 0 ;
40483 PyObject * obj0 = 0 ;
40484 PyObject * obj1 = 0 ;
40485 char * kwnames[] = {
40486 (char *) "self",(char *) "source", NULL
40487 };
40488
40489 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) SWIG_fail;
40490 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40491 if (!SWIG_IsOK(res1)) {
40492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_UpdateUI" "', expected argument " "1"" of type '" "wxMenu *""'");
40493 }
40494 arg1 = reinterpret_cast< wxMenu * >(argp1);
40495 if (obj1) {
40496 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
40497 if (!SWIG_IsOK(res2)) {
40498 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_UpdateUI" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
40499 }
40500 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
40501 }
40502 {
40503 PyThreadState* __tstate = wxPyBeginAllowThreads();
40504 (arg1)->UpdateUI(arg2);
40505 wxPyEndAllowThreads(__tstate);
40506 if (PyErr_Occurred()) SWIG_fail;
40507 }
40508 resultobj = SWIG_Py_Void();
40509 return resultobj;
40510 fail:
40511 return NULL;
40512 }
40513
40514
40515 SWIGINTERN PyObject *_wrap_Menu_GetMenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40516 PyObject *resultobj = 0;
40517 wxMenu *arg1 = (wxMenu *) 0 ;
40518 wxMenuBar *result = 0 ;
40519 void *argp1 = 0 ;
40520 int res1 = 0 ;
40521 PyObject *swig_obj[1] ;
40522
40523 if (!args) SWIG_fail;
40524 swig_obj[0] = args;
40525 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40526 if (!SWIG_IsOK(res1)) {
40527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuBar" "', expected argument " "1"" of type '" "wxMenu const *""'");
40528 }
40529 arg1 = reinterpret_cast< wxMenu * >(argp1);
40530 {
40531 PyThreadState* __tstate = wxPyBeginAllowThreads();
40532 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
40533 wxPyEndAllowThreads(__tstate);
40534 if (PyErr_Occurred()) SWIG_fail;
40535 }
40536 {
40537 resultobj = wxPyMake_wxObject(result, (bool)0);
40538 }
40539 return resultobj;
40540 fail:
40541 return NULL;
40542 }
40543
40544
40545 SWIGINTERN PyObject *_wrap_Menu_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40546 PyObject *resultobj = 0;
40547 wxMenu *arg1 = (wxMenu *) 0 ;
40548 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
40549 void *argp1 = 0 ;
40550 int res1 = 0 ;
40551 void *argp2 = 0 ;
40552 int res2 = 0 ;
40553 PyObject * obj0 = 0 ;
40554 PyObject * obj1 = 0 ;
40555 char * kwnames[] = {
40556 (char *) "self",(char *) "menubar", NULL
40557 };
40558
40559 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
40560 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40561 if (!SWIG_IsOK(res1)) {
40562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Attach" "', expected argument " "1"" of type '" "wxMenu *""'");
40563 }
40564 arg1 = reinterpret_cast< wxMenu * >(argp1);
40565 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuBarBase, 0 | 0 );
40566 if (!SWIG_IsOK(res2)) {
40567 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_Attach" "', expected argument " "2"" of type '" "wxMenuBarBase *""'");
40568 }
40569 arg2 = reinterpret_cast< wxMenuBarBase * >(argp2);
40570 {
40571 PyThreadState* __tstate = wxPyBeginAllowThreads();
40572 (arg1)->Attach(arg2);
40573 wxPyEndAllowThreads(__tstate);
40574 if (PyErr_Occurred()) SWIG_fail;
40575 }
40576 resultobj = SWIG_Py_Void();
40577 return resultobj;
40578 fail:
40579 return NULL;
40580 }
40581
40582
40583 SWIGINTERN PyObject *_wrap_Menu_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40584 PyObject *resultobj = 0;
40585 wxMenu *arg1 = (wxMenu *) 0 ;
40586 void *argp1 = 0 ;
40587 int res1 = 0 ;
40588 PyObject *swig_obj[1] ;
40589
40590 if (!args) SWIG_fail;
40591 swig_obj[0] = args;
40592 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40593 if (!SWIG_IsOK(res1)) {
40594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Detach" "', expected argument " "1"" of type '" "wxMenu *""'");
40595 }
40596 arg1 = reinterpret_cast< wxMenu * >(argp1);
40597 {
40598 PyThreadState* __tstate = wxPyBeginAllowThreads();
40599 (arg1)->Detach();
40600 wxPyEndAllowThreads(__tstate);
40601 if (PyErr_Occurred()) SWIG_fail;
40602 }
40603 resultobj = SWIG_Py_Void();
40604 return resultobj;
40605 fail:
40606 return NULL;
40607 }
40608
40609
40610 SWIGINTERN PyObject *_wrap_Menu_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40611 PyObject *resultobj = 0;
40612 wxMenu *arg1 = (wxMenu *) 0 ;
40613 bool result;
40614 void *argp1 = 0 ;
40615 int res1 = 0 ;
40616 PyObject *swig_obj[1] ;
40617
40618 if (!args) SWIG_fail;
40619 swig_obj[0] = args;
40620 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40621 if (!SWIG_IsOK(res1)) {
40622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsAttached" "', expected argument " "1"" of type '" "wxMenu const *""'");
40623 }
40624 arg1 = reinterpret_cast< wxMenu * >(argp1);
40625 {
40626 PyThreadState* __tstate = wxPyBeginAllowThreads();
40627 result = (bool)((wxMenu const *)arg1)->IsAttached();
40628 wxPyEndAllowThreads(__tstate);
40629 if (PyErr_Occurred()) SWIG_fail;
40630 }
40631 {
40632 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40633 }
40634 return resultobj;
40635 fail:
40636 return NULL;
40637 }
40638
40639
40640 SWIGINTERN PyObject *_wrap_Menu_SetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40641 PyObject *resultobj = 0;
40642 wxMenu *arg1 = (wxMenu *) 0 ;
40643 wxMenu *arg2 = (wxMenu *) 0 ;
40644 void *argp1 = 0 ;
40645 int res1 = 0 ;
40646 void *argp2 = 0 ;
40647 int res2 = 0 ;
40648 PyObject * obj0 = 0 ;
40649 PyObject * obj1 = 0 ;
40650 char * kwnames[] = {
40651 (char *) "self",(char *) "parent", NULL
40652 };
40653
40654 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) SWIG_fail;
40655 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40656 if (!SWIG_IsOK(res1)) {
40657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetParent" "', expected argument " "1"" of type '" "wxMenu *""'");
40658 }
40659 arg1 = reinterpret_cast< wxMenu * >(argp1);
40660 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
40661 if (!SWIG_IsOK(res2)) {
40662 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetParent" "', expected argument " "2"" of type '" "wxMenu *""'");
40663 }
40664 arg2 = reinterpret_cast< wxMenu * >(argp2);
40665 {
40666 PyThreadState* __tstate = wxPyBeginAllowThreads();
40667 (arg1)->SetParent(arg2);
40668 wxPyEndAllowThreads(__tstate);
40669 if (PyErr_Occurred()) SWIG_fail;
40670 }
40671 resultobj = SWIG_Py_Void();
40672 return resultobj;
40673 fail:
40674 return NULL;
40675 }
40676
40677
40678 SWIGINTERN PyObject *_wrap_Menu_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40679 PyObject *resultobj = 0;
40680 wxMenu *arg1 = (wxMenu *) 0 ;
40681 wxMenu *result = 0 ;
40682 void *argp1 = 0 ;
40683 int res1 = 0 ;
40684 PyObject *swig_obj[1] ;
40685
40686 if (!args) SWIG_fail;
40687 swig_obj[0] = args;
40688 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40689 if (!SWIG_IsOK(res1)) {
40690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetParent" "', expected argument " "1"" of type '" "wxMenu const *""'");
40691 }
40692 arg1 = reinterpret_cast< wxMenu * >(argp1);
40693 {
40694 PyThreadState* __tstate = wxPyBeginAllowThreads();
40695 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
40696 wxPyEndAllowThreads(__tstate);
40697 if (PyErr_Occurred()) SWIG_fail;
40698 }
40699 {
40700 resultobj = wxPyMake_wxObject(result, 0);
40701 }
40702 return resultobj;
40703 fail:
40704 return NULL;
40705 }
40706
40707
40708 SWIGINTERN PyObject *Menu_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40709 PyObject *obj;
40710 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
40711 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenu, SWIG_NewClientData(obj));
40712 return SWIG_Py_Void();
40713 }
40714
40715 SWIGINTERN PyObject *Menu_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40716 return SWIG_Python_InitShadowInstance(args);
40717 }
40718
40719 SWIGINTERN PyObject *_wrap_new_MenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40720 PyObject *resultobj = 0;
40721 long arg1 = (long) 0 ;
40722 wxMenuBar *result = 0 ;
40723 long val1 ;
40724 int ecode1 = 0 ;
40725 PyObject * obj0 = 0 ;
40726 char * kwnames[] = {
40727 (char *) "style", NULL
40728 };
40729
40730 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) SWIG_fail;
40731 if (obj0) {
40732 ecode1 = SWIG_AsVal_long(obj0, &val1);
40733 if (!SWIG_IsOK(ecode1)) {
40734 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuBar" "', expected argument " "1"" of type '" "long""'");
40735 }
40736 arg1 = static_cast< long >(val1);
40737 }
40738 {
40739 if (!wxPyCheckForApp()) SWIG_fail;
40740 PyThreadState* __tstate = wxPyBeginAllowThreads();
40741 result = (wxMenuBar *)new wxMenuBar(arg1);
40742 wxPyEndAllowThreads(__tstate);
40743 if (PyErr_Occurred()) SWIG_fail;
40744 }
40745 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuBar, SWIG_POINTER_NEW | 0 );
40746 return resultobj;
40747 fail:
40748 return NULL;
40749 }
40750
40751
40752 SWIGINTERN PyObject *_wrap_MenuBar_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40753 PyObject *resultobj = 0;
40754 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40755 wxMenu *arg2 = (wxMenu *) 0 ;
40756 wxString *arg3 = 0 ;
40757 bool result;
40758 void *argp1 = 0 ;
40759 int res1 = 0 ;
40760 void *argp2 = 0 ;
40761 int res2 = 0 ;
40762 bool temp3 = false ;
40763 PyObject * obj0 = 0 ;
40764 PyObject * obj1 = 0 ;
40765 PyObject * obj2 = 0 ;
40766 char * kwnames[] = {
40767 (char *) "self",(char *) "menu",(char *) "title", NULL
40768 };
40769
40770 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40771 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40772 if (!SWIG_IsOK(res1)) {
40773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Append" "', expected argument " "1"" of type '" "wxMenuBar *""'");
40774 }
40775 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40776 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
40777 if (!SWIG_IsOK(res2)) {
40778 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Append" "', expected argument " "2"" of type '" "wxMenu *""'");
40779 }
40780 arg2 = reinterpret_cast< wxMenu * >(argp2);
40781 {
40782 arg3 = wxString_in_helper(obj2);
40783 if (arg3 == NULL) SWIG_fail;
40784 temp3 = true;
40785 }
40786 {
40787 PyThreadState* __tstate = wxPyBeginAllowThreads();
40788 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
40789 wxPyEndAllowThreads(__tstate);
40790 if (PyErr_Occurred()) SWIG_fail;
40791 }
40792 {
40793 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40794 }
40795 {
40796 if (temp3)
40797 delete arg3;
40798 }
40799 return resultobj;
40800 fail:
40801 {
40802 if (temp3)
40803 delete arg3;
40804 }
40805 return NULL;
40806 }
40807
40808
40809 SWIGINTERN PyObject *_wrap_MenuBar_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40810 PyObject *resultobj = 0;
40811 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40812 size_t arg2 ;
40813 wxMenu *arg3 = (wxMenu *) 0 ;
40814 wxString *arg4 = 0 ;
40815 bool result;
40816 void *argp1 = 0 ;
40817 int res1 = 0 ;
40818 size_t val2 ;
40819 int ecode2 = 0 ;
40820 void *argp3 = 0 ;
40821 int res3 = 0 ;
40822 bool temp4 = false ;
40823 PyObject * obj0 = 0 ;
40824 PyObject * obj1 = 0 ;
40825 PyObject * obj2 = 0 ;
40826 PyObject * obj3 = 0 ;
40827 char * kwnames[] = {
40828 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
40829 };
40830
40831 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40832 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40833 if (!SWIG_IsOK(res1)) {
40834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Insert" "', expected argument " "1"" of type '" "wxMenuBar *""'");
40835 }
40836 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40837 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40838 if (!SWIG_IsOK(ecode2)) {
40839 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Insert" "', expected argument " "2"" of type '" "size_t""'");
40840 }
40841 arg2 = static_cast< size_t >(val2);
40842 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
40843 if (!SWIG_IsOK(res3)) {
40844 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Insert" "', expected argument " "3"" of type '" "wxMenu *""'");
40845 }
40846 arg3 = reinterpret_cast< wxMenu * >(argp3);
40847 {
40848 arg4 = wxString_in_helper(obj3);
40849 if (arg4 == NULL) SWIG_fail;
40850 temp4 = true;
40851 }
40852 {
40853 PyThreadState* __tstate = wxPyBeginAllowThreads();
40854 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
40855 wxPyEndAllowThreads(__tstate);
40856 if (PyErr_Occurred()) SWIG_fail;
40857 }
40858 {
40859 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40860 }
40861 {
40862 if (temp4)
40863 delete arg4;
40864 }
40865 return resultobj;
40866 fail:
40867 {
40868 if (temp4)
40869 delete arg4;
40870 }
40871 return NULL;
40872 }
40873
40874
40875 SWIGINTERN PyObject *_wrap_MenuBar_GetMenuCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40876 PyObject *resultobj = 0;
40877 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40878 size_t result;
40879 void *argp1 = 0 ;
40880 int res1 = 0 ;
40881 PyObject *swig_obj[1] ;
40882
40883 if (!args) SWIG_fail;
40884 swig_obj[0] = args;
40885 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40886 if (!SWIG_IsOK(res1)) {
40887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenuCount" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
40888 }
40889 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40890 {
40891 PyThreadState* __tstate = wxPyBeginAllowThreads();
40892 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
40893 wxPyEndAllowThreads(__tstate);
40894 if (PyErr_Occurred()) SWIG_fail;
40895 }
40896 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
40897 return resultobj;
40898 fail:
40899 return NULL;
40900 }
40901
40902
40903 SWIGINTERN PyObject *_wrap_MenuBar_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40904 PyObject *resultobj = 0;
40905 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40906 size_t arg2 ;
40907 wxMenu *result = 0 ;
40908 void *argp1 = 0 ;
40909 int res1 = 0 ;
40910 size_t val2 ;
40911 int ecode2 = 0 ;
40912 PyObject * obj0 = 0 ;
40913 PyObject * obj1 = 0 ;
40914 char * kwnames[] = {
40915 (char *) "self",(char *) "pos", NULL
40916 };
40917
40918 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
40919 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40920 if (!SWIG_IsOK(res1)) {
40921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenu" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
40922 }
40923 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40924 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40925 if (!SWIG_IsOK(ecode2)) {
40926 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetMenu" "', expected argument " "2"" of type '" "size_t""'");
40927 }
40928 arg2 = static_cast< size_t >(val2);
40929 {
40930 PyThreadState* __tstate = wxPyBeginAllowThreads();
40931 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
40932 wxPyEndAllowThreads(__tstate);
40933 if (PyErr_Occurred()) SWIG_fail;
40934 }
40935 {
40936 resultobj = wxPyMake_wxObject(result, 0);
40937 }
40938 return resultobj;
40939 fail:
40940 return NULL;
40941 }
40942
40943
40944 SWIGINTERN PyObject *_wrap_MenuBar_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40945 PyObject *resultobj = 0;
40946 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40947 size_t arg2 ;
40948 wxMenu *arg3 = (wxMenu *) 0 ;
40949 wxString *arg4 = 0 ;
40950 wxMenu *result = 0 ;
40951 void *argp1 = 0 ;
40952 int res1 = 0 ;
40953 size_t val2 ;
40954 int ecode2 = 0 ;
40955 void *argp3 = 0 ;
40956 int res3 = 0 ;
40957 bool temp4 = false ;
40958 PyObject * obj0 = 0 ;
40959 PyObject * obj1 = 0 ;
40960 PyObject * obj2 = 0 ;
40961 PyObject * obj3 = 0 ;
40962 char * kwnames[] = {
40963 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
40964 };
40965
40966 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40967 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40968 if (!SWIG_IsOK(res1)) {
40969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Replace" "', expected argument " "1"" of type '" "wxMenuBar *""'");
40970 }
40971 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40972 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40973 if (!SWIG_IsOK(ecode2)) {
40974 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Replace" "', expected argument " "2"" of type '" "size_t""'");
40975 }
40976 arg2 = static_cast< size_t >(val2);
40977 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
40978 if (!SWIG_IsOK(res3)) {
40979 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Replace" "', expected argument " "3"" of type '" "wxMenu *""'");
40980 }
40981 arg3 = reinterpret_cast< wxMenu * >(argp3);
40982 {
40983 arg4 = wxString_in_helper(obj3);
40984 if (arg4 == NULL) SWIG_fail;
40985 temp4 = true;
40986 }
40987 {
40988 PyThreadState* __tstate = wxPyBeginAllowThreads();
40989 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
40990 wxPyEndAllowThreads(__tstate);
40991 if (PyErr_Occurred()) SWIG_fail;
40992 }
40993 {
40994 resultobj = wxPyMake_wxObject(result, 0);
40995 }
40996 {
40997 if (temp4)
40998 delete arg4;
40999 }
41000 return resultobj;
41001 fail:
41002 {
41003 if (temp4)
41004 delete arg4;
41005 }
41006 return NULL;
41007 }
41008
41009
41010 SWIGINTERN PyObject *_wrap_MenuBar_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41011 PyObject *resultobj = 0;
41012 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41013 size_t arg2 ;
41014 wxMenu *result = 0 ;
41015 void *argp1 = 0 ;
41016 int res1 = 0 ;
41017 size_t val2 ;
41018 int ecode2 = 0 ;
41019 PyObject * obj0 = 0 ;
41020 PyObject * obj1 = 0 ;
41021 char * kwnames[] = {
41022 (char *) "self",(char *) "pos", NULL
41023 };
41024
41025 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
41026 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41027 if (!SWIG_IsOK(res1)) {
41028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Remove" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41029 }
41030 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41031 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41032 if (!SWIG_IsOK(ecode2)) {
41033 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Remove" "', expected argument " "2"" of type '" "size_t""'");
41034 }
41035 arg2 = static_cast< size_t >(val2);
41036 {
41037 PyThreadState* __tstate = wxPyBeginAllowThreads();
41038 result = (wxMenu *)(arg1)->Remove(arg2);
41039 wxPyEndAllowThreads(__tstate);
41040 if (PyErr_Occurred()) SWIG_fail;
41041 }
41042 {
41043 resultobj = wxPyMake_wxObject(result, 0);
41044 }
41045 return resultobj;
41046 fail:
41047 return NULL;
41048 }
41049
41050
41051 SWIGINTERN PyObject *_wrap_MenuBar_EnableTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41052 PyObject *resultobj = 0;
41053 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41054 size_t arg2 ;
41055 bool arg3 ;
41056 void *argp1 = 0 ;
41057 int res1 = 0 ;
41058 size_t val2 ;
41059 int ecode2 = 0 ;
41060 bool val3 ;
41061 int ecode3 = 0 ;
41062 PyObject * obj0 = 0 ;
41063 PyObject * obj1 = 0 ;
41064 PyObject * obj2 = 0 ;
41065 char * kwnames[] = {
41066 (char *) "self",(char *) "pos",(char *) "enable", NULL
41067 };
41068
41069 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41070 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41071 if (!SWIG_IsOK(res1)) {
41072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_EnableTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41073 }
41074 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41075 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41076 if (!SWIG_IsOK(ecode2)) {
41077 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_EnableTop" "', expected argument " "2"" of type '" "size_t""'");
41078 }
41079 arg2 = static_cast< size_t >(val2);
41080 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41081 if (!SWIG_IsOK(ecode3)) {
41082 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_EnableTop" "', expected argument " "3"" of type '" "bool""'");
41083 }
41084 arg3 = static_cast< bool >(val3);
41085 {
41086 PyThreadState* __tstate = wxPyBeginAllowThreads();
41087 (arg1)->EnableTop(arg2,arg3);
41088 wxPyEndAllowThreads(__tstate);
41089 if (PyErr_Occurred()) SWIG_fail;
41090 }
41091 resultobj = SWIG_Py_Void();
41092 return resultobj;
41093 fail:
41094 return NULL;
41095 }
41096
41097
41098 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41099 PyObject *resultobj = 0;
41100 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41101 size_t arg2 ;
41102 bool result;
41103 void *argp1 = 0 ;
41104 int res1 = 0 ;
41105 size_t val2 ;
41106 int ecode2 = 0 ;
41107 PyObject * obj0 = 0 ;
41108 PyObject * obj1 = 0 ;
41109 char * kwnames[] = {
41110 (char *) "self",(char *) "pos", NULL
41111 };
41112
41113 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) SWIG_fail;
41114 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41115 if (!SWIG_IsOK(res1)) {
41116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41117 }
41118 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41119 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41120 if (!SWIG_IsOK(ecode2)) {
41121 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "2"" of type '" "size_t""'");
41122 }
41123 arg2 = static_cast< size_t >(val2);
41124 {
41125 PyThreadState* __tstate = wxPyBeginAllowThreads();
41126 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
41127 wxPyEndAllowThreads(__tstate);
41128 if (PyErr_Occurred()) SWIG_fail;
41129 }
41130 {
41131 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41132 }
41133 return resultobj;
41134 fail:
41135 return NULL;
41136 }
41137
41138
41139 SWIGINTERN PyObject *_wrap_MenuBar_SetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41140 PyObject *resultobj = 0;
41141 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41142 size_t arg2 ;
41143 wxString *arg3 = 0 ;
41144 void *argp1 = 0 ;
41145 int res1 = 0 ;
41146 size_t val2 ;
41147 int ecode2 = 0 ;
41148 bool temp3 = false ;
41149 PyObject * obj0 = 0 ;
41150 PyObject * obj1 = 0 ;
41151 PyObject * obj2 = 0 ;
41152 char * kwnames[] = {
41153 (char *) "self",(char *) "pos",(char *) "label", NULL
41154 };
41155
41156 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41157 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41158 if (!SWIG_IsOK(res1)) {
41159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41160 }
41161 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41162 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41163 if (!SWIG_IsOK(ecode2)) {
41164 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
41165 }
41166 arg2 = static_cast< size_t >(val2);
41167 {
41168 arg3 = wxString_in_helper(obj2);
41169 if (arg3 == NULL) SWIG_fail;
41170 temp3 = true;
41171 }
41172 {
41173 PyThreadState* __tstate = wxPyBeginAllowThreads();
41174 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
41175 wxPyEndAllowThreads(__tstate);
41176 if (PyErr_Occurred()) SWIG_fail;
41177 }
41178 resultobj = SWIG_Py_Void();
41179 {
41180 if (temp3)
41181 delete arg3;
41182 }
41183 return resultobj;
41184 fail:
41185 {
41186 if (temp3)
41187 delete arg3;
41188 }
41189 return NULL;
41190 }
41191
41192
41193 SWIGINTERN PyObject *_wrap_MenuBar_GetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41194 PyObject *resultobj = 0;
41195 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41196 size_t arg2 ;
41197 wxString result;
41198 void *argp1 = 0 ;
41199 int res1 = 0 ;
41200 size_t val2 ;
41201 int ecode2 = 0 ;
41202 PyObject * obj0 = 0 ;
41203 PyObject * obj1 = 0 ;
41204 char * kwnames[] = {
41205 (char *) "self",(char *) "pos", NULL
41206 };
41207
41208 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) SWIG_fail;
41209 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41210 if (!SWIG_IsOK(res1)) {
41211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41212 }
41213 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41214 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41215 if (!SWIG_IsOK(ecode2)) {
41216 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
41217 }
41218 arg2 = static_cast< size_t >(val2);
41219 {
41220 PyThreadState* __tstate = wxPyBeginAllowThreads();
41221 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
41222 wxPyEndAllowThreads(__tstate);
41223 if (PyErr_Occurred()) SWIG_fail;
41224 }
41225 {
41226 #if wxUSE_UNICODE
41227 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41228 #else
41229 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41230 #endif
41231 }
41232 return resultobj;
41233 fail:
41234 return NULL;
41235 }
41236
41237
41238 SWIGINTERN PyObject *_wrap_MenuBar_FindMenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41239 PyObject *resultobj = 0;
41240 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41241 wxString *arg2 = 0 ;
41242 wxString *arg3 = 0 ;
41243 int result;
41244 void *argp1 = 0 ;
41245 int res1 = 0 ;
41246 bool temp2 = false ;
41247 bool temp3 = false ;
41248 PyObject * obj0 = 0 ;
41249 PyObject * obj1 = 0 ;
41250 PyObject * obj2 = 0 ;
41251 char * kwnames[] = {
41252 (char *) "self",(char *) "menu",(char *) "item", NULL
41253 };
41254
41255 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41256 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41257 if (!SWIG_IsOK(res1)) {
41258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenuItem" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41259 }
41260 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41261 {
41262 arg2 = wxString_in_helper(obj1);
41263 if (arg2 == NULL) SWIG_fail;
41264 temp2 = true;
41265 }
41266 {
41267 arg3 = wxString_in_helper(obj2);
41268 if (arg3 == NULL) SWIG_fail;
41269 temp3 = true;
41270 }
41271 {
41272 PyThreadState* __tstate = wxPyBeginAllowThreads();
41273 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
41274 wxPyEndAllowThreads(__tstate);
41275 if (PyErr_Occurred()) SWIG_fail;
41276 }
41277 resultobj = SWIG_From_int(static_cast< int >(result));
41278 {
41279 if (temp2)
41280 delete arg2;
41281 }
41282 {
41283 if (temp3)
41284 delete arg3;
41285 }
41286 return resultobj;
41287 fail:
41288 {
41289 if (temp2)
41290 delete arg2;
41291 }
41292 {
41293 if (temp3)
41294 delete arg3;
41295 }
41296 return NULL;
41297 }
41298
41299
41300 SWIGINTERN PyObject *_wrap_MenuBar_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41301 PyObject *resultobj = 0;
41302 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41303 int arg2 ;
41304 wxMenuItem *result = 0 ;
41305 void *argp1 = 0 ;
41306 int res1 = 0 ;
41307 int val2 ;
41308 int ecode2 = 0 ;
41309 PyObject * obj0 = 0 ;
41310 PyObject * obj1 = 0 ;
41311 char * kwnames[] = {
41312 (char *) "self",(char *) "id", NULL
41313 };
41314
41315 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
41316 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41317 if (!SWIG_IsOK(res1)) {
41318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindItemById" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41319 }
41320 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41321 ecode2 = SWIG_AsVal_int(obj1, &val2);
41322 if (!SWIG_IsOK(ecode2)) {
41323 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_FindItemById" "', expected argument " "2"" of type '" "int""'");
41324 }
41325 arg2 = static_cast< int >(val2);
41326 {
41327 PyThreadState* __tstate = wxPyBeginAllowThreads();
41328 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
41329 wxPyEndAllowThreads(__tstate);
41330 if (PyErr_Occurred()) SWIG_fail;
41331 }
41332 {
41333 resultobj = wxPyMake_wxObject(result, (bool)0);
41334 }
41335 return resultobj;
41336 fail:
41337 return NULL;
41338 }
41339
41340
41341 SWIGINTERN PyObject *_wrap_MenuBar_FindMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41342 PyObject *resultobj = 0;
41343 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41344 wxString *arg2 = 0 ;
41345 int result;
41346 void *argp1 = 0 ;
41347 int res1 = 0 ;
41348 bool temp2 = false ;
41349 PyObject * obj0 = 0 ;
41350 PyObject * obj1 = 0 ;
41351 char * kwnames[] = {
41352 (char *) "self",(char *) "title", NULL
41353 };
41354
41355 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) SWIG_fail;
41356 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41357 if (!SWIG_IsOK(res1)) {
41358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenu" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41359 }
41360 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41361 {
41362 arg2 = wxString_in_helper(obj1);
41363 if (arg2 == NULL) SWIG_fail;
41364 temp2 = true;
41365 }
41366 {
41367 PyThreadState* __tstate = wxPyBeginAllowThreads();
41368 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
41369 wxPyEndAllowThreads(__tstate);
41370 if (PyErr_Occurred()) SWIG_fail;
41371 }
41372 resultobj = SWIG_From_int(static_cast< int >(result));
41373 {
41374 if (temp2)
41375 delete arg2;
41376 }
41377 return resultobj;
41378 fail:
41379 {
41380 if (temp2)
41381 delete arg2;
41382 }
41383 return NULL;
41384 }
41385
41386
41387 SWIGINTERN PyObject *_wrap_MenuBar_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41388 PyObject *resultobj = 0;
41389 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41390 int arg2 ;
41391 bool arg3 ;
41392 void *argp1 = 0 ;
41393 int res1 = 0 ;
41394 int val2 ;
41395 int ecode2 = 0 ;
41396 bool val3 ;
41397 int ecode3 = 0 ;
41398 PyObject * obj0 = 0 ;
41399 PyObject * obj1 = 0 ;
41400 PyObject * obj2 = 0 ;
41401 char * kwnames[] = {
41402 (char *) "self",(char *) "id",(char *) "enable", NULL
41403 };
41404
41405 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41406 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41407 if (!SWIG_IsOK(res1)) {
41408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Enable" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41409 }
41410 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41411 ecode2 = SWIG_AsVal_int(obj1, &val2);
41412 if (!SWIG_IsOK(ecode2)) {
41413 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Enable" "', expected argument " "2"" of type '" "int""'");
41414 }
41415 arg2 = static_cast< int >(val2);
41416 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41417 if (!SWIG_IsOK(ecode3)) {
41418 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Enable" "', expected argument " "3"" of type '" "bool""'");
41419 }
41420 arg3 = static_cast< bool >(val3);
41421 {
41422 PyThreadState* __tstate = wxPyBeginAllowThreads();
41423 (arg1)->Enable(arg2,arg3);
41424 wxPyEndAllowThreads(__tstate);
41425 if (PyErr_Occurred()) SWIG_fail;
41426 }
41427 resultobj = SWIG_Py_Void();
41428 return resultobj;
41429 fail:
41430 return NULL;
41431 }
41432
41433
41434 SWIGINTERN PyObject *_wrap_MenuBar_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41435 PyObject *resultobj = 0;
41436 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41437 int arg2 ;
41438 bool arg3 ;
41439 void *argp1 = 0 ;
41440 int res1 = 0 ;
41441 int val2 ;
41442 int ecode2 = 0 ;
41443 bool val3 ;
41444 int ecode3 = 0 ;
41445 PyObject * obj0 = 0 ;
41446 PyObject * obj1 = 0 ;
41447 PyObject * obj2 = 0 ;
41448 char * kwnames[] = {
41449 (char *) "self",(char *) "id",(char *) "check", NULL
41450 };
41451
41452 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41453 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41454 if (!SWIG_IsOK(res1)) {
41455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Check" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41456 }
41457 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41458 ecode2 = SWIG_AsVal_int(obj1, &val2);
41459 if (!SWIG_IsOK(ecode2)) {
41460 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Check" "', expected argument " "2"" of type '" "int""'");
41461 }
41462 arg2 = static_cast< int >(val2);
41463 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41464 if (!SWIG_IsOK(ecode3)) {
41465 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Check" "', expected argument " "3"" of type '" "bool""'");
41466 }
41467 arg3 = static_cast< bool >(val3);
41468 {
41469 PyThreadState* __tstate = wxPyBeginAllowThreads();
41470 (arg1)->Check(arg2,arg3);
41471 wxPyEndAllowThreads(__tstate);
41472 if (PyErr_Occurred()) SWIG_fail;
41473 }
41474 resultobj = SWIG_Py_Void();
41475 return resultobj;
41476 fail:
41477 return NULL;
41478 }
41479
41480
41481 SWIGINTERN PyObject *_wrap_MenuBar_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41482 PyObject *resultobj = 0;
41483 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41484 int arg2 ;
41485 bool result;
41486 void *argp1 = 0 ;
41487 int res1 = 0 ;
41488 int val2 ;
41489 int ecode2 = 0 ;
41490 PyObject * obj0 = 0 ;
41491 PyObject * obj1 = 0 ;
41492 char * kwnames[] = {
41493 (char *) "self",(char *) "id", NULL
41494 };
41495
41496 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
41497 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41498 if (!SWIG_IsOK(res1)) {
41499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsChecked" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41500 }
41501 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41502 ecode2 = SWIG_AsVal_int(obj1, &val2);
41503 if (!SWIG_IsOK(ecode2)) {
41504 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsChecked" "', expected argument " "2"" of type '" "int""'");
41505 }
41506 arg2 = static_cast< int >(val2);
41507 {
41508 PyThreadState* __tstate = wxPyBeginAllowThreads();
41509 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
41510 wxPyEndAllowThreads(__tstate);
41511 if (PyErr_Occurred()) SWIG_fail;
41512 }
41513 {
41514 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41515 }
41516 return resultobj;
41517 fail:
41518 return NULL;
41519 }
41520
41521
41522 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41523 PyObject *resultobj = 0;
41524 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41525 int arg2 ;
41526 bool result;
41527 void *argp1 = 0 ;
41528 int res1 = 0 ;
41529 int val2 ;
41530 int ecode2 = 0 ;
41531 PyObject * obj0 = 0 ;
41532 PyObject * obj1 = 0 ;
41533 char * kwnames[] = {
41534 (char *) "self",(char *) "id", NULL
41535 };
41536
41537 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
41538 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41539 if (!SWIG_IsOK(res1)) {
41540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabled" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41541 }
41542 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41543 ecode2 = SWIG_AsVal_int(obj1, &val2);
41544 if (!SWIG_IsOK(ecode2)) {
41545 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabled" "', expected argument " "2"" of type '" "int""'");
41546 }
41547 arg2 = static_cast< int >(val2);
41548 {
41549 PyThreadState* __tstate = wxPyBeginAllowThreads();
41550 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
41551 wxPyEndAllowThreads(__tstate);
41552 if (PyErr_Occurred()) SWIG_fail;
41553 }
41554 {
41555 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41556 }
41557 return resultobj;
41558 fail:
41559 return NULL;
41560 }
41561
41562
41563 SWIGINTERN PyObject *_wrap_MenuBar_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41564 PyObject *resultobj = 0;
41565 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41566 int arg2 ;
41567 wxString *arg3 = 0 ;
41568 void *argp1 = 0 ;
41569 int res1 = 0 ;
41570 int val2 ;
41571 int ecode2 = 0 ;
41572 bool temp3 = false ;
41573 PyObject * obj0 = 0 ;
41574 PyObject * obj1 = 0 ;
41575 PyObject * obj2 = 0 ;
41576 char * kwnames[] = {
41577 (char *) "self",(char *) "id",(char *) "label", NULL
41578 };
41579
41580 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41581 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41582 if (!SWIG_IsOK(res1)) {
41583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabel" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41584 }
41585 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41586 ecode2 = SWIG_AsVal_int(obj1, &val2);
41587 if (!SWIG_IsOK(ecode2)) {
41588 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabel" "', expected argument " "2"" of type '" "int""'");
41589 }
41590 arg2 = static_cast< int >(val2);
41591 {
41592 arg3 = wxString_in_helper(obj2);
41593 if (arg3 == NULL) SWIG_fail;
41594 temp3 = true;
41595 }
41596 {
41597 PyThreadState* __tstate = wxPyBeginAllowThreads();
41598 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
41599 wxPyEndAllowThreads(__tstate);
41600 if (PyErr_Occurred()) SWIG_fail;
41601 }
41602 resultobj = SWIG_Py_Void();
41603 {
41604 if (temp3)
41605 delete arg3;
41606 }
41607 return resultobj;
41608 fail:
41609 {
41610 if (temp3)
41611 delete arg3;
41612 }
41613 return NULL;
41614 }
41615
41616
41617 SWIGINTERN PyObject *_wrap_MenuBar_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41618 PyObject *resultobj = 0;
41619 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41620 int arg2 ;
41621 wxString result;
41622 void *argp1 = 0 ;
41623 int res1 = 0 ;
41624 int val2 ;
41625 int ecode2 = 0 ;
41626 PyObject * obj0 = 0 ;
41627 PyObject * obj1 = 0 ;
41628 char * kwnames[] = {
41629 (char *) "self",(char *) "id", NULL
41630 };
41631
41632 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
41633 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41634 if (!SWIG_IsOK(res1)) {
41635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabel" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41636 }
41637 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41638 ecode2 = SWIG_AsVal_int(obj1, &val2);
41639 if (!SWIG_IsOK(ecode2)) {
41640 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabel" "', expected argument " "2"" of type '" "int""'");
41641 }
41642 arg2 = static_cast< int >(val2);
41643 {
41644 PyThreadState* __tstate = wxPyBeginAllowThreads();
41645 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
41646 wxPyEndAllowThreads(__tstate);
41647 if (PyErr_Occurred()) SWIG_fail;
41648 }
41649 {
41650 #if wxUSE_UNICODE
41651 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41652 #else
41653 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41654 #endif
41655 }
41656 return resultobj;
41657 fail:
41658 return NULL;
41659 }
41660
41661
41662 SWIGINTERN PyObject *_wrap_MenuBar_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41663 PyObject *resultobj = 0;
41664 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41665 int arg2 ;
41666 wxString *arg3 = 0 ;
41667 void *argp1 = 0 ;
41668 int res1 = 0 ;
41669 int val2 ;
41670 int ecode2 = 0 ;
41671 bool temp3 = false ;
41672 PyObject * obj0 = 0 ;
41673 PyObject * obj1 = 0 ;
41674 PyObject * obj2 = 0 ;
41675 char * kwnames[] = {
41676 (char *) "self",(char *) "id",(char *) "helpString", NULL
41677 };
41678
41679 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41680 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41681 if (!SWIG_IsOK(res1)) {
41682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetHelpString" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41683 }
41684 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41685 ecode2 = SWIG_AsVal_int(obj1, &val2);
41686 if (!SWIG_IsOK(ecode2)) {
41687 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetHelpString" "', expected argument " "2"" of type '" "int""'");
41688 }
41689 arg2 = static_cast< int >(val2);
41690 {
41691 arg3 = wxString_in_helper(obj2);
41692 if (arg3 == NULL) SWIG_fail;
41693 temp3 = true;
41694 }
41695 {
41696 PyThreadState* __tstate = wxPyBeginAllowThreads();
41697 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
41698 wxPyEndAllowThreads(__tstate);
41699 if (PyErr_Occurred()) SWIG_fail;
41700 }
41701 resultobj = SWIG_Py_Void();
41702 {
41703 if (temp3)
41704 delete arg3;
41705 }
41706 return resultobj;
41707 fail:
41708 {
41709 if (temp3)
41710 delete arg3;
41711 }
41712 return NULL;
41713 }
41714
41715
41716 SWIGINTERN PyObject *_wrap_MenuBar_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41717 PyObject *resultobj = 0;
41718 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41719 int arg2 ;
41720 wxString result;
41721 void *argp1 = 0 ;
41722 int res1 = 0 ;
41723 int val2 ;
41724 int ecode2 = 0 ;
41725 PyObject * obj0 = 0 ;
41726 PyObject * obj1 = 0 ;
41727 char * kwnames[] = {
41728 (char *) "self",(char *) "id", NULL
41729 };
41730
41731 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
41732 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41733 if (!SWIG_IsOK(res1)) {
41734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetHelpString" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41735 }
41736 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41737 ecode2 = SWIG_AsVal_int(obj1, &val2);
41738 if (!SWIG_IsOK(ecode2)) {
41739 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetHelpString" "', expected argument " "2"" of type '" "int""'");
41740 }
41741 arg2 = static_cast< int >(val2);
41742 {
41743 PyThreadState* __tstate = wxPyBeginAllowThreads();
41744 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
41745 wxPyEndAllowThreads(__tstate);
41746 if (PyErr_Occurred()) SWIG_fail;
41747 }
41748 {
41749 #if wxUSE_UNICODE
41750 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41751 #else
41752 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41753 #endif
41754 }
41755 return resultobj;
41756 fail:
41757 return NULL;
41758 }
41759
41760
41761 SWIGINTERN PyObject *_wrap_MenuBar_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41762 PyObject *resultobj = 0;
41763 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41764 wxFrame *result = 0 ;
41765 void *argp1 = 0 ;
41766 int res1 = 0 ;
41767 PyObject *swig_obj[1] ;
41768
41769 if (!args) SWIG_fail;
41770 swig_obj[0] = args;
41771 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41772 if (!SWIG_IsOK(res1)) {
41773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetFrame" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41774 }
41775 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41776 {
41777 PyThreadState* __tstate = wxPyBeginAllowThreads();
41778 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
41779 wxPyEndAllowThreads(__tstate);
41780 if (PyErr_Occurred()) SWIG_fail;
41781 }
41782 {
41783 resultobj = wxPyMake_wxObject(result, (bool)0);
41784 }
41785 return resultobj;
41786 fail:
41787 return NULL;
41788 }
41789
41790
41791 SWIGINTERN PyObject *_wrap_MenuBar_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41792 PyObject *resultobj = 0;
41793 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41794 bool result;
41795 void *argp1 = 0 ;
41796 int res1 = 0 ;
41797 PyObject *swig_obj[1] ;
41798
41799 if (!args) SWIG_fail;
41800 swig_obj[0] = args;
41801 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41802 if (!SWIG_IsOK(res1)) {
41803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsAttached" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41804 }
41805 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41806 {
41807 PyThreadState* __tstate = wxPyBeginAllowThreads();
41808 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
41809 wxPyEndAllowThreads(__tstate);
41810 if (PyErr_Occurred()) SWIG_fail;
41811 }
41812 {
41813 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41814 }
41815 return resultobj;
41816 fail:
41817 return NULL;
41818 }
41819
41820
41821 SWIGINTERN PyObject *_wrap_MenuBar_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41822 PyObject *resultobj = 0;
41823 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41824 wxFrame *arg2 = (wxFrame *) 0 ;
41825 void *argp1 = 0 ;
41826 int res1 = 0 ;
41827 void *argp2 = 0 ;
41828 int res2 = 0 ;
41829 PyObject * obj0 = 0 ;
41830 PyObject * obj1 = 0 ;
41831 char * kwnames[] = {
41832 (char *) "self",(char *) "frame", NULL
41833 };
41834
41835 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
41836 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41837 if (!SWIG_IsOK(res1)) {
41838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Attach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41839 }
41840 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41841 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFrame, 0 | 0 );
41842 if (!SWIG_IsOK(res2)) {
41843 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Attach" "', expected argument " "2"" of type '" "wxFrame *""'");
41844 }
41845 arg2 = reinterpret_cast< wxFrame * >(argp2);
41846 {
41847 PyThreadState* __tstate = wxPyBeginAllowThreads();
41848 (arg1)->Attach(arg2);
41849 wxPyEndAllowThreads(__tstate);
41850 if (PyErr_Occurred()) SWIG_fail;
41851 }
41852 resultobj = SWIG_Py_Void();
41853 return resultobj;
41854 fail:
41855 return NULL;
41856 }
41857
41858
41859 SWIGINTERN PyObject *_wrap_MenuBar_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41860 PyObject *resultobj = 0;
41861 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41862 void *argp1 = 0 ;
41863 int res1 = 0 ;
41864 PyObject *swig_obj[1] ;
41865
41866 if (!args) SWIG_fail;
41867 swig_obj[0] = args;
41868 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41869 if (!SWIG_IsOK(res1)) {
41870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Detach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41871 }
41872 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41873 {
41874 PyThreadState* __tstate = wxPyBeginAllowThreads();
41875 (arg1)->Detach();
41876 wxPyEndAllowThreads(__tstate);
41877 if (PyErr_Occurred()) SWIG_fail;
41878 }
41879 resultobj = SWIG_Py_Void();
41880 return resultobj;
41881 fail:
41882 return NULL;
41883 }
41884
41885
41886 SWIGINTERN PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41887 PyObject *resultobj = 0;
41888 bool arg1 ;
41889 bool val1 ;
41890 int ecode1 = 0 ;
41891 PyObject * obj0 = 0 ;
41892 char * kwnames[] = {
41893 (char *) "enable", NULL
41894 };
41895
41896 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) SWIG_fail;
41897 ecode1 = SWIG_AsVal_bool(obj0, &val1);
41898 if (!SWIG_IsOK(ecode1)) {
41899 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MenuBar_SetAutoWindowMenu" "', expected argument " "1"" of type '" "bool""'");
41900 }
41901 arg1 = static_cast< bool >(val1);
41902 {
41903 PyThreadState* __tstate = wxPyBeginAllowThreads();
41904 wxMenuBar_SetAutoWindowMenu(arg1);
41905 wxPyEndAllowThreads(__tstate);
41906 if (PyErr_Occurred()) SWIG_fail;
41907 }
41908 resultobj = SWIG_Py_Void();
41909 return resultobj;
41910 fail:
41911 return NULL;
41912 }
41913
41914
41915 SWIGINTERN PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41916 PyObject *resultobj = 0;
41917 bool result;
41918
41919 if (!SWIG_Python_UnpackTuple(args,"MenuBar_GetAutoWindowMenu",0,0,0)) SWIG_fail;
41920 {
41921 PyThreadState* __tstate = wxPyBeginAllowThreads();
41922 result = (bool)wxMenuBar_GetAutoWindowMenu();
41923 wxPyEndAllowThreads(__tstate);
41924 if (PyErr_Occurred()) SWIG_fail;
41925 }
41926 {
41927 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41928 }
41929 return resultobj;
41930 fail:
41931 return NULL;
41932 }
41933
41934
41935 SWIGINTERN PyObject *MenuBar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41936 PyObject *obj;
41937 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41938 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuBar, SWIG_NewClientData(obj));
41939 return SWIG_Py_Void();
41940 }
41941
41942 SWIGINTERN PyObject *MenuBar_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41943 return SWIG_Python_InitShadowInstance(args);
41944 }
41945
41946 SWIGINTERN PyObject *_wrap_new_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41947 PyObject *resultobj = 0;
41948 wxMenu *arg1 = (wxMenu *) NULL ;
41949 int arg2 = (int) wxID_ANY ;
41950 wxString const &arg3_defvalue = wxPyEmptyString ;
41951 wxString *arg3 = (wxString *) &arg3_defvalue ;
41952 wxString const &arg4_defvalue = wxPyEmptyString ;
41953 wxString *arg4 = (wxString *) &arg4_defvalue ;
41954 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
41955 wxMenu *arg6 = (wxMenu *) NULL ;
41956 wxMenuItem *result = 0 ;
41957 void *argp1 = 0 ;
41958 int res1 = 0 ;
41959 int val2 ;
41960 int ecode2 = 0 ;
41961 bool temp3 = false ;
41962 bool temp4 = false ;
41963 int val5 ;
41964 int ecode5 = 0 ;
41965 void *argp6 = 0 ;
41966 int res6 = 0 ;
41967 PyObject * obj0 = 0 ;
41968 PyObject * obj1 = 0 ;
41969 PyObject * obj2 = 0 ;
41970 PyObject * obj3 = 0 ;
41971 PyObject * obj4 = 0 ;
41972 PyObject * obj5 = 0 ;
41973 char * kwnames[] = {
41974 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
41975 };
41976
41977 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
41978 if (obj0) {
41979 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41980 if (!SWIG_IsOK(res1)) {
41981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MenuItem" "', expected argument " "1"" of type '" "wxMenu *""'");
41982 }
41983 arg1 = reinterpret_cast< wxMenu * >(argp1);
41984 }
41985 if (obj1) {
41986 ecode2 = SWIG_AsVal_int(obj1, &val2);
41987 if (!SWIG_IsOK(ecode2)) {
41988 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuItem" "', expected argument " "2"" of type '" "int""'");
41989 }
41990 arg2 = static_cast< int >(val2);
41991 }
41992 if (obj2) {
41993 {
41994 arg3 = wxString_in_helper(obj2);
41995 if (arg3 == NULL) SWIG_fail;
41996 temp3 = true;
41997 }
41998 }
41999 if (obj3) {
42000 {
42001 arg4 = wxString_in_helper(obj3);
42002 if (arg4 == NULL) SWIG_fail;
42003 temp4 = true;
42004 }
42005 }
42006 if (obj4) {
42007 ecode5 = SWIG_AsVal_int(obj4, &val5);
42008 if (!SWIG_IsOK(ecode5)) {
42009 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MenuItem" "', expected argument " "5"" of type '" "wxItemKind""'");
42010 }
42011 arg5 = static_cast< wxItemKind >(val5);
42012 }
42013 if (obj5) {
42014 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxMenu, 0 | 0 );
42015 if (!SWIG_IsOK(res6)) {
42016 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MenuItem" "', expected argument " "6"" of type '" "wxMenu *""'");
42017 }
42018 arg6 = reinterpret_cast< wxMenu * >(argp6);
42019 }
42020 {
42021 PyThreadState* __tstate = wxPyBeginAllowThreads();
42022 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
42023 wxPyEndAllowThreads(__tstate);
42024 if (PyErr_Occurred()) SWIG_fail;
42025 }
42026 {
42027 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
42028 }
42029 {
42030 if (temp3)
42031 delete arg3;
42032 }
42033 {
42034 if (temp4)
42035 delete arg4;
42036 }
42037 return resultobj;
42038 fail:
42039 {
42040 if (temp3)
42041 delete arg3;
42042 }
42043 {
42044 if (temp4)
42045 delete arg4;
42046 }
42047 return NULL;
42048 }
42049
42050
42051 SWIGINTERN PyObject *_wrap_delete_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42052 PyObject *resultobj = 0;
42053 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42054 void *argp1 = 0 ;
42055 int res1 = 0 ;
42056 PyObject *swig_obj[1] ;
42057
42058 if (!args) SWIG_fail;
42059 swig_obj[0] = args;
42060 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42061 if (!SWIG_IsOK(res1)) {
42062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MenuItem" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42063 }
42064 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42065 {
42066 PyThreadState* __tstate = wxPyBeginAllowThreads();
42067 delete arg1;
42068
42069 wxPyEndAllowThreads(__tstate);
42070 if (PyErr_Occurred()) SWIG_fail;
42071 }
42072 resultobj = SWIG_Py_Void();
42073 return resultobj;
42074 fail:
42075 return NULL;
42076 }
42077
42078
42079 SWIGINTERN PyObject *_wrap_MenuItem_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42080 PyObject *resultobj = 0;
42081 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42082 wxMenu *result = 0 ;
42083 void *argp1 = 0 ;
42084 int res1 = 0 ;
42085 PyObject *swig_obj[1] ;
42086
42087 if (!args) SWIG_fail;
42088 swig_obj[0] = args;
42089 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42090 if (!SWIG_IsOK(res1)) {
42091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42092 }
42093 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42094 {
42095 PyThreadState* __tstate = wxPyBeginAllowThreads();
42096 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
42097 wxPyEndAllowThreads(__tstate);
42098 if (PyErr_Occurred()) SWIG_fail;
42099 }
42100 {
42101 resultobj = wxPyMake_wxObject(result, 0);
42102 }
42103 return resultobj;
42104 fail:
42105 return NULL;
42106 }
42107
42108
42109 SWIGINTERN PyObject *_wrap_MenuItem_SetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42110 PyObject *resultobj = 0;
42111 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42112 wxMenu *arg2 = (wxMenu *) 0 ;
42113 void *argp1 = 0 ;
42114 int res1 = 0 ;
42115 void *argp2 = 0 ;
42116 int res2 = 0 ;
42117 PyObject * obj0 = 0 ;
42118 PyObject * obj1 = 0 ;
42119 char * kwnames[] = {
42120 (char *) "self",(char *) "menu", NULL
42121 };
42122
42123 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42124 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42125 if (!SWIG_IsOK(res1)) {
42126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42127 }
42128 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42129 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42130 if (!SWIG_IsOK(res2)) {
42131 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
42132 }
42133 arg2 = reinterpret_cast< wxMenu * >(argp2);
42134 {
42135 PyThreadState* __tstate = wxPyBeginAllowThreads();
42136 (arg1)->SetMenu(arg2);
42137 wxPyEndAllowThreads(__tstate);
42138 if (PyErr_Occurred()) SWIG_fail;
42139 }
42140 resultobj = SWIG_Py_Void();
42141 return resultobj;
42142 fail:
42143 return NULL;
42144 }
42145
42146
42147 SWIGINTERN PyObject *_wrap_MenuItem_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42148 PyObject *resultobj = 0;
42149 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42150 int arg2 ;
42151 void *argp1 = 0 ;
42152 int res1 = 0 ;
42153 int val2 ;
42154 int ecode2 = 0 ;
42155 PyObject * obj0 = 0 ;
42156 PyObject * obj1 = 0 ;
42157 char * kwnames[] = {
42158 (char *) "self",(char *) "id", NULL
42159 };
42160
42161 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
42162 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42163 if (!SWIG_IsOK(res1)) {
42164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetId" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42165 }
42166 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42167 ecode2 = SWIG_AsVal_int(obj1, &val2);
42168 if (!SWIG_IsOK(ecode2)) {
42169 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetId" "', expected argument " "2"" of type '" "int""'");
42170 }
42171 arg2 = static_cast< int >(val2);
42172 {
42173 PyThreadState* __tstate = wxPyBeginAllowThreads();
42174 (arg1)->SetId(arg2);
42175 wxPyEndAllowThreads(__tstate);
42176 if (PyErr_Occurred()) SWIG_fail;
42177 }
42178 resultobj = SWIG_Py_Void();
42179 return resultobj;
42180 fail:
42181 return NULL;
42182 }
42183
42184
42185 SWIGINTERN PyObject *_wrap_MenuItem_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42186 PyObject *resultobj = 0;
42187 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42188 int result;
42189 void *argp1 = 0 ;
42190 int res1 = 0 ;
42191 PyObject *swig_obj[1] ;
42192
42193 if (!args) SWIG_fail;
42194 swig_obj[0] = args;
42195 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42196 if (!SWIG_IsOK(res1)) {
42197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetId" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42198 }
42199 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42200 {
42201 PyThreadState* __tstate = wxPyBeginAllowThreads();
42202 result = (int)((wxMenuItem const *)arg1)->GetId();
42203 wxPyEndAllowThreads(__tstate);
42204 if (PyErr_Occurred()) SWIG_fail;
42205 }
42206 resultobj = SWIG_From_int(static_cast< int >(result));
42207 return resultobj;
42208 fail:
42209 return NULL;
42210 }
42211
42212
42213 SWIGINTERN PyObject *_wrap_MenuItem_IsSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42214 PyObject *resultobj = 0;
42215 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42216 bool result;
42217 void *argp1 = 0 ;
42218 int res1 = 0 ;
42219 PyObject *swig_obj[1] ;
42220
42221 if (!args) SWIG_fail;
42222 swig_obj[0] = args;
42223 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42224 if (!SWIG_IsOK(res1)) {
42225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSeparator" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42226 }
42227 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42228 {
42229 PyThreadState* __tstate = wxPyBeginAllowThreads();
42230 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
42231 wxPyEndAllowThreads(__tstate);
42232 if (PyErr_Occurred()) SWIG_fail;
42233 }
42234 {
42235 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42236 }
42237 return resultobj;
42238 fail:
42239 return NULL;
42240 }
42241
42242
42243 SWIGINTERN PyObject *_wrap_MenuItem_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42244 PyObject *resultobj = 0;
42245 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42246 wxString *arg2 = 0 ;
42247 void *argp1 = 0 ;
42248 int res1 = 0 ;
42249 bool temp2 = false ;
42250 PyObject * obj0 = 0 ;
42251 PyObject * obj1 = 0 ;
42252 char * kwnames[] = {
42253 (char *) "self",(char *) "str", NULL
42254 };
42255
42256 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
42257 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42258 if (!SWIG_IsOK(res1)) {
42259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetText" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42260 }
42261 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42262 {
42263 arg2 = wxString_in_helper(obj1);
42264 if (arg2 == NULL) SWIG_fail;
42265 temp2 = true;
42266 }
42267 {
42268 PyThreadState* __tstate = wxPyBeginAllowThreads();
42269 (arg1)->SetText((wxString const &)*arg2);
42270 wxPyEndAllowThreads(__tstate);
42271 if (PyErr_Occurred()) SWIG_fail;
42272 }
42273 resultobj = SWIG_Py_Void();
42274 {
42275 if (temp2)
42276 delete arg2;
42277 }
42278 return resultobj;
42279 fail:
42280 {
42281 if (temp2)
42282 delete arg2;
42283 }
42284 return NULL;
42285 }
42286
42287
42288 SWIGINTERN PyObject *_wrap_MenuItem_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42289 PyObject *resultobj = 0;
42290 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42291 wxString result;
42292 void *argp1 = 0 ;
42293 int res1 = 0 ;
42294 PyObject *swig_obj[1] ;
42295
42296 if (!args) SWIG_fail;
42297 swig_obj[0] = args;
42298 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42299 if (!SWIG_IsOK(res1)) {
42300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetLabel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42301 }
42302 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42303 {
42304 PyThreadState* __tstate = wxPyBeginAllowThreads();
42305 result = ((wxMenuItem const *)arg1)->GetLabel();
42306 wxPyEndAllowThreads(__tstate);
42307 if (PyErr_Occurred()) SWIG_fail;
42308 }
42309 {
42310 #if wxUSE_UNICODE
42311 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42312 #else
42313 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42314 #endif
42315 }
42316 return resultobj;
42317 fail:
42318 return NULL;
42319 }
42320
42321
42322 SWIGINTERN PyObject *_wrap_MenuItem_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42323 PyObject *resultobj = 0;
42324 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42325 wxString *result = 0 ;
42326 void *argp1 = 0 ;
42327 int res1 = 0 ;
42328 PyObject *swig_obj[1] ;
42329
42330 if (!args) SWIG_fail;
42331 swig_obj[0] = args;
42332 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42333 if (!SWIG_IsOK(res1)) {
42334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetText" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42335 }
42336 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42337 {
42338 PyThreadState* __tstate = wxPyBeginAllowThreads();
42339 {
42340 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
42341 result = (wxString *) &_result_ref;
42342 }
42343 wxPyEndAllowThreads(__tstate);
42344 if (PyErr_Occurred()) SWIG_fail;
42345 }
42346 {
42347 #if wxUSE_UNICODE
42348 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
42349 #else
42350 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
42351 #endif
42352 }
42353 return resultobj;
42354 fail:
42355 return NULL;
42356 }
42357
42358
42359 SWIGINTERN PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42360 PyObject *resultobj = 0;
42361 wxString *arg1 = 0 ;
42362 wxString result;
42363 bool temp1 = false ;
42364 PyObject * obj0 = 0 ;
42365 char * kwnames[] = {
42366 (char *) "text", NULL
42367 };
42368
42369 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) SWIG_fail;
42370 {
42371 arg1 = wxString_in_helper(obj0);
42372 if (arg1 == NULL) SWIG_fail;
42373 temp1 = true;
42374 }
42375 {
42376 PyThreadState* __tstate = wxPyBeginAllowThreads();
42377 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
42378 wxPyEndAllowThreads(__tstate);
42379 if (PyErr_Occurred()) SWIG_fail;
42380 }
42381 {
42382 #if wxUSE_UNICODE
42383 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42384 #else
42385 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42386 #endif
42387 }
42388 {
42389 if (temp1)
42390 delete arg1;
42391 }
42392 return resultobj;
42393 fail:
42394 {
42395 if (temp1)
42396 delete arg1;
42397 }
42398 return NULL;
42399 }
42400
42401
42402 SWIGINTERN PyObject *_wrap_MenuItem_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42403 PyObject *resultobj = 0;
42404 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42405 wxItemKind result;
42406 void *argp1 = 0 ;
42407 int res1 = 0 ;
42408 PyObject *swig_obj[1] ;
42409
42410 if (!args) SWIG_fail;
42411 swig_obj[0] = args;
42412 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42413 if (!SWIG_IsOK(res1)) {
42414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetKind" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42415 }
42416 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42417 {
42418 PyThreadState* __tstate = wxPyBeginAllowThreads();
42419 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
42420 wxPyEndAllowThreads(__tstate);
42421 if (PyErr_Occurred()) SWIG_fail;
42422 }
42423 resultobj = SWIG_From_int(static_cast< int >(result));
42424 return resultobj;
42425 fail:
42426 return NULL;
42427 }
42428
42429
42430 SWIGINTERN PyObject *_wrap_MenuItem_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42431 PyObject *resultobj = 0;
42432 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42433 wxItemKind arg2 ;
42434 void *argp1 = 0 ;
42435 int res1 = 0 ;
42436 int val2 ;
42437 int ecode2 = 0 ;
42438 PyObject * obj0 = 0 ;
42439 PyObject * obj1 = 0 ;
42440 char * kwnames[] = {
42441 (char *) "self",(char *) "kind", NULL
42442 };
42443
42444 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
42445 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42446 if (!SWIG_IsOK(res1)) {
42447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetKind" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42448 }
42449 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42450 ecode2 = SWIG_AsVal_int(obj1, &val2);
42451 if (!SWIG_IsOK(ecode2)) {
42452 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetKind" "', expected argument " "2"" of type '" "wxItemKind""'");
42453 }
42454 arg2 = static_cast< wxItemKind >(val2);
42455 {
42456 PyThreadState* __tstate = wxPyBeginAllowThreads();
42457 (arg1)->SetKind(arg2);
42458 wxPyEndAllowThreads(__tstate);
42459 if (PyErr_Occurred()) SWIG_fail;
42460 }
42461 resultobj = SWIG_Py_Void();
42462 return resultobj;
42463 fail:
42464 return NULL;
42465 }
42466
42467
42468 SWIGINTERN PyObject *_wrap_MenuItem_SetCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42469 PyObject *resultobj = 0;
42470 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42471 bool arg2 ;
42472 void *argp1 = 0 ;
42473 int res1 = 0 ;
42474 bool val2 ;
42475 int ecode2 = 0 ;
42476 PyObject * obj0 = 0 ;
42477 PyObject * obj1 = 0 ;
42478 char * kwnames[] = {
42479 (char *) "self",(char *) "checkable", NULL
42480 };
42481
42482 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) SWIG_fail;
42483 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42484 if (!SWIG_IsOK(res1)) {
42485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetCheckable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42486 }
42487 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42488 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42489 if (!SWIG_IsOK(ecode2)) {
42490 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetCheckable" "', expected argument " "2"" of type '" "bool""'");
42491 }
42492 arg2 = static_cast< bool >(val2);
42493 {
42494 PyThreadState* __tstate = wxPyBeginAllowThreads();
42495 (arg1)->SetCheckable(arg2);
42496 wxPyEndAllowThreads(__tstate);
42497 if (PyErr_Occurred()) SWIG_fail;
42498 }
42499 resultobj = SWIG_Py_Void();
42500 return resultobj;
42501 fail:
42502 return NULL;
42503 }
42504
42505
42506 SWIGINTERN PyObject *_wrap_MenuItem_IsCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42507 PyObject *resultobj = 0;
42508 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42509 bool result;
42510 void *argp1 = 0 ;
42511 int res1 = 0 ;
42512 PyObject *swig_obj[1] ;
42513
42514 if (!args) SWIG_fail;
42515 swig_obj[0] = args;
42516 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42517 if (!SWIG_IsOK(res1)) {
42518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsCheckable" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42519 }
42520 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42521 {
42522 PyThreadState* __tstate = wxPyBeginAllowThreads();
42523 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
42524 wxPyEndAllowThreads(__tstate);
42525 if (PyErr_Occurred()) SWIG_fail;
42526 }
42527 {
42528 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42529 }
42530 return resultobj;
42531 fail:
42532 return NULL;
42533 }
42534
42535
42536 SWIGINTERN PyObject *_wrap_MenuItem_IsSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42537 PyObject *resultobj = 0;
42538 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42539 bool result;
42540 void *argp1 = 0 ;
42541 int res1 = 0 ;
42542 PyObject *swig_obj[1] ;
42543
42544 if (!args) SWIG_fail;
42545 swig_obj[0] = args;
42546 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42547 if (!SWIG_IsOK(res1)) {
42548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42549 }
42550 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42551 {
42552 PyThreadState* __tstate = wxPyBeginAllowThreads();
42553 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
42554 wxPyEndAllowThreads(__tstate);
42555 if (PyErr_Occurred()) SWIG_fail;
42556 }
42557 {
42558 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42559 }
42560 return resultobj;
42561 fail:
42562 return NULL;
42563 }
42564
42565
42566 SWIGINTERN PyObject *_wrap_MenuItem_SetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42567 PyObject *resultobj = 0;
42568 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42569 wxMenu *arg2 = (wxMenu *) 0 ;
42570 void *argp1 = 0 ;
42571 int res1 = 0 ;
42572 void *argp2 = 0 ;
42573 int res2 = 0 ;
42574 PyObject * obj0 = 0 ;
42575 PyObject * obj1 = 0 ;
42576 char * kwnames[] = {
42577 (char *) "self",(char *) "menu", NULL
42578 };
42579
42580 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42581 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42582 if (!SWIG_IsOK(res1)) {
42583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42584 }
42585 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42586 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42587 if (!SWIG_IsOK(res2)) {
42588 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
42589 }
42590 arg2 = reinterpret_cast< wxMenu * >(argp2);
42591 {
42592 PyThreadState* __tstate = wxPyBeginAllowThreads();
42593 (arg1)->SetSubMenu(arg2);
42594 wxPyEndAllowThreads(__tstate);
42595 if (PyErr_Occurred()) SWIG_fail;
42596 }
42597 resultobj = SWIG_Py_Void();
42598 return resultobj;
42599 fail:
42600 return NULL;
42601 }
42602
42603
42604 SWIGINTERN PyObject *_wrap_MenuItem_GetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42605 PyObject *resultobj = 0;
42606 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42607 wxMenu *result = 0 ;
42608 void *argp1 = 0 ;
42609 int res1 = 0 ;
42610 PyObject *swig_obj[1] ;
42611
42612 if (!args) SWIG_fail;
42613 swig_obj[0] = args;
42614 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42615 if (!SWIG_IsOK(res1)) {
42616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42617 }
42618 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42619 {
42620 PyThreadState* __tstate = wxPyBeginAllowThreads();
42621 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
42622 wxPyEndAllowThreads(__tstate);
42623 if (PyErr_Occurred()) SWIG_fail;
42624 }
42625 {
42626 resultobj = wxPyMake_wxObject(result, 0);
42627 }
42628 return resultobj;
42629 fail:
42630 return NULL;
42631 }
42632
42633
42634 SWIGINTERN PyObject *_wrap_MenuItem_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42635 PyObject *resultobj = 0;
42636 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42637 bool arg2 = (bool) true ;
42638 void *argp1 = 0 ;
42639 int res1 = 0 ;
42640 bool val2 ;
42641 int ecode2 = 0 ;
42642 PyObject * obj0 = 0 ;
42643 PyObject * obj1 = 0 ;
42644 char * kwnames[] = {
42645 (char *) "self",(char *) "enable", NULL
42646 };
42647
42648 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
42649 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42650 if (!SWIG_IsOK(res1)) {
42651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Enable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42652 }
42653 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42654 if (obj1) {
42655 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42656 if (!SWIG_IsOK(ecode2)) {
42657 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Enable" "', expected argument " "2"" of type '" "bool""'");
42658 }
42659 arg2 = static_cast< bool >(val2);
42660 }
42661 {
42662 PyThreadState* __tstate = wxPyBeginAllowThreads();
42663 (arg1)->Enable(arg2);
42664 wxPyEndAllowThreads(__tstate);
42665 if (PyErr_Occurred()) SWIG_fail;
42666 }
42667 resultobj = SWIG_Py_Void();
42668 return resultobj;
42669 fail:
42670 return NULL;
42671 }
42672
42673
42674 SWIGINTERN PyObject *_wrap_MenuItem_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42675 PyObject *resultobj = 0;
42676 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42677 bool result;
42678 void *argp1 = 0 ;
42679 int res1 = 0 ;
42680 PyObject *swig_obj[1] ;
42681
42682 if (!args) SWIG_fail;
42683 swig_obj[0] = args;
42684 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42685 if (!SWIG_IsOK(res1)) {
42686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsEnabled" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42687 }
42688 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42689 {
42690 PyThreadState* __tstate = wxPyBeginAllowThreads();
42691 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
42692 wxPyEndAllowThreads(__tstate);
42693 if (PyErr_Occurred()) SWIG_fail;
42694 }
42695 {
42696 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42697 }
42698 return resultobj;
42699 fail:
42700 return NULL;
42701 }
42702
42703
42704 SWIGINTERN PyObject *_wrap_MenuItem_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42705 PyObject *resultobj = 0;
42706 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42707 bool arg2 = (bool) true ;
42708 void *argp1 = 0 ;
42709 int res1 = 0 ;
42710 bool val2 ;
42711 int ecode2 = 0 ;
42712 PyObject * obj0 = 0 ;
42713 PyObject * obj1 = 0 ;
42714 char * kwnames[] = {
42715 (char *) "self",(char *) "check", NULL
42716 };
42717
42718 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) SWIG_fail;
42719 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42720 if (!SWIG_IsOK(res1)) {
42721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Check" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42722 }
42723 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42724 if (obj1) {
42725 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42726 if (!SWIG_IsOK(ecode2)) {
42727 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Check" "', expected argument " "2"" of type '" "bool""'");
42728 }
42729 arg2 = static_cast< bool >(val2);
42730 }
42731 {
42732 PyThreadState* __tstate = wxPyBeginAllowThreads();
42733 (arg1)->Check(arg2);
42734 wxPyEndAllowThreads(__tstate);
42735 if (PyErr_Occurred()) SWIG_fail;
42736 }
42737 resultobj = SWIG_Py_Void();
42738 return resultobj;
42739 fail:
42740 return NULL;
42741 }
42742
42743
42744 SWIGINTERN PyObject *_wrap_MenuItem_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42745 PyObject *resultobj = 0;
42746 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42747 bool result;
42748 void *argp1 = 0 ;
42749 int res1 = 0 ;
42750 PyObject *swig_obj[1] ;
42751
42752 if (!args) SWIG_fail;
42753 swig_obj[0] = args;
42754 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42755 if (!SWIG_IsOK(res1)) {
42756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsChecked" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42757 }
42758 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42759 {
42760 PyThreadState* __tstate = wxPyBeginAllowThreads();
42761 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
42762 wxPyEndAllowThreads(__tstate);
42763 if (PyErr_Occurred()) SWIG_fail;
42764 }
42765 {
42766 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42767 }
42768 return resultobj;
42769 fail:
42770 return NULL;
42771 }
42772
42773
42774 SWIGINTERN PyObject *_wrap_MenuItem_Toggle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42775 PyObject *resultobj = 0;
42776 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42777 void *argp1 = 0 ;
42778 int res1 = 0 ;
42779 PyObject *swig_obj[1] ;
42780
42781 if (!args) SWIG_fail;
42782 swig_obj[0] = args;
42783 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42784 if (!SWIG_IsOK(res1)) {
42785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Toggle" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42786 }
42787 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42788 {
42789 PyThreadState* __tstate = wxPyBeginAllowThreads();
42790 (arg1)->Toggle();
42791 wxPyEndAllowThreads(__tstate);
42792 if (PyErr_Occurred()) SWIG_fail;
42793 }
42794 resultobj = SWIG_Py_Void();
42795 return resultobj;
42796 fail:
42797 return NULL;
42798 }
42799
42800
42801 SWIGINTERN PyObject *_wrap_MenuItem_SetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42802 PyObject *resultobj = 0;
42803 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42804 wxString *arg2 = 0 ;
42805 void *argp1 = 0 ;
42806 int res1 = 0 ;
42807 bool temp2 = false ;
42808 PyObject * obj0 = 0 ;
42809 PyObject * obj1 = 0 ;
42810 char * kwnames[] = {
42811 (char *) "self",(char *) "str", NULL
42812 };
42813
42814 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) SWIG_fail;
42815 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42816 if (!SWIG_IsOK(res1)) {
42817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetHelp" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42818 }
42819 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42820 {
42821 arg2 = wxString_in_helper(obj1);
42822 if (arg2 == NULL) SWIG_fail;
42823 temp2 = true;
42824 }
42825 {
42826 PyThreadState* __tstate = wxPyBeginAllowThreads();
42827 (arg1)->SetHelp((wxString const &)*arg2);
42828 wxPyEndAllowThreads(__tstate);
42829 if (PyErr_Occurred()) SWIG_fail;
42830 }
42831 resultobj = SWIG_Py_Void();
42832 {
42833 if (temp2)
42834 delete arg2;
42835 }
42836 return resultobj;
42837 fail:
42838 {
42839 if (temp2)
42840 delete arg2;
42841 }
42842 return NULL;
42843 }
42844
42845
42846 SWIGINTERN PyObject *_wrap_MenuItem_GetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42847 PyObject *resultobj = 0;
42848 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42849 wxString *result = 0 ;
42850 void *argp1 = 0 ;
42851 int res1 = 0 ;
42852 PyObject *swig_obj[1] ;
42853
42854 if (!args) SWIG_fail;
42855 swig_obj[0] = args;
42856 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42857 if (!SWIG_IsOK(res1)) {
42858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetHelp" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42859 }
42860 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42861 {
42862 PyThreadState* __tstate = wxPyBeginAllowThreads();
42863 {
42864 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
42865 result = (wxString *) &_result_ref;
42866 }
42867 wxPyEndAllowThreads(__tstate);
42868 if (PyErr_Occurred()) SWIG_fail;
42869 }
42870 {
42871 #if wxUSE_UNICODE
42872 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
42873 #else
42874 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
42875 #endif
42876 }
42877 return resultobj;
42878 fail:
42879 return NULL;
42880 }
42881
42882
42883 SWIGINTERN PyObject *_wrap_MenuItem_GetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42884 PyObject *resultobj = 0;
42885 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42886 wxAcceleratorEntry *result = 0 ;
42887 void *argp1 = 0 ;
42888 int res1 = 0 ;
42889 PyObject *swig_obj[1] ;
42890
42891 if (!args) SWIG_fail;
42892 swig_obj[0] = args;
42893 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42894 if (!SWIG_IsOK(res1)) {
42895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetAccel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42896 }
42897 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42898 {
42899 PyThreadState* __tstate = wxPyBeginAllowThreads();
42900 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
42901 wxPyEndAllowThreads(__tstate);
42902 if (PyErr_Occurred()) SWIG_fail;
42903 }
42904 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
42905 return resultobj;
42906 fail:
42907 return NULL;
42908 }
42909
42910
42911 SWIGINTERN PyObject *_wrap_MenuItem_SetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42912 PyObject *resultobj = 0;
42913 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42914 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
42915 void *argp1 = 0 ;
42916 int res1 = 0 ;
42917 void *argp2 = 0 ;
42918 int res2 = 0 ;
42919 PyObject * obj0 = 0 ;
42920 PyObject * obj1 = 0 ;
42921 char * kwnames[] = {
42922 (char *) "self",(char *) "accel", NULL
42923 };
42924
42925 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) SWIG_fail;
42926 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42927 if (!SWIG_IsOK(res1)) {
42928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetAccel" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42929 }
42930 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42931 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
42932 if (!SWIG_IsOK(res2)) {
42933 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetAccel" "', expected argument " "2"" of type '" "wxAcceleratorEntry *""'");
42934 }
42935 arg2 = reinterpret_cast< wxAcceleratorEntry * >(argp2);
42936 {
42937 PyThreadState* __tstate = wxPyBeginAllowThreads();
42938 (arg1)->SetAccel(arg2);
42939 wxPyEndAllowThreads(__tstate);
42940 if (PyErr_Occurred()) SWIG_fail;
42941 }
42942 resultobj = SWIG_Py_Void();
42943 return resultobj;
42944 fail:
42945 return NULL;
42946 }
42947
42948
42949 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42950 PyObject *resultobj = 0;
42951 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42952 wxBitmap *arg2 = 0 ;
42953 void *argp1 = 0 ;
42954 int res1 = 0 ;
42955 void *argp2 = 0 ;
42956 int res2 = 0 ;
42957 PyObject * obj0 = 0 ;
42958 PyObject * obj1 = 0 ;
42959 char * kwnames[] = {
42960 (char *) "self",(char *) "bitmap", NULL
42961 };
42962
42963 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
42964 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42965 if (!SWIG_IsOK(res1)) {
42966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42967 }
42968 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42969 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
42970 if (!SWIG_IsOK(res2)) {
42971 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
42972 }
42973 if (!argp2) {
42974 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
42975 }
42976 arg2 = reinterpret_cast< wxBitmap * >(argp2);
42977 {
42978 PyThreadState* __tstate = wxPyBeginAllowThreads();
42979 (arg1)->SetBitmap((wxBitmap const &)*arg2);
42980 wxPyEndAllowThreads(__tstate);
42981 if (PyErr_Occurred()) SWIG_fail;
42982 }
42983 resultobj = SWIG_Py_Void();
42984 return resultobj;
42985 fail:
42986 return NULL;
42987 }
42988
42989
42990 SWIGINTERN PyObject *_wrap_MenuItem_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42991 PyObject *resultobj = 0;
42992 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42993 wxBitmap *result = 0 ;
42994 void *argp1 = 0 ;
42995 int res1 = 0 ;
42996 PyObject *swig_obj[1] ;
42997
42998 if (!args) SWIG_fail;
42999 swig_obj[0] = args;
43000 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43001 if (!SWIG_IsOK(res1)) {
43002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43003 }
43004 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43005 {
43006 PyThreadState* __tstate = wxPyBeginAllowThreads();
43007 {
43008 wxBitmap const &_result_ref = (arg1)->GetBitmap();
43009 result = (wxBitmap *) &_result_ref;
43010 }
43011 wxPyEndAllowThreads(__tstate);
43012 if (PyErr_Occurred()) SWIG_fail;
43013 }
43014 {
43015 wxBitmap* resultptr = new wxBitmap(*result);
43016 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
43017 }
43018 return resultobj;
43019 fail:
43020 return NULL;
43021 }
43022
43023
43024 SWIGINTERN PyObject *_wrap_MenuItem_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43025 PyObject *resultobj = 0;
43026 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43027 wxFont *arg2 = 0 ;
43028 void *argp1 = 0 ;
43029 int res1 = 0 ;
43030 void *argp2 = 0 ;
43031 int res2 = 0 ;
43032 PyObject * obj0 = 0 ;
43033 PyObject * obj1 = 0 ;
43034 char * kwnames[] = {
43035 (char *) "self",(char *) "font", NULL
43036 };
43037
43038 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
43039 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43040 if (!SWIG_IsOK(res1)) {
43041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43042 }
43043 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43044 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
43045 if (!SWIG_IsOK(res2)) {
43046 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
43047 }
43048 if (!argp2) {
43049 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
43050 }
43051 arg2 = reinterpret_cast< wxFont * >(argp2);
43052 {
43053 PyThreadState* __tstate = wxPyBeginAllowThreads();
43054 wxMenuItem_SetFont(arg1,(wxFont const &)*arg2);
43055 wxPyEndAllowThreads(__tstate);
43056 if (PyErr_Occurred()) SWIG_fail;
43057 }
43058 resultobj = SWIG_Py_Void();
43059 return resultobj;
43060 fail:
43061 return NULL;
43062 }
43063
43064
43065 SWIGINTERN PyObject *_wrap_MenuItem_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43066 PyObject *resultobj = 0;
43067 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43068 wxFont result;
43069 void *argp1 = 0 ;
43070 int res1 = 0 ;
43071 PyObject *swig_obj[1] ;
43072
43073 if (!args) SWIG_fail;
43074 swig_obj[0] = args;
43075 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43076 if (!SWIG_IsOK(res1)) {
43077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43078 }
43079 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43080 {
43081 PyThreadState* __tstate = wxPyBeginAllowThreads();
43082 result = wxMenuItem_GetFont(arg1);
43083 wxPyEndAllowThreads(__tstate);
43084 if (PyErr_Occurred()) SWIG_fail;
43085 }
43086 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
43087 return resultobj;
43088 fail:
43089 return NULL;
43090 }
43091
43092
43093 SWIGINTERN PyObject *_wrap_MenuItem_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43094 PyObject *resultobj = 0;
43095 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43096 wxColour *arg2 = 0 ;
43097 void *argp1 = 0 ;
43098 int res1 = 0 ;
43099 wxColour temp2 ;
43100 PyObject * obj0 = 0 ;
43101 PyObject * obj1 = 0 ;
43102 char * kwnames[] = {
43103 (char *) "self",(char *) "colText", NULL
43104 };
43105
43106 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
43107 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43108 if (!SWIG_IsOK(res1)) {
43109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43110 }
43111 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43112 {
43113 arg2 = &temp2;
43114 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
43115 }
43116 {
43117 PyThreadState* __tstate = wxPyBeginAllowThreads();
43118 wxMenuItem_SetTextColour(arg1,(wxColour const &)*arg2);
43119 wxPyEndAllowThreads(__tstate);
43120 if (PyErr_Occurred()) SWIG_fail;
43121 }
43122 resultobj = SWIG_Py_Void();
43123 return resultobj;
43124 fail:
43125 return NULL;
43126 }
43127
43128
43129 SWIGINTERN PyObject *_wrap_MenuItem_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43130 PyObject *resultobj = 0;
43131 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43132 wxColour result;
43133 void *argp1 = 0 ;
43134 int res1 = 0 ;
43135 PyObject *swig_obj[1] ;
43136
43137 if (!args) SWIG_fail;
43138 swig_obj[0] = args;
43139 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43140 if (!SWIG_IsOK(res1)) {
43141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43142 }
43143 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43144 {
43145 PyThreadState* __tstate = wxPyBeginAllowThreads();
43146 result = wxMenuItem_GetTextColour(arg1);
43147 wxPyEndAllowThreads(__tstate);
43148 if (PyErr_Occurred()) SWIG_fail;
43149 }
43150 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
43151 return resultobj;
43152 fail:
43153 return NULL;
43154 }
43155
43156
43157 SWIGINTERN PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43158 PyObject *resultobj = 0;
43159 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43160 wxColour *arg2 = 0 ;
43161 void *argp1 = 0 ;
43162 int res1 = 0 ;
43163 wxColour temp2 ;
43164 PyObject * obj0 = 0 ;
43165 PyObject * obj1 = 0 ;
43166 char * kwnames[] = {
43167 (char *) "self",(char *) "colBack", NULL
43168 };
43169
43170 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
43171 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43172 if (!SWIG_IsOK(res1)) {
43173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43174 }
43175 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43176 {
43177 arg2 = &temp2;
43178 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
43179 }
43180 {
43181 PyThreadState* __tstate = wxPyBeginAllowThreads();
43182 wxMenuItem_SetBackgroundColour(arg1,(wxColour const &)*arg2);
43183 wxPyEndAllowThreads(__tstate);
43184 if (PyErr_Occurred()) SWIG_fail;
43185 }
43186 resultobj = SWIG_Py_Void();
43187 return resultobj;
43188 fail:
43189 return NULL;
43190 }
43191
43192
43193 SWIGINTERN PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43194 PyObject *resultobj = 0;
43195 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43196 wxColour result;
43197 void *argp1 = 0 ;
43198 int res1 = 0 ;
43199 PyObject *swig_obj[1] ;
43200
43201 if (!args) SWIG_fail;
43202 swig_obj[0] = args;
43203 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43204 if (!SWIG_IsOK(res1)) {
43205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43206 }
43207 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43208 {
43209 PyThreadState* __tstate = wxPyBeginAllowThreads();
43210 result = wxMenuItem_GetBackgroundColour(arg1);
43211 wxPyEndAllowThreads(__tstate);
43212 if (PyErr_Occurred()) SWIG_fail;
43213 }
43214 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
43215 return resultobj;
43216 fail:
43217 return NULL;
43218 }
43219
43220
43221 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43222 PyObject *resultobj = 0;
43223 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43224 wxBitmap *arg2 = 0 ;
43225 wxBitmap const &arg3_defvalue = wxNullBitmap ;
43226 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
43227 void *argp1 = 0 ;
43228 int res1 = 0 ;
43229 void *argp2 = 0 ;
43230 int res2 = 0 ;
43231 void *argp3 = 0 ;
43232 int res3 = 0 ;
43233 PyObject * obj0 = 0 ;
43234 PyObject * obj1 = 0 ;
43235 PyObject * obj2 = 0 ;
43236 char * kwnames[] = {
43237 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
43238 };
43239
43240 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43241 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43242 if (!SWIG_IsOK(res1)) {
43243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmaps" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43244 }
43245 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43246 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43247 if (!SWIG_IsOK(res2)) {
43248 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43249 }
43250 if (!argp2) {
43251 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43252 }
43253 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43254 if (obj2) {
43255 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
43256 if (!SWIG_IsOK(res3)) {
43257 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
43258 }
43259 if (!argp3) {
43260 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
43261 }
43262 arg3 = reinterpret_cast< wxBitmap * >(argp3);
43263 }
43264 {
43265 PyThreadState* __tstate = wxPyBeginAllowThreads();
43266 wxMenuItem_SetBitmaps(arg1,(wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
43267 wxPyEndAllowThreads(__tstate);
43268 if (PyErr_Occurred()) SWIG_fail;
43269 }
43270 resultobj = SWIG_Py_Void();
43271 return resultobj;
43272 fail:
43273 return NULL;
43274 }
43275
43276
43277 SWIGINTERN PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43278 PyObject *resultobj = 0;
43279 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43280 wxBitmap *arg2 = 0 ;
43281 void *argp1 = 0 ;
43282 int res1 = 0 ;
43283 void *argp2 = 0 ;
43284 int res2 = 0 ;
43285 PyObject * obj0 = 0 ;
43286 PyObject * obj1 = 0 ;
43287 char * kwnames[] = {
43288 (char *) "self",(char *) "bmpDisabled", NULL
43289 };
43290
43291 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
43292 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43293 if (!SWIG_IsOK(res1)) {
43294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43295 }
43296 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43297 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43298 if (!SWIG_IsOK(res2)) {
43299 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43300 }
43301 if (!argp2) {
43302 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43303 }
43304 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43305 {
43306 PyThreadState* __tstate = wxPyBeginAllowThreads();
43307 wxMenuItem_SetDisabledBitmap(arg1,(wxBitmap const &)*arg2);
43308 wxPyEndAllowThreads(__tstate);
43309 if (PyErr_Occurred()) SWIG_fail;
43310 }
43311 resultobj = SWIG_Py_Void();
43312 return resultobj;
43313 fail:
43314 return NULL;
43315 }
43316
43317
43318 SWIGINTERN PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43319 PyObject *resultobj = 0;
43320 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43321 wxBitmap *result = 0 ;
43322 void *argp1 = 0 ;
43323 int res1 = 0 ;
43324 PyObject *swig_obj[1] ;
43325
43326 if (!args) SWIG_fail;
43327 swig_obj[0] = args;
43328 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43329 if (!SWIG_IsOK(res1)) {
43330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43331 }
43332 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43333 {
43334 PyThreadState* __tstate = wxPyBeginAllowThreads();
43335 {
43336 wxBitmap const &_result_ref = wxMenuItem_GetDisabledBitmap((wxMenuItem const *)arg1);
43337 result = (wxBitmap *) &_result_ref;
43338 }
43339 wxPyEndAllowThreads(__tstate);
43340 if (PyErr_Occurred()) SWIG_fail;
43341 }
43342 {
43343 wxBitmap* resultptr = new wxBitmap(*result);
43344 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
43345 }
43346 return resultobj;
43347 fail:
43348 return NULL;
43349 }
43350
43351
43352 SWIGINTERN PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43353 PyObject *resultobj = 0;
43354 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43355 int arg2 ;
43356 void *argp1 = 0 ;
43357 int res1 = 0 ;
43358 int val2 ;
43359 int ecode2 = 0 ;
43360 PyObject * obj0 = 0 ;
43361 PyObject * obj1 = 0 ;
43362 char * kwnames[] = {
43363 (char *) "self",(char *) "nWidth", NULL
43364 };
43365
43366 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) SWIG_fail;
43367 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43368 if (!SWIG_IsOK(res1)) {
43369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43370 }
43371 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43372 ecode2 = SWIG_AsVal_int(obj1, &val2);
43373 if (!SWIG_IsOK(ecode2)) {
43374 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "2"" of type '" "int""'");
43375 }
43376 arg2 = static_cast< int >(val2);
43377 {
43378 PyThreadState* __tstate = wxPyBeginAllowThreads();
43379 wxMenuItem_SetMarginWidth(arg1,arg2);
43380 wxPyEndAllowThreads(__tstate);
43381 if (PyErr_Occurred()) SWIG_fail;
43382 }
43383 resultobj = SWIG_Py_Void();
43384 return resultobj;
43385 fail:
43386 return NULL;
43387 }
43388
43389
43390 SWIGINTERN PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43391 PyObject *resultobj = 0;
43392 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43393 int result;
43394 void *argp1 = 0 ;
43395 int res1 = 0 ;
43396 PyObject *swig_obj[1] ;
43397
43398 if (!args) SWIG_fail;
43399 swig_obj[0] = args;
43400 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43401 if (!SWIG_IsOK(res1)) {
43402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43403 }
43404 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43405 {
43406 PyThreadState* __tstate = wxPyBeginAllowThreads();
43407 result = (int)wxMenuItem_GetMarginWidth(arg1);
43408 wxPyEndAllowThreads(__tstate);
43409 if (PyErr_Occurred()) SWIG_fail;
43410 }
43411 resultobj = SWIG_From_int(static_cast< int >(result));
43412 return resultobj;
43413 fail:
43414 return NULL;
43415 }
43416
43417
43418 SWIGINTERN PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43419 PyObject *resultobj = 0;
43420 int result;
43421
43422 if (!SWIG_Python_UnpackTuple(args,"MenuItem_GetDefaultMarginWidth",0,0,0)) SWIG_fail;
43423 {
43424 PyThreadState* __tstate = wxPyBeginAllowThreads();
43425 result = (int)wxMenuItem_GetDefaultMarginWidth();
43426 wxPyEndAllowThreads(__tstate);
43427 if (PyErr_Occurred()) SWIG_fail;
43428 }
43429 resultobj = SWIG_From_int(static_cast< int >(result));
43430 return resultobj;
43431 fail:
43432 return NULL;
43433 }
43434
43435
43436 SWIGINTERN PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43437 PyObject *resultobj = 0;
43438 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43439 bool result;
43440 void *argp1 = 0 ;
43441 int res1 = 0 ;
43442 PyObject *swig_obj[1] ;
43443
43444 if (!args) SWIG_fail;
43445 swig_obj[0] = args;
43446 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43447 if (!SWIG_IsOK(res1)) {
43448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43449 }
43450 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43451 {
43452 PyThreadState* __tstate = wxPyBeginAllowThreads();
43453 result = (bool)wxMenuItem_IsOwnerDrawn(arg1);
43454 wxPyEndAllowThreads(__tstate);
43455 if (PyErr_Occurred()) SWIG_fail;
43456 }
43457 {
43458 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43459 }
43460 return resultobj;
43461 fail:
43462 return NULL;
43463 }
43464
43465
43466 SWIGINTERN PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43467 PyObject *resultobj = 0;
43468 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43469 bool arg2 = (bool) true ;
43470 void *argp1 = 0 ;
43471 int res1 = 0 ;
43472 bool val2 ;
43473 int ecode2 = 0 ;
43474 PyObject * obj0 = 0 ;
43475 PyObject * obj1 = 0 ;
43476 char * kwnames[] = {
43477 (char *) "self",(char *) "ownerDrawn", NULL
43478 };
43479
43480 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) SWIG_fail;
43481 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43482 if (!SWIG_IsOK(res1)) {
43483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43484 }
43485 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43486 if (obj1) {
43487 ecode2 = SWIG_AsVal_bool(obj1, &val2);
43488 if (!SWIG_IsOK(ecode2)) {
43489 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "2"" of type '" "bool""'");
43490 }
43491 arg2 = static_cast< bool >(val2);
43492 }
43493 {
43494 PyThreadState* __tstate = wxPyBeginAllowThreads();
43495 wxMenuItem_SetOwnerDrawn(arg1,arg2);
43496 wxPyEndAllowThreads(__tstate);
43497 if (PyErr_Occurred()) SWIG_fail;
43498 }
43499 resultobj = SWIG_Py_Void();
43500 return resultobj;
43501 fail:
43502 return NULL;
43503 }
43504
43505
43506 SWIGINTERN PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43507 PyObject *resultobj = 0;
43508 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43509 void *argp1 = 0 ;
43510 int res1 = 0 ;
43511 PyObject *swig_obj[1] ;
43512
43513 if (!args) SWIG_fail;
43514 swig_obj[0] = args;
43515 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43516 if (!SWIG_IsOK(res1)) {
43517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_ResetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43518 }
43519 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43520 {
43521 PyThreadState* __tstate = wxPyBeginAllowThreads();
43522 wxMenuItem_ResetOwnerDrawn(arg1);
43523 wxPyEndAllowThreads(__tstate);
43524 if (PyErr_Occurred()) SWIG_fail;
43525 }
43526 resultobj = SWIG_Py_Void();
43527 return resultobj;
43528 fail:
43529 return NULL;
43530 }
43531
43532
43533 SWIGINTERN PyObject *MenuItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43534 PyObject *obj;
43535 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
43536 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuItem, SWIG_NewClientData(obj));
43537 return SWIG_Py_Void();
43538 }
43539
43540 SWIGINTERN PyObject *MenuItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43541 return SWIG_Python_InitShadowInstance(args);
43542 }
43543
43544 SWIGINTERN int ControlNameStr_set(PyObject *) {
43545 SWIG_Error(SWIG_AttributeError,"Variable ControlNameStr is read-only.");
43546 return 1;
43547 }
43548
43549
43550 SWIGINTERN PyObject *ControlNameStr_get(void) {
43551 PyObject *pyobj = 0;
43552
43553 {
43554 #if wxUSE_UNICODE
43555 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
43556 #else
43557 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
43558 #endif
43559 }
43560 return pyobj;
43561 }
43562
43563
43564 SWIGINTERN PyObject *_wrap_new_Control(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43565 PyObject *resultobj = 0;
43566 wxWindow *arg1 = (wxWindow *) 0 ;
43567 int arg2 = (int) -1 ;
43568 wxPoint const &arg3_defvalue = wxDefaultPosition ;
43569 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
43570 wxSize const &arg4_defvalue = wxDefaultSize ;
43571 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
43572 long arg5 = (long) 0 ;
43573 wxValidator const &arg6_defvalue = wxDefaultValidator ;
43574 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
43575 wxString const &arg7_defvalue = wxPyControlNameStr ;
43576 wxString *arg7 = (wxString *) &arg7_defvalue ;
43577 wxControl *result = 0 ;
43578 void *argp1 = 0 ;
43579 int res1 = 0 ;
43580 int val2 ;
43581 int ecode2 = 0 ;
43582 wxPoint temp3 ;
43583 wxSize temp4 ;
43584 long val5 ;
43585 int ecode5 = 0 ;
43586 void *argp6 = 0 ;
43587 int res6 = 0 ;
43588 bool temp7 = false ;
43589 PyObject * obj0 = 0 ;
43590 PyObject * obj1 = 0 ;
43591 PyObject * obj2 = 0 ;
43592 PyObject * obj3 = 0 ;
43593 PyObject * obj4 = 0 ;
43594 PyObject * obj5 = 0 ;
43595 PyObject * obj6 = 0 ;
43596 char * kwnames[] = {
43597 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
43598 };
43599
43600 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
43601 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
43602 if (!SWIG_IsOK(res1)) {
43603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Control" "', expected argument " "1"" of type '" "wxWindow *""'");
43604 }
43605 arg1 = reinterpret_cast< wxWindow * >(argp1);
43606 if (obj1) {
43607 ecode2 = SWIG_AsVal_int(obj1, &val2);
43608 if (!SWIG_IsOK(ecode2)) {
43609 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Control" "', expected argument " "2"" of type '" "int""'");
43610 }
43611 arg2 = static_cast< int >(val2);
43612 }
43613 if (obj2) {
43614 {
43615 arg3 = &temp3;
43616 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
43617 }
43618 }
43619 if (obj3) {
43620 {
43621 arg4 = &temp4;
43622 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
43623 }
43624 }
43625 if (obj4) {
43626 ecode5 = SWIG_AsVal_long(obj4, &val5);
43627 if (!SWIG_IsOK(ecode5)) {
43628 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Control" "', expected argument " "5"" of type '" "long""'");
43629 }
43630 arg5 = static_cast< long >(val5);
43631 }
43632 if (obj5) {
43633 res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_wxValidator, 0 | 0);
43634 if (!SWIG_IsOK(res6)) {
43635 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
43636 }
43637 if (!argp6) {
43638 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
43639 }
43640 arg6 = reinterpret_cast< wxValidator * >(argp6);
43641 }
43642 if (obj6) {
43643 {
43644 arg7 = wxString_in_helper(obj6);
43645 if (arg7 == NULL) SWIG_fail;
43646 temp7 = true;
43647 }
43648 }
43649 {
43650 if (!wxPyCheckForApp()) SWIG_fail;
43651 PyThreadState* __tstate = wxPyBeginAllowThreads();
43652 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
43653 wxPyEndAllowThreads(__tstate);
43654 if (PyErr_Occurred()) SWIG_fail;
43655 }
43656 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_NEW | 0 );
43657 {
43658 if (temp7)
43659 delete arg7;
43660 }
43661 return resultobj;
43662 fail:
43663 {
43664 if (temp7)
43665 delete arg7;
43666 }
43667 return NULL;
43668 }
43669
43670
43671 SWIGINTERN PyObject *_wrap_new_PreControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43672 PyObject *resultobj = 0;
43673 wxControl *result = 0 ;
43674
43675 if (!SWIG_Python_UnpackTuple(args,"new_PreControl",0,0,0)) SWIG_fail;
43676 {
43677 if (!wxPyCheckForApp()) SWIG_fail;
43678 PyThreadState* __tstate = wxPyBeginAllowThreads();
43679 result = (wxControl *)new wxControl();
43680 wxPyEndAllowThreads(__tstate);
43681 if (PyErr_Occurred()) SWIG_fail;
43682 }
43683 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_OWN | 0 );
43684 return resultobj;
43685 fail:
43686 return NULL;
43687 }
43688
43689
43690 SWIGINTERN PyObject *_wrap_Control_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43691 PyObject *resultobj = 0;
43692 wxControl *arg1 = (wxControl *) 0 ;
43693 wxWindow *arg2 = (wxWindow *) 0 ;
43694 int arg3 = (int) -1 ;
43695 wxPoint const &arg4_defvalue = wxDefaultPosition ;
43696 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
43697 wxSize const &arg5_defvalue = wxDefaultSize ;
43698 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
43699 long arg6 = (long) 0 ;
43700 wxValidator const &arg7_defvalue = wxDefaultValidator ;
43701 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
43702 wxString const &arg8_defvalue = wxPyControlNameStr ;
43703 wxString *arg8 = (wxString *) &arg8_defvalue ;
43704 bool result;
43705 void *argp1 = 0 ;
43706 int res1 = 0 ;
43707 void *argp2 = 0 ;
43708 int res2 = 0 ;
43709 int val3 ;
43710 int ecode3 = 0 ;
43711 wxPoint temp4 ;
43712 wxSize temp5 ;
43713 long val6 ;
43714 int ecode6 = 0 ;
43715 void *argp7 = 0 ;
43716 int res7 = 0 ;
43717 bool temp8 = false ;
43718 PyObject * obj0 = 0 ;
43719 PyObject * obj1 = 0 ;
43720 PyObject * obj2 = 0 ;
43721 PyObject * obj3 = 0 ;
43722 PyObject * obj4 = 0 ;
43723 PyObject * obj5 = 0 ;
43724 PyObject * obj6 = 0 ;
43725 PyObject * obj7 = 0 ;
43726 char * kwnames[] = {
43727 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
43728 };
43729
43730 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
43731 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
43732 if (!SWIG_IsOK(res1)) {
43733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Create" "', expected argument " "1"" of type '" "wxControl *""'");
43734 }
43735 arg1 = reinterpret_cast< wxControl * >(argp1);
43736 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
43737 if (!SWIG_IsOK(res2)) {
43738 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
43739 }
43740 arg2 = reinterpret_cast< wxWindow * >(argp2);
43741 if (obj2) {
43742 ecode3 = SWIG_AsVal_int(obj2, &val3);
43743 if (!SWIG_IsOK(ecode3)) {
43744 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Control_Create" "', expected argument " "3"" of type '" "int""'");
43745 }
43746 arg3 = static_cast< int >(val3);
43747 }
43748 if (obj3) {
43749 {
43750 arg4 = &temp4;
43751 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
43752 }
43753 }
43754 if (obj4) {
43755 {
43756 arg5 = &temp5;
43757 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
43758 }
43759 }
43760 if (obj5) {
43761 ecode6 = SWIG_AsVal_long(obj5, &val6);
43762 if (!SWIG_IsOK(ecode6)) {
43763 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Control_Create" "', expected argument " "6"" of type '" "long""'");
43764 }
43765 arg6 = static_cast< long >(val6);
43766 }
43767 if (obj6) {
43768 res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator, 0 | 0);
43769 if (!SWIG_IsOK(res7)) {
43770 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
43771 }
43772 if (!argp7) {
43773 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
43774 }
43775 arg7 = reinterpret_cast< wxValidator * >(argp7);
43776 }
43777 if (obj7) {
43778 {
43779 arg8 = wxString_in_helper(obj7);
43780 if (arg8 == NULL) SWIG_fail;
43781 temp8 = true;
43782 }
43783 }
43784 {
43785 PyThreadState* __tstate = wxPyBeginAllowThreads();
43786 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
43787 wxPyEndAllowThreads(__tstate);
43788 if (PyErr_Occurred()) SWIG_fail;
43789 }
43790 {
43791 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43792 }
43793 {
43794 if (temp8)
43795 delete arg8;
43796 }
43797 return resultobj;
43798 fail:
43799 {
43800 if (temp8)
43801 delete arg8;
43802 }
43803 return NULL;
43804 }
43805
43806
43807 SWIGINTERN PyObject *_wrap_Control_Command(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43808 PyObject *resultobj = 0;
43809 wxControl *arg1 = (wxControl *) 0 ;
43810 wxCommandEvent *arg2 = 0 ;
43811 void *argp1 = 0 ;
43812 int res1 = 0 ;
43813 void *argp2 = 0 ;
43814 int res2 = 0 ;
43815 PyObject * obj0 = 0 ;
43816 PyObject * obj1 = 0 ;
43817 char * kwnames[] = {
43818 (char *) "self",(char *) "event", NULL
43819 };
43820
43821 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) SWIG_fail;
43822 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
43823 if (!SWIG_IsOK(res1)) {
43824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Command" "', expected argument " "1"" of type '" "wxControl *""'");
43825 }
43826 arg1 = reinterpret_cast< wxControl * >(argp1);
43827 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCommandEvent, 0 );
43828 if (!SWIG_IsOK(res2)) {
43829 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
43830 }
43831 if (!argp2) {
43832 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
43833 }
43834 arg2 = reinterpret_cast< wxCommandEvent * >(argp2);
43835 {
43836 PyThreadState* __tstate = wxPyBeginAllowThreads();
43837 (arg1)->Command(*arg2);
43838 wxPyEndAllowThreads(__tstate);
43839 if (PyErr_Occurred()) SWIG_fail;
43840 }
43841 resultobj = SWIG_Py_Void();
43842 return resultobj;
43843 fail:
43844 return NULL;
43845 }
43846
43847
43848 SWIGINTERN PyObject *_wrap_Control_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43849 PyObject *resultobj = 0;
43850 wxControl *arg1 = (wxControl *) 0 ;
43851 wxString result;
43852 void *argp1 = 0 ;
43853 int res1 = 0 ;
43854 PyObject *swig_obj[1] ;
43855
43856 if (!args) SWIG_fail;
43857 swig_obj[0] = args;
43858 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
43859 if (!SWIG_IsOK(res1)) {
43860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabel" "', expected argument " "1"" of type '" "wxControl *""'");
43861 }
43862 arg1 = reinterpret_cast< wxControl * >(argp1);
43863 {
43864 PyThreadState* __tstate = wxPyBeginAllowThreads();
43865 result = (arg1)->GetLabel();
43866 wxPyEndAllowThreads(__tstate);
43867 if (PyErr_Occurred()) SWIG_fail;
43868 }
43869 {
43870 #if wxUSE_UNICODE
43871 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43872 #else
43873 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43874 #endif
43875 }
43876 return resultobj;
43877 fail:
43878 return NULL;
43879 }
43880
43881
43882 SWIGINTERN PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43883 PyObject *resultobj = 0;
43884 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
43885 SwigValueWrapper<wxVisualAttributes > result;
43886 int val1 ;
43887 int ecode1 = 0 ;
43888 PyObject * obj0 = 0 ;
43889 char * kwnames[] = {
43890 (char *) "variant", NULL
43891 };
43892
43893 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
43894 if (obj0) {
43895 ecode1 = SWIG_AsVal_int(obj0, &val1);
43896 if (!SWIG_IsOK(ecode1)) {
43897 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Control_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
43898 }
43899 arg1 = static_cast< wxWindowVariant >(val1);
43900 }
43901 {
43902 if (!wxPyCheckForApp()) SWIG_fail;
43903 PyThreadState* __tstate = wxPyBeginAllowThreads();
43904 result = wxControl::GetClassDefaultAttributes(arg1);
43905 wxPyEndAllowThreads(__tstate);
43906 if (PyErr_Occurred()) SWIG_fail;
43907 }
43908 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
43909 return resultobj;
43910 fail:
43911 return NULL;
43912 }
43913
43914
43915 SWIGINTERN PyObject *Control_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43916 PyObject *obj;
43917 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
43918 SWIG_TypeNewClientData(SWIGTYPE_p_wxControl, SWIG_NewClientData(obj));
43919 return SWIG_Py_Void();
43920 }
43921
43922 SWIGINTERN PyObject *Control_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43923 return SWIG_Python_InitShadowInstance(args);
43924 }
43925
43926 SWIGINTERN PyObject *_wrap_ItemContainer_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43927 PyObject *resultobj = 0;
43928 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
43929 wxString *arg2 = 0 ;
43930 PyObject *arg3 = (PyObject *) NULL ;
43931 int result;
43932 void *argp1 = 0 ;
43933 int res1 = 0 ;
43934 bool temp2 = false ;
43935 PyObject * obj0 = 0 ;
43936 PyObject * obj1 = 0 ;
43937 PyObject * obj2 = 0 ;
43938 char * kwnames[] = {
43939 (char *) "self",(char *) "item",(char *) "clientData", NULL
43940 };
43941
43942 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43943 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
43944 if (!SWIG_IsOK(res1)) {
43945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Append" "', expected argument " "1"" of type '" "wxItemContainer *""'");
43946 }
43947 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
43948 {
43949 arg2 = wxString_in_helper(obj1);
43950 if (arg2 == NULL) SWIG_fail;
43951 temp2 = true;
43952 }
43953 if (obj2) {
43954 arg3 = obj2;
43955 }
43956 {
43957 PyThreadState* __tstate = wxPyBeginAllowThreads();
43958 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
43959 wxPyEndAllowThreads(__tstate);
43960 if (PyErr_Occurred()) SWIG_fail;
43961 }
43962 resultobj = SWIG_From_int(static_cast< int >(result));
43963 {
43964 if (temp2)
43965 delete arg2;
43966 }
43967 return resultobj;
43968 fail:
43969 {
43970 if (temp2)
43971 delete arg2;
43972 }
43973 return NULL;
43974 }
43975
43976
43977 SWIGINTERN PyObject *_wrap_ItemContainer_AppendItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43978 PyObject *resultobj = 0;
43979 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
43980 wxArrayString *arg2 = 0 ;
43981 void *argp1 = 0 ;
43982 int res1 = 0 ;
43983 bool temp2 = false ;
43984 PyObject * obj0 = 0 ;
43985 PyObject * obj1 = 0 ;
43986 char * kwnames[] = {
43987 (char *) "self",(char *) "strings", NULL
43988 };
43989
43990 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) SWIG_fail;
43991 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
43992 if (!SWIG_IsOK(res1)) {
43993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_AppendItems" "', expected argument " "1"" of type '" "wxItemContainer *""'");
43994 }
43995 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
43996 {
43997 if (! PySequence_Check(obj1)) {
43998 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
43999 SWIG_fail;
44000 }
44001 arg2 = new wxArrayString;
44002 temp2 = true;
44003 int i, len=PySequence_Length(obj1);
44004 for (i=0; i<len; i++) {
44005 PyObject* item = PySequence_GetItem(obj1, i);
44006 wxString* s = wxString_in_helper(item);
44007 if (PyErr_Occurred()) SWIG_fail;
44008 arg2->Add(*s);
44009 delete s;
44010 Py_DECREF(item);
44011 }
44012 }
44013 {
44014 PyThreadState* __tstate = wxPyBeginAllowThreads();
44015 (arg1)->Append((wxArrayString const &)*arg2);
44016 wxPyEndAllowThreads(__tstate);
44017 if (PyErr_Occurred()) SWIG_fail;
44018 }
44019 resultobj = SWIG_Py_Void();
44020 {
44021 if (temp2) delete arg2;
44022 }
44023 return resultobj;
44024 fail:
44025 {
44026 if (temp2) delete arg2;
44027 }
44028 return NULL;
44029 }
44030
44031
44032 SWIGINTERN PyObject *_wrap_ItemContainer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44033 PyObject *resultobj = 0;
44034 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44035 wxString *arg2 = 0 ;
44036 unsigned int arg3 ;
44037 PyObject *arg4 = (PyObject *) NULL ;
44038 int result;
44039 void *argp1 = 0 ;
44040 int res1 = 0 ;
44041 bool temp2 = false ;
44042 unsigned int val3 ;
44043 int ecode3 = 0 ;
44044 PyObject * obj0 = 0 ;
44045 PyObject * obj1 = 0 ;
44046 PyObject * obj2 = 0 ;
44047 PyObject * obj3 = 0 ;
44048 char * kwnames[] = {
44049 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
44050 };
44051
44052 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
44053 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44054 if (!SWIG_IsOK(res1)) {
44055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Insert" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44056 }
44057 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44058 {
44059 arg2 = wxString_in_helper(obj1);
44060 if (arg2 == NULL) SWIG_fail;
44061 temp2 = true;
44062 }
44063 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
44064 if (!SWIG_IsOK(ecode3)) {
44065 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ItemContainer_Insert" "', expected argument " "3"" of type '" "unsigned int""'");
44066 }
44067 arg3 = static_cast< unsigned int >(val3);
44068 if (obj3) {
44069 arg4 = obj3;
44070 }
44071 {
44072 PyThreadState* __tstate = wxPyBeginAllowThreads();
44073 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
44074 wxPyEndAllowThreads(__tstate);
44075 if (PyErr_Occurred()) SWIG_fail;
44076 }
44077 resultobj = SWIG_From_int(static_cast< int >(result));
44078 {
44079 if (temp2)
44080 delete arg2;
44081 }
44082 return resultobj;
44083 fail:
44084 {
44085 if (temp2)
44086 delete arg2;
44087 }
44088 return NULL;
44089 }
44090
44091
44092 SWIGINTERN PyObject *_wrap_ItemContainer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44093 PyObject *resultobj = 0;
44094 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44095 void *argp1 = 0 ;
44096 int res1 = 0 ;
44097 PyObject *swig_obj[1] ;
44098
44099 if (!args) SWIG_fail;
44100 swig_obj[0] = args;
44101 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44102 if (!SWIG_IsOK(res1)) {
44103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Clear" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44104 }
44105 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44106 {
44107 PyThreadState* __tstate = wxPyBeginAllowThreads();
44108 (arg1)->Clear();
44109 wxPyEndAllowThreads(__tstate);
44110 if (PyErr_Occurred()) SWIG_fail;
44111 }
44112 resultobj = SWIG_Py_Void();
44113 return resultobj;
44114 fail:
44115 return NULL;
44116 }
44117
44118
44119 SWIGINTERN PyObject *_wrap_ItemContainer_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44120 PyObject *resultobj = 0;
44121 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44122 unsigned int arg2 ;
44123 void *argp1 = 0 ;
44124 int res1 = 0 ;
44125 unsigned int val2 ;
44126 int ecode2 = 0 ;
44127 PyObject * obj0 = 0 ;
44128 PyObject * obj1 = 0 ;
44129 char * kwnames[] = {
44130 (char *) "self",(char *) "n", NULL
44131 };
44132
44133 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
44134 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44135 if (!SWIG_IsOK(res1)) {
44136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Delete" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44137 }
44138 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44139 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44140 if (!SWIG_IsOK(ecode2)) {
44141 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Delete" "', expected argument " "2"" of type '" "unsigned int""'");
44142 }
44143 arg2 = static_cast< unsigned int >(val2);
44144 {
44145 PyThreadState* __tstate = wxPyBeginAllowThreads();
44146 (arg1)->Delete(arg2);
44147 wxPyEndAllowThreads(__tstate);
44148 if (PyErr_Occurred()) SWIG_fail;
44149 }
44150 resultobj = SWIG_Py_Void();
44151 return resultobj;
44152 fail:
44153 return NULL;
44154 }
44155
44156
44157 SWIGINTERN PyObject *_wrap_ItemContainer_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44158 PyObject *resultobj = 0;
44159 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44160 unsigned int arg2 ;
44161 PyObject *result = 0 ;
44162 void *argp1 = 0 ;
44163 int res1 = 0 ;
44164 unsigned int val2 ;
44165 int ecode2 = 0 ;
44166 PyObject * obj0 = 0 ;
44167 PyObject * obj1 = 0 ;
44168 char * kwnames[] = {
44169 (char *) "self",(char *) "n", NULL
44170 };
44171
44172 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
44173 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44174 if (!SWIG_IsOK(res1)) {
44175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44176 }
44177 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44178 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44179 if (!SWIG_IsOK(ecode2)) {
44180 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
44181 }
44182 arg2 = static_cast< unsigned int >(val2);
44183 {
44184 PyThreadState* __tstate = wxPyBeginAllowThreads();
44185 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
44186 wxPyEndAllowThreads(__tstate);
44187 if (PyErr_Occurred()) SWIG_fail;
44188 }
44189 resultobj = result;
44190 return resultobj;
44191 fail:
44192 return NULL;
44193 }
44194
44195
44196 SWIGINTERN PyObject *_wrap_ItemContainer_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44197 PyObject *resultobj = 0;
44198 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44199 unsigned int arg2 ;
44200 PyObject *arg3 = (PyObject *) 0 ;
44201 void *argp1 = 0 ;
44202 int res1 = 0 ;
44203 unsigned int val2 ;
44204 int ecode2 = 0 ;
44205 PyObject * obj0 = 0 ;
44206 PyObject * obj1 = 0 ;
44207 PyObject * obj2 = 0 ;
44208 char * kwnames[] = {
44209 (char *) "self",(char *) "n",(char *) "clientData", NULL
44210 };
44211
44212 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) 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_SetClientData" "', 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_SetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
44221 }
44222 arg2 = static_cast< unsigned int >(val2);
44223 arg3 = obj2;
44224 {
44225 PyThreadState* __tstate = wxPyBeginAllowThreads();
44226 wxItemContainer_SetClientData(arg1,arg2,arg3);
44227 wxPyEndAllowThreads(__tstate);
44228 if (PyErr_Occurred()) SWIG_fail;
44229 }
44230 resultobj = SWIG_Py_Void();
44231 return resultobj;
44232 fail:
44233 return NULL;
44234 }
44235
44236
44237 SWIGINTERN PyObject *_wrap_ItemContainer_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44238 PyObject *resultobj = 0;
44239 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44240 unsigned int result;
44241 void *argp1 = 0 ;
44242 int res1 = 0 ;
44243 PyObject *swig_obj[1] ;
44244
44245 if (!args) SWIG_fail;
44246 swig_obj[0] = args;
44247 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44248 if (!SWIG_IsOK(res1)) {
44249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetCount" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44250 }
44251 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44252 {
44253 PyThreadState* __tstate = wxPyBeginAllowThreads();
44254 result = (unsigned int)((wxItemContainer const *)arg1)->GetCount();
44255 wxPyEndAllowThreads(__tstate);
44256 if (PyErr_Occurred()) SWIG_fail;
44257 }
44258 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
44259 return resultobj;
44260 fail:
44261 return NULL;
44262 }
44263
44264
44265 SWIGINTERN PyObject *_wrap_ItemContainer_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44266 PyObject *resultobj = 0;
44267 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44268 bool result;
44269 void *argp1 = 0 ;
44270 int res1 = 0 ;
44271 PyObject *swig_obj[1] ;
44272
44273 if (!args) SWIG_fail;
44274 swig_obj[0] = args;
44275 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44276 if (!SWIG_IsOK(res1)) {
44277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_IsEmpty" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44278 }
44279 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44280 {
44281 PyThreadState* __tstate = wxPyBeginAllowThreads();
44282 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
44283 wxPyEndAllowThreads(__tstate);
44284 if (PyErr_Occurred()) SWIG_fail;
44285 }
44286 {
44287 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44288 }
44289 return resultobj;
44290 fail:
44291 return NULL;
44292 }
44293
44294
44295 SWIGINTERN PyObject *_wrap_ItemContainer_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44296 PyObject *resultobj = 0;
44297 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44298 unsigned int arg2 ;
44299 wxString result;
44300 void *argp1 = 0 ;
44301 int res1 = 0 ;
44302 unsigned int val2 ;
44303 int ecode2 = 0 ;
44304 PyObject * obj0 = 0 ;
44305 PyObject * obj1 = 0 ;
44306 char * kwnames[] = {
44307 (char *) "self",(char *) "n", NULL
44308 };
44309
44310 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) SWIG_fail;
44311 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44312 if (!SWIG_IsOK(res1)) {
44313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44314 }
44315 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44316 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44317 if (!SWIG_IsOK(ecode2)) {
44318 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetString" "', expected argument " "2"" of type '" "unsigned int""'");
44319 }
44320 arg2 = static_cast< unsigned int >(val2);
44321 {
44322 PyThreadState* __tstate = wxPyBeginAllowThreads();
44323 result = ((wxItemContainer const *)arg1)->GetString(arg2);
44324 wxPyEndAllowThreads(__tstate);
44325 if (PyErr_Occurred()) SWIG_fail;
44326 }
44327 {
44328 #if wxUSE_UNICODE
44329 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44330 #else
44331 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44332 #endif
44333 }
44334 return resultobj;
44335 fail:
44336 return NULL;
44337 }
44338
44339
44340 SWIGINTERN PyObject *_wrap_ItemContainer_GetStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44341 PyObject *resultobj = 0;
44342 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44343 wxArrayString result;
44344 void *argp1 = 0 ;
44345 int res1 = 0 ;
44346 PyObject *swig_obj[1] ;
44347
44348 if (!args) SWIG_fail;
44349 swig_obj[0] = args;
44350 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44351 if (!SWIG_IsOK(res1)) {
44352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStrings" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44353 }
44354 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44355 {
44356 PyThreadState* __tstate = wxPyBeginAllowThreads();
44357 result = ((wxItemContainer const *)arg1)->GetStrings();
44358 wxPyEndAllowThreads(__tstate);
44359 if (PyErr_Occurred()) SWIG_fail;
44360 }
44361 {
44362 resultobj = wxArrayString2PyList_helper(result);
44363 }
44364 return resultobj;
44365 fail:
44366 return NULL;
44367 }
44368
44369
44370 SWIGINTERN PyObject *_wrap_ItemContainer_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44371 PyObject *resultobj = 0;
44372 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44373 unsigned int arg2 ;
44374 wxString *arg3 = 0 ;
44375 void *argp1 = 0 ;
44376 int res1 = 0 ;
44377 unsigned int val2 ;
44378 int ecode2 = 0 ;
44379 bool temp3 = false ;
44380 PyObject * obj0 = 0 ;
44381 PyObject * obj1 = 0 ;
44382 PyObject * obj2 = 0 ;
44383 char * kwnames[] = {
44384 (char *) "self",(char *) "n",(char *) "s", NULL
44385 };
44386
44387 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44388 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44389 if (!SWIG_IsOK(res1)) {
44390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetString" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44391 }
44392 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44393 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44394 if (!SWIG_IsOK(ecode2)) {
44395 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetString" "', expected argument " "2"" of type '" "unsigned int""'");
44396 }
44397 arg2 = static_cast< unsigned int >(val2);
44398 {
44399 arg3 = wxString_in_helper(obj2);
44400 if (arg3 == NULL) SWIG_fail;
44401 temp3 = true;
44402 }
44403 {
44404 PyThreadState* __tstate = wxPyBeginAllowThreads();
44405 (arg1)->SetString(arg2,(wxString const &)*arg3);
44406 wxPyEndAllowThreads(__tstate);
44407 if (PyErr_Occurred()) SWIG_fail;
44408 }
44409 resultobj = SWIG_Py_Void();
44410 {
44411 if (temp3)
44412 delete arg3;
44413 }
44414 return resultobj;
44415 fail:
44416 {
44417 if (temp3)
44418 delete arg3;
44419 }
44420 return NULL;
44421 }
44422
44423
44424 SWIGINTERN PyObject *_wrap_ItemContainer_FindString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44425 PyObject *resultobj = 0;
44426 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44427 wxString *arg2 = 0 ;
44428 int result;
44429 void *argp1 = 0 ;
44430 int res1 = 0 ;
44431 bool temp2 = false ;
44432 PyObject * obj0 = 0 ;
44433 PyObject * obj1 = 0 ;
44434 char * kwnames[] = {
44435 (char *) "self",(char *) "s", NULL
44436 };
44437
44438 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) SWIG_fail;
44439 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44440 if (!SWIG_IsOK(res1)) {
44441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_FindString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44442 }
44443 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44444 {
44445 arg2 = wxString_in_helper(obj1);
44446 if (arg2 == NULL) SWIG_fail;
44447 temp2 = true;
44448 }
44449 {
44450 PyThreadState* __tstate = wxPyBeginAllowThreads();
44451 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
44452 wxPyEndAllowThreads(__tstate);
44453 if (PyErr_Occurred()) SWIG_fail;
44454 }
44455 resultobj = SWIG_From_int(static_cast< int >(result));
44456 {
44457 if (temp2)
44458 delete arg2;
44459 }
44460 return resultobj;
44461 fail:
44462 {
44463 if (temp2)
44464 delete arg2;
44465 }
44466 return NULL;
44467 }
44468
44469
44470 SWIGINTERN PyObject *_wrap_ItemContainer_SetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44471 PyObject *resultobj = 0;
44472 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44473 int arg2 ;
44474 void *argp1 = 0 ;
44475 int res1 = 0 ;
44476 int val2 ;
44477 int ecode2 = 0 ;
44478 PyObject * obj0 = 0 ;
44479 PyObject * obj1 = 0 ;
44480 char * kwnames[] = {
44481 (char *) "self",(char *) "n", NULL
44482 };
44483
44484 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) SWIG_fail;
44485 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44486 if (!SWIG_IsOK(res1)) {
44487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44488 }
44489 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44490 ecode2 = SWIG_AsVal_int(obj1, &val2);
44491 if (!SWIG_IsOK(ecode2)) {
44492 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetSelection" "', expected argument " "2"" of type '" "int""'");
44493 }
44494 arg2 = static_cast< int >(val2);
44495 {
44496 PyThreadState* __tstate = wxPyBeginAllowThreads();
44497 (arg1)->SetSelection(arg2);
44498 wxPyEndAllowThreads(__tstate);
44499 if (PyErr_Occurred()) SWIG_fail;
44500 }
44501 resultobj = SWIG_Py_Void();
44502 return resultobj;
44503 fail:
44504 return NULL;
44505 }
44506
44507
44508 SWIGINTERN PyObject *_wrap_ItemContainer_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44509 PyObject *resultobj = 0;
44510 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44511 int result;
44512 void *argp1 = 0 ;
44513 int res1 = 0 ;
44514 PyObject *swig_obj[1] ;
44515
44516 if (!args) SWIG_fail;
44517 swig_obj[0] = args;
44518 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44519 if (!SWIG_IsOK(res1)) {
44520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44521 }
44522 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44523 {
44524 PyThreadState* __tstate = wxPyBeginAllowThreads();
44525 result = (int)((wxItemContainer const *)arg1)->GetSelection();
44526 wxPyEndAllowThreads(__tstate);
44527 if (PyErr_Occurred()) SWIG_fail;
44528 }
44529 resultobj = SWIG_From_int(static_cast< int >(result));
44530 return resultobj;
44531 fail:
44532 return NULL;
44533 }
44534
44535
44536 SWIGINTERN PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44537 PyObject *resultobj = 0;
44538 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44539 wxString *arg2 = 0 ;
44540 bool result;
44541 void *argp1 = 0 ;
44542 int res1 = 0 ;
44543 bool temp2 = false ;
44544 PyObject * obj0 = 0 ;
44545 PyObject * obj1 = 0 ;
44546 char * kwnames[] = {
44547 (char *) "self",(char *) "s", NULL
44548 };
44549
44550 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) SWIG_fail;
44551 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44552 if (!SWIG_IsOK(res1)) {
44553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44554 }
44555 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44556 {
44557 arg2 = wxString_in_helper(obj1);
44558 if (arg2 == NULL) SWIG_fail;
44559 temp2 = true;
44560 }
44561 {
44562 PyThreadState* __tstate = wxPyBeginAllowThreads();
44563 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
44564 wxPyEndAllowThreads(__tstate);
44565 if (PyErr_Occurred()) SWIG_fail;
44566 }
44567 {
44568 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44569 }
44570 {
44571 if (temp2)
44572 delete arg2;
44573 }
44574 return resultobj;
44575 fail:
44576 {
44577 if (temp2)
44578 delete arg2;
44579 }
44580 return NULL;
44581 }
44582
44583
44584 SWIGINTERN PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44585 PyObject *resultobj = 0;
44586 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44587 wxString result;
44588 void *argp1 = 0 ;
44589 int res1 = 0 ;
44590 PyObject *swig_obj[1] ;
44591
44592 if (!args) SWIG_fail;
44593 swig_obj[0] = args;
44594 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44595 if (!SWIG_IsOK(res1)) {
44596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44597 }
44598 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44599 {
44600 PyThreadState* __tstate = wxPyBeginAllowThreads();
44601 result = ((wxItemContainer const *)arg1)->GetStringSelection();
44602 wxPyEndAllowThreads(__tstate);
44603 if (PyErr_Occurred()) SWIG_fail;
44604 }
44605 {
44606 #if wxUSE_UNICODE
44607 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44608 #else
44609 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44610 #endif
44611 }
44612 return resultobj;
44613 fail:
44614 return NULL;
44615 }
44616
44617
44618 SWIGINTERN PyObject *_wrap_ItemContainer_Select(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44619 PyObject *resultobj = 0;
44620 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44621 int arg2 ;
44622 void *argp1 = 0 ;
44623 int res1 = 0 ;
44624 int val2 ;
44625 int ecode2 = 0 ;
44626 PyObject * obj0 = 0 ;
44627 PyObject * obj1 = 0 ;
44628 char * kwnames[] = {
44629 (char *) "self",(char *) "n", NULL
44630 };
44631
44632 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) SWIG_fail;
44633 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44634 if (!SWIG_IsOK(res1)) {
44635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Select" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44636 }
44637 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44638 ecode2 = SWIG_AsVal_int(obj1, &val2);
44639 if (!SWIG_IsOK(ecode2)) {
44640 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Select" "', expected argument " "2"" of type '" "int""'");
44641 }
44642 arg2 = static_cast< int >(val2);
44643 {
44644 PyThreadState* __tstate = wxPyBeginAllowThreads();
44645 (arg1)->Select(arg2);
44646 wxPyEndAllowThreads(__tstate);
44647 if (PyErr_Occurred()) SWIG_fail;
44648 }
44649 resultobj = SWIG_Py_Void();
44650 return resultobj;
44651 fail:
44652 return NULL;
44653 }
44654
44655
44656 SWIGINTERN PyObject *ItemContainer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44657 PyObject *obj;
44658 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44659 SWIG_TypeNewClientData(SWIGTYPE_p_wxItemContainer, SWIG_NewClientData(obj));
44660 return SWIG_Py_Void();
44661 }
44662
44663 SWIGINTERN PyObject *ControlWithItems_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44664 PyObject *obj;
44665 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44666 SWIG_TypeNewClientData(SWIGTYPE_p_wxControlWithItems, SWIG_NewClientData(obj));
44667 return SWIG_Py_Void();
44668 }
44669
44670 SWIGINTERN PyObject *_wrap_new_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44671 PyObject *resultobj = 0;
44672 wxSizerItem *result = 0 ;
44673
44674 if (!SWIG_Python_UnpackTuple(args,"new_SizerItem",0,0,0)) SWIG_fail;
44675 {
44676 PyThreadState* __tstate = wxPyBeginAllowThreads();
44677 result = (wxSizerItem *)new wxSizerItem();
44678 wxPyEndAllowThreads(__tstate);
44679 if (PyErr_Occurred()) SWIG_fail;
44680 }
44681 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_NEW | 0 );
44682 return resultobj;
44683 fail:
44684 return NULL;
44685 }
44686
44687
44688 SWIGINTERN PyObject *_wrap_delete_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44689 PyObject *resultobj = 0;
44690 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44691 void *argp1 = 0 ;
44692 int res1 = 0 ;
44693 PyObject *swig_obj[1] ;
44694
44695 if (!args) SWIG_fail;
44696 swig_obj[0] = args;
44697 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
44698 if (!SWIG_IsOK(res1)) {
44699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerItem" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44700 }
44701 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44702 {
44703 PyThreadState* __tstate = wxPyBeginAllowThreads();
44704 delete arg1;
44705
44706 wxPyEndAllowThreads(__tstate);
44707 if (PyErr_Occurred()) SWIG_fail;
44708 }
44709 resultobj = SWIG_Py_Void();
44710 return resultobj;
44711 fail:
44712 return NULL;
44713 }
44714
44715
44716 SWIGINTERN PyObject *_wrap_new_SizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44717 PyObject *resultobj = 0;
44718 wxWindow *arg1 = (wxWindow *) 0 ;
44719 int arg2 ;
44720 int arg3 ;
44721 int arg4 ;
44722 PyObject *arg5 = (PyObject *) NULL ;
44723 wxSizerItem *result = 0 ;
44724 void *argp1 = 0 ;
44725 int res1 = 0 ;
44726 int val2 ;
44727 int ecode2 = 0 ;
44728 int val3 ;
44729 int ecode3 = 0 ;
44730 int val4 ;
44731 int ecode4 = 0 ;
44732 PyObject * obj0 = 0 ;
44733 PyObject * obj1 = 0 ;
44734 PyObject * obj2 = 0 ;
44735 PyObject * obj3 = 0 ;
44736 PyObject * obj4 = 0 ;
44737 char * kwnames[] = {
44738 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
44739 };
44740
44741 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
44742 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
44743 if (!SWIG_IsOK(res1)) {
44744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
44745 }
44746 arg1 = reinterpret_cast< wxWindow * >(argp1);
44747 ecode2 = SWIG_AsVal_int(obj1, &val2);
44748 if (!SWIG_IsOK(ecode2)) {
44749 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemWindow" "', expected argument " "2"" of type '" "int""'");
44750 }
44751 arg2 = static_cast< int >(val2);
44752 ecode3 = SWIG_AsVal_int(obj2, &val3);
44753 if (!SWIG_IsOK(ecode3)) {
44754 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemWindow" "', expected argument " "3"" of type '" "int""'");
44755 }
44756 arg3 = static_cast< int >(val3);
44757 ecode4 = SWIG_AsVal_int(obj3, &val4);
44758 if (!SWIG_IsOK(ecode4)) {
44759 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemWindow" "', expected argument " "4"" of type '" "int""'");
44760 }
44761 arg4 = static_cast< int >(val4);
44762 if (obj4) {
44763 arg5 = obj4;
44764 }
44765 {
44766 PyThreadState* __tstate = wxPyBeginAllowThreads();
44767 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
44768 wxPyEndAllowThreads(__tstate);
44769 if (PyErr_Occurred()) SWIG_fail;
44770 }
44771 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
44772 return resultobj;
44773 fail:
44774 return NULL;
44775 }
44776
44777
44778 SWIGINTERN PyObject *_wrap_new_SizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44779 PyObject *resultobj = 0;
44780 int arg1 ;
44781 int arg2 ;
44782 int arg3 ;
44783 int arg4 ;
44784 int arg5 ;
44785 PyObject *arg6 = (PyObject *) NULL ;
44786 wxSizerItem *result = 0 ;
44787 int val1 ;
44788 int ecode1 = 0 ;
44789 int val2 ;
44790 int ecode2 = 0 ;
44791 int val3 ;
44792 int ecode3 = 0 ;
44793 int val4 ;
44794 int ecode4 = 0 ;
44795 int val5 ;
44796 int ecode5 = 0 ;
44797 PyObject * obj0 = 0 ;
44798 PyObject * obj1 = 0 ;
44799 PyObject * obj2 = 0 ;
44800 PyObject * obj3 = 0 ;
44801 PyObject * obj4 = 0 ;
44802 PyObject * obj5 = 0 ;
44803 char * kwnames[] = {
44804 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
44805 };
44806
44807 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
44808 ecode1 = SWIG_AsVal_int(obj0, &val1);
44809 if (!SWIG_IsOK(ecode1)) {
44810 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
44811 }
44812 arg1 = static_cast< int >(val1);
44813 ecode2 = SWIG_AsVal_int(obj1, &val2);
44814 if (!SWIG_IsOK(ecode2)) {
44815 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
44816 }
44817 arg2 = static_cast< int >(val2);
44818 ecode3 = SWIG_AsVal_int(obj2, &val3);
44819 if (!SWIG_IsOK(ecode3)) {
44820 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSpacer" "', expected argument " "3"" of type '" "int""'");
44821 }
44822 arg3 = static_cast< int >(val3);
44823 ecode4 = SWIG_AsVal_int(obj3, &val4);
44824 if (!SWIG_IsOK(ecode4)) {
44825 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSpacer" "', expected argument " "4"" of type '" "int""'");
44826 }
44827 arg4 = static_cast< int >(val4);
44828 ecode5 = SWIG_AsVal_int(obj4, &val5);
44829 if (!SWIG_IsOK(ecode5)) {
44830 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
44831 }
44832 arg5 = static_cast< int >(val5);
44833 if (obj5) {
44834 arg6 = obj5;
44835 }
44836 {
44837 PyThreadState* __tstate = wxPyBeginAllowThreads();
44838 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
44839 wxPyEndAllowThreads(__tstate);
44840 if (PyErr_Occurred()) SWIG_fail;
44841 }
44842 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
44843 return resultobj;
44844 fail:
44845 return NULL;
44846 }
44847
44848
44849 SWIGINTERN PyObject *_wrap_new_SizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44850 PyObject *resultobj = 0;
44851 wxSizer *arg1 = (wxSizer *) 0 ;
44852 int arg2 ;
44853 int arg3 ;
44854 int arg4 ;
44855 PyObject *arg5 = (PyObject *) NULL ;
44856 wxSizerItem *result = 0 ;
44857 int res1 = 0 ;
44858 int val2 ;
44859 int ecode2 = 0 ;
44860 int val3 ;
44861 int ecode3 = 0 ;
44862 int val4 ;
44863 int ecode4 = 0 ;
44864 PyObject * obj0 = 0 ;
44865 PyObject * obj1 = 0 ;
44866 PyObject * obj2 = 0 ;
44867 PyObject * obj3 = 0 ;
44868 PyObject * obj4 = 0 ;
44869 char * kwnames[] = {
44870 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
44871 };
44872
44873 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
44874 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
44875 if (!SWIG_IsOK(res1)) {
44876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
44877 }
44878 ecode2 = SWIG_AsVal_int(obj1, &val2);
44879 if (!SWIG_IsOK(ecode2)) {
44880 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSizer" "', expected argument " "2"" of type '" "int""'");
44881 }
44882 arg2 = static_cast< int >(val2);
44883 ecode3 = SWIG_AsVal_int(obj2, &val3);
44884 if (!SWIG_IsOK(ecode3)) {
44885 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSizer" "', expected argument " "3"" of type '" "int""'");
44886 }
44887 arg3 = static_cast< int >(val3);
44888 ecode4 = SWIG_AsVal_int(obj3, &val4);
44889 if (!SWIG_IsOK(ecode4)) {
44890 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSizer" "', expected argument " "4"" of type '" "int""'");
44891 }
44892 arg4 = static_cast< int >(val4);
44893 if (obj4) {
44894 arg5 = obj4;
44895 }
44896 {
44897 PyThreadState* __tstate = wxPyBeginAllowThreads();
44898 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
44899 wxPyEndAllowThreads(__tstate);
44900 if (PyErr_Occurred()) SWIG_fail;
44901 }
44902 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
44903 return resultobj;
44904 fail:
44905 return NULL;
44906 }
44907
44908
44909 SWIGINTERN PyObject *_wrap_SizerItem_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44910 PyObject *resultobj = 0;
44911 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44912 void *argp1 = 0 ;
44913 int res1 = 0 ;
44914 PyObject *swig_obj[1] ;
44915
44916 if (!args) SWIG_fail;
44917 swig_obj[0] = args;
44918 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
44919 if (!SWIG_IsOK(res1)) {
44920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DeleteWindows" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44921 }
44922 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44923 {
44924 PyThreadState* __tstate = wxPyBeginAllowThreads();
44925 (arg1)->DeleteWindows();
44926 wxPyEndAllowThreads(__tstate);
44927 if (PyErr_Occurred()) SWIG_fail;
44928 }
44929 resultobj = SWIG_Py_Void();
44930 return resultobj;
44931 fail:
44932 return NULL;
44933 }
44934
44935
44936 SWIGINTERN PyObject *_wrap_SizerItem_DetachSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44937 PyObject *resultobj = 0;
44938 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44939 void *argp1 = 0 ;
44940 int res1 = 0 ;
44941 PyObject *swig_obj[1] ;
44942
44943 if (!args) SWIG_fail;
44944 swig_obj[0] = args;
44945 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
44946 if (!SWIG_IsOK(res1)) {
44947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DetachSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44948 }
44949 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44950 {
44951 PyThreadState* __tstate = wxPyBeginAllowThreads();
44952 (arg1)->DetachSizer();
44953 wxPyEndAllowThreads(__tstate);
44954 if (PyErr_Occurred()) SWIG_fail;
44955 }
44956 resultobj = SWIG_Py_Void();
44957 return resultobj;
44958 fail:
44959 return NULL;
44960 }
44961
44962
44963 SWIGINTERN PyObject *_wrap_SizerItem_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44964 PyObject *resultobj = 0;
44965 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44966 wxSize result;
44967 void *argp1 = 0 ;
44968 int res1 = 0 ;
44969 PyObject *swig_obj[1] ;
44970
44971 if (!args) SWIG_fail;
44972 swig_obj[0] = args;
44973 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
44974 if (!SWIG_IsOK(res1)) {
44975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44976 }
44977 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44978 {
44979 PyThreadState* __tstate = wxPyBeginAllowThreads();
44980 result = (arg1)->GetSize();
44981 wxPyEndAllowThreads(__tstate);
44982 if (PyErr_Occurred()) SWIG_fail;
44983 }
44984 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
44985 return resultobj;
44986 fail:
44987 return NULL;
44988 }
44989
44990
44991 SWIGINTERN PyObject *_wrap_SizerItem_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44992 PyObject *resultobj = 0;
44993 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44994 wxSize result;
44995 void *argp1 = 0 ;
44996 int res1 = 0 ;
44997 PyObject *swig_obj[1] ;
44998
44999 if (!args) SWIG_fail;
45000 swig_obj[0] = args;
45001 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45002 if (!SWIG_IsOK(res1)) {
45003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_CalcMin" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45004 }
45005 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45006 {
45007 PyThreadState* __tstate = wxPyBeginAllowThreads();
45008 result = (arg1)->CalcMin();
45009 wxPyEndAllowThreads(__tstate);
45010 if (PyErr_Occurred()) SWIG_fail;
45011 }
45012 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45013 return resultobj;
45014 fail:
45015 return NULL;
45016 }
45017
45018
45019 SWIGINTERN PyObject *_wrap_SizerItem_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45020 PyObject *resultobj = 0;
45021 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45022 wxPoint *arg2 = 0 ;
45023 wxSize *arg3 = 0 ;
45024 void *argp1 = 0 ;
45025 int res1 = 0 ;
45026 wxPoint temp2 ;
45027 wxSize temp3 ;
45028 PyObject * obj0 = 0 ;
45029 PyObject * obj1 = 0 ;
45030 PyObject * obj2 = 0 ;
45031 char * kwnames[] = {
45032 (char *) "self",(char *) "pos",(char *) "size", NULL
45033 };
45034
45035 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45036 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45037 if (!SWIG_IsOK(res1)) {
45038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetDimension" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45039 }
45040 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45041 {
45042 arg2 = &temp2;
45043 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
45044 }
45045 {
45046 arg3 = &temp3;
45047 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
45048 }
45049 {
45050 PyThreadState* __tstate = wxPyBeginAllowThreads();
45051 (arg1)->SetDimension((wxPoint const &)*arg2,(wxSize const &)*arg3);
45052 wxPyEndAllowThreads(__tstate);
45053 if (PyErr_Occurred()) SWIG_fail;
45054 }
45055 resultobj = SWIG_Py_Void();
45056 return resultobj;
45057 fail:
45058 return NULL;
45059 }
45060
45061
45062 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45063 PyObject *resultobj = 0;
45064 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45065 wxSize result;
45066 void *argp1 = 0 ;
45067 int res1 = 0 ;
45068 PyObject *swig_obj[1] ;
45069
45070 if (!args) SWIG_fail;
45071 swig_obj[0] = args;
45072 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45073 if (!SWIG_IsOK(res1)) {
45074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45075 }
45076 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45077 {
45078 PyThreadState* __tstate = wxPyBeginAllowThreads();
45079 result = (arg1)->GetMinSize();
45080 wxPyEndAllowThreads(__tstate);
45081 if (PyErr_Occurred()) SWIG_fail;
45082 }
45083 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45084 return resultobj;
45085 fail:
45086 return NULL;
45087 }
45088
45089
45090 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45091 PyObject *resultobj = 0;
45092 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45093 wxSize result;
45094 void *argp1 = 0 ;
45095 int res1 = 0 ;
45096 PyObject *swig_obj[1] ;
45097
45098 if (!args) SWIG_fail;
45099 swig_obj[0] = args;
45100 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45101 if (!SWIG_IsOK(res1)) {
45102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSizeWithBorder" "', expected argument " "1"" of type '" "wxSizerItem const *""'");
45103 }
45104 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45105 {
45106 PyThreadState* __tstate = wxPyBeginAllowThreads();
45107 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
45108 wxPyEndAllowThreads(__tstate);
45109 if (PyErr_Occurred()) SWIG_fail;
45110 }
45111 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45112 return resultobj;
45113 fail:
45114 return NULL;
45115 }
45116
45117
45118 SWIGINTERN PyObject *_wrap_SizerItem_SetInitSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45119 PyObject *resultobj = 0;
45120 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45121 int arg2 ;
45122 int arg3 ;
45123 void *argp1 = 0 ;
45124 int res1 = 0 ;
45125 int val2 ;
45126 int ecode2 = 0 ;
45127 int val3 ;
45128 int ecode3 = 0 ;
45129 PyObject * obj0 = 0 ;
45130 PyObject * obj1 = 0 ;
45131 PyObject * obj2 = 0 ;
45132 char * kwnames[] = {
45133 (char *) "self",(char *) "x",(char *) "y", NULL
45134 };
45135
45136 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45137 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45138 if (!SWIG_IsOK(res1)) {
45139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetInitSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45140 }
45141 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45142 ecode2 = SWIG_AsVal_int(obj1, &val2);
45143 if (!SWIG_IsOK(ecode2)) {
45144 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetInitSize" "', expected argument " "2"" of type '" "int""'");
45145 }
45146 arg2 = static_cast< int >(val2);
45147 ecode3 = SWIG_AsVal_int(obj2, &val3);
45148 if (!SWIG_IsOK(ecode3)) {
45149 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetInitSize" "', expected argument " "3"" of type '" "int""'");
45150 }
45151 arg3 = static_cast< int >(val3);
45152 {
45153 PyThreadState* __tstate = wxPyBeginAllowThreads();
45154 (arg1)->SetInitSize(arg2,arg3);
45155 wxPyEndAllowThreads(__tstate);
45156 if (PyErr_Occurred()) SWIG_fail;
45157 }
45158 resultobj = SWIG_Py_Void();
45159 return resultobj;
45160 fail:
45161 return NULL;
45162 }
45163
45164
45165 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45166 PyObject *resultobj = 0;
45167 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45168 int arg2 ;
45169 int arg3 ;
45170 void *argp1 = 0 ;
45171 int res1 = 0 ;
45172 int val2 ;
45173 int ecode2 = 0 ;
45174 int val3 ;
45175 int ecode3 = 0 ;
45176 PyObject * obj0 = 0 ;
45177 PyObject * obj1 = 0 ;
45178 PyObject * obj2 = 0 ;
45179 char * kwnames[] = {
45180 (char *) "self",(char *) "width",(char *) "height", NULL
45181 };
45182
45183 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45184 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45185 if (!SWIG_IsOK(res1)) {
45186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioWH" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45187 }
45188 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45189 ecode2 = SWIG_AsVal_int(obj1, &val2);
45190 if (!SWIG_IsOK(ecode2)) {
45191 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatioWH" "', expected argument " "2"" of type '" "int""'");
45192 }
45193 arg2 = static_cast< int >(val2);
45194 ecode3 = SWIG_AsVal_int(obj2, &val3);
45195 if (!SWIG_IsOK(ecode3)) {
45196 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetRatioWH" "', expected argument " "3"" of type '" "int""'");
45197 }
45198 arg3 = static_cast< int >(val3);
45199 {
45200 PyThreadState* __tstate = wxPyBeginAllowThreads();
45201 (arg1)->SetRatio(arg2,arg3);
45202 wxPyEndAllowThreads(__tstate);
45203 if (PyErr_Occurred()) SWIG_fail;
45204 }
45205 resultobj = SWIG_Py_Void();
45206 return resultobj;
45207 fail:
45208 return NULL;
45209 }
45210
45211
45212 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45213 PyObject *resultobj = 0;
45214 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45215 wxSize *arg2 = 0 ;
45216 void *argp1 = 0 ;
45217 int res1 = 0 ;
45218 wxSize temp2 ;
45219 PyObject * obj0 = 0 ;
45220 PyObject * obj1 = 0 ;
45221 char * kwnames[] = {
45222 (char *) "self",(char *) "size", NULL
45223 };
45224
45225 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) SWIG_fail;
45226 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45227 if (!SWIG_IsOK(res1)) {
45228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45229 }
45230 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45231 {
45232 arg2 = &temp2;
45233 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
45234 }
45235 {
45236 PyThreadState* __tstate = wxPyBeginAllowThreads();
45237 (arg1)->SetRatio((wxSize const &)*arg2);
45238 wxPyEndAllowThreads(__tstate);
45239 if (PyErr_Occurred()) SWIG_fail;
45240 }
45241 resultobj = SWIG_Py_Void();
45242 return resultobj;
45243 fail:
45244 return NULL;
45245 }
45246
45247
45248 SWIGINTERN PyObject *_wrap_SizerItem_SetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45249 PyObject *resultobj = 0;
45250 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45251 float arg2 ;
45252 void *argp1 = 0 ;
45253 int res1 = 0 ;
45254 float val2 ;
45255 int ecode2 = 0 ;
45256 PyObject * obj0 = 0 ;
45257 PyObject * obj1 = 0 ;
45258 char * kwnames[] = {
45259 (char *) "self",(char *) "ratio", NULL
45260 };
45261
45262 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) 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_SetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45266 }
45267 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45268 ecode2 = SWIG_AsVal_float(obj1, &val2);
45269 if (!SWIG_IsOK(ecode2)) {
45270 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatio" "', expected argument " "2"" of type '" "float""'");
45271 }
45272 arg2 = static_cast< float >(val2);
45273 {
45274 PyThreadState* __tstate = wxPyBeginAllowThreads();
45275 (arg1)->SetRatio(arg2);
45276 wxPyEndAllowThreads(__tstate);
45277 if (PyErr_Occurred()) SWIG_fail;
45278 }
45279 resultobj = SWIG_Py_Void();
45280 return resultobj;
45281 fail:
45282 return NULL;
45283 }
45284
45285
45286 SWIGINTERN PyObject *_wrap_SizerItem_GetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45287 PyObject *resultobj = 0;
45288 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45289 float result;
45290 void *argp1 = 0 ;
45291 int res1 = 0 ;
45292 PyObject *swig_obj[1] ;
45293
45294 if (!args) SWIG_fail;
45295 swig_obj[0] = args;
45296 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45297 if (!SWIG_IsOK(res1)) {
45298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45299 }
45300 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45301 {
45302 PyThreadState* __tstate = wxPyBeginAllowThreads();
45303 result = (float)(arg1)->GetRatio();
45304 wxPyEndAllowThreads(__tstate);
45305 if (PyErr_Occurred()) SWIG_fail;
45306 }
45307 resultobj = SWIG_From_float(static_cast< float >(result));
45308 return resultobj;
45309 fail:
45310 return NULL;
45311 }
45312
45313
45314 SWIGINTERN PyObject *_wrap_SizerItem_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45315 PyObject *resultobj = 0;
45316 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45317 wxRect result;
45318 void *argp1 = 0 ;
45319 int res1 = 0 ;
45320 PyObject *swig_obj[1] ;
45321
45322 if (!args) SWIG_fail;
45323 swig_obj[0] = args;
45324 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45325 if (!SWIG_IsOK(res1)) {
45326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRect" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45327 }
45328 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45329 {
45330 PyThreadState* __tstate = wxPyBeginAllowThreads();
45331 result = (arg1)->GetRect();
45332 wxPyEndAllowThreads(__tstate);
45333 if (PyErr_Occurred()) SWIG_fail;
45334 }
45335 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
45336 return resultobj;
45337 fail:
45338 return NULL;
45339 }
45340
45341
45342 SWIGINTERN PyObject *_wrap_SizerItem_IsWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45343 PyObject *resultobj = 0;
45344 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45345 bool result;
45346 void *argp1 = 0 ;
45347 int res1 = 0 ;
45348 PyObject *swig_obj[1] ;
45349
45350 if (!args) SWIG_fail;
45351 swig_obj[0] = args;
45352 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45353 if (!SWIG_IsOK(res1)) {
45354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45355 }
45356 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45357 {
45358 PyThreadState* __tstate = wxPyBeginAllowThreads();
45359 result = (bool)(arg1)->IsWindow();
45360 wxPyEndAllowThreads(__tstate);
45361 if (PyErr_Occurred()) SWIG_fail;
45362 }
45363 {
45364 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45365 }
45366 return resultobj;
45367 fail:
45368 return NULL;
45369 }
45370
45371
45372 SWIGINTERN PyObject *_wrap_SizerItem_IsSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45373 PyObject *resultobj = 0;
45374 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45375 bool result;
45376 void *argp1 = 0 ;
45377 int res1 = 0 ;
45378 PyObject *swig_obj[1] ;
45379
45380 if (!args) SWIG_fail;
45381 swig_obj[0] = args;
45382 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45383 if (!SWIG_IsOK(res1)) {
45384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45385 }
45386 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45387 {
45388 PyThreadState* __tstate = wxPyBeginAllowThreads();
45389 result = (bool)(arg1)->IsSizer();
45390 wxPyEndAllowThreads(__tstate);
45391 if (PyErr_Occurred()) SWIG_fail;
45392 }
45393 {
45394 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45395 }
45396 return resultobj;
45397 fail:
45398 return NULL;
45399 }
45400
45401
45402 SWIGINTERN PyObject *_wrap_SizerItem_IsSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45403 PyObject *resultobj = 0;
45404 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45405 bool result;
45406 void *argp1 = 0 ;
45407 int res1 = 0 ;
45408 PyObject *swig_obj[1] ;
45409
45410 if (!args) SWIG_fail;
45411 swig_obj[0] = args;
45412 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45413 if (!SWIG_IsOK(res1)) {
45414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45415 }
45416 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45417 {
45418 PyThreadState* __tstate = wxPyBeginAllowThreads();
45419 result = (bool)(arg1)->IsSpacer();
45420 wxPyEndAllowThreads(__tstate);
45421 if (PyErr_Occurred()) SWIG_fail;
45422 }
45423 {
45424 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45425 }
45426 return resultobj;
45427 fail:
45428 return NULL;
45429 }
45430
45431
45432 SWIGINTERN PyObject *_wrap_SizerItem_SetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45433 PyObject *resultobj = 0;
45434 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45435 int arg2 ;
45436 void *argp1 = 0 ;
45437 int res1 = 0 ;
45438 int val2 ;
45439 int ecode2 = 0 ;
45440 PyObject * obj0 = 0 ;
45441 PyObject * obj1 = 0 ;
45442 char * kwnames[] = {
45443 (char *) "self",(char *) "proportion", NULL
45444 };
45445
45446 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) SWIG_fail;
45447 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45448 if (!SWIG_IsOK(res1)) {
45449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45450 }
45451 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45452 ecode2 = SWIG_AsVal_int(obj1, &val2);
45453 if (!SWIG_IsOK(ecode2)) {
45454 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetProportion" "', expected argument " "2"" of type '" "int""'");
45455 }
45456 arg2 = static_cast< int >(val2);
45457 {
45458 PyThreadState* __tstate = wxPyBeginAllowThreads();
45459 (arg1)->SetProportion(arg2);
45460 wxPyEndAllowThreads(__tstate);
45461 if (PyErr_Occurred()) SWIG_fail;
45462 }
45463 resultobj = SWIG_Py_Void();
45464 return resultobj;
45465 fail:
45466 return NULL;
45467 }
45468
45469
45470 SWIGINTERN PyObject *_wrap_SizerItem_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45471 PyObject *resultobj = 0;
45472 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45473 int result;
45474 void *argp1 = 0 ;
45475 int res1 = 0 ;
45476 PyObject *swig_obj[1] ;
45477
45478 if (!args) SWIG_fail;
45479 swig_obj[0] = args;
45480 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45481 if (!SWIG_IsOK(res1)) {
45482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45483 }
45484 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45485 {
45486 PyThreadState* __tstate = wxPyBeginAllowThreads();
45487 result = (int)(arg1)->GetProportion();
45488 wxPyEndAllowThreads(__tstate);
45489 if (PyErr_Occurred()) SWIG_fail;
45490 }
45491 resultobj = SWIG_From_int(static_cast< int >(result));
45492 return resultobj;
45493 fail:
45494 return NULL;
45495 }
45496
45497
45498 SWIGINTERN PyObject *_wrap_SizerItem_SetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45499 PyObject *resultobj = 0;
45500 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45501 int arg2 ;
45502 void *argp1 = 0 ;
45503 int res1 = 0 ;
45504 int val2 ;
45505 int ecode2 = 0 ;
45506 PyObject * obj0 = 0 ;
45507 PyObject * obj1 = 0 ;
45508 char * kwnames[] = {
45509 (char *) "self",(char *) "flag", NULL
45510 };
45511
45512 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) SWIG_fail;
45513 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45514 if (!SWIG_IsOK(res1)) {
45515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45516 }
45517 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45518 ecode2 = SWIG_AsVal_int(obj1, &val2);
45519 if (!SWIG_IsOK(ecode2)) {
45520 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetFlag" "', expected argument " "2"" of type '" "int""'");
45521 }
45522 arg2 = static_cast< int >(val2);
45523 {
45524 PyThreadState* __tstate = wxPyBeginAllowThreads();
45525 (arg1)->SetFlag(arg2);
45526 wxPyEndAllowThreads(__tstate);
45527 if (PyErr_Occurred()) SWIG_fail;
45528 }
45529 resultobj = SWIG_Py_Void();
45530 return resultobj;
45531 fail:
45532 return NULL;
45533 }
45534
45535
45536 SWIGINTERN PyObject *_wrap_SizerItem_GetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45537 PyObject *resultobj = 0;
45538 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45539 int result;
45540 void *argp1 = 0 ;
45541 int res1 = 0 ;
45542 PyObject *swig_obj[1] ;
45543
45544 if (!args) SWIG_fail;
45545 swig_obj[0] = args;
45546 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45547 if (!SWIG_IsOK(res1)) {
45548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45549 }
45550 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45551 {
45552 PyThreadState* __tstate = wxPyBeginAllowThreads();
45553 result = (int)(arg1)->GetFlag();
45554 wxPyEndAllowThreads(__tstate);
45555 if (PyErr_Occurred()) SWIG_fail;
45556 }
45557 resultobj = SWIG_From_int(static_cast< int >(result));
45558 return resultobj;
45559 fail:
45560 return NULL;
45561 }
45562
45563
45564 SWIGINTERN PyObject *_wrap_SizerItem_SetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45565 PyObject *resultobj = 0;
45566 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45567 int arg2 ;
45568 void *argp1 = 0 ;
45569 int res1 = 0 ;
45570 int val2 ;
45571 int ecode2 = 0 ;
45572 PyObject * obj0 = 0 ;
45573 PyObject * obj1 = 0 ;
45574 char * kwnames[] = {
45575 (char *) "self",(char *) "border", NULL
45576 };
45577
45578 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) SWIG_fail;
45579 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45580 if (!SWIG_IsOK(res1)) {
45581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45582 }
45583 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45584 ecode2 = SWIG_AsVal_int(obj1, &val2);
45585 if (!SWIG_IsOK(ecode2)) {
45586 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetBorder" "', expected argument " "2"" of type '" "int""'");
45587 }
45588 arg2 = static_cast< int >(val2);
45589 {
45590 PyThreadState* __tstate = wxPyBeginAllowThreads();
45591 (arg1)->SetBorder(arg2);
45592 wxPyEndAllowThreads(__tstate);
45593 if (PyErr_Occurred()) SWIG_fail;
45594 }
45595 resultobj = SWIG_Py_Void();
45596 return resultobj;
45597 fail:
45598 return NULL;
45599 }
45600
45601
45602 SWIGINTERN PyObject *_wrap_SizerItem_GetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45603 PyObject *resultobj = 0;
45604 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45605 int result;
45606 void *argp1 = 0 ;
45607 int res1 = 0 ;
45608 PyObject *swig_obj[1] ;
45609
45610 if (!args) SWIG_fail;
45611 swig_obj[0] = args;
45612 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45613 if (!SWIG_IsOK(res1)) {
45614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45615 }
45616 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45617 {
45618 PyThreadState* __tstate = wxPyBeginAllowThreads();
45619 result = (int)(arg1)->GetBorder();
45620 wxPyEndAllowThreads(__tstate);
45621 if (PyErr_Occurred()) SWIG_fail;
45622 }
45623 resultobj = SWIG_From_int(static_cast< int >(result));
45624 return resultobj;
45625 fail:
45626 return NULL;
45627 }
45628
45629
45630 SWIGINTERN PyObject *_wrap_SizerItem_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45631 PyObject *resultobj = 0;
45632 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45633 wxWindow *result = 0 ;
45634 void *argp1 = 0 ;
45635 int res1 = 0 ;
45636 PyObject *swig_obj[1] ;
45637
45638 if (!args) SWIG_fail;
45639 swig_obj[0] = args;
45640 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45641 if (!SWIG_IsOK(res1)) {
45642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45643 }
45644 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45645 {
45646 PyThreadState* __tstate = wxPyBeginAllowThreads();
45647 result = (wxWindow *)(arg1)->GetWindow();
45648 wxPyEndAllowThreads(__tstate);
45649 if (PyErr_Occurred()) SWIG_fail;
45650 }
45651 {
45652 resultobj = wxPyMake_wxObject(result, 0);
45653 }
45654 return resultobj;
45655 fail:
45656 return NULL;
45657 }
45658
45659
45660 SWIGINTERN PyObject *_wrap_SizerItem_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45661 PyObject *resultobj = 0;
45662 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45663 wxWindow *arg2 = (wxWindow *) 0 ;
45664 void *argp1 = 0 ;
45665 int res1 = 0 ;
45666 void *argp2 = 0 ;
45667 int res2 = 0 ;
45668 PyObject * obj0 = 0 ;
45669 PyObject * obj1 = 0 ;
45670 char * kwnames[] = {
45671 (char *) "self",(char *) "window", NULL
45672 };
45673
45674 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
45675 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45676 if (!SWIG_IsOK(res1)) {
45677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45678 }
45679 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45680 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
45681 if (!SWIG_IsOK(res2)) {
45682 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
45683 }
45684 arg2 = reinterpret_cast< wxWindow * >(argp2);
45685 {
45686 PyThreadState* __tstate = wxPyBeginAllowThreads();
45687 (arg1)->SetWindow(arg2);
45688 wxPyEndAllowThreads(__tstate);
45689 if (PyErr_Occurred()) SWIG_fail;
45690 }
45691 resultobj = SWIG_Py_Void();
45692 return resultobj;
45693 fail:
45694 return NULL;
45695 }
45696
45697
45698 SWIGINTERN PyObject *_wrap_SizerItem_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45699 PyObject *resultobj = 0;
45700 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45701 wxSizer *result = 0 ;
45702 void *argp1 = 0 ;
45703 int res1 = 0 ;
45704 PyObject *swig_obj[1] ;
45705
45706 if (!args) SWIG_fail;
45707 swig_obj[0] = args;
45708 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45709 if (!SWIG_IsOK(res1)) {
45710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45711 }
45712 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45713 {
45714 PyThreadState* __tstate = wxPyBeginAllowThreads();
45715 result = (wxSizer *)(arg1)->GetSizer();
45716 wxPyEndAllowThreads(__tstate);
45717 if (PyErr_Occurred()) SWIG_fail;
45718 }
45719 {
45720 resultobj = wxPyMake_wxObject(result, (bool)0);
45721 }
45722 return resultobj;
45723 fail:
45724 return NULL;
45725 }
45726
45727
45728 SWIGINTERN PyObject *_wrap_SizerItem_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45729 PyObject *resultobj = 0;
45730 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45731 wxSizer *arg2 = (wxSizer *) 0 ;
45732 void *argp1 = 0 ;
45733 int res1 = 0 ;
45734 int res2 = 0 ;
45735 PyObject * obj0 = 0 ;
45736 PyObject * obj1 = 0 ;
45737 char * kwnames[] = {
45738 (char *) "self",(char *) "sizer", NULL
45739 };
45740
45741 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) SWIG_fail;
45742 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45743 if (!SWIG_IsOK(res1)) {
45744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45745 }
45746 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45747 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
45748 if (!SWIG_IsOK(res2)) {
45749 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
45750 }
45751 {
45752 PyThreadState* __tstate = wxPyBeginAllowThreads();
45753 (arg1)->SetSizer(arg2);
45754 wxPyEndAllowThreads(__tstate);
45755 if (PyErr_Occurred()) SWIG_fail;
45756 }
45757 resultobj = SWIG_Py_Void();
45758 return resultobj;
45759 fail:
45760 return NULL;
45761 }
45762
45763
45764 SWIGINTERN PyObject *_wrap_SizerItem_GetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45765 PyObject *resultobj = 0;
45766 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45767 wxSize *result = 0 ;
45768 void *argp1 = 0 ;
45769 int res1 = 0 ;
45770 PyObject *swig_obj[1] ;
45771
45772 if (!args) SWIG_fail;
45773 swig_obj[0] = args;
45774 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45775 if (!SWIG_IsOK(res1)) {
45776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45777 }
45778 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45779 {
45780 PyThreadState* __tstate = wxPyBeginAllowThreads();
45781 {
45782 wxSize const &_result_ref = (arg1)->GetSpacer();
45783 result = (wxSize *) &_result_ref;
45784 }
45785 wxPyEndAllowThreads(__tstate);
45786 if (PyErr_Occurred()) SWIG_fail;
45787 }
45788 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
45789 return resultobj;
45790 fail:
45791 return NULL;
45792 }
45793
45794
45795 SWIGINTERN PyObject *_wrap_SizerItem_SetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45796 PyObject *resultobj = 0;
45797 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45798 wxSize *arg2 = 0 ;
45799 void *argp1 = 0 ;
45800 int res1 = 0 ;
45801 wxSize temp2 ;
45802 PyObject * obj0 = 0 ;
45803 PyObject * obj1 = 0 ;
45804 char * kwnames[] = {
45805 (char *) "self",(char *) "size", NULL
45806 };
45807
45808 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) SWIG_fail;
45809 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45810 if (!SWIG_IsOK(res1)) {
45811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45812 }
45813 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45814 {
45815 arg2 = &temp2;
45816 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
45817 }
45818 {
45819 PyThreadState* __tstate = wxPyBeginAllowThreads();
45820 (arg1)->SetSpacer((wxSize const &)*arg2);
45821 wxPyEndAllowThreads(__tstate);
45822 if (PyErr_Occurred()) SWIG_fail;
45823 }
45824 resultobj = SWIG_Py_Void();
45825 return resultobj;
45826 fail:
45827 return NULL;
45828 }
45829
45830
45831 SWIGINTERN PyObject *_wrap_SizerItem_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45832 PyObject *resultobj = 0;
45833 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45834 bool arg2 ;
45835 void *argp1 = 0 ;
45836 int res1 = 0 ;
45837 bool val2 ;
45838 int ecode2 = 0 ;
45839 PyObject * obj0 = 0 ;
45840 PyObject * obj1 = 0 ;
45841 char * kwnames[] = {
45842 (char *) "self",(char *) "show", NULL
45843 };
45844
45845 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) SWIG_fail;
45846 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45847 if (!SWIG_IsOK(res1)) {
45848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_Show" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45849 }
45850 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45851 ecode2 = SWIG_AsVal_bool(obj1, &val2);
45852 if (!SWIG_IsOK(ecode2)) {
45853 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_Show" "', expected argument " "2"" of type '" "bool""'");
45854 }
45855 arg2 = static_cast< bool >(val2);
45856 {
45857 PyThreadState* __tstate = wxPyBeginAllowThreads();
45858 (arg1)->Show(arg2);
45859 wxPyEndAllowThreads(__tstate);
45860 if (PyErr_Occurred()) SWIG_fail;
45861 }
45862 resultobj = SWIG_Py_Void();
45863 return resultobj;
45864 fail:
45865 return NULL;
45866 }
45867
45868
45869 SWIGINTERN PyObject *_wrap_SizerItem_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45870 PyObject *resultobj = 0;
45871 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45872 bool result;
45873 void *argp1 = 0 ;
45874 int res1 = 0 ;
45875 PyObject *swig_obj[1] ;
45876
45877 if (!args) SWIG_fail;
45878 swig_obj[0] = args;
45879 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45880 if (!SWIG_IsOK(res1)) {
45881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsShown" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45882 }
45883 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45884 {
45885 PyThreadState* __tstate = wxPyBeginAllowThreads();
45886 result = (bool)(arg1)->IsShown();
45887 wxPyEndAllowThreads(__tstate);
45888 if (PyErr_Occurred()) SWIG_fail;
45889 }
45890 {
45891 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45892 }
45893 return resultobj;
45894 fail:
45895 return NULL;
45896 }
45897
45898
45899 SWIGINTERN PyObject *_wrap_SizerItem_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45900 PyObject *resultobj = 0;
45901 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45902 wxPoint result;
45903 void *argp1 = 0 ;
45904 int res1 = 0 ;
45905 PyObject *swig_obj[1] ;
45906
45907 if (!args) SWIG_fail;
45908 swig_obj[0] = args;
45909 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45910 if (!SWIG_IsOK(res1)) {
45911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetPosition" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45912 }
45913 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45914 {
45915 PyThreadState* __tstate = wxPyBeginAllowThreads();
45916 result = (arg1)->GetPosition();
45917 wxPyEndAllowThreads(__tstate);
45918 if (PyErr_Occurred()) SWIG_fail;
45919 }
45920 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
45921 return resultobj;
45922 fail:
45923 return NULL;
45924 }
45925
45926
45927 SWIGINTERN PyObject *_wrap_SizerItem_GetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45928 PyObject *resultobj = 0;
45929 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45930 PyObject *result = 0 ;
45931 void *argp1 = 0 ;
45932 int res1 = 0 ;
45933 PyObject *swig_obj[1] ;
45934
45935 if (!args) SWIG_fail;
45936 swig_obj[0] = args;
45937 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45938 if (!SWIG_IsOK(res1)) {
45939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45940 }
45941 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45942 {
45943 PyThreadState* __tstate = wxPyBeginAllowThreads();
45944 result = (PyObject *)wxSizerItem_GetUserData(arg1);
45945 wxPyEndAllowThreads(__tstate);
45946 if (PyErr_Occurred()) SWIG_fail;
45947 }
45948 resultobj = result;
45949 return resultobj;
45950 fail:
45951 return NULL;
45952 }
45953
45954
45955 SWIGINTERN PyObject *_wrap_SizerItem_SetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45956 PyObject *resultobj = 0;
45957 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45958 PyObject *arg2 = (PyObject *) 0 ;
45959 void *argp1 = 0 ;
45960 int res1 = 0 ;
45961 PyObject * obj0 = 0 ;
45962 PyObject * obj1 = 0 ;
45963 char * kwnames[] = {
45964 (char *) "self",(char *) "userData", NULL
45965 };
45966
45967 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetUserData",kwnames,&obj0,&obj1)) SWIG_fail;
45968 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45969 if (!SWIG_IsOK(res1)) {
45970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45971 }
45972 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45973 arg2 = obj1;
45974 {
45975 PyThreadState* __tstate = wxPyBeginAllowThreads();
45976 wxSizerItem_SetUserData(arg1,arg2);
45977 wxPyEndAllowThreads(__tstate);
45978 if (PyErr_Occurred()) SWIG_fail;
45979 }
45980 resultobj = SWIG_Py_Void();
45981 return resultobj;
45982 fail:
45983 return NULL;
45984 }
45985
45986
45987 SWIGINTERN PyObject *SizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45988 PyObject *obj;
45989 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45990 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerItem, SWIG_NewClientData(obj));
45991 return SWIG_Py_Void();
45992 }
45993
45994 SWIGINTERN PyObject *SizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45995 return SWIG_Python_InitShadowInstance(args);
45996 }
45997
45998 SWIGINTERN PyObject *_wrap_delete_Sizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45999 PyObject *resultobj = 0;
46000 wxSizer *arg1 = (wxSizer *) 0 ;
46001 void *argp1 = 0 ;
46002 int res1 = 0 ;
46003 PyObject *swig_obj[1] ;
46004
46005 if (!args) SWIG_fail;
46006 swig_obj[0] = args;
46007 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
46008 if (!SWIG_IsOK(res1)) {
46009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sizer" "', expected argument " "1"" of type '" "wxSizer *""'");
46010 }
46011 arg1 = reinterpret_cast< wxSizer * >(argp1);
46012 {
46013 PyThreadState* __tstate = wxPyBeginAllowThreads();
46014 delete arg1;
46015
46016 wxPyEndAllowThreads(__tstate);
46017 if (PyErr_Occurred()) SWIG_fail;
46018 }
46019 resultobj = SWIG_Py_Void();
46020 return resultobj;
46021 fail:
46022 return NULL;
46023 }
46024
46025
46026 SWIGINTERN PyObject *_wrap_Sizer__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46027 PyObject *resultobj = 0;
46028 wxSizer *arg1 = (wxSizer *) 0 ;
46029 PyObject *arg2 = (PyObject *) 0 ;
46030 void *argp1 = 0 ;
46031 int res1 = 0 ;
46032 PyObject * obj0 = 0 ;
46033 PyObject * obj1 = 0 ;
46034 char * kwnames[] = {
46035 (char *) "self",(char *) "_self", NULL
46036 };
46037
46038 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
46039 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46040 if (!SWIG_IsOK(res1)) {
46041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__setOORInfo" "', expected argument " "1"" of type '" "wxSizer *""'");
46042 }
46043 arg1 = reinterpret_cast< wxSizer * >(argp1);
46044 arg2 = obj1;
46045 {
46046 PyThreadState* __tstate = wxPyBeginAllowThreads();
46047 wxSizer__setOORInfo(arg1,arg2);
46048 wxPyEndAllowThreads(__tstate);
46049 if (PyErr_Occurred()) SWIG_fail;
46050 }
46051 resultobj = SWIG_Py_Void();
46052 return resultobj;
46053 fail:
46054 return NULL;
46055 }
46056
46057
46058 SWIGINTERN PyObject *_wrap_Sizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46059 PyObject *resultobj = 0;
46060 wxSizer *arg1 = (wxSizer *) 0 ;
46061 PyObject *arg2 = (PyObject *) 0 ;
46062 int arg3 = (int) 0 ;
46063 int arg4 = (int) 0 ;
46064 int arg5 = (int) 0 ;
46065 PyObject *arg6 = (PyObject *) NULL ;
46066 wxSizerItem *result = 0 ;
46067 void *argp1 = 0 ;
46068 int res1 = 0 ;
46069 int val3 ;
46070 int ecode3 = 0 ;
46071 int val4 ;
46072 int ecode4 = 0 ;
46073 int val5 ;
46074 int ecode5 = 0 ;
46075 PyObject * obj0 = 0 ;
46076 PyObject * obj1 = 0 ;
46077 PyObject * obj2 = 0 ;
46078 PyObject * obj3 = 0 ;
46079 PyObject * obj4 = 0 ;
46080 PyObject * obj5 = 0 ;
46081 char * kwnames[] = {
46082 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46083 };
46084
46085 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
46086 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46087 if (!SWIG_IsOK(res1)) {
46088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Add" "', expected argument " "1"" of type '" "wxSizer *""'");
46089 }
46090 arg1 = reinterpret_cast< wxSizer * >(argp1);
46091 arg2 = obj1;
46092 if (obj2) {
46093 ecode3 = SWIG_AsVal_int(obj2, &val3);
46094 if (!SWIG_IsOK(ecode3)) {
46095 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Add" "', expected argument " "3"" of type '" "int""'");
46096 }
46097 arg3 = static_cast< int >(val3);
46098 }
46099 if (obj3) {
46100 ecode4 = SWIG_AsVal_int(obj3, &val4);
46101 if (!SWIG_IsOK(ecode4)) {
46102 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Add" "', expected argument " "4"" of type '" "int""'");
46103 }
46104 arg4 = static_cast< int >(val4);
46105 }
46106 if (obj4) {
46107 ecode5 = SWIG_AsVal_int(obj4, &val5);
46108 if (!SWIG_IsOK(ecode5)) {
46109 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Add" "', expected argument " "5"" of type '" "int""'");
46110 }
46111 arg5 = static_cast< int >(val5);
46112 }
46113 if (obj5) {
46114 arg6 = obj5;
46115 }
46116 {
46117 PyThreadState* __tstate = wxPyBeginAllowThreads();
46118 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
46119 wxPyEndAllowThreads(__tstate);
46120 if (PyErr_Occurred()) SWIG_fail;
46121 }
46122 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46123 return resultobj;
46124 fail:
46125 return NULL;
46126 }
46127
46128
46129 SWIGINTERN PyObject *_wrap_Sizer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46130 PyObject *resultobj = 0;
46131 wxSizer *arg1 = (wxSizer *) 0 ;
46132 int arg2 ;
46133 PyObject *arg3 = (PyObject *) 0 ;
46134 int arg4 = (int) 0 ;
46135 int arg5 = (int) 0 ;
46136 int arg6 = (int) 0 ;
46137 PyObject *arg7 = (PyObject *) NULL ;
46138 wxSizerItem *result = 0 ;
46139 void *argp1 = 0 ;
46140 int res1 = 0 ;
46141 int val2 ;
46142 int ecode2 = 0 ;
46143 int val4 ;
46144 int ecode4 = 0 ;
46145 int val5 ;
46146 int ecode5 = 0 ;
46147 int val6 ;
46148 int ecode6 = 0 ;
46149 PyObject * obj0 = 0 ;
46150 PyObject * obj1 = 0 ;
46151 PyObject * obj2 = 0 ;
46152 PyObject * obj3 = 0 ;
46153 PyObject * obj4 = 0 ;
46154 PyObject * obj5 = 0 ;
46155 PyObject * obj6 = 0 ;
46156 char * kwnames[] = {
46157 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46158 };
46159
46160 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
46161 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46162 if (!SWIG_IsOK(res1)) {
46163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Insert" "', expected argument " "1"" of type '" "wxSizer *""'");
46164 }
46165 arg1 = reinterpret_cast< wxSizer * >(argp1);
46166 ecode2 = SWIG_AsVal_int(obj1, &val2);
46167 if (!SWIG_IsOK(ecode2)) {
46168 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Insert" "', expected argument " "2"" of type '" "int""'");
46169 }
46170 arg2 = static_cast< int >(val2);
46171 arg3 = obj2;
46172 if (obj3) {
46173 ecode4 = SWIG_AsVal_int(obj3, &val4);
46174 if (!SWIG_IsOK(ecode4)) {
46175 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Insert" "', expected argument " "4"" of type '" "int""'");
46176 }
46177 arg4 = static_cast< int >(val4);
46178 }
46179 if (obj4) {
46180 ecode5 = SWIG_AsVal_int(obj4, &val5);
46181 if (!SWIG_IsOK(ecode5)) {
46182 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Insert" "', expected argument " "5"" of type '" "int""'");
46183 }
46184 arg5 = static_cast< int >(val5);
46185 }
46186 if (obj5) {
46187 ecode6 = SWIG_AsVal_int(obj5, &val6);
46188 if (!SWIG_IsOK(ecode6)) {
46189 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Sizer_Insert" "', expected argument " "6"" of type '" "int""'");
46190 }
46191 arg6 = static_cast< int >(val6);
46192 }
46193 if (obj6) {
46194 arg7 = obj6;
46195 }
46196 {
46197 PyThreadState* __tstate = wxPyBeginAllowThreads();
46198 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
46199 wxPyEndAllowThreads(__tstate);
46200 if (PyErr_Occurred()) SWIG_fail;
46201 }
46202 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46203 return resultobj;
46204 fail:
46205 return NULL;
46206 }
46207
46208
46209 SWIGINTERN PyObject *_wrap_Sizer_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46210 PyObject *resultobj = 0;
46211 wxSizer *arg1 = (wxSizer *) 0 ;
46212 PyObject *arg2 = (PyObject *) 0 ;
46213 int arg3 = (int) 0 ;
46214 int arg4 = (int) 0 ;
46215 int arg5 = (int) 0 ;
46216 PyObject *arg6 = (PyObject *) NULL ;
46217 wxSizerItem *result = 0 ;
46218 void *argp1 = 0 ;
46219 int res1 = 0 ;
46220 int val3 ;
46221 int ecode3 = 0 ;
46222 int val4 ;
46223 int ecode4 = 0 ;
46224 int val5 ;
46225 int ecode5 = 0 ;
46226 PyObject * obj0 = 0 ;
46227 PyObject * obj1 = 0 ;
46228 PyObject * obj2 = 0 ;
46229 PyObject * obj3 = 0 ;
46230 PyObject * obj4 = 0 ;
46231 PyObject * obj5 = 0 ;
46232 char * kwnames[] = {
46233 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46234 };
46235
46236 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
46237 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46238 if (!SWIG_IsOK(res1)) {
46239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Prepend" "', expected argument " "1"" of type '" "wxSizer *""'");
46240 }
46241 arg1 = reinterpret_cast< wxSizer * >(argp1);
46242 arg2 = obj1;
46243 if (obj2) {
46244 ecode3 = SWIG_AsVal_int(obj2, &val3);
46245 if (!SWIG_IsOK(ecode3)) {
46246 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Prepend" "', expected argument " "3"" of type '" "int""'");
46247 }
46248 arg3 = static_cast< int >(val3);
46249 }
46250 if (obj3) {
46251 ecode4 = SWIG_AsVal_int(obj3, &val4);
46252 if (!SWIG_IsOK(ecode4)) {
46253 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Prepend" "', expected argument " "4"" of type '" "int""'");
46254 }
46255 arg4 = static_cast< int >(val4);
46256 }
46257 if (obj4) {
46258 ecode5 = SWIG_AsVal_int(obj4, &val5);
46259 if (!SWIG_IsOK(ecode5)) {
46260 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Prepend" "', expected argument " "5"" of type '" "int""'");
46261 }
46262 arg5 = static_cast< int >(val5);
46263 }
46264 if (obj5) {
46265 arg6 = obj5;
46266 }
46267 {
46268 PyThreadState* __tstate = wxPyBeginAllowThreads();
46269 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
46270 wxPyEndAllowThreads(__tstate);
46271 if (PyErr_Occurred()) SWIG_fail;
46272 }
46273 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46274 return resultobj;
46275 fail:
46276 return NULL;
46277 }
46278
46279
46280 SWIGINTERN PyObject *_wrap_Sizer_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46281 PyObject *resultobj = 0;
46282 wxSizer *arg1 = (wxSizer *) 0 ;
46283 PyObject *arg2 = (PyObject *) 0 ;
46284 bool result;
46285 void *argp1 = 0 ;
46286 int res1 = 0 ;
46287 PyObject * obj0 = 0 ;
46288 PyObject * obj1 = 0 ;
46289 char * kwnames[] = {
46290 (char *) "self",(char *) "item", NULL
46291 };
46292
46293 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
46294 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46295 if (!SWIG_IsOK(res1)) {
46296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Remove" "', expected argument " "1"" of type '" "wxSizer *""'");
46297 }
46298 arg1 = reinterpret_cast< wxSizer * >(argp1);
46299 arg2 = obj1;
46300 {
46301 PyThreadState* __tstate = wxPyBeginAllowThreads();
46302 result = (bool)wxSizer_Remove(arg1,arg2);
46303 wxPyEndAllowThreads(__tstate);
46304 if (PyErr_Occurred()) SWIG_fail;
46305 }
46306 {
46307 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46308 }
46309 return resultobj;
46310 fail:
46311 return NULL;
46312 }
46313
46314
46315 SWIGINTERN PyObject *_wrap_Sizer_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46316 PyObject *resultobj = 0;
46317 wxSizer *arg1 = (wxSizer *) 0 ;
46318 PyObject *arg2 = (PyObject *) 0 ;
46319 bool result;
46320 void *argp1 = 0 ;
46321 int res1 = 0 ;
46322 PyObject * obj0 = 0 ;
46323 PyObject * obj1 = 0 ;
46324 char * kwnames[] = {
46325 (char *) "self",(char *) "item", NULL
46326 };
46327
46328 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) SWIG_fail;
46329 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46330 if (!SWIG_IsOK(res1)) {
46331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Detach" "', expected argument " "1"" of type '" "wxSizer *""'");
46332 }
46333 arg1 = reinterpret_cast< wxSizer * >(argp1);
46334 arg2 = obj1;
46335 {
46336 PyThreadState* __tstate = wxPyBeginAllowThreads();
46337 result = (bool)wxSizer_Detach(arg1,arg2);
46338 wxPyEndAllowThreads(__tstate);
46339 if (PyErr_Occurred()) SWIG_fail;
46340 }
46341 {
46342 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46343 }
46344 return resultobj;
46345 fail:
46346 return NULL;
46347 }
46348
46349
46350 SWIGINTERN PyObject *_wrap_Sizer_GetItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46351 PyObject *resultobj = 0;
46352 wxSizer *arg1 = (wxSizer *) 0 ;
46353 PyObject *arg2 = (PyObject *) 0 ;
46354 wxSizerItem *result = 0 ;
46355 void *argp1 = 0 ;
46356 int res1 = 0 ;
46357 PyObject * obj0 = 0 ;
46358 PyObject * obj1 = 0 ;
46359 char * kwnames[] = {
46360 (char *) "self",(char *) "item", NULL
46361 };
46362
46363 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) SWIG_fail;
46364 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46365 if (!SWIG_IsOK(res1)) {
46366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46367 }
46368 arg1 = reinterpret_cast< wxSizer * >(argp1);
46369 arg2 = obj1;
46370 {
46371 PyThreadState* __tstate = wxPyBeginAllowThreads();
46372 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
46373 wxPyEndAllowThreads(__tstate);
46374 if (PyErr_Occurred()) SWIG_fail;
46375 }
46376 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46377 return resultobj;
46378 fail:
46379 return NULL;
46380 }
46381
46382
46383 SWIGINTERN PyObject *_wrap_Sizer__SetItemMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46384 PyObject *resultobj = 0;
46385 wxSizer *arg1 = (wxSizer *) 0 ;
46386 PyObject *arg2 = (PyObject *) 0 ;
46387 wxSize *arg3 = 0 ;
46388 void *argp1 = 0 ;
46389 int res1 = 0 ;
46390 wxSize temp3 ;
46391 PyObject * obj0 = 0 ;
46392 PyObject * obj1 = 0 ;
46393 PyObject * obj2 = 0 ;
46394 char * kwnames[] = {
46395 (char *) "self",(char *) "item",(char *) "size", NULL
46396 };
46397
46398 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46399 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46400 if (!SWIG_IsOK(res1)) {
46401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__SetItemMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46402 }
46403 arg1 = reinterpret_cast< wxSizer * >(argp1);
46404 arg2 = obj1;
46405 {
46406 arg3 = &temp3;
46407 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
46408 }
46409 {
46410 PyThreadState* __tstate = wxPyBeginAllowThreads();
46411 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
46412 wxPyEndAllowThreads(__tstate);
46413 if (PyErr_Occurred()) SWIG_fail;
46414 }
46415 resultobj = SWIG_Py_Void();
46416 return resultobj;
46417 fail:
46418 return NULL;
46419 }
46420
46421
46422 SWIGINTERN PyObject *_wrap_Sizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46423 PyObject *resultobj = 0;
46424 wxSizer *arg1 = (wxSizer *) 0 ;
46425 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
46426 wxSizerItem *result = 0 ;
46427 void *argp1 = 0 ;
46428 int res1 = 0 ;
46429 int res2 = 0 ;
46430 PyObject * obj0 = 0 ;
46431 PyObject * obj1 = 0 ;
46432 char * kwnames[] = {
46433 (char *) "self",(char *) "item", NULL
46434 };
46435
46436 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
46437 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46438 if (!SWIG_IsOK(res1)) {
46439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46440 }
46441 arg1 = reinterpret_cast< wxSizer * >(argp1);
46442 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46443 if (!SWIG_IsOK(res2)) {
46444 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_AddItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
46445 }
46446 {
46447 PyThreadState* __tstate = wxPyBeginAllowThreads();
46448 result = (wxSizerItem *)(arg1)->Add(arg2);
46449 wxPyEndAllowThreads(__tstate);
46450 if (PyErr_Occurred()) SWIG_fail;
46451 }
46452 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46453 return resultobj;
46454 fail:
46455 return NULL;
46456 }
46457
46458
46459 SWIGINTERN PyObject *_wrap_Sizer_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46460 PyObject *resultobj = 0;
46461 wxSizer *arg1 = (wxSizer *) 0 ;
46462 size_t arg2 ;
46463 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
46464 wxSizerItem *result = 0 ;
46465 void *argp1 = 0 ;
46466 int res1 = 0 ;
46467 size_t val2 ;
46468 int ecode2 = 0 ;
46469 int res3 = 0 ;
46470 PyObject * obj0 = 0 ;
46471 PyObject * obj1 = 0 ;
46472 PyObject * obj2 = 0 ;
46473 char * kwnames[] = {
46474 (char *) "self",(char *) "index",(char *) "item", NULL
46475 };
46476
46477 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",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_InsertItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46481 }
46482 arg1 = reinterpret_cast< wxSizer * >(argp1);
46483 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
46484 if (!SWIG_IsOK(ecode2)) {
46485 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
46486 }
46487 arg2 = static_cast< size_t >(val2);
46488 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46489 if (!SWIG_IsOK(res3)) {
46490 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_InsertItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
46491 }
46492 {
46493 PyThreadState* __tstate = wxPyBeginAllowThreads();
46494 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
46495 wxPyEndAllowThreads(__tstate);
46496 if (PyErr_Occurred()) SWIG_fail;
46497 }
46498 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46499 return resultobj;
46500 fail:
46501 return NULL;
46502 }
46503
46504
46505 SWIGINTERN PyObject *_wrap_Sizer_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46506 PyObject *resultobj = 0;
46507 wxSizer *arg1 = (wxSizer *) 0 ;
46508 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
46509 wxSizerItem *result = 0 ;
46510 void *argp1 = 0 ;
46511 int res1 = 0 ;
46512 int res2 = 0 ;
46513 PyObject * obj0 = 0 ;
46514 PyObject * obj1 = 0 ;
46515 char * kwnames[] = {
46516 (char *) "self",(char *) "item", NULL
46517 };
46518
46519 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
46520 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46521 if (!SWIG_IsOK(res1)) {
46522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_PrependItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46523 }
46524 arg1 = reinterpret_cast< wxSizer * >(argp1);
46525 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46526 if (!SWIG_IsOK(res2)) {
46527 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_PrependItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
46528 }
46529 {
46530 PyThreadState* __tstate = wxPyBeginAllowThreads();
46531 result = (wxSizerItem *)(arg1)->Prepend(arg2);
46532 wxPyEndAllowThreads(__tstate);
46533 if (PyErr_Occurred()) SWIG_fail;
46534 }
46535 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46536 return resultobj;
46537 fail:
46538 return NULL;
46539 }
46540
46541
46542 SWIGINTERN PyObject *_wrap_Sizer_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46543 PyObject *resultobj = 0;
46544 wxSizer *arg1 = (wxSizer *) 0 ;
46545 int arg2 ;
46546 int arg3 ;
46547 int arg4 ;
46548 int arg5 ;
46549 void *argp1 = 0 ;
46550 int res1 = 0 ;
46551 int val2 ;
46552 int ecode2 = 0 ;
46553 int val3 ;
46554 int ecode3 = 0 ;
46555 int val4 ;
46556 int ecode4 = 0 ;
46557 int val5 ;
46558 int ecode5 = 0 ;
46559 PyObject * obj0 = 0 ;
46560 PyObject * obj1 = 0 ;
46561 PyObject * obj2 = 0 ;
46562 PyObject * obj3 = 0 ;
46563 PyObject * obj4 = 0 ;
46564 char * kwnames[] = {
46565 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
46566 };
46567
46568 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
46569 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46570 if (!SWIG_IsOK(res1)) {
46571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetDimension" "', expected argument " "1"" of type '" "wxSizer *""'");
46572 }
46573 arg1 = reinterpret_cast< wxSizer * >(argp1);
46574 ecode2 = SWIG_AsVal_int(obj1, &val2);
46575 if (!SWIG_IsOK(ecode2)) {
46576 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_SetDimension" "', expected argument " "2"" of type '" "int""'");
46577 }
46578 arg2 = static_cast< int >(val2);
46579 ecode3 = SWIG_AsVal_int(obj2, &val3);
46580 if (!SWIG_IsOK(ecode3)) {
46581 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_SetDimension" "', expected argument " "3"" of type '" "int""'");
46582 }
46583 arg3 = static_cast< int >(val3);
46584 ecode4 = SWIG_AsVal_int(obj3, &val4);
46585 if (!SWIG_IsOK(ecode4)) {
46586 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_SetDimension" "', expected argument " "4"" of type '" "int""'");
46587 }
46588 arg4 = static_cast< int >(val4);
46589 ecode5 = SWIG_AsVal_int(obj4, &val5);
46590 if (!SWIG_IsOK(ecode5)) {
46591 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_SetDimension" "', expected argument " "5"" of type '" "int""'");
46592 }
46593 arg5 = static_cast< int >(val5);
46594 {
46595 PyThreadState* __tstate = wxPyBeginAllowThreads();
46596 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
46597 wxPyEndAllowThreads(__tstate);
46598 if (PyErr_Occurred()) SWIG_fail;
46599 }
46600 resultobj = SWIG_Py_Void();
46601 return resultobj;
46602 fail:
46603 return NULL;
46604 }
46605
46606
46607 SWIGINTERN PyObject *_wrap_Sizer_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46608 PyObject *resultobj = 0;
46609 wxSizer *arg1 = (wxSizer *) 0 ;
46610 wxSize *arg2 = 0 ;
46611 void *argp1 = 0 ;
46612 int res1 = 0 ;
46613 wxSize temp2 ;
46614 PyObject * obj0 = 0 ;
46615 PyObject * obj1 = 0 ;
46616 char * kwnames[] = {
46617 (char *) "self",(char *) "size", NULL
46618 };
46619
46620 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
46621 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46622 if (!SWIG_IsOK(res1)) {
46623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46624 }
46625 arg1 = reinterpret_cast< wxSizer * >(argp1);
46626 {
46627 arg2 = &temp2;
46628 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
46629 }
46630 {
46631 PyThreadState* __tstate = wxPyBeginAllowThreads();
46632 (arg1)->SetMinSize((wxSize const &)*arg2);
46633 wxPyEndAllowThreads(__tstate);
46634 if (PyErr_Occurred()) SWIG_fail;
46635 }
46636 resultobj = SWIG_Py_Void();
46637 return resultobj;
46638 fail:
46639 return NULL;
46640 }
46641
46642
46643 SWIGINTERN PyObject *_wrap_Sizer_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46644 PyObject *resultobj = 0;
46645 wxSizer *arg1 = (wxSizer *) 0 ;
46646 wxSize result;
46647 void *argp1 = 0 ;
46648 int res1 = 0 ;
46649 PyObject *swig_obj[1] ;
46650
46651 if (!args) SWIG_fail;
46652 swig_obj[0] = args;
46653 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46654 if (!SWIG_IsOK(res1)) {
46655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46656 }
46657 arg1 = reinterpret_cast< wxSizer * >(argp1);
46658 {
46659 PyThreadState* __tstate = wxPyBeginAllowThreads();
46660 result = (arg1)->GetSize();
46661 wxPyEndAllowThreads(__tstate);
46662 if (PyErr_Occurred()) SWIG_fail;
46663 }
46664 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46665 return resultobj;
46666 fail:
46667 return NULL;
46668 }
46669
46670
46671 SWIGINTERN PyObject *_wrap_Sizer_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46672 PyObject *resultobj = 0;
46673 wxSizer *arg1 = (wxSizer *) 0 ;
46674 wxPoint result;
46675 void *argp1 = 0 ;
46676 int res1 = 0 ;
46677 PyObject *swig_obj[1] ;
46678
46679 if (!args) SWIG_fail;
46680 swig_obj[0] = args;
46681 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46682 if (!SWIG_IsOK(res1)) {
46683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetPosition" "', expected argument " "1"" of type '" "wxSizer *""'");
46684 }
46685 arg1 = reinterpret_cast< wxSizer * >(argp1);
46686 {
46687 PyThreadState* __tstate = wxPyBeginAllowThreads();
46688 result = (arg1)->GetPosition();
46689 wxPyEndAllowThreads(__tstate);
46690 if (PyErr_Occurred()) SWIG_fail;
46691 }
46692 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
46693 return resultobj;
46694 fail:
46695 return NULL;
46696 }
46697
46698
46699 SWIGINTERN PyObject *_wrap_Sizer_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46700 PyObject *resultobj = 0;
46701 wxSizer *arg1 = (wxSizer *) 0 ;
46702 wxSize result;
46703 void *argp1 = 0 ;
46704 int res1 = 0 ;
46705 PyObject *swig_obj[1] ;
46706
46707 if (!args) SWIG_fail;
46708 swig_obj[0] = args;
46709 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46710 if (!SWIG_IsOK(res1)) {
46711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46712 }
46713 arg1 = reinterpret_cast< wxSizer * >(argp1);
46714 {
46715 PyThreadState* __tstate = wxPyBeginAllowThreads();
46716 result = (arg1)->GetMinSize();
46717 wxPyEndAllowThreads(__tstate);
46718 if (PyErr_Occurred()) SWIG_fail;
46719 }
46720 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46721 return resultobj;
46722 fail:
46723 return NULL;
46724 }
46725
46726
46727 SWIGINTERN PyObject *_wrap_Sizer_RecalcSizes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46728 PyObject *resultobj = 0;
46729 wxSizer *arg1 = (wxSizer *) 0 ;
46730 void *argp1 = 0 ;
46731 int res1 = 0 ;
46732 PyObject *swig_obj[1] ;
46733
46734 if (!args) SWIG_fail;
46735 swig_obj[0] = args;
46736 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46737 if (!SWIG_IsOK(res1)) {
46738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_RecalcSizes" "', expected argument " "1"" of type '" "wxSizer *""'");
46739 }
46740 arg1 = reinterpret_cast< wxSizer * >(argp1);
46741 {
46742 PyThreadState* __tstate = wxPyBeginAllowThreads();
46743 (arg1)->RecalcSizes();
46744 wxPyEndAllowThreads(__tstate);
46745 if (PyErr_Occurred()) SWIG_fail;
46746 }
46747 resultobj = SWIG_Py_Void();
46748 return resultobj;
46749 fail:
46750 return NULL;
46751 }
46752
46753
46754 SWIGINTERN PyObject *_wrap_Sizer_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46755 PyObject *resultobj = 0;
46756 wxSizer *arg1 = (wxSizer *) 0 ;
46757 wxSize result;
46758 void *argp1 = 0 ;
46759 int res1 = 0 ;
46760 PyObject *swig_obj[1] ;
46761
46762 if (!args) SWIG_fail;
46763 swig_obj[0] = args;
46764 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46765 if (!SWIG_IsOK(res1)) {
46766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_CalcMin" "', expected argument " "1"" of type '" "wxSizer *""'");
46767 }
46768 arg1 = reinterpret_cast< wxSizer * >(argp1);
46769 {
46770 PyThreadState* __tstate = wxPyBeginAllowThreads();
46771 result = (arg1)->CalcMin();
46772 wxPyEndAllowThreads(__tstate);
46773 if (PyErr_Occurred()) SWIG_fail;
46774 }
46775 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46776 return resultobj;
46777 fail:
46778 return NULL;
46779 }
46780
46781
46782 SWIGINTERN PyObject *_wrap_Sizer_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46783 PyObject *resultobj = 0;
46784 wxSizer *arg1 = (wxSizer *) 0 ;
46785 void *argp1 = 0 ;
46786 int res1 = 0 ;
46787 PyObject *swig_obj[1] ;
46788
46789 if (!args) SWIG_fail;
46790 swig_obj[0] = args;
46791 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46792 if (!SWIG_IsOK(res1)) {
46793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Layout" "', expected argument " "1"" of type '" "wxSizer *""'");
46794 }
46795 arg1 = reinterpret_cast< wxSizer * >(argp1);
46796 {
46797 PyThreadState* __tstate = wxPyBeginAllowThreads();
46798 (arg1)->Layout();
46799 wxPyEndAllowThreads(__tstate);
46800 if (PyErr_Occurred()) SWIG_fail;
46801 }
46802 resultobj = SWIG_Py_Void();
46803 return resultobj;
46804 fail:
46805 return NULL;
46806 }
46807
46808
46809 SWIGINTERN PyObject *_wrap_Sizer_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46810 PyObject *resultobj = 0;
46811 wxSizer *arg1 = (wxSizer *) 0 ;
46812 wxWindow *arg2 = (wxWindow *) 0 ;
46813 wxSize result;
46814 void *argp1 = 0 ;
46815 int res1 = 0 ;
46816 void *argp2 = 0 ;
46817 int res2 = 0 ;
46818 PyObject * obj0 = 0 ;
46819 PyObject * obj1 = 0 ;
46820 char * kwnames[] = {
46821 (char *) "self",(char *) "window", NULL
46822 };
46823
46824 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) SWIG_fail;
46825 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46826 if (!SWIG_IsOK(res1)) {
46827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Fit" "', expected argument " "1"" of type '" "wxSizer *""'");
46828 }
46829 arg1 = reinterpret_cast< wxSizer * >(argp1);
46830 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
46831 if (!SWIG_IsOK(res2)) {
46832 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_Fit" "', expected argument " "2"" of type '" "wxWindow *""'");
46833 }
46834 arg2 = reinterpret_cast< wxWindow * >(argp2);
46835 {
46836 PyThreadState* __tstate = wxPyBeginAllowThreads();
46837 result = (arg1)->Fit(arg2);
46838 wxPyEndAllowThreads(__tstate);
46839 if (PyErr_Occurred()) SWIG_fail;
46840 }
46841 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46842 return resultobj;
46843 fail:
46844 return NULL;
46845 }
46846
46847
46848 SWIGINTERN PyObject *_wrap_Sizer_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46849 PyObject *resultobj = 0;
46850 wxSizer *arg1 = (wxSizer *) 0 ;
46851 wxWindow *arg2 = (wxWindow *) 0 ;
46852 void *argp1 = 0 ;
46853 int res1 = 0 ;
46854 void *argp2 = 0 ;
46855 int res2 = 0 ;
46856 PyObject * obj0 = 0 ;
46857 PyObject * obj1 = 0 ;
46858 char * kwnames[] = {
46859 (char *) "self",(char *) "window", NULL
46860 };
46861
46862 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) SWIG_fail;
46863 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46864 if (!SWIG_IsOK(res1)) {
46865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_FitInside" "', expected argument " "1"" of type '" "wxSizer *""'");
46866 }
46867 arg1 = reinterpret_cast< wxSizer * >(argp1);
46868 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
46869 if (!SWIG_IsOK(res2)) {
46870 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_FitInside" "', expected argument " "2"" of type '" "wxWindow *""'");
46871 }
46872 arg2 = reinterpret_cast< wxWindow * >(argp2);
46873 {
46874 PyThreadState* __tstate = wxPyBeginAllowThreads();
46875 (arg1)->FitInside(arg2);
46876 wxPyEndAllowThreads(__tstate);
46877 if (PyErr_Occurred()) SWIG_fail;
46878 }
46879 resultobj = SWIG_Py_Void();
46880 return resultobj;
46881 fail:
46882 return NULL;
46883 }
46884
46885
46886 SWIGINTERN PyObject *_wrap_Sizer_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46887 PyObject *resultobj = 0;
46888 wxSizer *arg1 = (wxSizer *) 0 ;
46889 wxWindow *arg2 = (wxWindow *) 0 ;
46890 void *argp1 = 0 ;
46891 int res1 = 0 ;
46892 void *argp2 = 0 ;
46893 int res2 = 0 ;
46894 PyObject * obj0 = 0 ;
46895 PyObject * obj1 = 0 ;
46896 char * kwnames[] = {
46897 (char *) "self",(char *) "window", NULL
46898 };
46899
46900 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
46901 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46902 if (!SWIG_IsOK(res1)) {
46903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
46904 }
46905 arg1 = reinterpret_cast< wxSizer * >(argp1);
46906 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
46907 if (!SWIG_IsOK(res2)) {
46908 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
46909 }
46910 arg2 = reinterpret_cast< wxWindow * >(argp2);
46911 {
46912 PyThreadState* __tstate = wxPyBeginAllowThreads();
46913 (arg1)->SetSizeHints(arg2);
46914 wxPyEndAllowThreads(__tstate);
46915 if (PyErr_Occurred()) SWIG_fail;
46916 }
46917 resultobj = SWIG_Py_Void();
46918 return resultobj;
46919 fail:
46920 return NULL;
46921 }
46922
46923
46924 SWIGINTERN PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46925 PyObject *resultobj = 0;
46926 wxSizer *arg1 = (wxSizer *) 0 ;
46927 wxWindow *arg2 = (wxWindow *) 0 ;
46928 void *argp1 = 0 ;
46929 int res1 = 0 ;
46930 void *argp2 = 0 ;
46931 int res2 = 0 ;
46932 PyObject * obj0 = 0 ;
46933 PyObject * obj1 = 0 ;
46934 char * kwnames[] = {
46935 (char *) "self",(char *) "window", NULL
46936 };
46937
46938 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
46939 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46940 if (!SWIG_IsOK(res1)) {
46941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
46942 }
46943 arg1 = reinterpret_cast< wxSizer * >(argp1);
46944 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
46945 if (!SWIG_IsOK(res2)) {
46946 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
46947 }
46948 arg2 = reinterpret_cast< wxWindow * >(argp2);
46949 {
46950 PyThreadState* __tstate = wxPyBeginAllowThreads();
46951 (arg1)->SetVirtualSizeHints(arg2);
46952 wxPyEndAllowThreads(__tstate);
46953 if (PyErr_Occurred()) SWIG_fail;
46954 }
46955 resultobj = SWIG_Py_Void();
46956 return resultobj;
46957 fail:
46958 return NULL;
46959 }
46960
46961
46962 SWIGINTERN PyObject *_wrap_Sizer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46963 PyObject *resultobj = 0;
46964 wxSizer *arg1 = (wxSizer *) 0 ;
46965 bool arg2 = (bool) false ;
46966 void *argp1 = 0 ;
46967 int res1 = 0 ;
46968 bool val2 ;
46969 int ecode2 = 0 ;
46970 PyObject * obj0 = 0 ;
46971 PyObject * obj1 = 0 ;
46972 char * kwnames[] = {
46973 (char *) "self",(char *) "deleteWindows", NULL
46974 };
46975
46976 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) SWIG_fail;
46977 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46978 if (!SWIG_IsOK(res1)) {
46979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Clear" "', expected argument " "1"" of type '" "wxSizer *""'");
46980 }
46981 arg1 = reinterpret_cast< wxSizer * >(argp1);
46982 if (obj1) {
46983 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46984 if (!SWIG_IsOK(ecode2)) {
46985 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Clear" "', expected argument " "2"" of type '" "bool""'");
46986 }
46987 arg2 = static_cast< bool >(val2);
46988 }
46989 {
46990 PyThreadState* __tstate = wxPyBeginAllowThreads();
46991 (arg1)->Clear(arg2);
46992 wxPyEndAllowThreads(__tstate);
46993 if (PyErr_Occurred()) SWIG_fail;
46994 }
46995 resultobj = SWIG_Py_Void();
46996 return resultobj;
46997 fail:
46998 return NULL;
46999 }
47000
47001
47002 SWIGINTERN PyObject *_wrap_Sizer_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47003 PyObject *resultobj = 0;
47004 wxSizer *arg1 = (wxSizer *) 0 ;
47005 void *argp1 = 0 ;
47006 int res1 = 0 ;
47007 PyObject *swig_obj[1] ;
47008
47009 if (!args) SWIG_fail;
47010 swig_obj[0] = args;
47011 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47012 if (!SWIG_IsOK(res1)) {
47013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_DeleteWindows" "', expected argument " "1"" of type '" "wxSizer *""'");
47014 }
47015 arg1 = reinterpret_cast< wxSizer * >(argp1);
47016 {
47017 PyThreadState* __tstate = wxPyBeginAllowThreads();
47018 (arg1)->DeleteWindows();
47019 wxPyEndAllowThreads(__tstate);
47020 if (PyErr_Occurred()) SWIG_fail;
47021 }
47022 resultobj = SWIG_Py_Void();
47023 return resultobj;
47024 fail:
47025 return NULL;
47026 }
47027
47028
47029 SWIGINTERN PyObject *_wrap_Sizer_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47030 PyObject *resultobj = 0;
47031 wxSizer *arg1 = (wxSizer *) 0 ;
47032 PyObject *result = 0 ;
47033 void *argp1 = 0 ;
47034 int res1 = 0 ;
47035 PyObject *swig_obj[1] ;
47036
47037 if (!args) SWIG_fail;
47038 swig_obj[0] = args;
47039 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47040 if (!SWIG_IsOK(res1)) {
47041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetChildren" "', expected argument " "1"" of type '" "wxSizer *""'");
47042 }
47043 arg1 = reinterpret_cast< wxSizer * >(argp1);
47044 {
47045 PyThreadState* __tstate = wxPyBeginAllowThreads();
47046 result = (PyObject *)wxSizer_GetChildren(arg1);
47047 wxPyEndAllowThreads(__tstate);
47048 if (PyErr_Occurred()) SWIG_fail;
47049 }
47050 resultobj = result;
47051 return resultobj;
47052 fail:
47053 return NULL;
47054 }
47055
47056
47057 SWIGINTERN PyObject *_wrap_Sizer_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47058 PyObject *resultobj = 0;
47059 wxSizer *arg1 = (wxSizer *) 0 ;
47060 PyObject *arg2 = (PyObject *) 0 ;
47061 bool arg3 = (bool) true ;
47062 bool arg4 = (bool) false ;
47063 bool result;
47064 void *argp1 = 0 ;
47065 int res1 = 0 ;
47066 bool val3 ;
47067 int ecode3 = 0 ;
47068 bool val4 ;
47069 int ecode4 = 0 ;
47070 PyObject * obj0 = 0 ;
47071 PyObject * obj1 = 0 ;
47072 PyObject * obj2 = 0 ;
47073 PyObject * obj3 = 0 ;
47074 char * kwnames[] = {
47075 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
47076 };
47077
47078 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47079 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47080 if (!SWIG_IsOK(res1)) {
47081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Show" "', expected argument " "1"" of type '" "wxSizer *""'");
47082 }
47083 arg1 = reinterpret_cast< wxSizer * >(argp1);
47084 arg2 = obj1;
47085 if (obj2) {
47086 ecode3 = SWIG_AsVal_bool(obj2, &val3);
47087 if (!SWIG_IsOK(ecode3)) {
47088 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Show" "', expected argument " "3"" of type '" "bool""'");
47089 }
47090 arg3 = static_cast< bool >(val3);
47091 }
47092 if (obj3) {
47093 ecode4 = SWIG_AsVal_bool(obj3, &val4);
47094 if (!SWIG_IsOK(ecode4)) {
47095 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Show" "', expected argument " "4"" of type '" "bool""'");
47096 }
47097 arg4 = static_cast< bool >(val4);
47098 }
47099 {
47100 PyThreadState* __tstate = wxPyBeginAllowThreads();
47101 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
47102 wxPyEndAllowThreads(__tstate);
47103 if (PyErr_Occurred()) SWIG_fail;
47104 }
47105 {
47106 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47107 }
47108 return resultobj;
47109 fail:
47110 return NULL;
47111 }
47112
47113
47114 SWIGINTERN PyObject *_wrap_Sizer_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47115 PyObject *resultobj = 0;
47116 wxSizer *arg1 = (wxSizer *) 0 ;
47117 PyObject *arg2 = (PyObject *) 0 ;
47118 bool result;
47119 void *argp1 = 0 ;
47120 int res1 = 0 ;
47121 PyObject * obj0 = 0 ;
47122 PyObject * obj1 = 0 ;
47123 char * kwnames[] = {
47124 (char *) "self",(char *) "item", NULL
47125 };
47126
47127 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) SWIG_fail;
47128 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47129 if (!SWIG_IsOK(res1)) {
47130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_IsShown" "', expected argument " "1"" of type '" "wxSizer *""'");
47131 }
47132 arg1 = reinterpret_cast< wxSizer * >(argp1);
47133 arg2 = obj1;
47134 {
47135 PyThreadState* __tstate = wxPyBeginAllowThreads();
47136 result = (bool)wxSizer_IsShown(arg1,arg2);
47137 wxPyEndAllowThreads(__tstate);
47138 if (PyErr_Occurred()) SWIG_fail;
47139 }
47140 {
47141 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47142 }
47143 return resultobj;
47144 fail:
47145 return NULL;
47146 }
47147
47148
47149 SWIGINTERN PyObject *_wrap_Sizer_ShowItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47150 PyObject *resultobj = 0;
47151 wxSizer *arg1 = (wxSizer *) 0 ;
47152 bool arg2 ;
47153 void *argp1 = 0 ;
47154 int res1 = 0 ;
47155 bool val2 ;
47156 int ecode2 = 0 ;
47157 PyObject * obj0 = 0 ;
47158 PyObject * obj1 = 0 ;
47159 char * kwnames[] = {
47160 (char *) "self",(char *) "show", NULL
47161 };
47162
47163 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) SWIG_fail;
47164 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47165 if (!SWIG_IsOK(res1)) {
47166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_ShowItems" "', expected argument " "1"" of type '" "wxSizer *""'");
47167 }
47168 arg1 = reinterpret_cast< wxSizer * >(argp1);
47169 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47170 if (!SWIG_IsOK(ecode2)) {
47171 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_ShowItems" "', expected argument " "2"" of type '" "bool""'");
47172 }
47173 arg2 = static_cast< bool >(val2);
47174 {
47175 PyThreadState* __tstate = wxPyBeginAllowThreads();
47176 (arg1)->ShowItems(arg2);
47177 wxPyEndAllowThreads(__tstate);
47178 if (PyErr_Occurred()) SWIG_fail;
47179 }
47180 resultobj = SWIG_Py_Void();
47181 return resultobj;
47182 fail:
47183 return NULL;
47184 }
47185
47186
47187 SWIGINTERN PyObject *Sizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47188 PyObject *obj;
47189 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47190 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizer, SWIG_NewClientData(obj));
47191 return SWIG_Py_Void();
47192 }
47193
47194 SWIGINTERN PyObject *_wrap_new_PySizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47195 PyObject *resultobj = 0;
47196 wxPySizer *result = 0 ;
47197
47198 if (!SWIG_Python_UnpackTuple(args,"new_PySizer",0,0,0)) SWIG_fail;
47199 {
47200 PyThreadState* __tstate = wxPyBeginAllowThreads();
47201 result = (wxPySizer *)new wxPySizer();
47202 wxPyEndAllowThreads(__tstate);
47203 if (PyErr_Occurred()) SWIG_fail;
47204 }
47205 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPySizer, SWIG_POINTER_NEW | 0 );
47206 return resultobj;
47207 fail:
47208 return NULL;
47209 }
47210
47211
47212 SWIGINTERN PyObject *_wrap_PySizer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47213 PyObject *resultobj = 0;
47214 wxPySizer *arg1 = (wxPySizer *) 0 ;
47215 PyObject *arg2 = (PyObject *) 0 ;
47216 PyObject *arg3 = (PyObject *) 0 ;
47217 void *argp1 = 0 ;
47218 int res1 = 0 ;
47219 PyObject * obj0 = 0 ;
47220 PyObject * obj1 = 0 ;
47221 PyObject * obj2 = 0 ;
47222 char * kwnames[] = {
47223 (char *) "self",(char *) "self",(char *) "_class", NULL
47224 };
47225
47226 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47227 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPySizer, 0 | 0 );
47228 if (!SWIG_IsOK(res1)) {
47229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySizer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPySizer *""'");
47230 }
47231 arg1 = reinterpret_cast< wxPySizer * >(argp1);
47232 arg2 = obj1;
47233 arg3 = obj2;
47234 {
47235 PyThreadState* __tstate = wxPyBeginAllowThreads();
47236 (arg1)->_setCallbackInfo(arg2,arg3);
47237 wxPyEndAllowThreads(__tstate);
47238 if (PyErr_Occurred()) SWIG_fail;
47239 }
47240 resultobj = SWIG_Py_Void();
47241 return resultobj;
47242 fail:
47243 return NULL;
47244 }
47245
47246
47247 SWIGINTERN PyObject *PySizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47248 PyObject *obj;
47249 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47250 SWIG_TypeNewClientData(SWIGTYPE_p_wxPySizer, SWIG_NewClientData(obj));
47251 return SWIG_Py_Void();
47252 }
47253
47254 SWIGINTERN PyObject *PySizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47255 return SWIG_Python_InitShadowInstance(args);
47256 }
47257
47258 SWIGINTERN PyObject *_wrap_new_BoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47259 PyObject *resultobj = 0;
47260 int arg1 = (int) wxHORIZONTAL ;
47261 wxBoxSizer *result = 0 ;
47262 int val1 ;
47263 int ecode1 = 0 ;
47264 PyObject * obj0 = 0 ;
47265 char * kwnames[] = {
47266 (char *) "orient", NULL
47267 };
47268
47269 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) SWIG_fail;
47270 if (obj0) {
47271 ecode1 = SWIG_AsVal_int(obj0, &val1);
47272 if (!SWIG_IsOK(ecode1)) {
47273 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BoxSizer" "', expected argument " "1"" of type '" "int""'");
47274 }
47275 arg1 = static_cast< int >(val1);
47276 }
47277 {
47278 PyThreadState* __tstate = wxPyBeginAllowThreads();
47279 result = (wxBoxSizer *)new wxBoxSizer(arg1);
47280 wxPyEndAllowThreads(__tstate);
47281 if (PyErr_Occurred()) SWIG_fail;
47282 }
47283 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_NEW | 0 );
47284 return resultobj;
47285 fail:
47286 return NULL;
47287 }
47288
47289
47290 SWIGINTERN PyObject *_wrap_BoxSizer_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47291 PyObject *resultobj = 0;
47292 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
47293 int result;
47294 void *argp1 = 0 ;
47295 int res1 = 0 ;
47296 PyObject *swig_obj[1] ;
47297
47298 if (!args) SWIG_fail;
47299 swig_obj[0] = args;
47300 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
47301 if (!SWIG_IsOK(res1)) {
47302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_GetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
47303 }
47304 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
47305 {
47306 PyThreadState* __tstate = wxPyBeginAllowThreads();
47307 result = (int)(arg1)->GetOrientation();
47308 wxPyEndAllowThreads(__tstate);
47309 if (PyErr_Occurred()) SWIG_fail;
47310 }
47311 resultobj = SWIG_From_int(static_cast< int >(result));
47312 return resultobj;
47313 fail:
47314 return NULL;
47315 }
47316
47317
47318 SWIGINTERN PyObject *_wrap_BoxSizer_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47319 PyObject *resultobj = 0;
47320 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
47321 int arg2 ;
47322 void *argp1 = 0 ;
47323 int res1 = 0 ;
47324 int val2 ;
47325 int ecode2 = 0 ;
47326 PyObject * obj0 = 0 ;
47327 PyObject * obj1 = 0 ;
47328 char * kwnames[] = {
47329 (char *) "self",(char *) "orient", NULL
47330 };
47331
47332 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
47333 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
47334 if (!SWIG_IsOK(res1)) {
47335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_SetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
47336 }
47337 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
47338 ecode2 = SWIG_AsVal_int(obj1, &val2);
47339 if (!SWIG_IsOK(ecode2)) {
47340 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoxSizer_SetOrientation" "', expected argument " "2"" of type '" "int""'");
47341 }
47342 arg2 = static_cast< int >(val2);
47343 {
47344 PyThreadState* __tstate = wxPyBeginAllowThreads();
47345 (arg1)->SetOrientation(arg2);
47346 wxPyEndAllowThreads(__tstate);
47347 if (PyErr_Occurred()) SWIG_fail;
47348 }
47349 resultobj = SWIG_Py_Void();
47350 return resultobj;
47351 fail:
47352 return NULL;
47353 }
47354
47355
47356 SWIGINTERN PyObject *BoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47357 PyObject *obj;
47358 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47359 SWIG_TypeNewClientData(SWIGTYPE_p_wxBoxSizer, SWIG_NewClientData(obj));
47360 return SWIG_Py_Void();
47361 }
47362
47363 SWIGINTERN PyObject *BoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47364 return SWIG_Python_InitShadowInstance(args);
47365 }
47366
47367 SWIGINTERN PyObject *_wrap_new_StaticBoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47368 PyObject *resultobj = 0;
47369 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
47370 int arg2 = (int) wxHORIZONTAL ;
47371 wxStaticBoxSizer *result = 0 ;
47372 void *argp1 = 0 ;
47373 int res1 = 0 ;
47374 int val2 ;
47375 int ecode2 = 0 ;
47376 PyObject * obj0 = 0 ;
47377 PyObject * obj1 = 0 ;
47378 char * kwnames[] = {
47379 (char *) "box",(char *) "orient", NULL
47380 };
47381
47382 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) SWIG_fail;
47383 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStaticBox, 0 | 0 );
47384 if (!SWIG_IsOK(res1)) {
47385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StaticBoxSizer" "', expected argument " "1"" of type '" "wxStaticBox *""'");
47386 }
47387 arg1 = reinterpret_cast< wxStaticBox * >(argp1);
47388 if (obj1) {
47389 ecode2 = SWIG_AsVal_int(obj1, &val2);
47390 if (!SWIG_IsOK(ecode2)) {
47391 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StaticBoxSizer" "', expected argument " "2"" of type '" "int""'");
47392 }
47393 arg2 = static_cast< int >(val2);
47394 }
47395 {
47396 PyThreadState* __tstate = wxPyBeginAllowThreads();
47397 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
47398 wxPyEndAllowThreads(__tstate);
47399 if (PyErr_Occurred()) SWIG_fail;
47400 }
47401 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_NEW | 0 );
47402 return resultobj;
47403 fail:
47404 return NULL;
47405 }
47406
47407
47408 SWIGINTERN PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47409 PyObject *resultobj = 0;
47410 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
47411 wxStaticBox *result = 0 ;
47412 void *argp1 = 0 ;
47413 int res1 = 0 ;
47414 PyObject *swig_obj[1] ;
47415
47416 if (!args) SWIG_fail;
47417 swig_obj[0] = args;
47418 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStaticBoxSizer, 0 | 0 );
47419 if (!SWIG_IsOK(res1)) {
47420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StaticBoxSizer_GetStaticBox" "', expected argument " "1"" of type '" "wxStaticBoxSizer *""'");
47421 }
47422 arg1 = reinterpret_cast< wxStaticBoxSizer * >(argp1);
47423 {
47424 PyThreadState* __tstate = wxPyBeginAllowThreads();
47425 result = (wxStaticBox *)(arg1)->GetStaticBox();
47426 wxPyEndAllowThreads(__tstate);
47427 if (PyErr_Occurred()) SWIG_fail;
47428 }
47429 {
47430 resultobj = wxPyMake_wxObject(result, (bool)0);
47431 }
47432 return resultobj;
47433 fail:
47434 return NULL;
47435 }
47436
47437
47438 SWIGINTERN PyObject *StaticBoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47439 PyObject *obj;
47440 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47441 SWIG_TypeNewClientData(SWIGTYPE_p_wxStaticBoxSizer, SWIG_NewClientData(obj));
47442 return SWIG_Py_Void();
47443 }
47444
47445 SWIGINTERN PyObject *StaticBoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47446 return SWIG_Python_InitShadowInstance(args);
47447 }
47448
47449 SWIGINTERN PyObject *_wrap_new_GridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47450 PyObject *resultobj = 0;
47451 int arg1 = (int) 1 ;
47452 int arg2 = (int) 0 ;
47453 int arg3 = (int) 0 ;
47454 int arg4 = (int) 0 ;
47455 wxGridSizer *result = 0 ;
47456 int val1 ;
47457 int ecode1 = 0 ;
47458 int val2 ;
47459 int ecode2 = 0 ;
47460 int val3 ;
47461 int ecode3 = 0 ;
47462 int val4 ;
47463 int ecode4 = 0 ;
47464 PyObject * obj0 = 0 ;
47465 PyObject * obj1 = 0 ;
47466 PyObject * obj2 = 0 ;
47467 PyObject * obj3 = 0 ;
47468 char * kwnames[] = {
47469 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
47470 };
47471
47472 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47473 if (obj0) {
47474 ecode1 = SWIG_AsVal_int(obj0, &val1);
47475 if (!SWIG_IsOK(ecode1)) {
47476 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizer" "', expected argument " "1"" of type '" "int""'");
47477 }
47478 arg1 = static_cast< int >(val1);
47479 }
47480 if (obj1) {
47481 ecode2 = SWIG_AsVal_int(obj1, &val2);
47482 if (!SWIG_IsOK(ecode2)) {
47483 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizer" "', expected argument " "2"" of type '" "int""'");
47484 }
47485 arg2 = static_cast< int >(val2);
47486 }
47487 if (obj2) {
47488 ecode3 = SWIG_AsVal_int(obj2, &val3);
47489 if (!SWIG_IsOK(ecode3)) {
47490 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridSizer" "', expected argument " "3"" of type '" "int""'");
47491 }
47492 arg3 = static_cast< int >(val3);
47493 }
47494 if (obj3) {
47495 ecode4 = SWIG_AsVal_int(obj3, &val4);
47496 if (!SWIG_IsOK(ecode4)) {
47497 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizer" "', expected argument " "4"" of type '" "int""'");
47498 }
47499 arg4 = static_cast< int >(val4);
47500 }
47501 {
47502 PyThreadState* __tstate = wxPyBeginAllowThreads();
47503 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
47504 wxPyEndAllowThreads(__tstate);
47505 if (PyErr_Occurred()) SWIG_fail;
47506 }
47507 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizer, SWIG_POINTER_NEW | 0 );
47508 return resultobj;
47509 fail:
47510 return NULL;
47511 }
47512
47513
47514 SWIGINTERN PyObject *_wrap_GridSizer_SetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47515 PyObject *resultobj = 0;
47516 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47517 int arg2 ;
47518 void *argp1 = 0 ;
47519 int res1 = 0 ;
47520 int val2 ;
47521 int ecode2 = 0 ;
47522 PyObject * obj0 = 0 ;
47523 PyObject * obj1 = 0 ;
47524 char * kwnames[] = {
47525 (char *) "self",(char *) "cols", NULL
47526 };
47527
47528 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) SWIG_fail;
47529 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47530 if (!SWIG_IsOK(res1)) {
47531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47532 }
47533 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47534 ecode2 = SWIG_AsVal_int(obj1, &val2);
47535 if (!SWIG_IsOK(ecode2)) {
47536 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetCols" "', expected argument " "2"" of type '" "int""'");
47537 }
47538 arg2 = static_cast< int >(val2);
47539 {
47540 PyThreadState* __tstate = wxPyBeginAllowThreads();
47541 (arg1)->SetCols(arg2);
47542 wxPyEndAllowThreads(__tstate);
47543 if (PyErr_Occurred()) SWIG_fail;
47544 }
47545 resultobj = SWIG_Py_Void();
47546 return resultobj;
47547 fail:
47548 return NULL;
47549 }
47550
47551
47552 SWIGINTERN PyObject *_wrap_GridSizer_SetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47553 PyObject *resultobj = 0;
47554 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47555 int arg2 ;
47556 void *argp1 = 0 ;
47557 int res1 = 0 ;
47558 int val2 ;
47559 int ecode2 = 0 ;
47560 PyObject * obj0 = 0 ;
47561 PyObject * obj1 = 0 ;
47562 char * kwnames[] = {
47563 (char *) "self",(char *) "rows", NULL
47564 };
47565
47566 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) SWIG_fail;
47567 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47568 if (!SWIG_IsOK(res1)) {
47569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47570 }
47571 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47572 ecode2 = SWIG_AsVal_int(obj1, &val2);
47573 if (!SWIG_IsOK(ecode2)) {
47574 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetRows" "', expected argument " "2"" of type '" "int""'");
47575 }
47576 arg2 = static_cast< int >(val2);
47577 {
47578 PyThreadState* __tstate = wxPyBeginAllowThreads();
47579 (arg1)->SetRows(arg2);
47580 wxPyEndAllowThreads(__tstate);
47581 if (PyErr_Occurred()) SWIG_fail;
47582 }
47583 resultobj = SWIG_Py_Void();
47584 return resultobj;
47585 fail:
47586 return NULL;
47587 }
47588
47589
47590 SWIGINTERN PyObject *_wrap_GridSizer_SetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47591 PyObject *resultobj = 0;
47592 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47593 int arg2 ;
47594 void *argp1 = 0 ;
47595 int res1 = 0 ;
47596 int val2 ;
47597 int ecode2 = 0 ;
47598 PyObject * obj0 = 0 ;
47599 PyObject * obj1 = 0 ;
47600 char * kwnames[] = {
47601 (char *) "self",(char *) "gap", NULL
47602 };
47603
47604 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) SWIG_fail;
47605 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47606 if (!SWIG_IsOK(res1)) {
47607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47608 }
47609 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47610 ecode2 = SWIG_AsVal_int(obj1, &val2);
47611 if (!SWIG_IsOK(ecode2)) {
47612 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetVGap" "', expected argument " "2"" of type '" "int""'");
47613 }
47614 arg2 = static_cast< int >(val2);
47615 {
47616 PyThreadState* __tstate = wxPyBeginAllowThreads();
47617 (arg1)->SetVGap(arg2);
47618 wxPyEndAllowThreads(__tstate);
47619 if (PyErr_Occurred()) SWIG_fail;
47620 }
47621 resultobj = SWIG_Py_Void();
47622 return resultobj;
47623 fail:
47624 return NULL;
47625 }
47626
47627
47628 SWIGINTERN PyObject *_wrap_GridSizer_SetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47629 PyObject *resultobj = 0;
47630 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47631 int arg2 ;
47632 void *argp1 = 0 ;
47633 int res1 = 0 ;
47634 int val2 ;
47635 int ecode2 = 0 ;
47636 PyObject * obj0 = 0 ;
47637 PyObject * obj1 = 0 ;
47638 char * kwnames[] = {
47639 (char *) "self",(char *) "gap", NULL
47640 };
47641
47642 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) SWIG_fail;
47643 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47644 if (!SWIG_IsOK(res1)) {
47645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47646 }
47647 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47648 ecode2 = SWIG_AsVal_int(obj1, &val2);
47649 if (!SWIG_IsOK(ecode2)) {
47650 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetHGap" "', expected argument " "2"" of type '" "int""'");
47651 }
47652 arg2 = static_cast< int >(val2);
47653 {
47654 PyThreadState* __tstate = wxPyBeginAllowThreads();
47655 (arg1)->SetHGap(arg2);
47656 wxPyEndAllowThreads(__tstate);
47657 if (PyErr_Occurred()) SWIG_fail;
47658 }
47659 resultobj = SWIG_Py_Void();
47660 return resultobj;
47661 fail:
47662 return NULL;
47663 }
47664
47665
47666 SWIGINTERN PyObject *_wrap_GridSizer_GetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47667 PyObject *resultobj = 0;
47668 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47669 int result;
47670 void *argp1 = 0 ;
47671 int res1 = 0 ;
47672 PyObject *swig_obj[1] ;
47673
47674 if (!args) SWIG_fail;
47675 swig_obj[0] = args;
47676 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47677 if (!SWIG_IsOK(res1)) {
47678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47679 }
47680 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47681 {
47682 PyThreadState* __tstate = wxPyBeginAllowThreads();
47683 result = (int)(arg1)->GetCols();
47684 wxPyEndAllowThreads(__tstate);
47685 if (PyErr_Occurred()) SWIG_fail;
47686 }
47687 resultobj = SWIG_From_int(static_cast< int >(result));
47688 return resultobj;
47689 fail:
47690 return NULL;
47691 }
47692
47693
47694 SWIGINTERN PyObject *_wrap_GridSizer_GetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47695 PyObject *resultobj = 0;
47696 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47697 int result;
47698 void *argp1 = 0 ;
47699 int res1 = 0 ;
47700 PyObject *swig_obj[1] ;
47701
47702 if (!args) SWIG_fail;
47703 swig_obj[0] = args;
47704 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47705 if (!SWIG_IsOK(res1)) {
47706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47707 }
47708 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47709 {
47710 PyThreadState* __tstate = wxPyBeginAllowThreads();
47711 result = (int)(arg1)->GetRows();
47712 wxPyEndAllowThreads(__tstate);
47713 if (PyErr_Occurred()) SWIG_fail;
47714 }
47715 resultobj = SWIG_From_int(static_cast< int >(result));
47716 return resultobj;
47717 fail:
47718 return NULL;
47719 }
47720
47721
47722 SWIGINTERN PyObject *_wrap_GridSizer_GetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47723 PyObject *resultobj = 0;
47724 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47725 int result;
47726 void *argp1 = 0 ;
47727 int res1 = 0 ;
47728 PyObject *swig_obj[1] ;
47729
47730 if (!args) SWIG_fail;
47731 swig_obj[0] = args;
47732 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47733 if (!SWIG_IsOK(res1)) {
47734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47735 }
47736 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47737 {
47738 PyThreadState* __tstate = wxPyBeginAllowThreads();
47739 result = (int)(arg1)->GetVGap();
47740 wxPyEndAllowThreads(__tstate);
47741 if (PyErr_Occurred()) SWIG_fail;
47742 }
47743 resultobj = SWIG_From_int(static_cast< int >(result));
47744 return resultobj;
47745 fail:
47746 return NULL;
47747 }
47748
47749
47750 SWIGINTERN PyObject *_wrap_GridSizer_GetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47751 PyObject *resultobj = 0;
47752 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47753 int result;
47754 void *argp1 = 0 ;
47755 int res1 = 0 ;
47756 PyObject *swig_obj[1] ;
47757
47758 if (!args) SWIG_fail;
47759 swig_obj[0] = args;
47760 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47761 if (!SWIG_IsOK(res1)) {
47762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47763 }
47764 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47765 {
47766 PyThreadState* __tstate = wxPyBeginAllowThreads();
47767 result = (int)(arg1)->GetHGap();
47768 wxPyEndAllowThreads(__tstate);
47769 if (PyErr_Occurred()) SWIG_fail;
47770 }
47771 resultobj = SWIG_From_int(static_cast< int >(result));
47772 return resultobj;
47773 fail:
47774 return NULL;
47775 }
47776
47777
47778 SWIGINTERN PyObject *GridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47779 PyObject *obj;
47780 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47781 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizer, SWIG_NewClientData(obj));
47782 return SWIG_Py_Void();
47783 }
47784
47785 SWIGINTERN PyObject *GridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47786 return SWIG_Python_InitShadowInstance(args);
47787 }
47788
47789 SWIGINTERN PyObject *_wrap_new_FlexGridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47790 PyObject *resultobj = 0;
47791 int arg1 = (int) 1 ;
47792 int arg2 = (int) 0 ;
47793 int arg3 = (int) 0 ;
47794 int arg4 = (int) 0 ;
47795 wxFlexGridSizer *result = 0 ;
47796 int val1 ;
47797 int ecode1 = 0 ;
47798 int val2 ;
47799 int ecode2 = 0 ;
47800 int val3 ;
47801 int ecode3 = 0 ;
47802 int val4 ;
47803 int ecode4 = 0 ;
47804 PyObject * obj0 = 0 ;
47805 PyObject * obj1 = 0 ;
47806 PyObject * obj2 = 0 ;
47807 PyObject * obj3 = 0 ;
47808 char * kwnames[] = {
47809 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
47810 };
47811
47812 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47813 if (obj0) {
47814 ecode1 = SWIG_AsVal_int(obj0, &val1);
47815 if (!SWIG_IsOK(ecode1)) {
47816 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlexGridSizer" "', expected argument " "1"" of type '" "int""'");
47817 }
47818 arg1 = static_cast< int >(val1);
47819 }
47820 if (obj1) {
47821 ecode2 = SWIG_AsVal_int(obj1, &val2);
47822 if (!SWIG_IsOK(ecode2)) {
47823 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlexGridSizer" "', expected argument " "2"" of type '" "int""'");
47824 }
47825 arg2 = static_cast< int >(val2);
47826 }
47827 if (obj2) {
47828 ecode3 = SWIG_AsVal_int(obj2, &val3);
47829 if (!SWIG_IsOK(ecode3)) {
47830 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FlexGridSizer" "', expected argument " "3"" of type '" "int""'");
47831 }
47832 arg3 = static_cast< int >(val3);
47833 }
47834 if (obj3) {
47835 ecode4 = SWIG_AsVal_int(obj3, &val4);
47836 if (!SWIG_IsOK(ecode4)) {
47837 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FlexGridSizer" "', expected argument " "4"" of type '" "int""'");
47838 }
47839 arg4 = static_cast< int >(val4);
47840 }
47841 {
47842 PyThreadState* __tstate = wxPyBeginAllowThreads();
47843 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
47844 wxPyEndAllowThreads(__tstate);
47845 if (PyErr_Occurred()) SWIG_fail;
47846 }
47847 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_NEW | 0 );
47848 return resultobj;
47849 fail:
47850 return NULL;
47851 }
47852
47853
47854 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47855 PyObject *resultobj = 0;
47856 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47857 size_t arg2 ;
47858 int arg3 = (int) 0 ;
47859 void *argp1 = 0 ;
47860 int res1 = 0 ;
47861 size_t val2 ;
47862 int ecode2 = 0 ;
47863 int val3 ;
47864 int ecode3 = 0 ;
47865 PyObject * obj0 = 0 ;
47866 PyObject * obj1 = 0 ;
47867 PyObject * obj2 = 0 ;
47868 char * kwnames[] = {
47869 (char *) "self",(char *) "idx",(char *) "proportion", NULL
47870 };
47871
47872 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47873 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
47874 if (!SWIG_IsOK(res1)) {
47875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
47876 }
47877 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
47878 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
47879 if (!SWIG_IsOK(ecode2)) {
47880 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
47881 }
47882 arg2 = static_cast< size_t >(val2);
47883 if (obj2) {
47884 ecode3 = SWIG_AsVal_int(obj2, &val3);
47885 if (!SWIG_IsOK(ecode3)) {
47886 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "3"" of type '" "int""'");
47887 }
47888 arg3 = static_cast< int >(val3);
47889 }
47890 {
47891 PyThreadState* __tstate = wxPyBeginAllowThreads();
47892 (arg1)->AddGrowableRow(arg2,arg3);
47893 wxPyEndAllowThreads(__tstate);
47894 if (PyErr_Occurred()) SWIG_fail;
47895 }
47896 resultobj = SWIG_Py_Void();
47897 return resultobj;
47898 fail:
47899 return NULL;
47900 }
47901
47902
47903 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47904 PyObject *resultobj = 0;
47905 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47906 size_t arg2 ;
47907 void *argp1 = 0 ;
47908 int res1 = 0 ;
47909 size_t val2 ;
47910 int ecode2 = 0 ;
47911 PyObject * obj0 = 0 ;
47912 PyObject * obj1 = 0 ;
47913 char * kwnames[] = {
47914 (char *) "self",(char *) "idx", NULL
47915 };
47916
47917 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) SWIG_fail;
47918 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
47919 if (!SWIG_IsOK(res1)) {
47920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
47921 }
47922 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
47923 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
47924 if (!SWIG_IsOK(ecode2)) {
47925 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
47926 }
47927 arg2 = static_cast< size_t >(val2);
47928 {
47929 PyThreadState* __tstate = wxPyBeginAllowThreads();
47930 (arg1)->RemoveGrowableRow(arg2);
47931 wxPyEndAllowThreads(__tstate);
47932 if (PyErr_Occurred()) SWIG_fail;
47933 }
47934 resultobj = SWIG_Py_Void();
47935 return resultobj;
47936 fail:
47937 return NULL;
47938 }
47939
47940
47941 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47942 PyObject *resultobj = 0;
47943 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47944 size_t arg2 ;
47945 int arg3 = (int) 0 ;
47946 void *argp1 = 0 ;
47947 int res1 = 0 ;
47948 size_t val2 ;
47949 int ecode2 = 0 ;
47950 int val3 ;
47951 int ecode3 = 0 ;
47952 PyObject * obj0 = 0 ;
47953 PyObject * obj1 = 0 ;
47954 PyObject * obj2 = 0 ;
47955 char * kwnames[] = {
47956 (char *) "self",(char *) "idx",(char *) "proportion", NULL
47957 };
47958
47959 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47960 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
47961 if (!SWIG_IsOK(res1)) {
47962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
47963 }
47964 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
47965 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
47966 if (!SWIG_IsOK(ecode2)) {
47967 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
47968 }
47969 arg2 = static_cast< size_t >(val2);
47970 if (obj2) {
47971 ecode3 = SWIG_AsVal_int(obj2, &val3);
47972 if (!SWIG_IsOK(ecode3)) {
47973 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "3"" of type '" "int""'");
47974 }
47975 arg3 = static_cast< int >(val3);
47976 }
47977 {
47978 PyThreadState* __tstate = wxPyBeginAllowThreads();
47979 (arg1)->AddGrowableCol(arg2,arg3);
47980 wxPyEndAllowThreads(__tstate);
47981 if (PyErr_Occurred()) SWIG_fail;
47982 }
47983 resultobj = SWIG_Py_Void();
47984 return resultobj;
47985 fail:
47986 return NULL;
47987 }
47988
47989
47990 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47991 PyObject *resultobj = 0;
47992 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47993 size_t arg2 ;
47994 void *argp1 = 0 ;
47995 int res1 = 0 ;
47996 size_t val2 ;
47997 int ecode2 = 0 ;
47998 PyObject * obj0 = 0 ;
47999 PyObject * obj1 = 0 ;
48000 char * kwnames[] = {
48001 (char *) "self",(char *) "idx", NULL
48002 };
48003
48004 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) SWIG_fail;
48005 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48006 if (!SWIG_IsOK(res1)) {
48007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48008 }
48009 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48010 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48011 if (!SWIG_IsOK(ecode2)) {
48012 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
48013 }
48014 arg2 = static_cast< size_t >(val2);
48015 {
48016 PyThreadState* __tstate = wxPyBeginAllowThreads();
48017 (arg1)->RemoveGrowableCol(arg2);
48018 wxPyEndAllowThreads(__tstate);
48019 if (PyErr_Occurred()) SWIG_fail;
48020 }
48021 resultobj = SWIG_Py_Void();
48022 return resultobj;
48023 fail:
48024 return NULL;
48025 }
48026
48027
48028 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48029 PyObject *resultobj = 0;
48030 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48031 int arg2 ;
48032 void *argp1 = 0 ;
48033 int res1 = 0 ;
48034 int val2 ;
48035 int ecode2 = 0 ;
48036 PyObject * obj0 = 0 ;
48037 PyObject * obj1 = 0 ;
48038 char * kwnames[] = {
48039 (char *) "self",(char *) "direction", NULL
48040 };
48041
48042 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) SWIG_fail;
48043 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48044 if (!SWIG_IsOK(res1)) {
48045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48046 }
48047 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48048 ecode2 = SWIG_AsVal_int(obj1, &val2);
48049 if (!SWIG_IsOK(ecode2)) {
48050 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "2"" of type '" "int""'");
48051 }
48052 arg2 = static_cast< int >(val2);
48053 {
48054 PyThreadState* __tstate = wxPyBeginAllowThreads();
48055 (arg1)->SetFlexibleDirection(arg2);
48056 wxPyEndAllowThreads(__tstate);
48057 if (PyErr_Occurred()) SWIG_fail;
48058 }
48059 resultobj = SWIG_Py_Void();
48060 return resultobj;
48061 fail:
48062 return NULL;
48063 }
48064
48065
48066 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48067 PyObject *resultobj = 0;
48068 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48069 int result;
48070 void *argp1 = 0 ;
48071 int res1 = 0 ;
48072 PyObject *swig_obj[1] ;
48073
48074 if (!args) SWIG_fail;
48075 swig_obj[0] = args;
48076 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48077 if (!SWIG_IsOK(res1)) {
48078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48079 }
48080 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48081 {
48082 PyThreadState* __tstate = wxPyBeginAllowThreads();
48083 result = (int)(arg1)->GetFlexibleDirection();
48084 wxPyEndAllowThreads(__tstate);
48085 if (PyErr_Occurred()) SWIG_fail;
48086 }
48087 resultobj = SWIG_From_int(static_cast< int >(result));
48088 return resultobj;
48089 fail:
48090 return NULL;
48091 }
48092
48093
48094 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48095 PyObject *resultobj = 0;
48096 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48097 wxFlexSizerGrowMode arg2 ;
48098 void *argp1 = 0 ;
48099 int res1 = 0 ;
48100 int val2 ;
48101 int ecode2 = 0 ;
48102 PyObject * obj0 = 0 ;
48103 PyObject * obj1 = 0 ;
48104 char * kwnames[] = {
48105 (char *) "self",(char *) "mode", NULL
48106 };
48107
48108 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) SWIG_fail;
48109 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48110 if (!SWIG_IsOK(res1)) {
48111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48112 }
48113 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48114 ecode2 = SWIG_AsVal_int(obj1, &val2);
48115 if (!SWIG_IsOK(ecode2)) {
48116 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "2"" of type '" "wxFlexSizerGrowMode""'");
48117 }
48118 arg2 = static_cast< wxFlexSizerGrowMode >(val2);
48119 {
48120 PyThreadState* __tstate = wxPyBeginAllowThreads();
48121 (arg1)->SetNonFlexibleGrowMode(arg2);
48122 wxPyEndAllowThreads(__tstate);
48123 if (PyErr_Occurred()) SWIG_fail;
48124 }
48125 resultobj = SWIG_Py_Void();
48126 return resultobj;
48127 fail:
48128 return NULL;
48129 }
48130
48131
48132 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48133 PyObject *resultobj = 0;
48134 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48135 wxFlexSizerGrowMode result;
48136 void *argp1 = 0 ;
48137 int res1 = 0 ;
48138 PyObject *swig_obj[1] ;
48139
48140 if (!args) SWIG_fail;
48141 swig_obj[0] = args;
48142 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48143 if (!SWIG_IsOK(res1)) {
48144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48145 }
48146 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48147 {
48148 PyThreadState* __tstate = wxPyBeginAllowThreads();
48149 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
48150 wxPyEndAllowThreads(__tstate);
48151 if (PyErr_Occurred()) SWIG_fail;
48152 }
48153 resultobj = SWIG_From_int(static_cast< int >(result));
48154 return resultobj;
48155 fail:
48156 return NULL;
48157 }
48158
48159
48160 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48161 PyObject *resultobj = 0;
48162 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48163 wxArrayInt *result = 0 ;
48164 void *argp1 = 0 ;
48165 int res1 = 0 ;
48166 PyObject *swig_obj[1] ;
48167
48168 if (!args) SWIG_fail;
48169 swig_obj[0] = args;
48170 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48171 if (!SWIG_IsOK(res1)) {
48172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetRowHeights" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
48173 }
48174 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48175 {
48176 PyThreadState* __tstate = wxPyBeginAllowThreads();
48177 {
48178 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
48179 result = (wxArrayInt *) &_result_ref;
48180 }
48181 wxPyEndAllowThreads(__tstate);
48182 if (PyErr_Occurred()) SWIG_fail;
48183 }
48184 {
48185 resultobj = PyList_New(0);
48186 size_t idx;
48187 for (idx = 0; idx < result->GetCount(); idx += 1) {
48188 PyObject* val = PyInt_FromLong( result->Item(idx) );
48189 PyList_Append(resultobj, val);
48190 Py_DECREF(val);
48191 }
48192 }
48193 return resultobj;
48194 fail:
48195 return NULL;
48196 }
48197
48198
48199 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48200 PyObject *resultobj = 0;
48201 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48202 wxArrayInt *result = 0 ;
48203 void *argp1 = 0 ;
48204 int res1 = 0 ;
48205 PyObject *swig_obj[1] ;
48206
48207 if (!args) SWIG_fail;
48208 swig_obj[0] = args;
48209 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48210 if (!SWIG_IsOK(res1)) {
48211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetColWidths" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
48212 }
48213 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48214 {
48215 PyThreadState* __tstate = wxPyBeginAllowThreads();
48216 {
48217 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
48218 result = (wxArrayInt *) &_result_ref;
48219 }
48220 wxPyEndAllowThreads(__tstate);
48221 if (PyErr_Occurred()) SWIG_fail;
48222 }
48223 {
48224 resultobj = PyList_New(0);
48225 size_t idx;
48226 for (idx = 0; idx < result->GetCount(); idx += 1) {
48227 PyObject* val = PyInt_FromLong( result->Item(idx) );
48228 PyList_Append(resultobj, val);
48229 Py_DECREF(val);
48230 }
48231 }
48232 return resultobj;
48233 fail:
48234 return NULL;
48235 }
48236
48237
48238 SWIGINTERN PyObject *FlexGridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48239 PyObject *obj;
48240 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48241 SWIG_TypeNewClientData(SWIGTYPE_p_wxFlexGridSizer, SWIG_NewClientData(obj));
48242 return SWIG_Py_Void();
48243 }
48244
48245 SWIGINTERN PyObject *FlexGridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48246 return SWIG_Python_InitShadowInstance(args);
48247 }
48248
48249 SWIGINTERN PyObject *_wrap_new_StdDialogButtonSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48250 PyObject *resultobj = 0;
48251 wxStdDialogButtonSizer *result = 0 ;
48252
48253 if (!SWIG_Python_UnpackTuple(args,"new_StdDialogButtonSizer",0,0,0)) SWIG_fail;
48254 {
48255 PyThreadState* __tstate = wxPyBeginAllowThreads();
48256 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
48257 wxPyEndAllowThreads(__tstate);
48258 if (PyErr_Occurred()) SWIG_fail;
48259 }
48260 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_NEW | 0 );
48261 return resultobj;
48262 fail:
48263 return NULL;
48264 }
48265
48266
48267 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48268 PyObject *resultobj = 0;
48269 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48270 wxButton *arg2 = (wxButton *) 0 ;
48271 void *argp1 = 0 ;
48272 int res1 = 0 ;
48273 void *argp2 = 0 ;
48274 int res2 = 0 ;
48275 PyObject * obj0 = 0 ;
48276 PyObject * obj1 = 0 ;
48277 char * kwnames[] = {
48278 (char *) "self",(char *) "button", NULL
48279 };
48280
48281 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) SWIG_fail;
48282 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48283 if (!SWIG_IsOK(res1)) {
48284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48285 }
48286 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48287 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48288 if (!SWIG_IsOK(res2)) {
48289 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "2"" of type '" "wxButton *""'");
48290 }
48291 arg2 = reinterpret_cast< wxButton * >(argp2);
48292 {
48293 PyThreadState* __tstate = wxPyBeginAllowThreads();
48294 (arg1)->AddButton(arg2);
48295 wxPyEndAllowThreads(__tstate);
48296 if (PyErr_Occurred()) SWIG_fail;
48297 }
48298 resultobj = SWIG_Py_Void();
48299 return resultobj;
48300 fail:
48301 return NULL;
48302 }
48303
48304
48305 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48306 PyObject *resultobj = 0;
48307 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48308 void *argp1 = 0 ;
48309 int res1 = 0 ;
48310 PyObject *swig_obj[1] ;
48311
48312 if (!args) SWIG_fail;
48313 swig_obj[0] = args;
48314 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48315 if (!SWIG_IsOK(res1)) {
48316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_Realize" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48317 }
48318 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48319 {
48320 PyThreadState* __tstate = wxPyBeginAllowThreads();
48321 (arg1)->Realize();
48322 wxPyEndAllowThreads(__tstate);
48323 if (PyErr_Occurred()) SWIG_fail;
48324 }
48325 resultobj = SWIG_Py_Void();
48326 return resultobj;
48327 fail:
48328 return NULL;
48329 }
48330
48331
48332 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48333 PyObject *resultobj = 0;
48334 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48335 wxButton *arg2 = (wxButton *) 0 ;
48336 void *argp1 = 0 ;
48337 int res1 = 0 ;
48338 void *argp2 = 0 ;
48339 int res2 = 0 ;
48340 PyObject * obj0 = 0 ;
48341 PyObject * obj1 = 0 ;
48342 char * kwnames[] = {
48343 (char *) "self",(char *) "button", NULL
48344 };
48345
48346 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
48347 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48348 if (!SWIG_IsOK(res1)) {
48349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48350 }
48351 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48352 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48353 if (!SWIG_IsOK(res2)) {
48354 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
48355 }
48356 arg2 = reinterpret_cast< wxButton * >(argp2);
48357 {
48358 PyThreadState* __tstate = wxPyBeginAllowThreads();
48359 (arg1)->SetAffirmativeButton(arg2);
48360 wxPyEndAllowThreads(__tstate);
48361 if (PyErr_Occurred()) SWIG_fail;
48362 }
48363 resultobj = SWIG_Py_Void();
48364 return resultobj;
48365 fail:
48366 return NULL;
48367 }
48368
48369
48370 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48371 PyObject *resultobj = 0;
48372 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48373 wxButton *arg2 = (wxButton *) 0 ;
48374 void *argp1 = 0 ;
48375 int res1 = 0 ;
48376 void *argp2 = 0 ;
48377 int res2 = 0 ;
48378 PyObject * obj0 = 0 ;
48379 PyObject * obj1 = 0 ;
48380 char * kwnames[] = {
48381 (char *) "self",(char *) "button", NULL
48382 };
48383
48384 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
48385 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48386 if (!SWIG_IsOK(res1)) {
48387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48388 }
48389 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48390 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48391 if (!SWIG_IsOK(res2)) {
48392 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
48393 }
48394 arg2 = reinterpret_cast< wxButton * >(argp2);
48395 {
48396 PyThreadState* __tstate = wxPyBeginAllowThreads();
48397 (arg1)->SetNegativeButton(arg2);
48398 wxPyEndAllowThreads(__tstate);
48399 if (PyErr_Occurred()) SWIG_fail;
48400 }
48401 resultobj = SWIG_Py_Void();
48402 return resultobj;
48403 fail:
48404 return NULL;
48405 }
48406
48407
48408 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48409 PyObject *resultobj = 0;
48410 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48411 wxButton *arg2 = (wxButton *) 0 ;
48412 void *argp1 = 0 ;
48413 int res1 = 0 ;
48414 void *argp2 = 0 ;
48415 int res2 = 0 ;
48416 PyObject * obj0 = 0 ;
48417 PyObject * obj1 = 0 ;
48418 char * kwnames[] = {
48419 (char *) "self",(char *) "button", NULL
48420 };
48421
48422 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) SWIG_fail;
48423 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48424 if (!SWIG_IsOK(res1)) {
48425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48426 }
48427 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48428 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48429 if (!SWIG_IsOK(res2)) {
48430 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "2"" of type '" "wxButton *""'");
48431 }
48432 arg2 = reinterpret_cast< wxButton * >(argp2);
48433 {
48434 PyThreadState* __tstate = wxPyBeginAllowThreads();
48435 (arg1)->SetCancelButton(arg2);
48436 wxPyEndAllowThreads(__tstate);
48437 if (PyErr_Occurred()) SWIG_fail;
48438 }
48439 resultobj = SWIG_Py_Void();
48440 return resultobj;
48441 fail:
48442 return NULL;
48443 }
48444
48445
48446 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48447 PyObject *resultobj = 0;
48448 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48449 wxButton *result = 0 ;
48450 void *argp1 = 0 ;
48451 int res1 = 0 ;
48452 PyObject *swig_obj[1] ;
48453
48454 if (!args) SWIG_fail;
48455 swig_obj[0] = args;
48456 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48457 if (!SWIG_IsOK(res1)) {
48458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48459 }
48460 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48461 {
48462 PyThreadState* __tstate = wxPyBeginAllowThreads();
48463 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
48464 wxPyEndAllowThreads(__tstate);
48465 if (PyErr_Occurred()) SWIG_fail;
48466 }
48467 {
48468 resultobj = wxPyMake_wxObject(result, (bool)0);
48469 }
48470 return resultobj;
48471 fail:
48472 return NULL;
48473 }
48474
48475
48476 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48477 PyObject *resultobj = 0;
48478 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48479 wxButton *result = 0 ;
48480 void *argp1 = 0 ;
48481 int res1 = 0 ;
48482 PyObject *swig_obj[1] ;
48483
48484 if (!args) SWIG_fail;
48485 swig_obj[0] = args;
48486 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48487 if (!SWIG_IsOK(res1)) {
48488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetApplyButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48489 }
48490 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48491 {
48492 PyThreadState* __tstate = wxPyBeginAllowThreads();
48493 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
48494 wxPyEndAllowThreads(__tstate);
48495 if (PyErr_Occurred()) SWIG_fail;
48496 }
48497 {
48498 resultobj = wxPyMake_wxObject(result, (bool)0);
48499 }
48500 return resultobj;
48501 fail:
48502 return NULL;
48503 }
48504
48505
48506 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48507 PyObject *resultobj = 0;
48508 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48509 wxButton *result = 0 ;
48510 void *argp1 = 0 ;
48511 int res1 = 0 ;
48512 PyObject *swig_obj[1] ;
48513
48514 if (!args) SWIG_fail;
48515 swig_obj[0] = args;
48516 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48517 if (!SWIG_IsOK(res1)) {
48518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48519 }
48520 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48521 {
48522 PyThreadState* __tstate = wxPyBeginAllowThreads();
48523 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
48524 wxPyEndAllowThreads(__tstate);
48525 if (PyErr_Occurred()) SWIG_fail;
48526 }
48527 {
48528 resultobj = wxPyMake_wxObject(result, (bool)0);
48529 }
48530 return resultobj;
48531 fail:
48532 return NULL;
48533 }
48534
48535
48536 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48537 PyObject *resultobj = 0;
48538 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48539 wxButton *result = 0 ;
48540 void *argp1 = 0 ;
48541 int res1 = 0 ;
48542 PyObject *swig_obj[1] ;
48543
48544 if (!args) SWIG_fail;
48545 swig_obj[0] = args;
48546 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48547 if (!SWIG_IsOK(res1)) {
48548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48549 }
48550 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48551 {
48552 PyThreadState* __tstate = wxPyBeginAllowThreads();
48553 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
48554 wxPyEndAllowThreads(__tstate);
48555 if (PyErr_Occurred()) SWIG_fail;
48556 }
48557 {
48558 resultobj = wxPyMake_wxObject(result, (bool)0);
48559 }
48560 return resultobj;
48561 fail:
48562 return NULL;
48563 }
48564
48565
48566 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48567 PyObject *resultobj = 0;
48568 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48569 wxButton *result = 0 ;
48570 void *argp1 = 0 ;
48571 int res1 = 0 ;
48572 PyObject *swig_obj[1] ;
48573
48574 if (!args) SWIG_fail;
48575 swig_obj[0] = args;
48576 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48577 if (!SWIG_IsOK(res1)) {
48578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetHelpButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48579 }
48580 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48581 {
48582 PyThreadState* __tstate = wxPyBeginAllowThreads();
48583 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
48584 wxPyEndAllowThreads(__tstate);
48585 if (PyErr_Occurred()) SWIG_fail;
48586 }
48587 {
48588 resultobj = wxPyMake_wxObject(result, (bool)0);
48589 }
48590 return resultobj;
48591 fail:
48592 return NULL;
48593 }
48594
48595
48596 SWIGINTERN PyObject *StdDialogButtonSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48597 PyObject *obj;
48598 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48599 SWIG_TypeNewClientData(SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_NewClientData(obj));
48600 return SWIG_Py_Void();
48601 }
48602
48603 SWIGINTERN PyObject *StdDialogButtonSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48604 return SWIG_Python_InitShadowInstance(args);
48605 }
48606
48607 SWIGINTERN PyObject *_wrap_new_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48608 PyObject *resultobj = 0;
48609 int arg1 = (int) 0 ;
48610 int arg2 = (int) 0 ;
48611 wxGBPosition *result = 0 ;
48612 int val1 ;
48613 int ecode1 = 0 ;
48614 int val2 ;
48615 int ecode2 = 0 ;
48616 PyObject * obj0 = 0 ;
48617 PyObject * obj1 = 0 ;
48618 char * kwnames[] = {
48619 (char *) "row",(char *) "col", NULL
48620 };
48621
48622 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) SWIG_fail;
48623 if (obj0) {
48624 ecode1 = SWIG_AsVal_int(obj0, &val1);
48625 if (!SWIG_IsOK(ecode1)) {
48626 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBPosition" "', expected argument " "1"" of type '" "int""'");
48627 }
48628 arg1 = static_cast< int >(val1);
48629 }
48630 if (obj1) {
48631 ecode2 = SWIG_AsVal_int(obj1, &val2);
48632 if (!SWIG_IsOK(ecode2)) {
48633 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBPosition" "', expected argument " "2"" of type '" "int""'");
48634 }
48635 arg2 = static_cast< int >(val2);
48636 }
48637 {
48638 PyThreadState* __tstate = wxPyBeginAllowThreads();
48639 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
48640 wxPyEndAllowThreads(__tstate);
48641 if (PyErr_Occurred()) SWIG_fail;
48642 }
48643 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_NEW | 0 );
48644 return resultobj;
48645 fail:
48646 return NULL;
48647 }
48648
48649
48650 SWIGINTERN PyObject *_wrap_delete_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48651 PyObject *resultobj = 0;
48652 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48653 void *argp1 = 0 ;
48654 int res1 = 0 ;
48655 PyObject *swig_obj[1] ;
48656
48657 if (!args) SWIG_fail;
48658 swig_obj[0] = args;
48659 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, SWIG_POINTER_DISOWN | 0 );
48660 if (!SWIG_IsOK(res1)) {
48661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBPosition" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48662 }
48663 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48664 {
48665 PyThreadState* __tstate = wxPyBeginAllowThreads();
48666 delete arg1;
48667
48668 wxPyEndAllowThreads(__tstate);
48669 if (PyErr_Occurred()) SWIG_fail;
48670 }
48671 resultobj = SWIG_Py_Void();
48672 return resultobj;
48673 fail:
48674 return NULL;
48675 }
48676
48677
48678 SWIGINTERN PyObject *_wrap_GBPosition_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48679 PyObject *resultobj = 0;
48680 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48681 int result;
48682 void *argp1 = 0 ;
48683 int res1 = 0 ;
48684 PyObject *swig_obj[1] ;
48685
48686 if (!args) SWIG_fail;
48687 swig_obj[0] = args;
48688 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48689 if (!SWIG_IsOK(res1)) {
48690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetRow" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
48691 }
48692 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48693 {
48694 PyThreadState* __tstate = wxPyBeginAllowThreads();
48695 result = (int)((wxGBPosition const *)arg1)->GetRow();
48696 wxPyEndAllowThreads(__tstate);
48697 if (PyErr_Occurred()) SWIG_fail;
48698 }
48699 resultobj = SWIG_From_int(static_cast< int >(result));
48700 return resultobj;
48701 fail:
48702 return NULL;
48703 }
48704
48705
48706 SWIGINTERN PyObject *_wrap_GBPosition_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48707 PyObject *resultobj = 0;
48708 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48709 int result;
48710 void *argp1 = 0 ;
48711 int res1 = 0 ;
48712 PyObject *swig_obj[1] ;
48713
48714 if (!args) SWIG_fail;
48715 swig_obj[0] = args;
48716 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48717 if (!SWIG_IsOK(res1)) {
48718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetCol" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
48719 }
48720 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48721 {
48722 PyThreadState* __tstate = wxPyBeginAllowThreads();
48723 result = (int)((wxGBPosition const *)arg1)->GetCol();
48724 wxPyEndAllowThreads(__tstate);
48725 if (PyErr_Occurred()) SWIG_fail;
48726 }
48727 resultobj = SWIG_From_int(static_cast< int >(result));
48728 return resultobj;
48729 fail:
48730 return NULL;
48731 }
48732
48733
48734 SWIGINTERN PyObject *_wrap_GBPosition_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48735 PyObject *resultobj = 0;
48736 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48737 int arg2 ;
48738 void *argp1 = 0 ;
48739 int res1 = 0 ;
48740 int val2 ;
48741 int ecode2 = 0 ;
48742 PyObject * obj0 = 0 ;
48743 PyObject * obj1 = 0 ;
48744 char * kwnames[] = {
48745 (char *) "self",(char *) "row", NULL
48746 };
48747
48748 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
48749 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48750 if (!SWIG_IsOK(res1)) {
48751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetRow" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48752 }
48753 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48754 ecode2 = SWIG_AsVal_int(obj1, &val2);
48755 if (!SWIG_IsOK(ecode2)) {
48756 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetRow" "', expected argument " "2"" of type '" "int""'");
48757 }
48758 arg2 = static_cast< int >(val2);
48759 {
48760 PyThreadState* __tstate = wxPyBeginAllowThreads();
48761 (arg1)->SetRow(arg2);
48762 wxPyEndAllowThreads(__tstate);
48763 if (PyErr_Occurred()) SWIG_fail;
48764 }
48765 resultobj = SWIG_Py_Void();
48766 return resultobj;
48767 fail:
48768 return NULL;
48769 }
48770
48771
48772 SWIGINTERN PyObject *_wrap_GBPosition_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48773 PyObject *resultobj = 0;
48774 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48775 int arg2 ;
48776 void *argp1 = 0 ;
48777 int res1 = 0 ;
48778 int val2 ;
48779 int ecode2 = 0 ;
48780 PyObject * obj0 = 0 ;
48781 PyObject * obj1 = 0 ;
48782 char * kwnames[] = {
48783 (char *) "self",(char *) "col", NULL
48784 };
48785
48786 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
48787 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48788 if (!SWIG_IsOK(res1)) {
48789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetCol" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48790 }
48791 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48792 ecode2 = SWIG_AsVal_int(obj1, &val2);
48793 if (!SWIG_IsOK(ecode2)) {
48794 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetCol" "', expected argument " "2"" of type '" "int""'");
48795 }
48796 arg2 = static_cast< int >(val2);
48797 {
48798 PyThreadState* __tstate = wxPyBeginAllowThreads();
48799 (arg1)->SetCol(arg2);
48800 wxPyEndAllowThreads(__tstate);
48801 if (PyErr_Occurred()) SWIG_fail;
48802 }
48803 resultobj = SWIG_Py_Void();
48804 return resultobj;
48805 fail:
48806 return NULL;
48807 }
48808
48809
48810 SWIGINTERN PyObject *_wrap_GBPosition___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48811 PyObject *resultobj = 0;
48812 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48813 PyObject *arg2 = (PyObject *) 0 ;
48814 bool result;
48815 void *argp1 = 0 ;
48816 int res1 = 0 ;
48817 PyObject * obj0 = 0 ;
48818 PyObject * obj1 = 0 ;
48819 char * kwnames[] = {
48820 (char *) "self",(char *) "other", NULL
48821 };
48822
48823 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
48824 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48825 if (!SWIG_IsOK(res1)) {
48826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___eq__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48827 }
48828 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48829 arg2 = obj1;
48830 {
48831 result = (bool)wxGBPosition___eq__(arg1,arg2);
48832 if (PyErr_Occurred()) SWIG_fail;
48833 }
48834 {
48835 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48836 }
48837 return resultobj;
48838 fail:
48839 return NULL;
48840 }
48841
48842
48843 SWIGINTERN PyObject *_wrap_GBPosition___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48844 PyObject *resultobj = 0;
48845 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48846 PyObject *arg2 = (PyObject *) 0 ;
48847 bool result;
48848 void *argp1 = 0 ;
48849 int res1 = 0 ;
48850 PyObject * obj0 = 0 ;
48851 PyObject * obj1 = 0 ;
48852 char * kwnames[] = {
48853 (char *) "self",(char *) "other", NULL
48854 };
48855
48856 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
48857 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48858 if (!SWIG_IsOK(res1)) {
48859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___ne__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48860 }
48861 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48862 arg2 = obj1;
48863 {
48864 result = (bool)wxGBPosition___ne__(arg1,arg2);
48865 if (PyErr_Occurred()) SWIG_fail;
48866 }
48867 {
48868 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48869 }
48870 return resultobj;
48871 fail:
48872 return NULL;
48873 }
48874
48875
48876 SWIGINTERN PyObject *_wrap_GBPosition_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48877 PyObject *resultobj = 0;
48878 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48879 int arg2 = (int) 0 ;
48880 int arg3 = (int) 0 ;
48881 void *argp1 = 0 ;
48882 int res1 = 0 ;
48883 int val2 ;
48884 int ecode2 = 0 ;
48885 int val3 ;
48886 int ecode3 = 0 ;
48887 PyObject * obj0 = 0 ;
48888 PyObject * obj1 = 0 ;
48889 PyObject * obj2 = 0 ;
48890 char * kwnames[] = {
48891 (char *) "self",(char *) "row",(char *) "col", NULL
48892 };
48893
48894 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48895 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48896 if (!SWIG_IsOK(res1)) {
48897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Set" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48898 }
48899 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48900 if (obj1) {
48901 ecode2 = SWIG_AsVal_int(obj1, &val2);
48902 if (!SWIG_IsOK(ecode2)) {
48903 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_Set" "', expected argument " "2"" of type '" "int""'");
48904 }
48905 arg2 = static_cast< int >(val2);
48906 }
48907 if (obj2) {
48908 ecode3 = SWIG_AsVal_int(obj2, &val3);
48909 if (!SWIG_IsOK(ecode3)) {
48910 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBPosition_Set" "', expected argument " "3"" of type '" "int""'");
48911 }
48912 arg3 = static_cast< int >(val3);
48913 }
48914 {
48915 PyThreadState* __tstate = wxPyBeginAllowThreads();
48916 wxGBPosition_Set(arg1,arg2,arg3);
48917 wxPyEndAllowThreads(__tstate);
48918 if (PyErr_Occurred()) SWIG_fail;
48919 }
48920 resultobj = SWIG_Py_Void();
48921 return resultobj;
48922 fail:
48923 return NULL;
48924 }
48925
48926
48927 SWIGINTERN PyObject *_wrap_GBPosition_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48928 PyObject *resultobj = 0;
48929 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48930 PyObject *result = 0 ;
48931 void *argp1 = 0 ;
48932 int res1 = 0 ;
48933 PyObject *swig_obj[1] ;
48934
48935 if (!args) SWIG_fail;
48936 swig_obj[0] = args;
48937 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48938 if (!SWIG_IsOK(res1)) {
48939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Get" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48940 }
48941 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48942 {
48943 PyThreadState* __tstate = wxPyBeginAllowThreads();
48944 result = (PyObject *)wxGBPosition_Get(arg1);
48945 wxPyEndAllowThreads(__tstate);
48946 if (PyErr_Occurred()) SWIG_fail;
48947 }
48948 resultobj = result;
48949 return resultobj;
48950 fail:
48951 return NULL;
48952 }
48953
48954
48955 SWIGINTERN PyObject *GBPosition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48956 PyObject *obj;
48957 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48958 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBPosition, SWIG_NewClientData(obj));
48959 return SWIG_Py_Void();
48960 }
48961
48962 SWIGINTERN PyObject *GBPosition_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48963 return SWIG_Python_InitShadowInstance(args);
48964 }
48965
48966 SWIGINTERN PyObject *_wrap_new_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48967 PyObject *resultobj = 0;
48968 int arg1 = (int) 1 ;
48969 int arg2 = (int) 1 ;
48970 wxGBSpan *result = 0 ;
48971 int val1 ;
48972 int ecode1 = 0 ;
48973 int val2 ;
48974 int ecode2 = 0 ;
48975 PyObject * obj0 = 0 ;
48976 PyObject * obj1 = 0 ;
48977 char * kwnames[] = {
48978 (char *) "rowspan",(char *) "colspan", NULL
48979 };
48980
48981 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) SWIG_fail;
48982 if (obj0) {
48983 ecode1 = SWIG_AsVal_int(obj0, &val1);
48984 if (!SWIG_IsOK(ecode1)) {
48985 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSpan" "', expected argument " "1"" of type '" "int""'");
48986 }
48987 arg1 = static_cast< int >(val1);
48988 }
48989 if (obj1) {
48990 ecode2 = SWIG_AsVal_int(obj1, &val2);
48991 if (!SWIG_IsOK(ecode2)) {
48992 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSpan" "', expected argument " "2"" of type '" "int""'");
48993 }
48994 arg2 = static_cast< int >(val2);
48995 }
48996 {
48997 PyThreadState* __tstate = wxPyBeginAllowThreads();
48998 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
48999 wxPyEndAllowThreads(__tstate);
49000 if (PyErr_Occurred()) SWIG_fail;
49001 }
49002 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_NEW | 0 );
49003 return resultobj;
49004 fail:
49005 return NULL;
49006 }
49007
49008
49009 SWIGINTERN PyObject *_wrap_delete_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49010 PyObject *resultobj = 0;
49011 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49012 void *argp1 = 0 ;
49013 int res1 = 0 ;
49014 PyObject *swig_obj[1] ;
49015
49016 if (!args) SWIG_fail;
49017 swig_obj[0] = args;
49018 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, SWIG_POINTER_DISOWN | 0 );
49019 if (!SWIG_IsOK(res1)) {
49020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSpan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49021 }
49022 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49023 {
49024 PyThreadState* __tstate = wxPyBeginAllowThreads();
49025 delete arg1;
49026
49027 wxPyEndAllowThreads(__tstate);
49028 if (PyErr_Occurred()) SWIG_fail;
49029 }
49030 resultobj = SWIG_Py_Void();
49031 return resultobj;
49032 fail:
49033 return NULL;
49034 }
49035
49036
49037 SWIGINTERN PyObject *_wrap_GBSpan_GetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49038 PyObject *resultobj = 0;
49039 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49040 int result;
49041 void *argp1 = 0 ;
49042 int res1 = 0 ;
49043 PyObject *swig_obj[1] ;
49044
49045 if (!args) SWIG_fail;
49046 swig_obj[0] = args;
49047 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49048 if (!SWIG_IsOK(res1)) {
49049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetRowspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
49050 }
49051 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49052 {
49053 PyThreadState* __tstate = wxPyBeginAllowThreads();
49054 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
49055 wxPyEndAllowThreads(__tstate);
49056 if (PyErr_Occurred()) SWIG_fail;
49057 }
49058 resultobj = SWIG_From_int(static_cast< int >(result));
49059 return resultobj;
49060 fail:
49061 return NULL;
49062 }
49063
49064
49065 SWIGINTERN PyObject *_wrap_GBSpan_GetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49066 PyObject *resultobj = 0;
49067 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49068 int result;
49069 void *argp1 = 0 ;
49070 int res1 = 0 ;
49071 PyObject *swig_obj[1] ;
49072
49073 if (!args) SWIG_fail;
49074 swig_obj[0] = args;
49075 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49076 if (!SWIG_IsOK(res1)) {
49077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetColspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
49078 }
49079 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49080 {
49081 PyThreadState* __tstate = wxPyBeginAllowThreads();
49082 result = (int)((wxGBSpan const *)arg1)->GetColspan();
49083 wxPyEndAllowThreads(__tstate);
49084 if (PyErr_Occurred()) SWIG_fail;
49085 }
49086 resultobj = SWIG_From_int(static_cast< int >(result));
49087 return resultobj;
49088 fail:
49089 return NULL;
49090 }
49091
49092
49093 SWIGINTERN PyObject *_wrap_GBSpan_SetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49094 PyObject *resultobj = 0;
49095 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49096 int arg2 ;
49097 void *argp1 = 0 ;
49098 int res1 = 0 ;
49099 int val2 ;
49100 int ecode2 = 0 ;
49101 PyObject * obj0 = 0 ;
49102 PyObject * obj1 = 0 ;
49103 char * kwnames[] = {
49104 (char *) "self",(char *) "rowspan", NULL
49105 };
49106
49107 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) SWIG_fail;
49108 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49109 if (!SWIG_IsOK(res1)) {
49110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetRowspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49111 }
49112 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49113 ecode2 = SWIG_AsVal_int(obj1, &val2);
49114 if (!SWIG_IsOK(ecode2)) {
49115 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetRowspan" "', expected argument " "2"" of type '" "int""'");
49116 }
49117 arg2 = static_cast< int >(val2);
49118 {
49119 PyThreadState* __tstate = wxPyBeginAllowThreads();
49120 (arg1)->SetRowspan(arg2);
49121 wxPyEndAllowThreads(__tstate);
49122 if (PyErr_Occurred()) SWIG_fail;
49123 }
49124 resultobj = SWIG_Py_Void();
49125 return resultobj;
49126 fail:
49127 return NULL;
49128 }
49129
49130
49131 SWIGINTERN PyObject *_wrap_GBSpan_SetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49132 PyObject *resultobj = 0;
49133 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49134 int arg2 ;
49135 void *argp1 = 0 ;
49136 int res1 = 0 ;
49137 int val2 ;
49138 int ecode2 = 0 ;
49139 PyObject * obj0 = 0 ;
49140 PyObject * obj1 = 0 ;
49141 char * kwnames[] = {
49142 (char *) "self",(char *) "colspan", NULL
49143 };
49144
49145 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) SWIG_fail;
49146 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49147 if (!SWIG_IsOK(res1)) {
49148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetColspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49149 }
49150 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49151 ecode2 = SWIG_AsVal_int(obj1, &val2);
49152 if (!SWIG_IsOK(ecode2)) {
49153 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetColspan" "', expected argument " "2"" of type '" "int""'");
49154 }
49155 arg2 = static_cast< int >(val2);
49156 {
49157 PyThreadState* __tstate = wxPyBeginAllowThreads();
49158 (arg1)->SetColspan(arg2);
49159 wxPyEndAllowThreads(__tstate);
49160 if (PyErr_Occurred()) SWIG_fail;
49161 }
49162 resultobj = SWIG_Py_Void();
49163 return resultobj;
49164 fail:
49165 return NULL;
49166 }
49167
49168
49169 SWIGINTERN PyObject *_wrap_GBSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49170 PyObject *resultobj = 0;
49171 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49172 PyObject *arg2 = (PyObject *) 0 ;
49173 bool result;
49174 void *argp1 = 0 ;
49175 int res1 = 0 ;
49176 PyObject * obj0 = 0 ;
49177 PyObject * obj1 = 0 ;
49178 char * kwnames[] = {
49179 (char *) "self",(char *) "other", NULL
49180 };
49181
49182 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
49183 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49184 if (!SWIG_IsOK(res1)) {
49185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___eq__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49186 }
49187 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49188 arg2 = obj1;
49189 {
49190 result = (bool)wxGBSpan___eq__(arg1,arg2);
49191 if (PyErr_Occurred()) SWIG_fail;
49192 }
49193 {
49194 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49195 }
49196 return resultobj;
49197 fail:
49198 return NULL;
49199 }
49200
49201
49202 SWIGINTERN PyObject *_wrap_GBSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49203 PyObject *resultobj = 0;
49204 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49205 PyObject *arg2 = (PyObject *) 0 ;
49206 bool result;
49207 void *argp1 = 0 ;
49208 int res1 = 0 ;
49209 PyObject * obj0 = 0 ;
49210 PyObject * obj1 = 0 ;
49211 char * kwnames[] = {
49212 (char *) "self",(char *) "other", NULL
49213 };
49214
49215 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
49216 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49217 if (!SWIG_IsOK(res1)) {
49218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___ne__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49219 }
49220 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49221 arg2 = obj1;
49222 {
49223 result = (bool)wxGBSpan___ne__(arg1,arg2);
49224 if (PyErr_Occurred()) SWIG_fail;
49225 }
49226 {
49227 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49228 }
49229 return resultobj;
49230 fail:
49231 return NULL;
49232 }
49233
49234
49235 SWIGINTERN PyObject *_wrap_GBSpan_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49236 PyObject *resultobj = 0;
49237 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49238 int arg2 = (int) 1 ;
49239 int arg3 = (int) 1 ;
49240 void *argp1 = 0 ;
49241 int res1 = 0 ;
49242 int val2 ;
49243 int ecode2 = 0 ;
49244 int val3 ;
49245 int ecode3 = 0 ;
49246 PyObject * obj0 = 0 ;
49247 PyObject * obj1 = 0 ;
49248 PyObject * obj2 = 0 ;
49249 char * kwnames[] = {
49250 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
49251 };
49252
49253 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49254 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49255 if (!SWIG_IsOK(res1)) {
49256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Set" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49257 }
49258 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49259 if (obj1) {
49260 ecode2 = SWIG_AsVal_int(obj1, &val2);
49261 if (!SWIG_IsOK(ecode2)) {
49262 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_Set" "', expected argument " "2"" of type '" "int""'");
49263 }
49264 arg2 = static_cast< int >(val2);
49265 }
49266 if (obj2) {
49267 ecode3 = SWIG_AsVal_int(obj2, &val3);
49268 if (!SWIG_IsOK(ecode3)) {
49269 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBSpan_Set" "', expected argument " "3"" of type '" "int""'");
49270 }
49271 arg3 = static_cast< int >(val3);
49272 }
49273 {
49274 PyThreadState* __tstate = wxPyBeginAllowThreads();
49275 wxGBSpan_Set(arg1,arg2,arg3);
49276 wxPyEndAllowThreads(__tstate);
49277 if (PyErr_Occurred()) SWIG_fail;
49278 }
49279 resultobj = SWIG_Py_Void();
49280 return resultobj;
49281 fail:
49282 return NULL;
49283 }
49284
49285
49286 SWIGINTERN PyObject *_wrap_GBSpan_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49287 PyObject *resultobj = 0;
49288 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49289 PyObject *result = 0 ;
49290 void *argp1 = 0 ;
49291 int res1 = 0 ;
49292 PyObject *swig_obj[1] ;
49293
49294 if (!args) SWIG_fail;
49295 swig_obj[0] = args;
49296 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49297 if (!SWIG_IsOK(res1)) {
49298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Get" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49299 }
49300 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49301 {
49302 PyThreadState* __tstate = wxPyBeginAllowThreads();
49303 result = (PyObject *)wxGBSpan_Get(arg1);
49304 wxPyEndAllowThreads(__tstate);
49305 if (PyErr_Occurred()) SWIG_fail;
49306 }
49307 resultobj = result;
49308 return resultobj;
49309 fail:
49310 return NULL;
49311 }
49312
49313
49314 SWIGINTERN PyObject *GBSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49315 PyObject *obj;
49316 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49317 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSpan, SWIG_NewClientData(obj));
49318 return SWIG_Py_Void();
49319 }
49320
49321 SWIGINTERN PyObject *GBSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49322 return SWIG_Python_InitShadowInstance(args);
49323 }
49324
49325 SWIGINTERN int DefaultSpan_set(PyObject *) {
49326 SWIG_Error(SWIG_AttributeError,"Variable DefaultSpan is read-only.");
49327 return 1;
49328 }
49329
49330
49331 SWIGINTERN PyObject *DefaultSpan_get(void) {
49332 PyObject *pyobj = 0;
49333
49334 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0 );
49335 return pyobj;
49336 }
49337
49338
49339 SWIGINTERN PyObject *_wrap_new_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49340 PyObject *resultobj = 0;
49341 wxGBSizerItem *result = 0 ;
49342
49343 if (!SWIG_Python_UnpackTuple(args,"new_GBSizerItem",0,0,0)) SWIG_fail;
49344 {
49345 PyThreadState* __tstate = wxPyBeginAllowThreads();
49346 result = (wxGBSizerItem *)new wxGBSizerItem();
49347 wxPyEndAllowThreads(__tstate);
49348 if (PyErr_Occurred()) SWIG_fail;
49349 }
49350 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_NEW | 0 );
49351 return resultobj;
49352 fail:
49353 return NULL;
49354 }
49355
49356
49357 SWIGINTERN PyObject *_wrap_delete_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49358 PyObject *resultobj = 0;
49359 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49360 void *argp1 = 0 ;
49361 int res1 = 0 ;
49362 PyObject *swig_obj[1] ;
49363
49364 if (!args) SWIG_fail;
49365 swig_obj[0] = args;
49366 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
49367 if (!SWIG_IsOK(res1)) {
49368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSizerItem" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49369 }
49370 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49371 {
49372 PyThreadState* __tstate = wxPyBeginAllowThreads();
49373 delete arg1;
49374
49375 wxPyEndAllowThreads(__tstate);
49376 if (PyErr_Occurred()) SWIG_fail;
49377 }
49378 resultobj = SWIG_Py_Void();
49379 return resultobj;
49380 fail:
49381 return NULL;
49382 }
49383
49384
49385 SWIGINTERN PyObject *_wrap_new_GBSizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49386 PyObject *resultobj = 0;
49387 wxWindow *arg1 = (wxWindow *) 0 ;
49388 wxGBPosition *arg2 = 0 ;
49389 wxGBSpan *arg3 = 0 ;
49390 int arg4 ;
49391 int arg5 ;
49392 PyObject *arg6 = (PyObject *) NULL ;
49393 wxGBSizerItem *result = 0 ;
49394 void *argp1 = 0 ;
49395 int res1 = 0 ;
49396 wxGBPosition temp2 ;
49397 wxGBSpan temp3 ;
49398 int val4 ;
49399 int ecode4 = 0 ;
49400 int val5 ;
49401 int ecode5 = 0 ;
49402 PyObject * obj0 = 0 ;
49403 PyObject * obj1 = 0 ;
49404 PyObject * obj2 = 0 ;
49405 PyObject * obj3 = 0 ;
49406 PyObject * obj4 = 0 ;
49407 PyObject * obj5 = 0 ;
49408 char * kwnames[] = {
49409 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49410 };
49411
49412 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49413 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
49414 if (!SWIG_IsOK(res1)) {
49415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
49416 }
49417 arg1 = reinterpret_cast< wxWindow * >(argp1);
49418 {
49419 arg2 = &temp2;
49420 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49421 }
49422 {
49423 arg3 = &temp3;
49424 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
49425 }
49426 ecode4 = SWIG_AsVal_int(obj3, &val4);
49427 if (!SWIG_IsOK(ecode4)) {
49428 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemWindow" "', expected argument " "4"" of type '" "int""'");
49429 }
49430 arg4 = static_cast< int >(val4);
49431 ecode5 = SWIG_AsVal_int(obj4, &val5);
49432 if (!SWIG_IsOK(ecode5)) {
49433 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemWindow" "', expected argument " "5"" of type '" "int""'");
49434 }
49435 arg5 = static_cast< int >(val5);
49436 if (obj5) {
49437 arg6 = obj5;
49438 }
49439 {
49440 PyThreadState* __tstate = wxPyBeginAllowThreads();
49441 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
49442 wxPyEndAllowThreads(__tstate);
49443 if (PyErr_Occurred()) SWIG_fail;
49444 }
49445 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49446 return resultobj;
49447 fail:
49448 return NULL;
49449 }
49450
49451
49452 SWIGINTERN PyObject *_wrap_new_GBSizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49453 PyObject *resultobj = 0;
49454 wxSizer *arg1 = (wxSizer *) 0 ;
49455 wxGBPosition *arg2 = 0 ;
49456 wxGBSpan *arg3 = 0 ;
49457 int arg4 ;
49458 int arg5 ;
49459 PyObject *arg6 = (PyObject *) NULL ;
49460 wxGBSizerItem *result = 0 ;
49461 int res1 = 0 ;
49462 wxGBPosition temp2 ;
49463 wxGBSpan temp3 ;
49464 int val4 ;
49465 int ecode4 = 0 ;
49466 int val5 ;
49467 int ecode5 = 0 ;
49468 PyObject * obj0 = 0 ;
49469 PyObject * obj1 = 0 ;
49470 PyObject * obj2 = 0 ;
49471 PyObject * obj3 = 0 ;
49472 PyObject * obj4 = 0 ;
49473 PyObject * obj5 = 0 ;
49474 char * kwnames[] = {
49475 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49476 };
49477
49478 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49479 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
49480 if (!SWIG_IsOK(res1)) {
49481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
49482 }
49483 {
49484 arg2 = &temp2;
49485 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49486 }
49487 {
49488 arg3 = &temp3;
49489 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
49490 }
49491 ecode4 = SWIG_AsVal_int(obj3, &val4);
49492 if (!SWIG_IsOK(ecode4)) {
49493 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemSizer" "', expected argument " "4"" of type '" "int""'");
49494 }
49495 arg4 = static_cast< int >(val4);
49496 ecode5 = SWIG_AsVal_int(obj4, &val5);
49497 if (!SWIG_IsOK(ecode5)) {
49498 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSizer" "', expected argument " "5"" of type '" "int""'");
49499 }
49500 arg5 = static_cast< int >(val5);
49501 if (obj5) {
49502 arg6 = obj5;
49503 }
49504 {
49505 PyThreadState* __tstate = wxPyBeginAllowThreads();
49506 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
49507 wxPyEndAllowThreads(__tstate);
49508 if (PyErr_Occurred()) SWIG_fail;
49509 }
49510 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49511 return resultobj;
49512 fail:
49513 return NULL;
49514 }
49515
49516
49517 SWIGINTERN PyObject *_wrap_new_GBSizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49518 PyObject *resultobj = 0;
49519 int arg1 ;
49520 int arg2 ;
49521 wxGBPosition *arg3 = 0 ;
49522 wxGBSpan *arg4 = 0 ;
49523 int arg5 ;
49524 int arg6 ;
49525 PyObject *arg7 = (PyObject *) NULL ;
49526 wxGBSizerItem *result = 0 ;
49527 int val1 ;
49528 int ecode1 = 0 ;
49529 int val2 ;
49530 int ecode2 = 0 ;
49531 wxGBPosition temp3 ;
49532 wxGBSpan temp4 ;
49533 int val5 ;
49534 int ecode5 = 0 ;
49535 int val6 ;
49536 int ecode6 = 0 ;
49537 PyObject * obj0 = 0 ;
49538 PyObject * obj1 = 0 ;
49539 PyObject * obj2 = 0 ;
49540 PyObject * obj3 = 0 ;
49541 PyObject * obj4 = 0 ;
49542 PyObject * obj5 = 0 ;
49543 PyObject * obj6 = 0 ;
49544 char * kwnames[] = {
49545 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49546 };
49547
49548 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
49549 ecode1 = SWIG_AsVal_int(obj0, &val1);
49550 if (!SWIG_IsOK(ecode1)) {
49551 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
49552 }
49553 arg1 = static_cast< int >(val1);
49554 ecode2 = SWIG_AsVal_int(obj1, &val2);
49555 if (!SWIG_IsOK(ecode2)) {
49556 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
49557 }
49558 arg2 = static_cast< int >(val2);
49559 {
49560 arg3 = &temp3;
49561 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
49562 }
49563 {
49564 arg4 = &temp4;
49565 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
49566 }
49567 ecode5 = SWIG_AsVal_int(obj4, &val5);
49568 if (!SWIG_IsOK(ecode5)) {
49569 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
49570 }
49571 arg5 = static_cast< int >(val5);
49572 ecode6 = SWIG_AsVal_int(obj5, &val6);
49573 if (!SWIG_IsOK(ecode6)) {
49574 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GBSizerItemSpacer" "', expected argument " "6"" of type '" "int""'");
49575 }
49576 arg6 = static_cast< int >(val6);
49577 if (obj6) {
49578 arg7 = obj6;
49579 }
49580 {
49581 PyThreadState* __tstate = wxPyBeginAllowThreads();
49582 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
49583 wxPyEndAllowThreads(__tstate);
49584 if (PyErr_Occurred()) SWIG_fail;
49585 }
49586 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49587 return resultobj;
49588 fail:
49589 return NULL;
49590 }
49591
49592
49593 SWIGINTERN PyObject *_wrap_GBSizerItem_GetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49594 PyObject *resultobj = 0;
49595 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49596 wxGBPosition result;
49597 void *argp1 = 0 ;
49598 int res1 = 0 ;
49599 PyObject *swig_obj[1] ;
49600
49601 if (!args) SWIG_fail;
49602 swig_obj[0] = args;
49603 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49604 if (!SWIG_IsOK(res1)) {
49605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetPos" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
49606 }
49607 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49608 {
49609 PyThreadState* __tstate = wxPyBeginAllowThreads();
49610 result = ((wxGBSizerItem const *)arg1)->GetPos();
49611 wxPyEndAllowThreads(__tstate);
49612 if (PyErr_Occurred()) SWIG_fail;
49613 }
49614 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
49615 return resultobj;
49616 fail:
49617 return NULL;
49618 }
49619
49620
49621 SWIGINTERN PyObject *_wrap_GBSizerItem_GetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49622 PyObject *resultobj = 0;
49623 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49624 wxGBSpan result;
49625 void *argp1 = 0 ;
49626 int res1 = 0 ;
49627 PyObject *swig_obj[1] ;
49628
49629 if (!args) SWIG_fail;
49630 swig_obj[0] = args;
49631 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49632 if (!SWIG_IsOK(res1)) {
49633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
49634 }
49635 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49636 {
49637 PyThreadState* __tstate = wxPyBeginAllowThreads();
49638 result = ((wxGBSizerItem const *)arg1)->GetSpan();
49639 wxPyEndAllowThreads(__tstate);
49640 if (PyErr_Occurred()) SWIG_fail;
49641 }
49642 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
49643 return resultobj;
49644 fail:
49645 return NULL;
49646 }
49647
49648
49649 SWIGINTERN PyObject *_wrap_GBSizerItem_SetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49650 PyObject *resultobj = 0;
49651 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49652 wxGBPosition *arg2 = 0 ;
49653 bool result;
49654 void *argp1 = 0 ;
49655 int res1 = 0 ;
49656 wxGBPosition temp2 ;
49657 PyObject * obj0 = 0 ;
49658 PyObject * obj1 = 0 ;
49659 char * kwnames[] = {
49660 (char *) "self",(char *) "pos", NULL
49661 };
49662
49663 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) SWIG_fail;
49664 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49665 if (!SWIG_IsOK(res1)) {
49666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49667 }
49668 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49669 {
49670 arg2 = &temp2;
49671 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49672 }
49673 {
49674 PyThreadState* __tstate = wxPyBeginAllowThreads();
49675 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
49676 wxPyEndAllowThreads(__tstate);
49677 if (PyErr_Occurred()) SWIG_fail;
49678 }
49679 {
49680 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49681 }
49682 return resultobj;
49683 fail:
49684 return NULL;
49685 }
49686
49687
49688 SWIGINTERN PyObject *_wrap_GBSizerItem_SetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49689 PyObject *resultobj = 0;
49690 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49691 wxGBSpan *arg2 = 0 ;
49692 bool result;
49693 void *argp1 = 0 ;
49694 int res1 = 0 ;
49695 wxGBSpan temp2 ;
49696 PyObject * obj0 = 0 ;
49697 PyObject * obj1 = 0 ;
49698 char * kwnames[] = {
49699 (char *) "self",(char *) "span", NULL
49700 };
49701
49702 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) SWIG_fail;
49703 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49704 if (!SWIG_IsOK(res1)) {
49705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49706 }
49707 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49708 {
49709 arg2 = &temp2;
49710 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
49711 }
49712 {
49713 PyThreadState* __tstate = wxPyBeginAllowThreads();
49714 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
49715 wxPyEndAllowThreads(__tstate);
49716 if (PyErr_Occurred()) SWIG_fail;
49717 }
49718 {
49719 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49720 }
49721 return resultobj;
49722 fail:
49723 return NULL;
49724 }
49725
49726
49727 SWIGINTERN PyObject *_wrap_GBSizerItem_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49728 PyObject *resultobj = 0;
49729 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49730 wxGBSizerItem *arg2 = 0 ;
49731 bool result;
49732 void *argp1 = 0 ;
49733 int res1 = 0 ;
49734 void *argp2 = 0 ;
49735 int res2 = 0 ;
49736 PyObject * obj0 = 0 ;
49737 PyObject * obj1 = 0 ;
49738 char * kwnames[] = {
49739 (char *) "self",(char *) "other", NULL
49740 };
49741
49742 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",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_Intersects" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49746 }
49747 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49748 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGBSizerItem, 0 | 0);
49749 if (!SWIG_IsOK(res2)) {
49750 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
49751 }
49752 if (!argp2) {
49753 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
49754 }
49755 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
49756 {
49757 PyThreadState* __tstate = wxPyBeginAllowThreads();
49758 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
49759 wxPyEndAllowThreads(__tstate);
49760 if (PyErr_Occurred()) SWIG_fail;
49761 }
49762 {
49763 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49764 }
49765 return resultobj;
49766 fail:
49767 return NULL;
49768 }
49769
49770
49771 SWIGINTERN PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49772 PyObject *resultobj = 0;
49773 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49774 wxGBPosition *arg2 = 0 ;
49775 wxGBSpan *arg3 = 0 ;
49776 bool result;
49777 void *argp1 = 0 ;
49778 int res1 = 0 ;
49779 wxGBPosition temp2 ;
49780 wxGBSpan temp3 ;
49781 PyObject * obj0 = 0 ;
49782 PyObject * obj1 = 0 ;
49783 PyObject * obj2 = 0 ;
49784 char * kwnames[] = {
49785 (char *) "self",(char *) "pos",(char *) "span", NULL
49786 };
49787
49788 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49789 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49790 if (!SWIG_IsOK(res1)) {
49791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_IntersectsPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49792 }
49793 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49794 {
49795 arg2 = &temp2;
49796 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49797 }
49798 {
49799 arg3 = &temp3;
49800 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
49801 }
49802 {
49803 PyThreadState* __tstate = wxPyBeginAllowThreads();
49804 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
49805 wxPyEndAllowThreads(__tstate);
49806 if (PyErr_Occurred()) SWIG_fail;
49807 }
49808 {
49809 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49810 }
49811 return resultobj;
49812 fail:
49813 return NULL;
49814 }
49815
49816
49817 SWIGINTERN PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49818 PyObject *resultobj = 0;
49819 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49820 wxGBPosition result;
49821 void *argp1 = 0 ;
49822 int res1 = 0 ;
49823 PyObject *swig_obj[1] ;
49824
49825 if (!args) SWIG_fail;
49826 swig_obj[0] = args;
49827 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49828 if (!SWIG_IsOK(res1)) {
49829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetEndPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49830 }
49831 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49832 {
49833 PyThreadState* __tstate = wxPyBeginAllowThreads();
49834 result = wxGBSizerItem_GetEndPos(arg1);
49835 wxPyEndAllowThreads(__tstate);
49836 if (PyErr_Occurred()) SWIG_fail;
49837 }
49838 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
49839 return resultobj;
49840 fail:
49841 return NULL;
49842 }
49843
49844
49845 SWIGINTERN PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49846 PyObject *resultobj = 0;
49847 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49848 wxGridBagSizer *result = 0 ;
49849 void *argp1 = 0 ;
49850 int res1 = 0 ;
49851 PyObject *swig_obj[1] ;
49852
49853 if (!args) SWIG_fail;
49854 swig_obj[0] = args;
49855 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49856 if (!SWIG_IsOK(res1)) {
49857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
49858 }
49859 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49860 {
49861 PyThreadState* __tstate = wxPyBeginAllowThreads();
49862 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
49863 wxPyEndAllowThreads(__tstate);
49864 if (PyErr_Occurred()) SWIG_fail;
49865 }
49866 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
49867 return resultobj;
49868 fail:
49869 return NULL;
49870 }
49871
49872
49873 SWIGINTERN PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49874 PyObject *resultobj = 0;
49875 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49876 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
49877 void *argp1 = 0 ;
49878 int res1 = 0 ;
49879 void *argp2 = 0 ;
49880 int res2 = 0 ;
49881 PyObject * obj0 = 0 ;
49882 PyObject * obj1 = 0 ;
49883 char * kwnames[] = {
49884 (char *) "self",(char *) "sizer", NULL
49885 };
49886
49887 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) SWIG_fail;
49888 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49889 if (!SWIG_IsOK(res1)) {
49890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49891 }
49892 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49893 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
49894 if (!SWIG_IsOK(res2)) {
49895 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "2"" of type '" "wxGridBagSizer *""'");
49896 }
49897 arg2 = reinterpret_cast< wxGridBagSizer * >(argp2);
49898 {
49899 PyThreadState* __tstate = wxPyBeginAllowThreads();
49900 (arg1)->SetGBSizer(arg2);
49901 wxPyEndAllowThreads(__tstate);
49902 if (PyErr_Occurred()) SWIG_fail;
49903 }
49904 resultobj = SWIG_Py_Void();
49905 return resultobj;
49906 fail:
49907 return NULL;
49908 }
49909
49910
49911 SWIGINTERN PyObject *GBSizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49912 PyObject *obj;
49913 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49914 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSizerItem, SWIG_NewClientData(obj));
49915 return SWIG_Py_Void();
49916 }
49917
49918 SWIGINTERN PyObject *GBSizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49919 return SWIG_Python_InitShadowInstance(args);
49920 }
49921
49922 SWIGINTERN PyObject *_wrap_new_GridBagSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49923 PyObject *resultobj = 0;
49924 int arg1 = (int) 0 ;
49925 int arg2 = (int) 0 ;
49926 wxGridBagSizer *result = 0 ;
49927 int val1 ;
49928 int ecode1 = 0 ;
49929 int val2 ;
49930 int ecode2 = 0 ;
49931 PyObject * obj0 = 0 ;
49932 PyObject * obj1 = 0 ;
49933 char * kwnames[] = {
49934 (char *) "vgap",(char *) "hgap", NULL
49935 };
49936
49937 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) SWIG_fail;
49938 if (obj0) {
49939 ecode1 = SWIG_AsVal_int(obj0, &val1);
49940 if (!SWIG_IsOK(ecode1)) {
49941 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridBagSizer" "', expected argument " "1"" of type '" "int""'");
49942 }
49943 arg1 = static_cast< int >(val1);
49944 }
49945 if (obj1) {
49946 ecode2 = SWIG_AsVal_int(obj1, &val2);
49947 if (!SWIG_IsOK(ecode2)) {
49948 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridBagSizer" "', expected argument " "2"" of type '" "int""'");
49949 }
49950 arg2 = static_cast< int >(val2);
49951 }
49952 {
49953 PyThreadState* __tstate = wxPyBeginAllowThreads();
49954 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
49955 wxPyEndAllowThreads(__tstate);
49956 if (PyErr_Occurred()) SWIG_fail;
49957 }
49958 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_NEW | 0 );
49959 return resultobj;
49960 fail:
49961 return NULL;
49962 }
49963
49964
49965 SWIGINTERN PyObject *_wrap_GridBagSizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49966 PyObject *resultobj = 0;
49967 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
49968 PyObject *arg2 = (PyObject *) 0 ;
49969 wxGBPosition *arg3 = 0 ;
49970 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
49971 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
49972 int arg5 = (int) 0 ;
49973 int arg6 = (int) 0 ;
49974 PyObject *arg7 = (PyObject *) NULL ;
49975 wxGBSizerItem *result = 0 ;
49976 void *argp1 = 0 ;
49977 int res1 = 0 ;
49978 wxGBPosition temp3 ;
49979 wxGBSpan temp4 ;
49980 int val5 ;
49981 int ecode5 = 0 ;
49982 int val6 ;
49983 int ecode6 = 0 ;
49984 PyObject * obj0 = 0 ;
49985 PyObject * obj1 = 0 ;
49986 PyObject * obj2 = 0 ;
49987 PyObject * obj3 = 0 ;
49988 PyObject * obj4 = 0 ;
49989 PyObject * obj5 = 0 ;
49990 PyObject * obj6 = 0 ;
49991 char * kwnames[] = {
49992 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49993 };
49994
49995 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
49996 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
49997 if (!SWIG_IsOK(res1)) {
49998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_Add" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
49999 }
50000 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50001 arg2 = obj1;
50002 {
50003 arg3 = &temp3;
50004 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
50005 }
50006 if (obj3) {
50007 {
50008 arg4 = &temp4;
50009 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
50010 }
50011 }
50012 if (obj4) {
50013 ecode5 = SWIG_AsVal_int(obj4, &val5);
50014 if (!SWIG_IsOK(ecode5)) {
50015 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridBagSizer_Add" "', expected argument " "5"" of type '" "int""'");
50016 }
50017 arg5 = static_cast< int >(val5);
50018 }
50019 if (obj5) {
50020 ecode6 = SWIG_AsVal_int(obj5, &val6);
50021 if (!SWIG_IsOK(ecode6)) {
50022 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridBagSizer_Add" "', expected argument " "6"" of type '" "int""'");
50023 }
50024 arg6 = static_cast< int >(val6);
50025 }
50026 if (obj6) {
50027 arg7 = obj6;
50028 }
50029 {
50030 PyThreadState* __tstate = wxPyBeginAllowThreads();
50031 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
50032 wxPyEndAllowThreads(__tstate);
50033 if (PyErr_Occurred()) SWIG_fail;
50034 }
50035 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50036 return resultobj;
50037 fail:
50038 return NULL;
50039 }
50040
50041
50042 SWIGINTERN PyObject *_wrap_GridBagSizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50043 PyObject *resultobj = 0;
50044 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50045 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
50046 wxGBSizerItem *result = 0 ;
50047 void *argp1 = 0 ;
50048 int res1 = 0 ;
50049 int res2 = 0 ;
50050 PyObject * obj0 = 0 ;
50051 PyObject * obj1 = 0 ;
50052 char * kwnames[] = {
50053 (char *) "self",(char *) "item", NULL
50054 };
50055
50056 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
50057 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50058 if (!SWIG_IsOK(res1)) {
50059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_AddItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50060 }
50061 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50062 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
50063 if (!SWIG_IsOK(res2)) {
50064 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_AddItem" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
50065 }
50066 {
50067 PyThreadState* __tstate = wxPyBeginAllowThreads();
50068 result = (wxGBSizerItem *)(arg1)->Add(arg2);
50069 wxPyEndAllowThreads(__tstate);
50070 if (PyErr_Occurred()) SWIG_fail;
50071 }
50072 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50073 return resultobj;
50074 fail:
50075 return NULL;
50076 }
50077
50078
50079 SWIGINTERN PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50080 PyObject *resultobj = 0;
50081 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50082 int arg2 ;
50083 int arg3 ;
50084 wxSize result;
50085 void *argp1 = 0 ;
50086 int res1 = 0 ;
50087 int val2 ;
50088 int ecode2 = 0 ;
50089 int val3 ;
50090 int ecode3 = 0 ;
50091 PyObject * obj0 = 0 ;
50092 PyObject * obj1 = 0 ;
50093 PyObject * obj2 = 0 ;
50094 char * kwnames[] = {
50095 (char *) "self",(char *) "row",(char *) "col", NULL
50096 };
50097
50098 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50099 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50100 if (!SWIG_IsOK(res1)) {
50101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
50102 }
50103 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50104 ecode2 = SWIG_AsVal_int(obj1, &val2);
50105 if (!SWIG_IsOK(ecode2)) {
50106 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "2"" of type '" "int""'");
50107 }
50108 arg2 = static_cast< int >(val2);
50109 ecode3 = SWIG_AsVal_int(obj2, &val3);
50110 if (!SWIG_IsOK(ecode3)) {
50111 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "3"" of type '" "int""'");
50112 }
50113 arg3 = static_cast< int >(val3);
50114 {
50115 PyThreadState* __tstate = wxPyBeginAllowThreads();
50116 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
50117 wxPyEndAllowThreads(__tstate);
50118 if (PyErr_Occurred()) SWIG_fail;
50119 }
50120 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50121 return resultobj;
50122 fail:
50123 return NULL;
50124 }
50125
50126
50127 SWIGINTERN PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50128 PyObject *resultobj = 0;
50129 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50130 wxSize result;
50131 void *argp1 = 0 ;
50132 int res1 = 0 ;
50133 PyObject *swig_obj[1] ;
50134
50135 if (!args) SWIG_fail;
50136 swig_obj[0] = args;
50137 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50138 if (!SWIG_IsOK(res1)) {
50139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
50140 }
50141 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50142 {
50143 PyThreadState* __tstate = wxPyBeginAllowThreads();
50144 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
50145 wxPyEndAllowThreads(__tstate);
50146 if (PyErr_Occurred()) SWIG_fail;
50147 }
50148 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50149 return resultobj;
50150 fail:
50151 return NULL;
50152 }
50153
50154
50155 SWIGINTERN PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50156 PyObject *resultobj = 0;
50157 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50158 wxSize *arg2 = 0 ;
50159 void *argp1 = 0 ;
50160 int res1 = 0 ;
50161 wxSize temp2 ;
50162 PyObject * obj0 = 0 ;
50163 PyObject * obj1 = 0 ;
50164 char * kwnames[] = {
50165 (char *) "self",(char *) "sz", NULL
50166 };
50167
50168 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) SWIG_fail;
50169 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50170 if (!SWIG_IsOK(res1)) {
50171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50172 }
50173 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50174 {
50175 arg2 = &temp2;
50176 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
50177 }
50178 {
50179 PyThreadState* __tstate = wxPyBeginAllowThreads();
50180 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
50181 wxPyEndAllowThreads(__tstate);
50182 if (PyErr_Occurred()) SWIG_fail;
50183 }
50184 resultobj = SWIG_Py_Void();
50185 return resultobj;
50186 fail:
50187 return NULL;
50188 }
50189
50190
50191 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50192 PyObject *resultobj = 0;
50193 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50194 wxWindow *arg2 = (wxWindow *) 0 ;
50195 wxGBPosition result;
50196 void *argp1 = 0 ;
50197 int res1 = 0 ;
50198 void *argp2 = 0 ;
50199 int res2 = 0 ;
50200
50201 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50202 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50203 if (!SWIG_IsOK(res1)) {
50204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50205 }
50206 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50207 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50208 if (!SWIG_IsOK(res2)) {
50209 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
50210 }
50211 arg2 = reinterpret_cast< wxWindow * >(argp2);
50212 {
50213 PyThreadState* __tstate = wxPyBeginAllowThreads();
50214 result = (arg1)->GetItemPosition(arg2);
50215 wxPyEndAllowThreads(__tstate);
50216 if (PyErr_Occurred()) SWIG_fail;
50217 }
50218 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50219 return resultobj;
50220 fail:
50221 return NULL;
50222 }
50223
50224
50225 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50226 PyObject *resultobj = 0;
50227 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50228 wxSizer *arg2 = (wxSizer *) 0 ;
50229 wxGBPosition result;
50230 void *argp1 = 0 ;
50231 int res1 = 0 ;
50232 void *argp2 = 0 ;
50233 int res2 = 0 ;
50234
50235 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50236 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50237 if (!SWIG_IsOK(res1)) {
50238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50239 }
50240 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50241 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50242 if (!SWIG_IsOK(res2)) {
50243 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
50244 }
50245 arg2 = reinterpret_cast< wxSizer * >(argp2);
50246 {
50247 PyThreadState* __tstate = wxPyBeginAllowThreads();
50248 result = (arg1)->GetItemPosition(arg2);
50249 wxPyEndAllowThreads(__tstate);
50250 if (PyErr_Occurred()) SWIG_fail;
50251 }
50252 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50253 return resultobj;
50254 fail:
50255 return NULL;
50256 }
50257
50258
50259 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50260 PyObject *resultobj = 0;
50261 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50262 size_t arg2 ;
50263 wxGBPosition result;
50264 void *argp1 = 0 ;
50265 int res1 = 0 ;
50266 size_t val2 ;
50267 int ecode2 = 0 ;
50268
50269 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50270 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50271 if (!SWIG_IsOK(res1)) {
50272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50273 }
50274 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50275 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50276 if (!SWIG_IsOK(ecode2)) {
50277 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
50278 }
50279 arg2 = static_cast< size_t >(val2);
50280 {
50281 PyThreadState* __tstate = wxPyBeginAllowThreads();
50282 result = (arg1)->GetItemPosition(arg2);
50283 wxPyEndAllowThreads(__tstate);
50284 if (PyErr_Occurred()) SWIG_fail;
50285 }
50286 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50287 return resultobj;
50288 fail:
50289 return NULL;
50290 }
50291
50292
50293 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
50294 int argc;
50295 PyObject *argv[3];
50296
50297 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemPosition",0,2,argv))) SWIG_fail;
50298 --argc;
50299 if (argc == 2) {
50300 int _v = 0;
50301 {
50302 void *vptr = 0;
50303 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50304 _v = SWIG_CheckState(res);
50305 }
50306 if (!_v) goto check_1;
50307 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self, argc, argv);
50308 }
50309 check_1:
50310
50311 if (argc == 2) {
50312 int _v = 0;
50313 {
50314 void *vptr = 0;
50315 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50316 _v = SWIG_CheckState(res);
50317 }
50318 if (!_v) goto check_2;
50319 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self, argc, argv);
50320 }
50321 check_2:
50322
50323 if (argc == 2) {
50324 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self, argc, argv);
50325 }
50326
50327 fail:
50328 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
50329 return NULL;
50330 }
50331
50332
50333 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50334 PyObject *resultobj = 0;
50335 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50336 wxWindow *arg2 = (wxWindow *) 0 ;
50337 wxGBPosition *arg3 = 0 ;
50338 bool result;
50339 void *argp1 = 0 ;
50340 int res1 = 0 ;
50341 void *argp2 = 0 ;
50342 int res2 = 0 ;
50343 wxGBPosition temp3 ;
50344
50345 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50346 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50347 if (!SWIG_IsOK(res1)) {
50348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50349 }
50350 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50351 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50352 if (!SWIG_IsOK(res2)) {
50353 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
50354 }
50355 arg2 = reinterpret_cast< wxWindow * >(argp2);
50356 {
50357 arg3 = &temp3;
50358 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50359 }
50360 {
50361 PyThreadState* __tstate = wxPyBeginAllowThreads();
50362 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50363 wxPyEndAllowThreads(__tstate);
50364 if (PyErr_Occurred()) SWIG_fail;
50365 }
50366 {
50367 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50368 }
50369 return resultobj;
50370 fail:
50371 return NULL;
50372 }
50373
50374
50375 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50376 PyObject *resultobj = 0;
50377 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50378 wxSizer *arg2 = (wxSizer *) 0 ;
50379 wxGBPosition *arg3 = 0 ;
50380 bool result;
50381 void *argp1 = 0 ;
50382 int res1 = 0 ;
50383 void *argp2 = 0 ;
50384 int res2 = 0 ;
50385 wxGBPosition temp3 ;
50386
50387 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50388 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50389 if (!SWIG_IsOK(res1)) {
50390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50391 }
50392 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50393 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50394 if (!SWIG_IsOK(res2)) {
50395 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
50396 }
50397 arg2 = reinterpret_cast< wxSizer * >(argp2);
50398 {
50399 arg3 = &temp3;
50400 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50401 }
50402 {
50403 PyThreadState* __tstate = wxPyBeginAllowThreads();
50404 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50405 wxPyEndAllowThreads(__tstate);
50406 if (PyErr_Occurred()) SWIG_fail;
50407 }
50408 {
50409 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50410 }
50411 return resultobj;
50412 fail:
50413 return NULL;
50414 }
50415
50416
50417 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50418 PyObject *resultobj = 0;
50419 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50420 size_t arg2 ;
50421 wxGBPosition *arg3 = 0 ;
50422 bool result;
50423 void *argp1 = 0 ;
50424 int res1 = 0 ;
50425 size_t val2 ;
50426 int ecode2 = 0 ;
50427 wxGBPosition temp3 ;
50428
50429 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50430 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50431 if (!SWIG_IsOK(res1)) {
50432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50433 }
50434 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50435 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50436 if (!SWIG_IsOK(ecode2)) {
50437 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
50438 }
50439 arg2 = static_cast< size_t >(val2);
50440 {
50441 arg3 = &temp3;
50442 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50443 }
50444 {
50445 PyThreadState* __tstate = wxPyBeginAllowThreads();
50446 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50447 wxPyEndAllowThreads(__tstate);
50448 if (PyErr_Occurred()) SWIG_fail;
50449 }
50450 {
50451 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50452 }
50453 return resultobj;
50454 fail:
50455 return NULL;
50456 }
50457
50458
50459 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
50460 int argc;
50461 PyObject *argv[4];
50462
50463 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemPosition",0,3,argv))) SWIG_fail;
50464 --argc;
50465 if (argc == 3) {
50466 int _v = 0;
50467 {
50468 void *vptr = 0;
50469 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50470 _v = SWIG_CheckState(res);
50471 }
50472 if (!_v) goto check_1;
50473 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self, argc, argv);
50474 }
50475 check_1:
50476
50477 if (argc == 3) {
50478 int _v = 0;
50479 {
50480 void *vptr = 0;
50481 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50482 _v = SWIG_CheckState(res);
50483 }
50484 if (!_v) goto check_2;
50485 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self, argc, argv);
50486 }
50487 check_2:
50488
50489 if (argc == 3) {
50490 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self, argc, argv);
50491 }
50492
50493 fail:
50494 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
50495 return NULL;
50496 }
50497
50498
50499 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50500 PyObject *resultobj = 0;
50501 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50502 wxWindow *arg2 = (wxWindow *) 0 ;
50503 wxGBSpan result;
50504 void *argp1 = 0 ;
50505 int res1 = 0 ;
50506 void *argp2 = 0 ;
50507 int res2 = 0 ;
50508
50509 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50510 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50511 if (!SWIG_IsOK(res1)) {
50512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50513 }
50514 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50515 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50516 if (!SWIG_IsOK(res2)) {
50517 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
50518 }
50519 arg2 = reinterpret_cast< wxWindow * >(argp2);
50520 {
50521 PyThreadState* __tstate = wxPyBeginAllowThreads();
50522 result = (arg1)->GetItemSpan(arg2);
50523 wxPyEndAllowThreads(__tstate);
50524 if (PyErr_Occurred()) SWIG_fail;
50525 }
50526 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50527 return resultobj;
50528 fail:
50529 return NULL;
50530 }
50531
50532
50533 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50534 PyObject *resultobj = 0;
50535 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50536 wxSizer *arg2 = (wxSizer *) 0 ;
50537 wxGBSpan result;
50538 void *argp1 = 0 ;
50539 int res1 = 0 ;
50540 void *argp2 = 0 ;
50541 int res2 = 0 ;
50542
50543 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50544 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50545 if (!SWIG_IsOK(res1)) {
50546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50547 }
50548 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50549 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50550 if (!SWIG_IsOK(res2)) {
50551 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
50552 }
50553 arg2 = reinterpret_cast< wxSizer * >(argp2);
50554 {
50555 PyThreadState* __tstate = wxPyBeginAllowThreads();
50556 result = (arg1)->GetItemSpan(arg2);
50557 wxPyEndAllowThreads(__tstate);
50558 if (PyErr_Occurred()) SWIG_fail;
50559 }
50560 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50561 return resultobj;
50562 fail:
50563 return NULL;
50564 }
50565
50566
50567 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50568 PyObject *resultobj = 0;
50569 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50570 size_t arg2 ;
50571 wxGBSpan result;
50572 void *argp1 = 0 ;
50573 int res1 = 0 ;
50574 size_t val2 ;
50575 int ecode2 = 0 ;
50576
50577 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50578 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50579 if (!SWIG_IsOK(res1)) {
50580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50581 }
50582 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50583 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50584 if (!SWIG_IsOK(ecode2)) {
50585 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
50586 }
50587 arg2 = static_cast< size_t >(val2);
50588 {
50589 PyThreadState* __tstate = wxPyBeginAllowThreads();
50590 result = (arg1)->GetItemSpan(arg2);
50591 wxPyEndAllowThreads(__tstate);
50592 if (PyErr_Occurred()) SWIG_fail;
50593 }
50594 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50595 return resultobj;
50596 fail:
50597 return NULL;
50598 }
50599
50600
50601 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
50602 int argc;
50603 PyObject *argv[3];
50604
50605 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemSpan",0,2,argv))) SWIG_fail;
50606 --argc;
50607 if (argc == 2) {
50608 int _v = 0;
50609 {
50610 void *vptr = 0;
50611 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50612 _v = SWIG_CheckState(res);
50613 }
50614 if (!_v) goto check_1;
50615 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self, argc, argv);
50616 }
50617 check_1:
50618
50619 if (argc == 2) {
50620 int _v = 0;
50621 {
50622 void *vptr = 0;
50623 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50624 _v = SWIG_CheckState(res);
50625 }
50626 if (!_v) goto check_2;
50627 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self, argc, argv);
50628 }
50629 check_2:
50630
50631 if (argc == 2) {
50632 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self, argc, argv);
50633 }
50634
50635 fail:
50636 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
50637 return NULL;
50638 }
50639
50640
50641 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50642 PyObject *resultobj = 0;
50643 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50644 wxWindow *arg2 = (wxWindow *) 0 ;
50645 wxGBSpan *arg3 = 0 ;
50646 bool result;
50647 void *argp1 = 0 ;
50648 int res1 = 0 ;
50649 void *argp2 = 0 ;
50650 int res2 = 0 ;
50651 wxGBSpan temp3 ;
50652
50653 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50654 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50655 if (!SWIG_IsOK(res1)) {
50656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50657 }
50658 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50659 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50660 if (!SWIG_IsOK(res2)) {
50661 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
50662 }
50663 arg2 = reinterpret_cast< wxWindow * >(argp2);
50664 {
50665 arg3 = &temp3;
50666 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
50667 }
50668 {
50669 PyThreadState* __tstate = wxPyBeginAllowThreads();
50670 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
50671 wxPyEndAllowThreads(__tstate);
50672 if (PyErr_Occurred()) SWIG_fail;
50673 }
50674 {
50675 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50676 }
50677 return resultobj;
50678 fail:
50679 return NULL;
50680 }
50681
50682
50683 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50684 PyObject *resultobj = 0;
50685 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50686 wxSizer *arg2 = (wxSizer *) 0 ;
50687 wxGBSpan *arg3 = 0 ;
50688 bool result;
50689 void *argp1 = 0 ;
50690 int res1 = 0 ;
50691 void *argp2 = 0 ;
50692 int res2 = 0 ;
50693 wxGBSpan temp3 ;
50694
50695 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50696 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50697 if (!SWIG_IsOK(res1)) {
50698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50699 }
50700 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50701 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50702 if (!SWIG_IsOK(res2)) {
50703 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
50704 }
50705 arg2 = reinterpret_cast< wxSizer * >(argp2);
50706 {
50707 arg3 = &temp3;
50708 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
50709 }
50710 {
50711 PyThreadState* __tstate = wxPyBeginAllowThreads();
50712 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
50713 wxPyEndAllowThreads(__tstate);
50714 if (PyErr_Occurred()) SWIG_fail;
50715 }
50716 {
50717 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50718 }
50719 return resultobj;
50720 fail:
50721 return NULL;
50722 }
50723
50724
50725 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50726 PyObject *resultobj = 0;
50727 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50728 size_t arg2 ;
50729 wxGBSpan *arg3 = 0 ;
50730 bool result;
50731 void *argp1 = 0 ;
50732 int res1 = 0 ;
50733 size_t val2 ;
50734 int ecode2 = 0 ;
50735 wxGBSpan temp3 ;
50736
50737 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50738 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50739 if (!SWIG_IsOK(res1)) {
50740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50741 }
50742 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50743 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50744 if (!SWIG_IsOK(ecode2)) {
50745 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
50746 }
50747 arg2 = static_cast< size_t >(val2);
50748 {
50749 arg3 = &temp3;
50750 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
50751 }
50752 {
50753 PyThreadState* __tstate = wxPyBeginAllowThreads();
50754 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
50755 wxPyEndAllowThreads(__tstate);
50756 if (PyErr_Occurred()) SWIG_fail;
50757 }
50758 {
50759 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50760 }
50761 return resultobj;
50762 fail:
50763 return NULL;
50764 }
50765
50766
50767 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
50768 int argc;
50769 PyObject *argv[4];
50770
50771 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemSpan",0,3,argv))) SWIG_fail;
50772 --argc;
50773 if (argc == 3) {
50774 int _v = 0;
50775 {
50776 void *vptr = 0;
50777 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50778 _v = SWIG_CheckState(res);
50779 }
50780 if (!_v) goto check_1;
50781 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self, argc, argv);
50782 }
50783 check_1:
50784
50785 if (argc == 3) {
50786 int _v = 0;
50787 {
50788 void *vptr = 0;
50789 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50790 _v = SWIG_CheckState(res);
50791 }
50792 if (!_v) goto check_2;
50793 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self, argc, argv);
50794 }
50795 check_2:
50796
50797 if (argc == 3) {
50798 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self, argc, argv);
50799 }
50800
50801 fail:
50802 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
50803 return NULL;
50804 }
50805
50806
50807 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50808 PyObject *resultobj = 0;
50809 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50810 wxWindow *arg2 = (wxWindow *) 0 ;
50811 wxGBSizerItem *result = 0 ;
50812 void *argp1 = 0 ;
50813 int res1 = 0 ;
50814 void *argp2 = 0 ;
50815 int res2 = 0 ;
50816
50817 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50818 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50819 if (!SWIG_IsOK(res1)) {
50820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50821 }
50822 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50823 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50824 if (!SWIG_IsOK(res2)) {
50825 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxWindow *""'");
50826 }
50827 arg2 = reinterpret_cast< wxWindow * >(argp2);
50828 {
50829 PyThreadState* __tstate = wxPyBeginAllowThreads();
50830 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
50831 wxPyEndAllowThreads(__tstate);
50832 if (PyErr_Occurred()) SWIG_fail;
50833 }
50834 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50835 return resultobj;
50836 fail:
50837 return NULL;
50838 }
50839
50840
50841 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50842 PyObject *resultobj = 0;
50843 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50844 wxSizer *arg2 = (wxSizer *) 0 ;
50845 wxGBSizerItem *result = 0 ;
50846 void *argp1 = 0 ;
50847 int res1 = 0 ;
50848 void *argp2 = 0 ;
50849 int res2 = 0 ;
50850
50851 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50852 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50853 if (!SWIG_IsOK(res1)) {
50854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50855 }
50856 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50857 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50858 if (!SWIG_IsOK(res2)) {
50859 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxSizer *""'");
50860 }
50861 arg2 = reinterpret_cast< wxSizer * >(argp2);
50862 {
50863 PyThreadState* __tstate = wxPyBeginAllowThreads();
50864 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
50865 wxPyEndAllowThreads(__tstate);
50866 if (PyErr_Occurred()) SWIG_fail;
50867 }
50868 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50869 return resultobj;
50870 fail:
50871 return NULL;
50872 }
50873
50874
50875 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
50876 int argc;
50877 PyObject *argv[3];
50878
50879 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_FindItem",0,2,argv))) SWIG_fail;
50880 --argc;
50881 if (argc == 2) {
50882 int _v = 0;
50883 {
50884 void *vptr = 0;
50885 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50886 _v = SWIG_CheckState(res);
50887 }
50888 if (!_v) goto check_1;
50889 return _wrap_GridBagSizer_FindItem__SWIG_0(self, argc, argv);
50890 }
50891 check_1:
50892
50893 if (argc == 2) {
50894 return _wrap_GridBagSizer_FindItem__SWIG_1(self, argc, argv);
50895 }
50896
50897 fail:
50898 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
50899 return NULL;
50900 }
50901
50902
50903 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50904 PyObject *resultobj = 0;
50905 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50906 wxGBPosition *arg2 = 0 ;
50907 wxGBSizerItem *result = 0 ;
50908 void *argp1 = 0 ;
50909 int res1 = 0 ;
50910 wxGBPosition temp2 ;
50911 PyObject * obj0 = 0 ;
50912 PyObject * obj1 = 0 ;
50913 char * kwnames[] = {
50914 (char *) "self",(char *) "pos", NULL
50915 };
50916
50917 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) SWIG_fail;
50918 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50919 if (!SWIG_IsOK(res1)) {
50920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50921 }
50922 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50923 {
50924 arg2 = &temp2;
50925 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50926 }
50927 {
50928 PyThreadState* __tstate = wxPyBeginAllowThreads();
50929 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
50930 wxPyEndAllowThreads(__tstate);
50931 if (PyErr_Occurred()) SWIG_fail;
50932 }
50933 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50934 return resultobj;
50935 fail:
50936 return NULL;
50937 }
50938
50939
50940 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50941 PyObject *resultobj = 0;
50942 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50943 wxPoint *arg2 = 0 ;
50944 wxGBSizerItem *result = 0 ;
50945 void *argp1 = 0 ;
50946 int res1 = 0 ;
50947 wxPoint temp2 ;
50948 PyObject * obj0 = 0 ;
50949 PyObject * obj1 = 0 ;
50950 char * kwnames[] = {
50951 (char *) "self",(char *) "pt", NULL
50952 };
50953
50954 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) SWIG_fail;
50955 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50956 if (!SWIG_IsOK(res1)) {
50957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPoint" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50958 }
50959 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50960 {
50961 arg2 = &temp2;
50962 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
50963 }
50964 {
50965 PyThreadState* __tstate = wxPyBeginAllowThreads();
50966 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
50967 wxPyEndAllowThreads(__tstate);
50968 if (PyErr_Occurred()) SWIG_fail;
50969 }
50970 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50971 return resultobj;
50972 fail:
50973 return NULL;
50974 }
50975
50976
50977 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50978 PyObject *resultobj = 0;
50979 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50980 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
50981 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
50982 bool result;
50983 void *argp1 = 0 ;
50984 int res1 = 0 ;
50985 void *argp2 = 0 ;
50986 int res2 = 0 ;
50987 void *argp3 = 0 ;
50988 int res3 = 0 ;
50989 PyObject * obj0 = 0 ;
50990 PyObject * obj1 = 0 ;
50991 PyObject * obj2 = 0 ;
50992 char * kwnames[] = {
50993 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
50994 };
50995
50996 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) 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_CheckForIntersection" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51000 }
51001 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51002 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51003 if (!SWIG_IsOK(res2)) {
51004 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
51005 }
51006 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
51007 if (obj2) {
51008 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51009 if (!SWIG_IsOK(res3)) {
51010 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "3"" of type '" "wxGBSizerItem *""'");
51011 }
51012 arg3 = reinterpret_cast< wxGBSizerItem * >(argp3);
51013 }
51014 {
51015 PyThreadState* __tstate = wxPyBeginAllowThreads();
51016 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
51017 wxPyEndAllowThreads(__tstate);
51018 if (PyErr_Occurred()) SWIG_fail;
51019 }
51020 {
51021 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51022 }
51023 return resultobj;
51024 fail:
51025 return NULL;
51026 }
51027
51028
51029 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51030 PyObject *resultobj = 0;
51031 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51032 wxGBPosition *arg2 = 0 ;
51033 wxGBSpan *arg3 = 0 ;
51034 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
51035 bool result;
51036 void *argp1 = 0 ;
51037 int res1 = 0 ;
51038 wxGBPosition temp2 ;
51039 wxGBSpan temp3 ;
51040 void *argp4 = 0 ;
51041 int res4 = 0 ;
51042 PyObject * obj0 = 0 ;
51043 PyObject * obj1 = 0 ;
51044 PyObject * obj2 = 0 ;
51045 PyObject * obj3 = 0 ;
51046 char * kwnames[] = {
51047 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
51048 };
51049
51050 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51051 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51052 if (!SWIG_IsOK(res1)) {
51053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51054 }
51055 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51056 {
51057 arg2 = &temp2;
51058 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51059 }
51060 {
51061 arg3 = &temp3;
51062 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
51063 }
51064 if (obj3) {
51065 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51066 if (!SWIG_IsOK(res4)) {
51067 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "4"" of type '" "wxGBSizerItem *""'");
51068 }
51069 arg4 = reinterpret_cast< wxGBSizerItem * >(argp4);
51070 }
51071 {
51072 PyThreadState* __tstate = wxPyBeginAllowThreads();
51073 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
51074 wxPyEndAllowThreads(__tstate);
51075 if (PyErr_Occurred()) SWIG_fail;
51076 }
51077 {
51078 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51079 }
51080 return resultobj;
51081 fail:
51082 return NULL;
51083 }
51084
51085
51086 SWIGINTERN PyObject *GridBagSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51087 PyObject *obj;
51088 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51089 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridBagSizer, SWIG_NewClientData(obj));
51090 return SWIG_Py_Void();
51091 }
51092
51093 SWIGINTERN PyObject *GridBagSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51094 return SWIG_Python_InitShadowInstance(args);
51095 }
51096
51097 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51098 PyObject *resultobj = 0;
51099 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51100 wxRelationship arg2 ;
51101 wxWindow *arg3 = (wxWindow *) 0 ;
51102 wxEdge arg4 ;
51103 int arg5 = (int) 0 ;
51104 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
51105 void *argp1 = 0 ;
51106 int res1 = 0 ;
51107 int val2 ;
51108 int ecode2 = 0 ;
51109 void *argp3 = 0 ;
51110 int res3 = 0 ;
51111 int val4 ;
51112 int ecode4 = 0 ;
51113 int val5 ;
51114 int ecode5 = 0 ;
51115 int val6 ;
51116 int ecode6 = 0 ;
51117 PyObject * obj0 = 0 ;
51118 PyObject * obj1 = 0 ;
51119 PyObject * obj2 = 0 ;
51120 PyObject * obj3 = 0 ;
51121 PyObject * obj4 = 0 ;
51122 PyObject * obj5 = 0 ;
51123 char * kwnames[] = {
51124 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
51125 };
51126
51127 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
51128 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51129 if (!SWIG_IsOK(res1)) {
51130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51131 }
51132 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51133 ecode2 = SWIG_AsVal_int(obj1, &val2);
51134 if (!SWIG_IsOK(ecode2)) {
51135 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "2"" of type '" "wxRelationship""'");
51136 }
51137 arg2 = static_cast< wxRelationship >(val2);
51138 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
51139 if (!SWIG_IsOK(res3)) {
51140 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "3"" of type '" "wxWindow *""'");
51141 }
51142 arg3 = reinterpret_cast< wxWindow * >(argp3);
51143 ecode4 = SWIG_AsVal_int(obj3, &val4);
51144 if (!SWIG_IsOK(ecode4)) {
51145 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "4"" of type '" "wxEdge""'");
51146 }
51147 arg4 = static_cast< wxEdge >(val4);
51148 if (obj4) {
51149 ecode5 = SWIG_AsVal_int(obj4, &val5);
51150 if (!SWIG_IsOK(ecode5)) {
51151 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "5"" of type '" "int""'");
51152 }
51153 arg5 = static_cast< int >(val5);
51154 }
51155 if (obj5) {
51156 ecode6 = SWIG_AsVal_int(obj5, &val6);
51157 if (!SWIG_IsOK(ecode6)) {
51158 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "6"" of type '" "int""'");
51159 }
51160 arg6 = static_cast< int >(val6);
51161 }
51162 {
51163 PyThreadState* __tstate = wxPyBeginAllowThreads();
51164 (arg1)->Set(arg2,arg3,arg4,arg5,arg6);
51165 wxPyEndAllowThreads(__tstate);
51166 if (PyErr_Occurred()) SWIG_fail;
51167 }
51168 resultobj = SWIG_Py_Void();
51169 return resultobj;
51170 fail:
51171 return NULL;
51172 }
51173
51174
51175 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51176 PyObject *resultobj = 0;
51177 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51178 wxWindow *arg2 = (wxWindow *) 0 ;
51179 int arg3 = (int) 0 ;
51180 void *argp1 = 0 ;
51181 int res1 = 0 ;
51182 void *argp2 = 0 ;
51183 int res2 = 0 ;
51184 int val3 ;
51185 int ecode3 = 0 ;
51186 PyObject * obj0 = 0 ;
51187 PyObject * obj1 = 0 ;
51188 PyObject * obj2 = 0 ;
51189 char * kwnames[] = {
51190 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51191 };
51192
51193 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51194 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51195 if (!SWIG_IsOK(res1)) {
51196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51197 }
51198 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51199 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51200 if (!SWIG_IsOK(res2)) {
51201 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51202 }
51203 arg2 = reinterpret_cast< wxWindow * >(argp2);
51204 if (obj2) {
51205 ecode3 = SWIG_AsVal_int(obj2, &val3);
51206 if (!SWIG_IsOK(ecode3)) {
51207 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "3"" of type '" "int""'");
51208 }
51209 arg3 = static_cast< int >(val3);
51210 }
51211 {
51212 PyThreadState* __tstate = wxPyBeginAllowThreads();
51213 (arg1)->LeftOf(arg2,arg3);
51214 wxPyEndAllowThreads(__tstate);
51215 if (PyErr_Occurred()) SWIG_fail;
51216 }
51217 resultobj = SWIG_Py_Void();
51218 return resultobj;
51219 fail:
51220 return NULL;
51221 }
51222
51223
51224 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51225 PyObject *resultobj = 0;
51226 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51227 wxWindow *arg2 = (wxWindow *) 0 ;
51228 int arg3 = (int) 0 ;
51229 void *argp1 = 0 ;
51230 int res1 = 0 ;
51231 void *argp2 = 0 ;
51232 int res2 = 0 ;
51233 int val3 ;
51234 int ecode3 = 0 ;
51235 PyObject * obj0 = 0 ;
51236 PyObject * obj1 = 0 ;
51237 PyObject * obj2 = 0 ;
51238 char * kwnames[] = {
51239 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51240 };
51241
51242 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51243 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51244 if (!SWIG_IsOK(res1)) {
51245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51246 }
51247 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51248 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51249 if (!SWIG_IsOK(res2)) {
51250 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51251 }
51252 arg2 = reinterpret_cast< wxWindow * >(argp2);
51253 if (obj2) {
51254 ecode3 = SWIG_AsVal_int(obj2, &val3);
51255 if (!SWIG_IsOK(ecode3)) {
51256 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "3"" of type '" "int""'");
51257 }
51258 arg3 = static_cast< int >(val3);
51259 }
51260 {
51261 PyThreadState* __tstate = wxPyBeginAllowThreads();
51262 (arg1)->RightOf(arg2,arg3);
51263 wxPyEndAllowThreads(__tstate);
51264 if (PyErr_Occurred()) SWIG_fail;
51265 }
51266 resultobj = SWIG_Py_Void();
51267 return resultobj;
51268 fail:
51269 return NULL;
51270 }
51271
51272
51273 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51274 PyObject *resultobj = 0;
51275 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51276 wxWindow *arg2 = (wxWindow *) 0 ;
51277 int arg3 = (int) 0 ;
51278 void *argp1 = 0 ;
51279 int res1 = 0 ;
51280 void *argp2 = 0 ;
51281 int res2 = 0 ;
51282 int val3 ;
51283 int ecode3 = 0 ;
51284 PyObject * obj0 = 0 ;
51285 PyObject * obj1 = 0 ;
51286 PyObject * obj2 = 0 ;
51287 char * kwnames[] = {
51288 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51289 };
51290
51291 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51292 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51293 if (!SWIG_IsOK(res1)) {
51294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51295 }
51296 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51297 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51298 if (!SWIG_IsOK(res2)) {
51299 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "2"" of type '" "wxWindow *""'");
51300 }
51301 arg2 = reinterpret_cast< wxWindow * >(argp2);
51302 if (obj2) {
51303 ecode3 = SWIG_AsVal_int(obj2, &val3);
51304 if (!SWIG_IsOK(ecode3)) {
51305 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "3"" of type '" "int""'");
51306 }
51307 arg3 = static_cast< int >(val3);
51308 }
51309 {
51310 PyThreadState* __tstate = wxPyBeginAllowThreads();
51311 (arg1)->Above(arg2,arg3);
51312 wxPyEndAllowThreads(__tstate);
51313 if (PyErr_Occurred()) SWIG_fail;
51314 }
51315 resultobj = SWIG_Py_Void();
51316 return resultobj;
51317 fail:
51318 return NULL;
51319 }
51320
51321
51322 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51323 PyObject *resultobj = 0;
51324 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51325 wxWindow *arg2 = (wxWindow *) 0 ;
51326 int arg3 = (int) 0 ;
51327 void *argp1 = 0 ;
51328 int res1 = 0 ;
51329 void *argp2 = 0 ;
51330 int res2 = 0 ;
51331 int val3 ;
51332 int ecode3 = 0 ;
51333 PyObject * obj0 = 0 ;
51334 PyObject * obj1 = 0 ;
51335 PyObject * obj2 = 0 ;
51336 char * kwnames[] = {
51337 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51338 };
51339
51340 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51341 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51342 if (!SWIG_IsOK(res1)) {
51343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51344 }
51345 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51346 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51347 if (!SWIG_IsOK(res2)) {
51348 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "2"" of type '" "wxWindow *""'");
51349 }
51350 arg2 = reinterpret_cast< wxWindow * >(argp2);
51351 if (obj2) {
51352 ecode3 = SWIG_AsVal_int(obj2, &val3);
51353 if (!SWIG_IsOK(ecode3)) {
51354 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "3"" of type '" "int""'");
51355 }
51356 arg3 = static_cast< int >(val3);
51357 }
51358 {
51359 PyThreadState* __tstate = wxPyBeginAllowThreads();
51360 (arg1)->Below(arg2,arg3);
51361 wxPyEndAllowThreads(__tstate);
51362 if (PyErr_Occurred()) SWIG_fail;
51363 }
51364 resultobj = SWIG_Py_Void();
51365 return resultobj;
51366 fail:
51367 return NULL;
51368 }
51369
51370
51371 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51372 PyObject *resultobj = 0;
51373 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51374 wxWindow *arg2 = (wxWindow *) 0 ;
51375 wxEdge arg3 ;
51376 int arg4 = (int) 0 ;
51377 void *argp1 = 0 ;
51378 int res1 = 0 ;
51379 void *argp2 = 0 ;
51380 int res2 = 0 ;
51381 int val3 ;
51382 int ecode3 = 0 ;
51383 int val4 ;
51384 int ecode4 = 0 ;
51385 PyObject * obj0 = 0 ;
51386 PyObject * obj1 = 0 ;
51387 PyObject * obj2 = 0 ;
51388 PyObject * obj3 = 0 ;
51389 char * kwnames[] = {
51390 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
51391 };
51392
51393 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51394 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51395 if (!SWIG_IsOK(res1)) {
51396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51397 }
51398 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51399 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51400 if (!SWIG_IsOK(res2)) {
51401 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "2"" of type '" "wxWindow *""'");
51402 }
51403 arg2 = reinterpret_cast< wxWindow * >(argp2);
51404 ecode3 = SWIG_AsVal_int(obj2, &val3);
51405 if (!SWIG_IsOK(ecode3)) {
51406 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "3"" of type '" "wxEdge""'");
51407 }
51408 arg3 = static_cast< wxEdge >(val3);
51409 if (obj3) {
51410 ecode4 = SWIG_AsVal_int(obj3, &val4);
51411 if (!SWIG_IsOK(ecode4)) {
51412 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "4"" of type '" "int""'");
51413 }
51414 arg4 = static_cast< int >(val4);
51415 }
51416 {
51417 PyThreadState* __tstate = wxPyBeginAllowThreads();
51418 (arg1)->SameAs(arg2,arg3,arg4);
51419 wxPyEndAllowThreads(__tstate);
51420 if (PyErr_Occurred()) SWIG_fail;
51421 }
51422 resultobj = SWIG_Py_Void();
51423 return resultobj;
51424 fail:
51425 return NULL;
51426 }
51427
51428
51429 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51430 PyObject *resultobj = 0;
51431 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51432 wxWindow *arg2 = (wxWindow *) 0 ;
51433 wxEdge arg3 ;
51434 int arg4 ;
51435 void *argp1 = 0 ;
51436 int res1 = 0 ;
51437 void *argp2 = 0 ;
51438 int res2 = 0 ;
51439 int val3 ;
51440 int ecode3 = 0 ;
51441 int val4 ;
51442 int ecode4 = 0 ;
51443 PyObject * obj0 = 0 ;
51444 PyObject * obj1 = 0 ;
51445 PyObject * obj2 = 0 ;
51446 PyObject * obj3 = 0 ;
51447 char * kwnames[] = {
51448 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
51449 };
51450
51451 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51452 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51453 if (!SWIG_IsOK(res1)) {
51454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51455 }
51456 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51457 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51458 if (!SWIG_IsOK(res2)) {
51459 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51460 }
51461 arg2 = reinterpret_cast< wxWindow * >(argp2);
51462 ecode3 = SWIG_AsVal_int(obj2, &val3);
51463 if (!SWIG_IsOK(ecode3)) {
51464 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "3"" of type '" "wxEdge""'");
51465 }
51466 arg3 = static_cast< wxEdge >(val3);
51467 ecode4 = SWIG_AsVal_int(obj3, &val4);
51468 if (!SWIG_IsOK(ecode4)) {
51469 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "4"" of type '" "int""'");
51470 }
51471 arg4 = static_cast< int >(val4);
51472 {
51473 PyThreadState* __tstate = wxPyBeginAllowThreads();
51474 (arg1)->PercentOf(arg2,arg3,arg4);
51475 wxPyEndAllowThreads(__tstate);
51476 if (PyErr_Occurred()) SWIG_fail;
51477 }
51478 resultobj = SWIG_Py_Void();
51479 return resultobj;
51480 fail:
51481 return NULL;
51482 }
51483
51484
51485 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51486 PyObject *resultobj = 0;
51487 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51488 int arg2 ;
51489 void *argp1 = 0 ;
51490 int res1 = 0 ;
51491 int val2 ;
51492 int ecode2 = 0 ;
51493 PyObject * obj0 = 0 ;
51494 PyObject * obj1 = 0 ;
51495 char * kwnames[] = {
51496 (char *) "self",(char *) "val", NULL
51497 };
51498
51499 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) SWIG_fail;
51500 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51501 if (!SWIG_IsOK(res1)) {
51502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51503 }
51504 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51505 ecode2 = SWIG_AsVal_int(obj1, &val2);
51506 if (!SWIG_IsOK(ecode2)) {
51507 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "2"" of type '" "int""'");
51508 }
51509 arg2 = static_cast< int >(val2);
51510 {
51511 PyThreadState* __tstate = wxPyBeginAllowThreads();
51512 (arg1)->Absolute(arg2);
51513 wxPyEndAllowThreads(__tstate);
51514 if (PyErr_Occurred()) SWIG_fail;
51515 }
51516 resultobj = SWIG_Py_Void();
51517 return resultobj;
51518 fail:
51519 return NULL;
51520 }
51521
51522
51523 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51524 PyObject *resultobj = 0;
51525 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51526 void *argp1 = 0 ;
51527 int res1 = 0 ;
51528 PyObject *swig_obj[1] ;
51529
51530 if (!args) SWIG_fail;
51531 swig_obj[0] = args;
51532 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51533 if (!SWIG_IsOK(res1)) {
51534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Unconstrained" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51535 }
51536 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51537 {
51538 PyThreadState* __tstate = wxPyBeginAllowThreads();
51539 (arg1)->Unconstrained();
51540 wxPyEndAllowThreads(__tstate);
51541 if (PyErr_Occurred()) SWIG_fail;
51542 }
51543 resultobj = SWIG_Py_Void();
51544 return resultobj;
51545 fail:
51546 return NULL;
51547 }
51548
51549
51550 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51551 PyObject *resultobj = 0;
51552 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51553 void *argp1 = 0 ;
51554 int res1 = 0 ;
51555 PyObject *swig_obj[1] ;
51556
51557 if (!args) SWIG_fail;
51558 swig_obj[0] = args;
51559 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51560 if (!SWIG_IsOK(res1)) {
51561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_AsIs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51562 }
51563 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51564 {
51565 PyThreadState* __tstate = wxPyBeginAllowThreads();
51566 (arg1)->AsIs();
51567 wxPyEndAllowThreads(__tstate);
51568 if (PyErr_Occurred()) SWIG_fail;
51569 }
51570 resultobj = SWIG_Py_Void();
51571 return resultobj;
51572 fail:
51573 return NULL;
51574 }
51575
51576
51577 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51578 PyObject *resultobj = 0;
51579 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51580 wxWindow *result = 0 ;
51581 void *argp1 = 0 ;
51582 int res1 = 0 ;
51583 PyObject *swig_obj[1] ;
51584
51585 if (!args) SWIG_fail;
51586 swig_obj[0] = args;
51587 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51588 if (!SWIG_IsOK(res1)) {
51589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherWindow" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51590 }
51591 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51592 {
51593 PyThreadState* __tstate = wxPyBeginAllowThreads();
51594 result = (wxWindow *)(arg1)->GetOtherWindow();
51595 wxPyEndAllowThreads(__tstate);
51596 if (PyErr_Occurred()) SWIG_fail;
51597 }
51598 {
51599 resultobj = wxPyMake_wxObject(result, 0);
51600 }
51601 return resultobj;
51602 fail:
51603 return NULL;
51604 }
51605
51606
51607 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51608 PyObject *resultobj = 0;
51609 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51610 wxEdge result;
51611 void *argp1 = 0 ;
51612 int res1 = 0 ;
51613 PyObject *swig_obj[1] ;
51614
51615 if (!args) SWIG_fail;
51616 swig_obj[0] = args;
51617 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51618 if (!SWIG_IsOK(res1)) {
51619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMyEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51620 }
51621 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51622 {
51623 PyThreadState* __tstate = wxPyBeginAllowThreads();
51624 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
51625 wxPyEndAllowThreads(__tstate);
51626 if (PyErr_Occurred()) SWIG_fail;
51627 }
51628 resultobj = SWIG_From_int(static_cast< int >(result));
51629 return resultobj;
51630 fail:
51631 return NULL;
51632 }
51633
51634
51635 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51636 PyObject *resultobj = 0;
51637 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51638 wxEdge arg2 ;
51639 void *argp1 = 0 ;
51640 int res1 = 0 ;
51641 int val2 ;
51642 int ecode2 = 0 ;
51643 PyObject * obj0 = 0 ;
51644 PyObject * obj1 = 0 ;
51645 char * kwnames[] = {
51646 (char *) "self",(char *) "which", NULL
51647 };
51648
51649 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) SWIG_fail;
51650 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51651 if (!SWIG_IsOK(res1)) {
51652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51653 }
51654 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51655 ecode2 = SWIG_AsVal_int(obj1, &val2);
51656 if (!SWIG_IsOK(ecode2)) {
51657 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
51658 }
51659 arg2 = static_cast< wxEdge >(val2);
51660 {
51661 PyThreadState* __tstate = wxPyBeginAllowThreads();
51662 (arg1)->SetEdge(arg2);
51663 wxPyEndAllowThreads(__tstate);
51664 if (PyErr_Occurred()) SWIG_fail;
51665 }
51666 resultobj = SWIG_Py_Void();
51667 return resultobj;
51668 fail:
51669 return NULL;
51670 }
51671
51672
51673 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51674 PyObject *resultobj = 0;
51675 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51676 int arg2 ;
51677 void *argp1 = 0 ;
51678 int res1 = 0 ;
51679 int val2 ;
51680 int ecode2 = 0 ;
51681 PyObject * obj0 = 0 ;
51682 PyObject * obj1 = 0 ;
51683 char * kwnames[] = {
51684 (char *) "self",(char *) "v", NULL
51685 };
51686
51687 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
51688 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51689 if (!SWIG_IsOK(res1)) {
51690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51691 }
51692 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51693 ecode2 = SWIG_AsVal_int(obj1, &val2);
51694 if (!SWIG_IsOK(ecode2)) {
51695 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "2"" of type '" "int""'");
51696 }
51697 arg2 = static_cast< int >(val2);
51698 {
51699 PyThreadState* __tstate = wxPyBeginAllowThreads();
51700 (arg1)->SetValue(arg2);
51701 wxPyEndAllowThreads(__tstate);
51702 if (PyErr_Occurred()) SWIG_fail;
51703 }
51704 resultobj = SWIG_Py_Void();
51705 return resultobj;
51706 fail:
51707 return NULL;
51708 }
51709
51710
51711 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51712 PyObject *resultobj = 0;
51713 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51714 int result;
51715 void *argp1 = 0 ;
51716 int res1 = 0 ;
51717 PyObject *swig_obj[1] ;
51718
51719 if (!args) SWIG_fail;
51720 swig_obj[0] = args;
51721 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51722 if (!SWIG_IsOK(res1)) {
51723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51724 }
51725 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51726 {
51727 PyThreadState* __tstate = wxPyBeginAllowThreads();
51728 result = (int)(arg1)->GetMargin();
51729 wxPyEndAllowThreads(__tstate);
51730 if (PyErr_Occurred()) SWIG_fail;
51731 }
51732 resultobj = SWIG_From_int(static_cast< int >(result));
51733 return resultobj;
51734 fail:
51735 return NULL;
51736 }
51737
51738
51739 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51740 PyObject *resultobj = 0;
51741 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51742 int arg2 ;
51743 void *argp1 = 0 ;
51744 int res1 = 0 ;
51745 int val2 ;
51746 int ecode2 = 0 ;
51747 PyObject * obj0 = 0 ;
51748 PyObject * obj1 = 0 ;
51749 char * kwnames[] = {
51750 (char *) "self",(char *) "m", NULL
51751 };
51752
51753 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) SWIG_fail;
51754 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51755 if (!SWIG_IsOK(res1)) {
51756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51757 }
51758 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51759 ecode2 = SWIG_AsVal_int(obj1, &val2);
51760 if (!SWIG_IsOK(ecode2)) {
51761 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "2"" of type '" "int""'");
51762 }
51763 arg2 = static_cast< int >(val2);
51764 {
51765 PyThreadState* __tstate = wxPyBeginAllowThreads();
51766 (arg1)->SetMargin(arg2);
51767 wxPyEndAllowThreads(__tstate);
51768 if (PyErr_Occurred()) SWIG_fail;
51769 }
51770 resultobj = SWIG_Py_Void();
51771 return resultobj;
51772 fail:
51773 return NULL;
51774 }
51775
51776
51777 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51778 PyObject *resultobj = 0;
51779 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51780 int result;
51781 void *argp1 = 0 ;
51782 int res1 = 0 ;
51783 PyObject *swig_obj[1] ;
51784
51785 if (!args) SWIG_fail;
51786 swig_obj[0] = args;
51787 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51788 if (!SWIG_IsOK(res1)) {
51789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51790 }
51791 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51792 {
51793 PyThreadState* __tstate = wxPyBeginAllowThreads();
51794 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
51795 wxPyEndAllowThreads(__tstate);
51796 if (PyErr_Occurred()) SWIG_fail;
51797 }
51798 resultobj = SWIG_From_int(static_cast< int >(result));
51799 return resultobj;
51800 fail:
51801 return NULL;
51802 }
51803
51804
51805 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51806 PyObject *resultobj = 0;
51807 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51808 int result;
51809 void *argp1 = 0 ;
51810 int res1 = 0 ;
51811 PyObject *swig_obj[1] ;
51812
51813 if (!args) SWIG_fail;
51814 swig_obj[0] = args;
51815 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51816 if (!SWIG_IsOK(res1)) {
51817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetPercent" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51818 }
51819 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51820 {
51821 PyThreadState* __tstate = wxPyBeginAllowThreads();
51822 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
51823 wxPyEndAllowThreads(__tstate);
51824 if (PyErr_Occurred()) SWIG_fail;
51825 }
51826 resultobj = SWIG_From_int(static_cast< int >(result));
51827 return resultobj;
51828 fail:
51829 return NULL;
51830 }
51831
51832
51833 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51834 PyObject *resultobj = 0;
51835 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51836 int result;
51837 void *argp1 = 0 ;
51838 int res1 = 0 ;
51839 PyObject *swig_obj[1] ;
51840
51841 if (!args) SWIG_fail;
51842 swig_obj[0] = args;
51843 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51844 if (!SWIG_IsOK(res1)) {
51845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51846 }
51847 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51848 {
51849 PyThreadState* __tstate = wxPyBeginAllowThreads();
51850 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
51851 wxPyEndAllowThreads(__tstate);
51852 if (PyErr_Occurred()) SWIG_fail;
51853 }
51854 resultobj = SWIG_From_int(static_cast< int >(result));
51855 return resultobj;
51856 fail:
51857 return NULL;
51858 }
51859
51860
51861 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51862 PyObject *resultobj = 0;
51863 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51864 bool result;
51865 void *argp1 = 0 ;
51866 int res1 = 0 ;
51867 PyObject *swig_obj[1] ;
51868
51869 if (!args) SWIG_fail;
51870 swig_obj[0] = args;
51871 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51872 if (!SWIG_IsOK(res1)) {
51873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51874 }
51875 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51876 {
51877 PyThreadState* __tstate = wxPyBeginAllowThreads();
51878 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
51879 wxPyEndAllowThreads(__tstate);
51880 if (PyErr_Occurred()) SWIG_fail;
51881 }
51882 {
51883 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51884 }
51885 return resultobj;
51886 fail:
51887 return NULL;
51888 }
51889
51890
51891 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51892 PyObject *resultobj = 0;
51893 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51894 bool arg2 ;
51895 void *argp1 = 0 ;
51896 int res1 = 0 ;
51897 bool val2 ;
51898 int ecode2 = 0 ;
51899 PyObject * obj0 = 0 ;
51900 PyObject * obj1 = 0 ;
51901 char * kwnames[] = {
51902 (char *) "self",(char *) "d", NULL
51903 };
51904
51905 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) SWIG_fail;
51906 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51907 if (!SWIG_IsOK(res1)) {
51908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51909 }
51910 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51911 ecode2 = SWIG_AsVal_bool(obj1, &val2);
51912 if (!SWIG_IsOK(ecode2)) {
51913 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "2"" of type '" "bool""'");
51914 }
51915 arg2 = static_cast< bool >(val2);
51916 {
51917 PyThreadState* __tstate = wxPyBeginAllowThreads();
51918 (arg1)->SetDone(arg2);
51919 wxPyEndAllowThreads(__tstate);
51920 if (PyErr_Occurred()) SWIG_fail;
51921 }
51922 resultobj = SWIG_Py_Void();
51923 return resultobj;
51924 fail:
51925 return NULL;
51926 }
51927
51928
51929 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51930 PyObject *resultobj = 0;
51931 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51932 wxRelationship result;
51933 void *argp1 = 0 ;
51934 int res1 = 0 ;
51935 PyObject *swig_obj[1] ;
51936
51937 if (!args) SWIG_fail;
51938 swig_obj[0] = args;
51939 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51940 if (!SWIG_IsOK(res1)) {
51941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51942 }
51943 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51944 {
51945 PyThreadState* __tstate = wxPyBeginAllowThreads();
51946 result = (wxRelationship)(arg1)->GetRelationship();
51947 wxPyEndAllowThreads(__tstate);
51948 if (PyErr_Occurred()) SWIG_fail;
51949 }
51950 resultobj = SWIG_From_int(static_cast< int >(result));
51951 return resultobj;
51952 fail:
51953 return NULL;
51954 }
51955
51956
51957 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51958 PyObject *resultobj = 0;
51959 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51960 wxRelationship arg2 ;
51961 void *argp1 = 0 ;
51962 int res1 = 0 ;
51963 int val2 ;
51964 int ecode2 = 0 ;
51965 PyObject * obj0 = 0 ;
51966 PyObject * obj1 = 0 ;
51967 char * kwnames[] = {
51968 (char *) "self",(char *) "r", NULL
51969 };
51970
51971 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) SWIG_fail;
51972 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51973 if (!SWIG_IsOK(res1)) {
51974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51975 }
51976 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51977 ecode2 = SWIG_AsVal_int(obj1, &val2);
51978 if (!SWIG_IsOK(ecode2)) {
51979 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "2"" of type '" "wxRelationship""'");
51980 }
51981 arg2 = static_cast< wxRelationship >(val2);
51982 {
51983 PyThreadState* __tstate = wxPyBeginAllowThreads();
51984 (arg1)->SetRelationship(arg2);
51985 wxPyEndAllowThreads(__tstate);
51986 if (PyErr_Occurred()) SWIG_fail;
51987 }
51988 resultobj = SWIG_Py_Void();
51989 return resultobj;
51990 fail:
51991 return NULL;
51992 }
51993
51994
51995 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51996 PyObject *resultobj = 0;
51997 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51998 wxWindow *arg2 = (wxWindow *) 0 ;
51999 bool result;
52000 void *argp1 = 0 ;
52001 int res1 = 0 ;
52002 void *argp2 = 0 ;
52003 int res2 = 0 ;
52004 PyObject * obj0 = 0 ;
52005 PyObject * obj1 = 0 ;
52006 char * kwnames[] = {
52007 (char *) "self",(char *) "otherW", NULL
52008 };
52009
52010 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) SWIG_fail;
52011 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52012 if (!SWIG_IsOK(res1)) {
52013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52014 }
52015 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52016 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52017 if (!SWIG_IsOK(res2)) {
52018 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "2"" of type '" "wxWindow *""'");
52019 }
52020 arg2 = reinterpret_cast< wxWindow * >(argp2);
52021 {
52022 PyThreadState* __tstate = wxPyBeginAllowThreads();
52023 result = (bool)(arg1)->ResetIfWin(arg2);
52024 wxPyEndAllowThreads(__tstate);
52025 if (PyErr_Occurred()) SWIG_fail;
52026 }
52027 {
52028 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52029 }
52030 return resultobj;
52031 fail:
52032 return NULL;
52033 }
52034
52035
52036 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52037 PyObject *resultobj = 0;
52038 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52039 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
52040 wxWindow *arg3 = (wxWindow *) 0 ;
52041 bool result;
52042 void *argp1 = 0 ;
52043 int res1 = 0 ;
52044 void *argp2 = 0 ;
52045 int res2 = 0 ;
52046 void *argp3 = 0 ;
52047 int res3 = 0 ;
52048 PyObject * obj0 = 0 ;
52049 PyObject * obj1 = 0 ;
52050 PyObject * obj2 = 0 ;
52051 char * kwnames[] = {
52052 (char *) "self",(char *) "constraints",(char *) "win", NULL
52053 };
52054
52055 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52056 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52057 if (!SWIG_IsOK(res1)) {
52058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52059 }
52060 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52061 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52062 if (!SWIG_IsOK(res2)) {
52063 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
52064 }
52065 arg2 = reinterpret_cast< wxLayoutConstraints * >(argp2);
52066 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
52067 if (!SWIG_IsOK(res3)) {
52068 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "3"" of type '" "wxWindow *""'");
52069 }
52070 arg3 = reinterpret_cast< wxWindow * >(argp3);
52071 {
52072 PyThreadState* __tstate = wxPyBeginAllowThreads();
52073 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
52074 wxPyEndAllowThreads(__tstate);
52075 if (PyErr_Occurred()) SWIG_fail;
52076 }
52077 {
52078 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52079 }
52080 return resultobj;
52081 fail:
52082 return NULL;
52083 }
52084
52085
52086 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52087 PyObject *resultobj = 0;
52088 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52089 wxEdge arg2 ;
52090 wxWindow *arg3 = (wxWindow *) 0 ;
52091 wxWindow *arg4 = (wxWindow *) 0 ;
52092 int result;
52093 void *argp1 = 0 ;
52094 int res1 = 0 ;
52095 int val2 ;
52096 int ecode2 = 0 ;
52097 void *argp3 = 0 ;
52098 int res3 = 0 ;
52099 void *argp4 = 0 ;
52100 int res4 = 0 ;
52101 PyObject * obj0 = 0 ;
52102 PyObject * obj1 = 0 ;
52103 PyObject * obj2 = 0 ;
52104 PyObject * obj3 = 0 ;
52105 char * kwnames[] = {
52106 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
52107 };
52108
52109 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52110 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52111 if (!SWIG_IsOK(res1)) {
52112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52113 }
52114 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52115 ecode2 = SWIG_AsVal_int(obj1, &val2);
52116 if (!SWIG_IsOK(ecode2)) {
52117 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
52118 }
52119 arg2 = static_cast< wxEdge >(val2);
52120 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
52121 if (!SWIG_IsOK(res3)) {
52122 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "3"" of type '" "wxWindow *""'");
52123 }
52124 arg3 = reinterpret_cast< wxWindow * >(argp3);
52125 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
52126 if (!SWIG_IsOK(res4)) {
52127 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "4"" of type '" "wxWindow *""'");
52128 }
52129 arg4 = reinterpret_cast< wxWindow * >(argp4);
52130 {
52131 PyThreadState* __tstate = wxPyBeginAllowThreads();
52132 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge(arg2,arg3,arg4);
52133 wxPyEndAllowThreads(__tstate);
52134 if (PyErr_Occurred()) SWIG_fail;
52135 }
52136 resultobj = SWIG_From_int(static_cast< int >(result));
52137 return resultobj;
52138 fail:
52139 return NULL;
52140 }
52141
52142
52143 SWIGINTERN PyObject *IndividualLayoutConstraint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52144 PyObject *obj;
52145 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52146 SWIG_TypeNewClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_NewClientData(obj));
52147 return SWIG_Py_Void();
52148 }
52149
52150 SWIGINTERN PyObject *_wrap_LayoutConstraints_left_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52151 PyObject *resultobj = 0;
52152 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52153 wxIndividualLayoutConstraint *result = 0 ;
52154 void *argp1 = 0 ;
52155 int res1 = 0 ;
52156 PyObject *swig_obj[1] ;
52157
52158 if (!args) SWIG_fail;
52159 swig_obj[0] = args;
52160 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52161 if (!SWIG_IsOK(res1)) {
52162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_left_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52163 }
52164 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52165 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
52166 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52167 return resultobj;
52168 fail:
52169 return NULL;
52170 }
52171
52172
52173 SWIGINTERN PyObject *_wrap_LayoutConstraints_top_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52174 PyObject *resultobj = 0;
52175 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52176 wxIndividualLayoutConstraint *result = 0 ;
52177 void *argp1 = 0 ;
52178 int res1 = 0 ;
52179 PyObject *swig_obj[1] ;
52180
52181 if (!args) SWIG_fail;
52182 swig_obj[0] = args;
52183 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52184 if (!SWIG_IsOK(res1)) {
52185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_top_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52186 }
52187 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52188 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
52189 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52190 return resultobj;
52191 fail:
52192 return NULL;
52193 }
52194
52195
52196 SWIGINTERN PyObject *_wrap_LayoutConstraints_right_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52197 PyObject *resultobj = 0;
52198 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52199 wxIndividualLayoutConstraint *result = 0 ;
52200 void *argp1 = 0 ;
52201 int res1 = 0 ;
52202 PyObject *swig_obj[1] ;
52203
52204 if (!args) SWIG_fail;
52205 swig_obj[0] = args;
52206 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52207 if (!SWIG_IsOK(res1)) {
52208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_right_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52209 }
52210 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52211 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
52212 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52213 return resultobj;
52214 fail:
52215 return NULL;
52216 }
52217
52218
52219 SWIGINTERN PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52220 PyObject *resultobj = 0;
52221 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52222 wxIndividualLayoutConstraint *result = 0 ;
52223 void *argp1 = 0 ;
52224 int res1 = 0 ;
52225 PyObject *swig_obj[1] ;
52226
52227 if (!args) SWIG_fail;
52228 swig_obj[0] = args;
52229 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52230 if (!SWIG_IsOK(res1)) {
52231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_bottom_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52232 }
52233 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52234 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
52235 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52236 return resultobj;
52237 fail:
52238 return NULL;
52239 }
52240
52241
52242 SWIGINTERN PyObject *_wrap_LayoutConstraints_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52243 PyObject *resultobj = 0;
52244 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52245 wxIndividualLayoutConstraint *result = 0 ;
52246 void *argp1 = 0 ;
52247 int res1 = 0 ;
52248 PyObject *swig_obj[1] ;
52249
52250 if (!args) SWIG_fail;
52251 swig_obj[0] = args;
52252 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52253 if (!SWIG_IsOK(res1)) {
52254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_width_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52255 }
52256 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52257 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
52258 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52259 return resultobj;
52260 fail:
52261 return NULL;
52262 }
52263
52264
52265 SWIGINTERN PyObject *_wrap_LayoutConstraints_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52266 PyObject *resultobj = 0;
52267 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52268 wxIndividualLayoutConstraint *result = 0 ;
52269 void *argp1 = 0 ;
52270 int res1 = 0 ;
52271 PyObject *swig_obj[1] ;
52272
52273 if (!args) SWIG_fail;
52274 swig_obj[0] = args;
52275 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52276 if (!SWIG_IsOK(res1)) {
52277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_height_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52278 }
52279 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52280 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
52281 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52282 return resultobj;
52283 fail:
52284 return NULL;
52285 }
52286
52287
52288 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52289 PyObject *resultobj = 0;
52290 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52291 wxIndividualLayoutConstraint *result = 0 ;
52292 void *argp1 = 0 ;
52293 int res1 = 0 ;
52294 PyObject *swig_obj[1] ;
52295
52296 if (!args) SWIG_fail;
52297 swig_obj[0] = args;
52298 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52299 if (!SWIG_IsOK(res1)) {
52300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreX_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52301 }
52302 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52303 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
52304 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52305 return resultobj;
52306 fail:
52307 return NULL;
52308 }
52309
52310
52311 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52312 PyObject *resultobj = 0;
52313 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52314 wxIndividualLayoutConstraint *result = 0 ;
52315 void *argp1 = 0 ;
52316 int res1 = 0 ;
52317 PyObject *swig_obj[1] ;
52318
52319 if (!args) SWIG_fail;
52320 swig_obj[0] = args;
52321 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52322 if (!SWIG_IsOK(res1)) {
52323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreY_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52324 }
52325 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52326 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
52327 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52328 return resultobj;
52329 fail:
52330 return NULL;
52331 }
52332
52333
52334 SWIGINTERN PyObject *_wrap_new_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52335 PyObject *resultobj = 0;
52336 wxLayoutConstraints *result = 0 ;
52337
52338 if (!SWIG_Python_UnpackTuple(args,"new_LayoutConstraints",0,0,0)) SWIG_fail;
52339 {
52340 PyThreadState* __tstate = wxPyBeginAllowThreads();
52341 result = (wxLayoutConstraints *)new wxLayoutConstraints();
52342 wxPyEndAllowThreads(__tstate);
52343 if (PyErr_Occurred()) SWIG_fail;
52344 }
52345 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_NEW | 0 );
52346 return resultobj;
52347 fail:
52348 return NULL;
52349 }
52350
52351
52352 SWIGINTERN PyObject *_wrap_delete_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52353 PyObject *resultobj = 0;
52354 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52355 void *argp1 = 0 ;
52356 int res1 = 0 ;
52357 PyObject *swig_obj[1] ;
52358
52359 if (!args) SWIG_fail;
52360 swig_obj[0] = args;
52361 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
52362 if (!SWIG_IsOK(res1)) {
52363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LayoutConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52364 }
52365 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52366 {
52367 PyThreadState* __tstate = wxPyBeginAllowThreads();
52368 delete arg1;
52369
52370 wxPyEndAllowThreads(__tstate);
52371 if (PyErr_Occurred()) SWIG_fail;
52372 }
52373 resultobj = SWIG_Py_Void();
52374 return resultobj;
52375 fail:
52376 return NULL;
52377 }
52378
52379
52380 SWIGINTERN PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52381 PyObject *resultobj = 0;
52382 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52383 wxWindow *arg2 = (wxWindow *) 0 ;
52384 int *arg3 = (int *) 0 ;
52385 bool result;
52386 void *argp1 = 0 ;
52387 int res1 = 0 ;
52388 void *argp2 = 0 ;
52389 int res2 = 0 ;
52390 int temp3 ;
52391 int res3 = SWIG_TMPOBJ ;
52392 PyObject * obj0 = 0 ;
52393 PyObject * obj1 = 0 ;
52394 char * kwnames[] = {
52395 (char *) "self",(char *) "win", NULL
52396 };
52397
52398 arg3 = &temp3;
52399 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
52400 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52401 if (!SWIG_IsOK(res1)) {
52402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52403 }
52404 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52405 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52406 if (!SWIG_IsOK(res2)) {
52407 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "2"" of type '" "wxWindow *""'");
52408 }
52409 arg2 = reinterpret_cast< wxWindow * >(argp2);
52410 {
52411 PyThreadState* __tstate = wxPyBeginAllowThreads();
52412 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
52413 wxPyEndAllowThreads(__tstate);
52414 if (PyErr_Occurred()) SWIG_fail;
52415 }
52416 {
52417 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52418 }
52419 if (SWIG_IsTmpObj(res3)) {
52420 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
52421 } else {
52422 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
52423 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
52424 }
52425 return resultobj;
52426 fail:
52427 return NULL;
52428 }
52429
52430
52431 SWIGINTERN PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52432 PyObject *resultobj = 0;
52433 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52434 bool result;
52435 void *argp1 = 0 ;
52436 int res1 = 0 ;
52437 PyObject *swig_obj[1] ;
52438
52439 if (!args) SWIG_fail;
52440 swig_obj[0] = args;
52441 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52442 if (!SWIG_IsOK(res1)) {
52443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_AreSatisfied" "', expected argument " "1"" of type '" "wxLayoutConstraints const *""'");
52444 }
52445 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52446 {
52447 PyThreadState* __tstate = wxPyBeginAllowThreads();
52448 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
52449 wxPyEndAllowThreads(__tstate);
52450 if (PyErr_Occurred()) SWIG_fail;
52451 }
52452 {
52453 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52454 }
52455 return resultobj;
52456 fail:
52457 return NULL;
52458 }
52459
52460
52461 SWIGINTERN PyObject *LayoutConstraints_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52462 PyObject *obj;
52463 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52464 SWIG_TypeNewClientData(SWIGTYPE_p_wxLayoutConstraints, SWIG_NewClientData(obj));
52465 return SWIG_Py_Void();
52466 }
52467
52468 SWIGINTERN PyObject *LayoutConstraints_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52469 return SWIG_Python_InitShadowInstance(args);
52470 }
52471
52472 static PyMethodDef SwigMethods[] = {
52473 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
52474 { (char *)"Object_GetClassName", (PyCFunction)_wrap_Object_GetClassName, METH_O, NULL},
52475 { (char *)"Object_Destroy", (PyCFunction)_wrap_Object_Destroy, METH_O, NULL},
52476 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
52477 { (char *)"Size_width_set", _wrap_Size_width_set, METH_VARARGS, NULL},
52478 { (char *)"Size_width_get", (PyCFunction)_wrap_Size_width_get, METH_O, NULL},
52479 { (char *)"Size_height_set", _wrap_Size_height_set, METH_VARARGS, NULL},
52480 { (char *)"Size_height_get", (PyCFunction)_wrap_Size_height_get, METH_O, NULL},
52481 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
52482 { (char *)"delete_Size", (PyCFunction)_wrap_delete_Size, METH_O, NULL},
52483 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52484 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52485 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52486 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52487 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
52488 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
52489 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52490 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
52491 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
52492 { (char *)"Size_GetWidth", (PyCFunction)_wrap_Size_GetWidth, METH_O, NULL},
52493 { (char *)"Size_GetHeight", (PyCFunction)_wrap_Size_GetHeight, METH_O, NULL},
52494 { (char *)"Size_IsFullySpecified", (PyCFunction)_wrap_Size_IsFullySpecified, METH_O, NULL},
52495 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
52496 { (char *)"Size_Get", (PyCFunction)_wrap_Size_Get, METH_O, NULL},
52497 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
52498 { (char *)"Size_swiginit", Size_swiginit, METH_VARARGS, NULL},
52499 { (char *)"RealPoint_x_set", _wrap_RealPoint_x_set, METH_VARARGS, NULL},
52500 { (char *)"RealPoint_x_get", (PyCFunction)_wrap_RealPoint_x_get, METH_O, NULL},
52501 { (char *)"RealPoint_y_set", _wrap_RealPoint_y_set, METH_VARARGS, NULL},
52502 { (char *)"RealPoint_y_get", (PyCFunction)_wrap_RealPoint_y_get, METH_O, NULL},
52503 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
52504 { (char *)"delete_RealPoint", (PyCFunction)_wrap_delete_RealPoint, METH_O, NULL},
52505 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52506 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52507 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52508 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52509 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52510 { (char *)"RealPoint_Get", (PyCFunction)_wrap_RealPoint_Get, METH_O, NULL},
52511 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
52512 { (char *)"RealPoint_swiginit", RealPoint_swiginit, METH_VARARGS, NULL},
52513 { (char *)"Point_x_set", _wrap_Point_x_set, METH_VARARGS, NULL},
52514 { (char *)"Point_x_get", (PyCFunction)_wrap_Point_x_get, METH_O, NULL},
52515 { (char *)"Point_y_set", _wrap_Point_y_set, METH_VARARGS, NULL},
52516 { (char *)"Point_y_get", (PyCFunction)_wrap_Point_y_get, METH_O, NULL},
52517 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
52518 { (char *)"delete_Point", (PyCFunction)_wrap_delete_Point, METH_O, NULL},
52519 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52520 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52521 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52522 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52523 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52524 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
52525 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52526 { (char *)"Point_Get", (PyCFunction)_wrap_Point_Get, METH_O, NULL},
52527 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
52528 { (char *)"Point_swiginit", Point_swiginit, METH_VARARGS, NULL},
52529 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
52530 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
52531 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
52532 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
52533 { (char *)"delete_Rect", (PyCFunction)_wrap_delete_Rect, METH_O, NULL},
52534 { (char *)"Rect_GetX", (PyCFunction)_wrap_Rect_GetX, METH_O, NULL},
52535 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
52536 { (char *)"Rect_GetY", (PyCFunction)_wrap_Rect_GetY, METH_O, NULL},
52537 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
52538 { (char *)"Rect_GetWidth", (PyCFunction)_wrap_Rect_GetWidth, METH_O, NULL},
52539 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
52540 { (char *)"Rect_GetHeight", (PyCFunction)_wrap_Rect_GetHeight, METH_O, NULL},
52541 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
52542 { (char *)"Rect_GetPosition", (PyCFunction)_wrap_Rect_GetPosition, METH_O, NULL},
52543 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
52544 { (char *)"Rect_GetSize", (PyCFunction)_wrap_Rect_GetSize, METH_O, NULL},
52545 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
52546 { (char *)"Rect_IsEmpty", (PyCFunction)_wrap_Rect_IsEmpty, METH_O, NULL},
52547 { (char *)"Rect_GetTopLeft", (PyCFunction)_wrap_Rect_GetTopLeft, METH_O, NULL},
52548 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
52549 { (char *)"Rect_GetBottomRight", (PyCFunction)_wrap_Rect_GetBottomRight, METH_O, NULL},
52550 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
52551 { (char *)"Rect_GetLeft", (PyCFunction)_wrap_Rect_GetLeft, METH_O, NULL},
52552 { (char *)"Rect_GetTop", (PyCFunction)_wrap_Rect_GetTop, METH_O, NULL},
52553 { (char *)"Rect_GetBottom", (PyCFunction)_wrap_Rect_GetBottom, METH_O, NULL},
52554 { (char *)"Rect_GetRight", (PyCFunction)_wrap_Rect_GetRight, METH_O, NULL},
52555 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
52556 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
52557 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
52558 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
52559 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
52560 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
52561 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
52562 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
52563 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
52564 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
52565 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52566 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52567 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52568 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52569 { (char *)"Rect_InsideXY", (PyCFunction) _wrap_Rect_InsideXY, METH_VARARGS | METH_KEYWORDS, NULL},
52570 { (char *)"Rect_Inside", (PyCFunction) _wrap_Rect_Inside, METH_VARARGS | METH_KEYWORDS, NULL},
52571 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
52572 { (char *)"Rect_CenterIn", (PyCFunction) _wrap_Rect_CenterIn, METH_VARARGS | METH_KEYWORDS, NULL},
52573 { (char *)"Rect_x_set", _wrap_Rect_x_set, METH_VARARGS, NULL},
52574 { (char *)"Rect_x_get", (PyCFunction)_wrap_Rect_x_get, METH_O, NULL},
52575 { (char *)"Rect_y_set", _wrap_Rect_y_set, METH_VARARGS, NULL},
52576 { (char *)"Rect_y_get", (PyCFunction)_wrap_Rect_y_get, METH_O, NULL},
52577 { (char *)"Rect_width_set", _wrap_Rect_width_set, METH_VARARGS, NULL},
52578 { (char *)"Rect_width_get", (PyCFunction)_wrap_Rect_width_get, METH_O, NULL},
52579 { (char *)"Rect_height_set", _wrap_Rect_height_set, METH_VARARGS, NULL},
52580 { (char *)"Rect_height_get", (PyCFunction)_wrap_Rect_height_get, METH_O, NULL},
52581 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52582 { (char *)"Rect_Get", (PyCFunction)_wrap_Rect_Get, METH_O, NULL},
52583 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
52584 { (char *)"Rect_swiginit", Rect_swiginit, METH_VARARGS, NULL},
52585 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
52586 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
52587 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
52588 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
52589 { (char *)"Point2D_GetFloor", (PyCFunction)_wrap_Point2D_GetFloor, METH_O, NULL},
52590 { (char *)"Point2D_GetRounded", (PyCFunction)_wrap_Point2D_GetRounded, METH_O, NULL},
52591 { (char *)"Point2D_GetVectorLength", (PyCFunction)_wrap_Point2D_GetVectorLength, METH_O, NULL},
52592 { (char *)"Point2D_GetVectorAngle", (PyCFunction)_wrap_Point2D_GetVectorAngle, METH_O, NULL},
52593 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
52594 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
52595 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
52596 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
52597 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
52598 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
52599 { (char *)"Point2D___neg__", (PyCFunction)_wrap_Point2D___neg__, METH_O, NULL},
52600 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52601 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
52602 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
52603 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
52604 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52605 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52606 { (char *)"Point2D_x_set", _wrap_Point2D_x_set, METH_VARARGS, NULL},
52607 { (char *)"Point2D_x_get", (PyCFunction)_wrap_Point2D_x_get, METH_O, NULL},
52608 { (char *)"Point2D_y_set", _wrap_Point2D_y_set, METH_VARARGS, NULL},
52609 { (char *)"Point2D_y_get", (PyCFunction)_wrap_Point2D_y_get, METH_O, NULL},
52610 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52611 { (char *)"Point2D_Get", (PyCFunction)_wrap_Point2D_Get, METH_O, NULL},
52612 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
52613 { (char *)"Point2D_swiginit", Point2D_swiginit, METH_VARARGS, NULL},
52614 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
52615 { (char *)"delete_InputStream", (PyCFunction)_wrap_delete_InputStream, METH_O, NULL},
52616 { (char *)"InputStream_close", (PyCFunction)_wrap_InputStream_close, METH_O, NULL},
52617 { (char *)"InputStream_flush", (PyCFunction)_wrap_InputStream_flush, METH_O, NULL},
52618 { (char *)"InputStream_eof", (PyCFunction)_wrap_InputStream_eof, METH_O, NULL},
52619 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
52620 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
52621 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
52622 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
52623 { (char *)"InputStream_tell", (PyCFunction)_wrap_InputStream_tell, METH_O, NULL},
52624 { (char *)"InputStream_Peek", (PyCFunction)_wrap_InputStream_Peek, METH_O, NULL},
52625 { (char *)"InputStream_GetC", (PyCFunction)_wrap_InputStream_GetC, METH_O, NULL},
52626 { (char *)"InputStream_LastRead", (PyCFunction)_wrap_InputStream_LastRead, METH_O, NULL},
52627 { (char *)"InputStream_CanRead", (PyCFunction)_wrap_InputStream_CanRead, METH_O, NULL},
52628 { (char *)"InputStream_Eof", (PyCFunction)_wrap_InputStream_Eof, METH_O, NULL},
52629 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
52630 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
52631 { (char *)"InputStream_TellI", (PyCFunction)_wrap_InputStream_TellI, METH_O, NULL},
52632 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
52633 { (char *)"InputStream_swiginit", InputStream_swiginit, METH_VARARGS, NULL},
52634 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
52635 { (char *)"OutputStream_LastWrite", (PyCFunction)_wrap_OutputStream_LastWrite, METH_O, NULL},
52636 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
52637 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
52638 { (char *)"delete_FSFile", (PyCFunction)_wrap_delete_FSFile, METH_O, NULL},
52639 { (char *)"FSFile_GetStream", (PyCFunction)_wrap_FSFile_GetStream, METH_O, NULL},
52640 { (char *)"FSFile_GetMimeType", (PyCFunction)_wrap_FSFile_GetMimeType, METH_O, NULL},
52641 { (char *)"FSFile_GetLocation", (PyCFunction)_wrap_FSFile_GetLocation, METH_O, NULL},
52642 { (char *)"FSFile_GetAnchor", (PyCFunction)_wrap_FSFile_GetAnchor, METH_O, NULL},
52643 { (char *)"FSFile_GetModificationTime", (PyCFunction)_wrap_FSFile_GetModificationTime, METH_O, NULL},
52644 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
52645 { (char *)"FSFile_swiginit", FSFile_swiginit, METH_VARARGS, NULL},
52646 { (char *)"delete_CPPFileSystemHandler", (PyCFunction)_wrap_delete_CPPFileSystemHandler, METH_O, NULL},
52647 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
52648 { (char *)"new_FileSystemHandler", (PyCFunction)_wrap_new_FileSystemHandler, METH_NOARGS, NULL},
52649 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
52650 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52651 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52652 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52653 { (char *)"FileSystemHandler_FindNext", (PyCFunction)_wrap_FileSystemHandler_FindNext, METH_O, NULL},
52654 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
52655 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
52656 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
52657 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
52658 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
52659 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
52660 { (char *)"FileSystemHandler_swiginit", FileSystemHandler_swiginit, METH_VARARGS, NULL},
52661 { (char *)"new_FileSystem", (PyCFunction)_wrap_new_FileSystem, METH_NOARGS, NULL},
52662 { (char *)"delete_FileSystem", (PyCFunction)_wrap_delete_FileSystem, METH_O, NULL},
52663 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
52664 { (char *)"FileSystem_GetPath", (PyCFunction)_wrap_FileSystem_GetPath, METH_O, NULL},
52665 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52666 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52667 { (char *)"FileSystem_FindNext", (PyCFunction)_wrap_FileSystem_FindNext, METH_O, NULL},
52668 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52669 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction)_wrap_FileSystem_CleanUpHandlers, METH_NOARGS, NULL},
52670 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
52671 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
52672 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
52673 { (char *)"FileSystem_swiginit", FileSystem_swiginit, METH_VARARGS, NULL},
52674 { (char *)"new_InternetFSHandler", (PyCFunction)_wrap_new_InternetFSHandler, METH_NOARGS, NULL},
52675 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52676 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52677 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
52678 { (char *)"InternetFSHandler_swiginit", InternetFSHandler_swiginit, METH_VARARGS, NULL},
52679 { (char *)"new_ZipFSHandler", (PyCFunction)_wrap_new_ZipFSHandler, METH_NOARGS, NULL},
52680 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52681 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52682 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52683 { (char *)"ZipFSHandler_FindNext", (PyCFunction)_wrap_ZipFSHandler_FindNext, METH_O, NULL},
52684 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
52685 { (char *)"ZipFSHandler_swiginit", ZipFSHandler_swiginit, METH_VARARGS, NULL},
52686 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
52687 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
52688 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
52689 { (char *)"new_MemoryFSHandler", (PyCFunction)_wrap_new_MemoryFSHandler, METH_NOARGS, NULL},
52690 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
52691 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52692 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52693 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52694 { (char *)"MemoryFSHandler_FindNext", (PyCFunction)_wrap_MemoryFSHandler_FindNext, METH_O, NULL},
52695 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
52696 { (char *)"MemoryFSHandler_swiginit", MemoryFSHandler_swiginit, METH_VARARGS, NULL},
52697 { (char *)"ImageHandler_GetName", (PyCFunction)_wrap_ImageHandler_GetName, METH_O, NULL},
52698 { (char *)"ImageHandler_GetExtension", (PyCFunction)_wrap_ImageHandler_GetExtension, METH_O, NULL},
52699 { (char *)"ImageHandler_GetType", (PyCFunction)_wrap_ImageHandler_GetType, METH_O, NULL},
52700 { (char *)"ImageHandler_GetMimeType", (PyCFunction)_wrap_ImageHandler_GetMimeType, METH_O, NULL},
52701 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
52702 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
52703 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
52704 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
52705 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
52706 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
52707 { (char *)"new_PyImageHandler", (PyCFunction)_wrap_new_PyImageHandler, METH_NOARGS, NULL},
52708 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
52709 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
52710 { (char *)"PyImageHandler_swiginit", PyImageHandler_swiginit, METH_VARARGS, NULL},
52711 { (char *)"new_ImageHistogram", (PyCFunction)_wrap_new_ImageHistogram, METH_NOARGS, NULL},
52712 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
52713 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
52714 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
52715 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
52716 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
52717 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
52718 { (char *)"ImageHistogram_swiginit", ImageHistogram_swiginit, METH_VARARGS, NULL},
52719 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
52720 { (char *)"Image_RGBValue_red_set", _wrap_Image_RGBValue_red_set, METH_VARARGS, NULL},
52721 { (char *)"Image_RGBValue_red_get", (PyCFunction)_wrap_Image_RGBValue_red_get, METH_O, NULL},
52722 { (char *)"Image_RGBValue_green_set", _wrap_Image_RGBValue_green_set, METH_VARARGS, NULL},
52723 { (char *)"Image_RGBValue_green_get", (PyCFunction)_wrap_Image_RGBValue_green_get, METH_O, NULL},
52724 { (char *)"Image_RGBValue_blue_set", _wrap_Image_RGBValue_blue_set, METH_VARARGS, NULL},
52725 { (char *)"Image_RGBValue_blue_get", (PyCFunction)_wrap_Image_RGBValue_blue_get, METH_O, NULL},
52726 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
52727 { (char *)"Image_RGBValue_swiginit", Image_RGBValue_swiginit, METH_VARARGS, NULL},
52728 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
52729 { (char *)"Image_HSVValue_hue_set", _wrap_Image_HSVValue_hue_set, METH_VARARGS, NULL},
52730 { (char *)"Image_HSVValue_hue_get", (PyCFunction)_wrap_Image_HSVValue_hue_get, METH_O, NULL},
52731 { (char *)"Image_HSVValue_saturation_set", _wrap_Image_HSVValue_saturation_set, METH_VARARGS, NULL},
52732 { (char *)"Image_HSVValue_saturation_get", (PyCFunction)_wrap_Image_HSVValue_saturation_get, METH_O, NULL},
52733 { (char *)"Image_HSVValue_value_set", _wrap_Image_HSVValue_value_set, METH_VARARGS, NULL},
52734 { (char *)"Image_HSVValue_value_get", (PyCFunction)_wrap_Image_HSVValue_value_get, METH_O, NULL},
52735 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
52736 { (char *)"Image_HSVValue_swiginit", Image_HSVValue_swiginit, METH_VARARGS, NULL},
52737 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
52738 { (char *)"delete_Image", (PyCFunction)_wrap_delete_Image, METH_O, NULL},
52739 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
52740 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
52741 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
52742 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
52743 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
52744 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
52745 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
52746 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
52747 { (char *)"Image_Destroy", (PyCFunction)_wrap_Image_Destroy, METH_O, NULL},
52748 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
52749 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
52750 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
52751 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
52752 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
52753 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
52754 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
52755 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
52756 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
52757 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
52758 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
52759 { (char *)"Image_HasAlpha", (PyCFunction)_wrap_Image_HasAlpha, METH_O, NULL},
52760 { (char *)"Image_InitAlpha", (PyCFunction)_wrap_Image_InitAlpha, METH_O, NULL},
52761 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
52762 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
52763 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
52764 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
52765 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
52766 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
52767 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
52768 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
52769 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
52770 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
52771 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
52772 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
52773 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
52774 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
52775 { (char *)"Image_Ok", (PyCFunction)_wrap_Image_Ok, METH_O, NULL},
52776 { (char *)"Image_GetWidth", (PyCFunction)_wrap_Image_GetWidth, METH_O, NULL},
52777 { (char *)"Image_GetHeight", (PyCFunction)_wrap_Image_GetHeight, METH_O, NULL},
52778 { (char *)"Image_GetSize", (PyCFunction)_wrap_Image_GetSize, METH_O, NULL},
52779 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
52780 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
52781 { (char *)"Image_Copy", (PyCFunction)_wrap_Image_Copy, METH_O, NULL},
52782 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
52783 { (char *)"Image_GetData", (PyCFunction)_wrap_Image_GetData, METH_O, NULL},
52784 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
52785 { (char *)"Image_GetDataBuffer", (PyCFunction)_wrap_Image_GetDataBuffer, METH_O, NULL},
52786 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
52787 { (char *)"Image_GetAlphaData", (PyCFunction)_wrap_Image_GetAlphaData, METH_O, NULL},
52788 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
52789 { (char *)"Image_GetAlphaBuffer", (PyCFunction)_wrap_Image_GetAlphaBuffer, METH_O, NULL},
52790 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
52791 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
52792 { (char *)"Image_GetOrFindMaskColour", (PyCFunction)_wrap_Image_GetOrFindMaskColour, METH_O, NULL},
52793 { (char *)"Image_GetMaskRed", (PyCFunction)_wrap_Image_GetMaskRed, METH_O, NULL},
52794 { (char *)"Image_GetMaskGreen", (PyCFunction)_wrap_Image_GetMaskGreen, METH_O, NULL},
52795 { (char *)"Image_GetMaskBlue", (PyCFunction)_wrap_Image_GetMaskBlue, METH_O, NULL},
52796 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
52797 { (char *)"Image_HasMask", (PyCFunction)_wrap_Image_HasMask, METH_O, NULL},
52798 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
52799 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
52800 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
52801 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
52802 { (char *)"Image_ConvertToGreyscale", (PyCFunction) _wrap_Image_ConvertToGreyscale, METH_VARARGS | METH_KEYWORDS, NULL},
52803 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
52804 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
52805 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
52806 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
52807 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
52808 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
52809 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
52810 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
52811 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52812 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52813 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52814 { (char *)"Image_GetHandlers", (PyCFunction)_wrap_Image_GetHandlers, METH_NOARGS, NULL},
52815 { (char *)"Image_GetImageExtWildcard", (PyCFunction)_wrap_Image_GetImageExtWildcard, METH_NOARGS, NULL},
52816 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
52817 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
52818 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
52819 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
52820 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
52821 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
52822 { (char *)"Image_swiginit", Image_swiginit, METH_VARARGS, NULL},
52823 { (char *)"new_BMPHandler", (PyCFunction)_wrap_new_BMPHandler, METH_NOARGS, NULL},
52824 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
52825 { (char *)"BMPHandler_swiginit", BMPHandler_swiginit, METH_VARARGS, NULL},
52826 { (char *)"new_ICOHandler", (PyCFunction)_wrap_new_ICOHandler, METH_NOARGS, NULL},
52827 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
52828 { (char *)"ICOHandler_swiginit", ICOHandler_swiginit, METH_VARARGS, NULL},
52829 { (char *)"new_CURHandler", (PyCFunction)_wrap_new_CURHandler, METH_NOARGS, NULL},
52830 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
52831 { (char *)"CURHandler_swiginit", CURHandler_swiginit, METH_VARARGS, NULL},
52832 { (char *)"new_ANIHandler", (PyCFunction)_wrap_new_ANIHandler, METH_NOARGS, NULL},
52833 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
52834 { (char *)"ANIHandler_swiginit", ANIHandler_swiginit, METH_VARARGS, NULL},
52835 { (char *)"new_PNGHandler", (PyCFunction)_wrap_new_PNGHandler, METH_NOARGS, NULL},
52836 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
52837 { (char *)"PNGHandler_swiginit", PNGHandler_swiginit, METH_VARARGS, NULL},
52838 { (char *)"new_GIFHandler", (PyCFunction)_wrap_new_GIFHandler, METH_NOARGS, NULL},
52839 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
52840 { (char *)"GIFHandler_swiginit", GIFHandler_swiginit, METH_VARARGS, NULL},
52841 { (char *)"new_PCXHandler", (PyCFunction)_wrap_new_PCXHandler, METH_NOARGS, NULL},
52842 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
52843 { (char *)"PCXHandler_swiginit", PCXHandler_swiginit, METH_VARARGS, NULL},
52844 { (char *)"new_JPEGHandler", (PyCFunction)_wrap_new_JPEGHandler, METH_NOARGS, NULL},
52845 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
52846 { (char *)"JPEGHandler_swiginit", JPEGHandler_swiginit, METH_VARARGS, NULL},
52847 { (char *)"new_PNMHandler", (PyCFunction)_wrap_new_PNMHandler, METH_NOARGS, NULL},
52848 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
52849 { (char *)"PNMHandler_swiginit", PNMHandler_swiginit, METH_VARARGS, NULL},
52850 { (char *)"new_XPMHandler", (PyCFunction)_wrap_new_XPMHandler, METH_NOARGS, NULL},
52851 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
52852 { (char *)"XPMHandler_swiginit", XPMHandler_swiginit, METH_VARARGS, NULL},
52853 { (char *)"new_TIFFHandler", (PyCFunction)_wrap_new_TIFFHandler, METH_NOARGS, NULL},
52854 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
52855 { (char *)"TIFFHandler_swiginit", TIFFHandler_swiginit, METH_VARARGS, NULL},
52856 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
52857 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
52858 { (char *)"new_EvtHandler", (PyCFunction)_wrap_new_EvtHandler, METH_NOARGS, NULL},
52859 { (char *)"EvtHandler_GetNextHandler", (PyCFunction)_wrap_EvtHandler_GetNextHandler, METH_O, NULL},
52860 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction)_wrap_EvtHandler_GetPreviousHandler, METH_O, NULL},
52861 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52862 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52863 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction)_wrap_EvtHandler_GetEvtHandlerEnabled, METH_O, NULL},
52864 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
52865 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52866 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52867 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction)_wrap_EvtHandler_ProcessPendingEvents, METH_O, NULL},
52868 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
52869 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
52870 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
52871 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
52872 { (char *)"EvtHandler_swiginit", EvtHandler_swiginit, METH_VARARGS, NULL},
52873 { (char *)"NewEventType", (PyCFunction)_wrap_NewEventType, METH_NOARGS, NULL},
52874 { (char *)"delete_Event", (PyCFunction)_wrap_delete_Event, METH_O, NULL},
52875 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
52876 { (char *)"Event_GetEventType", (PyCFunction)_wrap_Event_GetEventType, METH_O, NULL},
52877 { (char *)"Event_GetEventObject", (PyCFunction)_wrap_Event_GetEventObject, METH_O, NULL},
52878 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
52879 { (char *)"Event_GetTimestamp", (PyCFunction)_wrap_Event_GetTimestamp, METH_O, NULL},
52880 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
52881 { (char *)"Event_GetId", (PyCFunction)_wrap_Event_GetId, METH_O, NULL},
52882 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
52883 { (char *)"Event_IsCommandEvent", (PyCFunction)_wrap_Event_IsCommandEvent, METH_O, NULL},
52884 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
52885 { (char *)"Event_GetSkipped", (PyCFunction)_wrap_Event_GetSkipped, METH_O, NULL},
52886 { (char *)"Event_ShouldPropagate", (PyCFunction)_wrap_Event_ShouldPropagate, METH_O, NULL},
52887 { (char *)"Event_StopPropagation", (PyCFunction)_wrap_Event_StopPropagation, METH_O, NULL},
52888 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
52889 { (char *)"Event_Clone", (PyCFunction)_wrap_Event_Clone, METH_O, NULL},
52890 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
52891 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
52892 { (char *)"delete_PropagationDisabler", (PyCFunction)_wrap_delete_PropagationDisabler, METH_O, NULL},
52893 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
52894 { (char *)"PropagationDisabler_swiginit", PropagationDisabler_swiginit, METH_VARARGS, NULL},
52895 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
52896 { (char *)"delete_PropagateOnce", (PyCFunction)_wrap_delete_PropagateOnce, METH_O, NULL},
52897 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
52898 { (char *)"PropagateOnce_swiginit", PropagateOnce_swiginit, METH_VARARGS, NULL},
52899 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52900 { (char *)"CommandEvent_GetSelection", (PyCFunction)_wrap_CommandEvent_GetSelection, METH_O, NULL},
52901 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
52902 { (char *)"CommandEvent_GetString", (PyCFunction)_wrap_CommandEvent_GetString, METH_O, NULL},
52903 { (char *)"CommandEvent_IsChecked", (PyCFunction)_wrap_CommandEvent_IsChecked, METH_O, NULL},
52904 { (char *)"CommandEvent_IsSelection", (PyCFunction)_wrap_CommandEvent_IsSelection, METH_O, NULL},
52905 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
52906 { (char *)"CommandEvent_GetExtraLong", (PyCFunction)_wrap_CommandEvent_GetExtraLong, METH_O, NULL},
52907 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
52908 { (char *)"CommandEvent_GetInt", (PyCFunction)_wrap_CommandEvent_GetInt, METH_O, NULL},
52909 { (char *)"CommandEvent_GetClientData", (PyCFunction)_wrap_CommandEvent_GetClientData, METH_O, NULL},
52910 { (char *)"CommandEvent_SetClientData", (PyCFunction) _wrap_CommandEvent_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
52911 { (char *)"CommandEvent_Clone", (PyCFunction)_wrap_CommandEvent_Clone, METH_O, NULL},
52912 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
52913 { (char *)"CommandEvent_swiginit", CommandEvent_swiginit, METH_VARARGS, NULL},
52914 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52915 { (char *)"NotifyEvent_Veto", (PyCFunction)_wrap_NotifyEvent_Veto, METH_O, NULL},
52916 { (char *)"NotifyEvent_Allow", (PyCFunction)_wrap_NotifyEvent_Allow, METH_O, NULL},
52917 { (char *)"NotifyEvent_IsAllowed", (PyCFunction)_wrap_NotifyEvent_IsAllowed, METH_O, NULL},
52918 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
52919 { (char *)"NotifyEvent_swiginit", NotifyEvent_swiginit, METH_VARARGS, NULL},
52920 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52921 { (char *)"ScrollEvent_GetOrientation", (PyCFunction)_wrap_ScrollEvent_GetOrientation, METH_O, NULL},
52922 { (char *)"ScrollEvent_GetPosition", (PyCFunction)_wrap_ScrollEvent_GetPosition, METH_O, NULL},
52923 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
52924 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
52925 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
52926 { (char *)"ScrollEvent_swiginit", ScrollEvent_swiginit, METH_VARARGS, NULL},
52927 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52928 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction)_wrap_ScrollWinEvent_GetOrientation, METH_O, NULL},
52929 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction)_wrap_ScrollWinEvent_GetPosition, METH_O, NULL},
52930 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
52931 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
52932 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
52933 { (char *)"ScrollWinEvent_swiginit", ScrollWinEvent_swiginit, METH_VARARGS, NULL},
52934 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52935 { (char *)"MouseEvent_IsButton", (PyCFunction)_wrap_MouseEvent_IsButton, METH_O, NULL},
52936 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
52937 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
52938 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
52939 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
52940 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
52941 { (char *)"MouseEvent_GetButton", (PyCFunction)_wrap_MouseEvent_GetButton, METH_O, NULL},
52942 { (char *)"MouseEvent_ControlDown", (PyCFunction)_wrap_MouseEvent_ControlDown, METH_O, NULL},
52943 { (char *)"MouseEvent_MetaDown", (PyCFunction)_wrap_MouseEvent_MetaDown, METH_O, NULL},
52944 { (char *)"MouseEvent_AltDown", (PyCFunction)_wrap_MouseEvent_AltDown, METH_O, NULL},
52945 { (char *)"MouseEvent_ShiftDown", (PyCFunction)_wrap_MouseEvent_ShiftDown, METH_O, NULL},
52946 { (char *)"MouseEvent_CmdDown", (PyCFunction)_wrap_MouseEvent_CmdDown, METH_O, NULL},
52947 { (char *)"MouseEvent_LeftDown", (PyCFunction)_wrap_MouseEvent_LeftDown, METH_O, NULL},
52948 { (char *)"MouseEvent_MiddleDown", (PyCFunction)_wrap_MouseEvent_MiddleDown, METH_O, NULL},
52949 { (char *)"MouseEvent_RightDown", (PyCFunction)_wrap_MouseEvent_RightDown, METH_O, NULL},
52950 { (char *)"MouseEvent_LeftUp", (PyCFunction)_wrap_MouseEvent_LeftUp, METH_O, NULL},
52951 { (char *)"MouseEvent_MiddleUp", (PyCFunction)_wrap_MouseEvent_MiddleUp, METH_O, NULL},
52952 { (char *)"MouseEvent_RightUp", (PyCFunction)_wrap_MouseEvent_RightUp, METH_O, NULL},
52953 { (char *)"MouseEvent_LeftDClick", (PyCFunction)_wrap_MouseEvent_LeftDClick, METH_O, NULL},
52954 { (char *)"MouseEvent_MiddleDClick", (PyCFunction)_wrap_MouseEvent_MiddleDClick, METH_O, NULL},
52955 { (char *)"MouseEvent_RightDClick", (PyCFunction)_wrap_MouseEvent_RightDClick, METH_O, NULL},
52956 { (char *)"MouseEvent_LeftIsDown", (PyCFunction)_wrap_MouseEvent_LeftIsDown, METH_O, NULL},
52957 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction)_wrap_MouseEvent_MiddleIsDown, METH_O, NULL},
52958 { (char *)"MouseEvent_RightIsDown", (PyCFunction)_wrap_MouseEvent_RightIsDown, METH_O, NULL},
52959 { (char *)"MouseEvent_Dragging", (PyCFunction)_wrap_MouseEvent_Dragging, METH_O, NULL},
52960 { (char *)"MouseEvent_Moving", (PyCFunction)_wrap_MouseEvent_Moving, METH_O, NULL},
52961 { (char *)"MouseEvent_Entering", (PyCFunction)_wrap_MouseEvent_Entering, METH_O, NULL},
52962 { (char *)"MouseEvent_Leaving", (PyCFunction)_wrap_MouseEvent_Leaving, METH_O, NULL},
52963 { (char *)"MouseEvent_GetPosition", (PyCFunction)_wrap_MouseEvent_GetPosition, METH_O, NULL},
52964 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction)_wrap_MouseEvent_GetPositionTuple, METH_O, NULL},
52965 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
52966 { (char *)"MouseEvent_GetX", (PyCFunction)_wrap_MouseEvent_GetX, METH_O, NULL},
52967 { (char *)"MouseEvent_GetY", (PyCFunction)_wrap_MouseEvent_GetY, METH_O, NULL},
52968 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction)_wrap_MouseEvent_GetWheelRotation, METH_O, NULL},
52969 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction)_wrap_MouseEvent_GetWheelDelta, METH_O, NULL},
52970 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction)_wrap_MouseEvent_GetLinesPerAction, METH_O, NULL},
52971 { (char *)"MouseEvent_IsPageScroll", (PyCFunction)_wrap_MouseEvent_IsPageScroll, METH_O, NULL},
52972 { (char *)"MouseEvent_m_x_set", _wrap_MouseEvent_m_x_set, METH_VARARGS, NULL},
52973 { (char *)"MouseEvent_m_x_get", (PyCFunction)_wrap_MouseEvent_m_x_get, METH_O, NULL},
52974 { (char *)"MouseEvent_m_y_set", _wrap_MouseEvent_m_y_set, METH_VARARGS, NULL},
52975 { (char *)"MouseEvent_m_y_get", (PyCFunction)_wrap_MouseEvent_m_y_get, METH_O, NULL},
52976 { (char *)"MouseEvent_m_leftDown_set", _wrap_MouseEvent_m_leftDown_set, METH_VARARGS, NULL},
52977 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction)_wrap_MouseEvent_m_leftDown_get, METH_O, NULL},
52978 { (char *)"MouseEvent_m_middleDown_set", _wrap_MouseEvent_m_middleDown_set, METH_VARARGS, NULL},
52979 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction)_wrap_MouseEvent_m_middleDown_get, METH_O, NULL},
52980 { (char *)"MouseEvent_m_rightDown_set", _wrap_MouseEvent_m_rightDown_set, METH_VARARGS, NULL},
52981 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction)_wrap_MouseEvent_m_rightDown_get, METH_O, NULL},
52982 { (char *)"MouseEvent_m_controlDown_set", _wrap_MouseEvent_m_controlDown_set, METH_VARARGS, NULL},
52983 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction)_wrap_MouseEvent_m_controlDown_get, METH_O, NULL},
52984 { (char *)"MouseEvent_m_shiftDown_set", _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS, NULL},
52985 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction)_wrap_MouseEvent_m_shiftDown_get, METH_O, NULL},
52986 { (char *)"MouseEvent_m_altDown_set", _wrap_MouseEvent_m_altDown_set, METH_VARARGS, NULL},
52987 { (char *)"MouseEvent_m_altDown_get", (PyCFunction)_wrap_MouseEvent_m_altDown_get, METH_O, NULL},
52988 { (char *)"MouseEvent_m_metaDown_set", _wrap_MouseEvent_m_metaDown_set, METH_VARARGS, NULL},
52989 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction)_wrap_MouseEvent_m_metaDown_get, METH_O, NULL},
52990 { (char *)"MouseEvent_m_wheelRotation_set", _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS, NULL},
52991 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction)_wrap_MouseEvent_m_wheelRotation_get, METH_O, NULL},
52992 { (char *)"MouseEvent_m_wheelDelta_set", _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS, NULL},
52993 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction)_wrap_MouseEvent_m_wheelDelta_get, METH_O, NULL},
52994 { (char *)"MouseEvent_m_linesPerAction_set", _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS, NULL},
52995 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction)_wrap_MouseEvent_m_linesPerAction_get, METH_O, NULL},
52996 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
52997 { (char *)"MouseEvent_swiginit", MouseEvent_swiginit, METH_VARARGS, NULL},
52998 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52999 { (char *)"SetCursorEvent_GetX", (PyCFunction)_wrap_SetCursorEvent_GetX, METH_O, NULL},
53000 { (char *)"SetCursorEvent_GetY", (PyCFunction)_wrap_SetCursorEvent_GetY, METH_O, NULL},
53001 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
53002 { (char *)"SetCursorEvent_GetCursor", (PyCFunction)_wrap_SetCursorEvent_GetCursor, METH_O, NULL},
53003 { (char *)"SetCursorEvent_HasCursor", (PyCFunction)_wrap_SetCursorEvent_HasCursor, METH_O, NULL},
53004 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
53005 { (char *)"SetCursorEvent_swiginit", SetCursorEvent_swiginit, METH_VARARGS, NULL},
53006 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53007 { (char *)"KeyEvent_GetModifiers", (PyCFunction)_wrap_KeyEvent_GetModifiers, METH_O, NULL},
53008 { (char *)"KeyEvent_ControlDown", (PyCFunction)_wrap_KeyEvent_ControlDown, METH_O, NULL},
53009 { (char *)"KeyEvent_MetaDown", (PyCFunction)_wrap_KeyEvent_MetaDown, METH_O, NULL},
53010 { (char *)"KeyEvent_AltDown", (PyCFunction)_wrap_KeyEvent_AltDown, METH_O, NULL},
53011 { (char *)"KeyEvent_ShiftDown", (PyCFunction)_wrap_KeyEvent_ShiftDown, METH_O, NULL},
53012 { (char *)"KeyEvent_CmdDown", (PyCFunction)_wrap_KeyEvent_CmdDown, METH_O, NULL},
53013 { (char *)"KeyEvent_HasModifiers", (PyCFunction)_wrap_KeyEvent_HasModifiers, METH_O, NULL},
53014 { (char *)"KeyEvent_GetKeyCode", (PyCFunction)_wrap_KeyEvent_GetKeyCode, METH_O, NULL},
53015 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction)_wrap_KeyEvent_GetUnicodeKey, METH_O, NULL},
53016 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction)_wrap_KeyEvent_GetRawKeyCode, METH_O, NULL},
53017 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction)_wrap_KeyEvent_GetRawKeyFlags, METH_O, NULL},
53018 { (char *)"KeyEvent_GetPosition", (PyCFunction)_wrap_KeyEvent_GetPosition, METH_O, NULL},
53019 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction)_wrap_KeyEvent_GetPositionTuple, METH_O, NULL},
53020 { (char *)"KeyEvent_GetX", (PyCFunction)_wrap_KeyEvent_GetX, METH_O, NULL},
53021 { (char *)"KeyEvent_GetY", (PyCFunction)_wrap_KeyEvent_GetY, METH_O, NULL},
53022 { (char *)"KeyEvent_m_x_set", _wrap_KeyEvent_m_x_set, METH_VARARGS, NULL},
53023 { (char *)"KeyEvent_m_x_get", (PyCFunction)_wrap_KeyEvent_m_x_get, METH_O, NULL},
53024 { (char *)"KeyEvent_m_y_set", _wrap_KeyEvent_m_y_set, METH_VARARGS, NULL},
53025 { (char *)"KeyEvent_m_y_get", (PyCFunction)_wrap_KeyEvent_m_y_get, METH_O, NULL},
53026 { (char *)"KeyEvent_m_keyCode_set", _wrap_KeyEvent_m_keyCode_set, METH_VARARGS, NULL},
53027 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction)_wrap_KeyEvent_m_keyCode_get, METH_O, NULL},
53028 { (char *)"KeyEvent_m_controlDown_set", _wrap_KeyEvent_m_controlDown_set, METH_VARARGS, NULL},
53029 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction)_wrap_KeyEvent_m_controlDown_get, METH_O, NULL},
53030 { (char *)"KeyEvent_m_shiftDown_set", _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS, NULL},
53031 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction)_wrap_KeyEvent_m_shiftDown_get, METH_O, NULL},
53032 { (char *)"KeyEvent_m_altDown_set", _wrap_KeyEvent_m_altDown_set, METH_VARARGS, NULL},
53033 { (char *)"KeyEvent_m_altDown_get", (PyCFunction)_wrap_KeyEvent_m_altDown_get, METH_O, NULL},
53034 { (char *)"KeyEvent_m_metaDown_set", _wrap_KeyEvent_m_metaDown_set, METH_VARARGS, NULL},
53035 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction)_wrap_KeyEvent_m_metaDown_get, METH_O, NULL},
53036 { (char *)"KeyEvent_m_scanCode_set", _wrap_KeyEvent_m_scanCode_set, METH_VARARGS, NULL},
53037 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction)_wrap_KeyEvent_m_scanCode_get, METH_O, NULL},
53038 { (char *)"KeyEvent_m_rawCode_set", _wrap_KeyEvent_m_rawCode_set, METH_VARARGS, NULL},
53039 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction)_wrap_KeyEvent_m_rawCode_get, METH_O, NULL},
53040 { (char *)"KeyEvent_m_rawFlags_set", _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS, NULL},
53041 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction)_wrap_KeyEvent_m_rawFlags_get, METH_O, NULL},
53042 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
53043 { (char *)"KeyEvent_swiginit", KeyEvent_swiginit, METH_VARARGS, NULL},
53044 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53045 { (char *)"SizeEvent_GetSize", (PyCFunction)_wrap_SizeEvent_GetSize, METH_O, NULL},
53046 { (char *)"SizeEvent_GetRect", (PyCFunction)_wrap_SizeEvent_GetRect, METH_O, NULL},
53047 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53048 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
53049 { (char *)"SizeEvent_m_size_set", _wrap_SizeEvent_m_size_set, METH_VARARGS, NULL},
53050 { (char *)"SizeEvent_m_size_get", (PyCFunction)_wrap_SizeEvent_m_size_get, METH_O, NULL},
53051 { (char *)"SizeEvent_m_rect_set", _wrap_SizeEvent_m_rect_set, METH_VARARGS, NULL},
53052 { (char *)"SizeEvent_m_rect_get", (PyCFunction)_wrap_SizeEvent_m_rect_get, METH_O, NULL},
53053 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
53054 { (char *)"SizeEvent_swiginit", SizeEvent_swiginit, METH_VARARGS, NULL},
53055 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53056 { (char *)"MoveEvent_GetPosition", (PyCFunction)_wrap_MoveEvent_GetPosition, METH_O, NULL},
53057 { (char *)"MoveEvent_GetRect", (PyCFunction)_wrap_MoveEvent_GetRect, METH_O, NULL},
53058 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53059 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53060 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
53061 { (char *)"MoveEvent_swiginit", MoveEvent_swiginit, METH_VARARGS, NULL},
53062 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53063 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
53064 { (char *)"PaintEvent_swiginit", PaintEvent_swiginit, METH_VARARGS, NULL},
53065 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53066 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
53067 { (char *)"NcPaintEvent_swiginit", NcPaintEvent_swiginit, METH_VARARGS, NULL},
53068 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53069 { (char *)"EraseEvent_GetDC", (PyCFunction)_wrap_EraseEvent_GetDC, METH_O, NULL},
53070 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
53071 { (char *)"EraseEvent_swiginit", EraseEvent_swiginit, METH_VARARGS, NULL},
53072 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53073 { (char *)"FocusEvent_GetWindow", (PyCFunction)_wrap_FocusEvent_GetWindow, METH_O, NULL},
53074 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53075 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
53076 { (char *)"FocusEvent_swiginit", FocusEvent_swiginit, METH_VARARGS, NULL},
53077 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53078 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction)_wrap_ChildFocusEvent_GetWindow, METH_O, NULL},
53079 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
53080 { (char *)"ChildFocusEvent_swiginit", ChildFocusEvent_swiginit, METH_VARARGS, NULL},
53081 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53082 { (char *)"ActivateEvent_GetActive", (PyCFunction)_wrap_ActivateEvent_GetActive, METH_O, NULL},
53083 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
53084 { (char *)"ActivateEvent_swiginit", ActivateEvent_swiginit, METH_VARARGS, NULL},
53085 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53086 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
53087 { (char *)"InitDialogEvent_swiginit", InitDialogEvent_swiginit, METH_VARARGS, NULL},
53088 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53089 { (char *)"MenuEvent_GetMenuId", (PyCFunction)_wrap_MenuEvent_GetMenuId, METH_O, NULL},
53090 { (char *)"MenuEvent_IsPopup", (PyCFunction)_wrap_MenuEvent_IsPopup, METH_O, NULL},
53091 { (char *)"MenuEvent_GetMenu", (PyCFunction)_wrap_MenuEvent_GetMenu, METH_O, NULL},
53092 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
53093 { (char *)"MenuEvent_swiginit", MenuEvent_swiginit, METH_VARARGS, NULL},
53094 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53095 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
53096 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction)_wrap_CloseEvent_GetLoggingOff, METH_O, NULL},
53097 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
53098 { (char *)"CloseEvent_GetVeto", (PyCFunction)_wrap_CloseEvent_GetVeto, METH_O, NULL},
53099 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
53100 { (char *)"CloseEvent_CanVeto", (PyCFunction)_wrap_CloseEvent_CanVeto, METH_O, NULL},
53101 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
53102 { (char *)"CloseEvent_swiginit", CloseEvent_swiginit, METH_VARARGS, NULL},
53103 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53104 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
53105 { (char *)"ShowEvent_GetShow", (PyCFunction)_wrap_ShowEvent_GetShow, METH_O, NULL},
53106 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
53107 { (char *)"ShowEvent_swiginit", ShowEvent_swiginit, METH_VARARGS, NULL},
53108 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53109 { (char *)"IconizeEvent_Iconized", (PyCFunction)_wrap_IconizeEvent_Iconized, METH_O, NULL},
53110 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
53111 { (char *)"IconizeEvent_swiginit", IconizeEvent_swiginit, METH_VARARGS, NULL},
53112 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53113 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
53114 { (char *)"MaximizeEvent_swiginit", MaximizeEvent_swiginit, METH_VARARGS, NULL},
53115 { (char *)"DropFilesEvent_GetPosition", (PyCFunction)_wrap_DropFilesEvent_GetPosition, METH_O, NULL},
53116 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction)_wrap_DropFilesEvent_GetNumberOfFiles, METH_O, NULL},
53117 { (char *)"DropFilesEvent_GetFiles", (PyCFunction)_wrap_DropFilesEvent_GetFiles, METH_O, NULL},
53118 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
53119 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53120 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetChecked, METH_O, NULL},
53121 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetEnabled, METH_O, NULL},
53122 { (char *)"UpdateUIEvent_GetShown", (PyCFunction)_wrap_UpdateUIEvent_GetShown, METH_O, NULL},
53123 { (char *)"UpdateUIEvent_GetText", (PyCFunction)_wrap_UpdateUIEvent_GetText, METH_O, NULL},
53124 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction)_wrap_UpdateUIEvent_GetSetText, METH_O, NULL},
53125 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetSetChecked, METH_O, NULL},
53126 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetSetEnabled, METH_O, NULL},
53127 { (char *)"UpdateUIEvent_GetSetShown", (PyCFunction)_wrap_UpdateUIEvent_GetSetShown, METH_O, NULL},
53128 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53129 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53130 { (char *)"UpdateUIEvent_Show", (PyCFunction) _wrap_UpdateUIEvent_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53131 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
53132 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
53133 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction)_wrap_UpdateUIEvent_GetUpdateInterval, METH_NOARGS, NULL},
53134 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
53135 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction)_wrap_UpdateUIEvent_ResetUpdateTime, METH_NOARGS, NULL},
53136 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
53137 { (char *)"UpdateUIEvent_GetMode", (PyCFunction)_wrap_UpdateUIEvent_GetMode, METH_NOARGS, NULL},
53138 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
53139 { (char *)"UpdateUIEvent_swiginit", UpdateUIEvent_swiginit, METH_VARARGS, NULL},
53140 { (char *)"new_SysColourChangedEvent", (PyCFunction)_wrap_new_SysColourChangedEvent, METH_NOARGS, NULL},
53141 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
53142 { (char *)"SysColourChangedEvent_swiginit", SysColourChangedEvent_swiginit, METH_VARARGS, NULL},
53143 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53144 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction)_wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_O, NULL},
53145 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
53146 { (char *)"MouseCaptureChangedEvent_swiginit", MouseCaptureChangedEvent_swiginit, METH_VARARGS, NULL},
53147 { (char *)"new_DisplayChangedEvent", (PyCFunction)_wrap_new_DisplayChangedEvent, METH_NOARGS, NULL},
53148 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
53149 { (char *)"DisplayChangedEvent_swiginit", DisplayChangedEvent_swiginit, METH_VARARGS, NULL},
53150 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53151 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53152 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction)_wrap_PaletteChangedEvent_GetChangedWindow, METH_O, NULL},
53153 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
53154 { (char *)"PaletteChangedEvent_swiginit", PaletteChangedEvent_swiginit, METH_VARARGS, NULL},
53155 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53156 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
53157 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction)_wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_O, NULL},
53158 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
53159 { (char *)"QueryNewPaletteEvent_swiginit", QueryNewPaletteEvent_swiginit, METH_VARARGS, NULL},
53160 { (char *)"new_NavigationKeyEvent", (PyCFunction)_wrap_new_NavigationKeyEvent, METH_NOARGS, NULL},
53161 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction)_wrap_NavigationKeyEvent_GetDirection, METH_O, NULL},
53162 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
53163 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction)_wrap_NavigationKeyEvent_IsWindowChange, METH_O, NULL},
53164 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
53165 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction)_wrap_NavigationKeyEvent_IsFromTab, METH_O, NULL},
53166 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
53167 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
53168 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction)_wrap_NavigationKeyEvent_GetCurrentFocus, METH_O, NULL},
53169 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
53170 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
53171 { (char *)"NavigationKeyEvent_swiginit", NavigationKeyEvent_swiginit, METH_VARARGS, NULL},
53172 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53173 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction)_wrap_WindowCreateEvent_GetWindow, METH_O, NULL},
53174 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
53175 { (char *)"WindowCreateEvent_swiginit", WindowCreateEvent_swiginit, METH_VARARGS, NULL},
53176 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53177 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction)_wrap_WindowDestroyEvent_GetWindow, METH_O, NULL},
53178 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
53179 { (char *)"WindowDestroyEvent_swiginit", WindowDestroyEvent_swiginit, METH_VARARGS, NULL},
53180 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53181 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction)_wrap_ContextMenuEvent_GetPosition, METH_O, NULL},
53182 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53183 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
53184 { (char *)"ContextMenuEvent_swiginit", ContextMenuEvent_swiginit, METH_VARARGS, NULL},
53185 { (char *)"new_IdleEvent", (PyCFunction)_wrap_new_IdleEvent, METH_NOARGS, NULL},
53186 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
53187 { (char *)"IdleEvent_MoreRequested", (PyCFunction)_wrap_IdleEvent_MoreRequested, METH_O, NULL},
53188 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
53189 { (char *)"IdleEvent_GetMode", (PyCFunction)_wrap_IdleEvent_GetMode, METH_NOARGS, NULL},
53190 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
53191 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
53192 { (char *)"IdleEvent_swiginit", IdleEvent_swiginit, METH_VARARGS, NULL},
53193 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53194 { (char *)"delete_PyEvent", (PyCFunction)_wrap_delete_PyEvent, METH_O, NULL},
53195 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53196 { (char *)"PyEvent__GetSelf", (PyCFunction)_wrap_PyEvent__GetSelf, METH_O, NULL},
53197 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
53198 { (char *)"PyEvent_swiginit", PyEvent_swiginit, METH_VARARGS, NULL},
53199 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53200 { (char *)"delete_PyCommandEvent", (PyCFunction)_wrap_delete_PyCommandEvent, METH_O, NULL},
53201 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53202 { (char *)"PyCommandEvent__GetSelf", (PyCFunction)_wrap_PyCommandEvent__GetSelf, METH_O, NULL},
53203 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
53204 { (char *)"PyCommandEvent_swiginit", PyCommandEvent_swiginit, METH_VARARGS, NULL},
53205 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53206 { (char *)"DateEvent_GetDate", (PyCFunction)_wrap_DateEvent_GetDate, METH_O, NULL},
53207 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
53208 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
53209 { (char *)"DateEvent_swiginit", DateEvent_swiginit, METH_VARARGS, NULL},
53210 { (char *)"new_PyApp", (PyCFunction)_wrap_new_PyApp, METH_NOARGS, NULL},
53211 { (char *)"delete_PyApp", (PyCFunction)_wrap_delete_PyApp, METH_O, NULL},
53212 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53213 { (char *)"PyApp_GetAppName", (PyCFunction)_wrap_PyApp_GetAppName, METH_O, NULL},
53214 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
53215 { (char *)"PyApp_GetClassName", (PyCFunction)_wrap_PyApp_GetClassName, METH_O, NULL},
53216 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
53217 { (char *)"PyApp_GetVendorName", (PyCFunction)_wrap_PyApp_GetVendorName, METH_O, NULL},
53218 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
53219 { (char *)"PyApp_GetTraits", (PyCFunction)_wrap_PyApp_GetTraits, METH_O, NULL},
53220 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction)_wrap_PyApp_ProcessPendingEvents, METH_O, NULL},
53221 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
53222 { (char *)"PyApp_WakeUpIdle", (PyCFunction)_wrap_PyApp_WakeUpIdle, METH_O, NULL},
53223 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction)_wrap_PyApp_IsMainLoopRunning, METH_NOARGS, NULL},
53224 { (char *)"PyApp_MainLoop", (PyCFunction)_wrap_PyApp_MainLoop, METH_O, NULL},
53225 { (char *)"PyApp_Exit", (PyCFunction)_wrap_PyApp_Exit, METH_O, NULL},
53226 { (char *)"PyApp_ExitMainLoop", (PyCFunction)_wrap_PyApp_ExitMainLoop, METH_O, NULL},
53227 { (char *)"PyApp_Pending", (PyCFunction)_wrap_PyApp_Pending, METH_O, NULL},
53228 { (char *)"PyApp_Dispatch", (PyCFunction)_wrap_PyApp_Dispatch, METH_O, NULL},
53229 { (char *)"PyApp_ProcessIdle", (PyCFunction)_wrap_PyApp_ProcessIdle, METH_O, NULL},
53230 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
53231 { (char *)"PyApp_IsActive", (PyCFunction)_wrap_PyApp_IsActive, METH_O, NULL},
53232 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53233 { (char *)"PyApp_GetTopWindow", (PyCFunction)_wrap_PyApp_GetTopWindow, METH_O, NULL},
53234 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
53235 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction)_wrap_PyApp_GetExitOnFrameDelete, METH_O, NULL},
53236 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
53237 { (char *)"PyApp_GetUseBestVisual", (PyCFunction)_wrap_PyApp_GetUseBestVisual, METH_O, NULL},
53238 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
53239 { (char *)"PyApp_GetPrintMode", (PyCFunction)_wrap_PyApp_GetPrintMode, METH_O, NULL},
53240 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
53241 { (char *)"PyApp_GetAssertMode", (PyCFunction)_wrap_PyApp_GetAssertMode, METH_O, NULL},
53242 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction)_wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_NOARGS, NULL},
53243 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction)_wrap_PyApp_GetMacAboutMenuItemId, METH_NOARGS, NULL},
53244 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction)_wrap_PyApp_GetMacPreferencesMenuItemId, METH_NOARGS, NULL},
53245 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction)_wrap_PyApp_GetMacExitMenuItemId, METH_NOARGS, NULL},
53246 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction)_wrap_PyApp_GetMacHelpMenuTitleName, METH_NOARGS, NULL},
53247 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
53248 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53249 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53250 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53251 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
53252 { (char *)"PyApp__BootstrapApp", (PyCFunction)_wrap_PyApp__BootstrapApp, METH_O, NULL},
53253 { (char *)"PyApp_GetComCtl32Version", (PyCFunction)_wrap_PyApp_GetComCtl32Version, METH_NOARGS, NULL},
53254 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
53255 { (char *)"PyApp_swiginit", PyApp_swiginit, METH_VARARGS, NULL},
53256 { (char *)"Exit", (PyCFunction)_wrap_Exit, METH_NOARGS, NULL},
53257 { (char *)"Yield", (PyCFunction)_wrap_Yield, METH_NOARGS, NULL},
53258 { (char *)"YieldIfNeeded", (PyCFunction)_wrap_YieldIfNeeded, METH_NOARGS, NULL},
53259 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
53260 { (char *)"WakeUpIdle", (PyCFunction)_wrap_WakeUpIdle, METH_NOARGS, NULL},
53261 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53262 { (char *)"App_CleanUp", (PyCFunction)_wrap_App_CleanUp, METH_NOARGS, NULL},
53263 { (char *)"GetApp", (PyCFunction)_wrap_GetApp, METH_NOARGS, NULL},
53264 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
53265 { (char *)"GetDefaultPyEncoding", (PyCFunction)_wrap_GetDefaultPyEncoding, METH_NOARGS, NULL},
53266 { (char *)"new_EventLoop", (PyCFunction)_wrap_new_EventLoop, METH_NOARGS, NULL},
53267 { (char *)"delete_EventLoop", (PyCFunction)_wrap_delete_EventLoop, METH_O, NULL},
53268 { (char *)"EventLoop_Run", (PyCFunction)_wrap_EventLoop_Run, METH_O, NULL},
53269 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
53270 { (char *)"EventLoop_Pending", (PyCFunction)_wrap_EventLoop_Pending, METH_O, NULL},
53271 { (char *)"EventLoop_Dispatch", (PyCFunction)_wrap_EventLoop_Dispatch, METH_O, NULL},
53272 { (char *)"EventLoop_IsRunning", (PyCFunction)_wrap_EventLoop_IsRunning, METH_O, NULL},
53273 { (char *)"EventLoop_GetActive", (PyCFunction)_wrap_EventLoop_GetActive, METH_NOARGS, NULL},
53274 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
53275 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
53276 { (char *)"EventLoop_swiginit", EventLoop_swiginit, METH_VARARGS, NULL},
53277 { (char *)"new_EventLoopActivator", (PyCFunction) _wrap_new_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
53278 { (char *)"delete_EventLoopActivator", (PyCFunction)_wrap_delete_EventLoopActivator, METH_O, NULL},
53279 { (char *)"EventLoopActivator_swigregister", EventLoopActivator_swigregister, METH_VARARGS, NULL},
53280 { (char *)"EventLoopActivator_swiginit", EventLoopActivator_swiginit, METH_VARARGS, NULL},
53281 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
53282 { (char *)"delete_AcceleratorEntry", (PyCFunction)_wrap_delete_AcceleratorEntry, METH_O, NULL},
53283 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53284 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction)_wrap_AcceleratorEntry_GetFlags, METH_O, NULL},
53285 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction)_wrap_AcceleratorEntry_GetKeyCode, METH_O, NULL},
53286 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction)_wrap_AcceleratorEntry_GetCommand, METH_O, NULL},
53287 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
53288 { (char *)"AcceleratorEntry_swiginit", AcceleratorEntry_swiginit, METH_VARARGS, NULL},
53289 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
53290 { (char *)"delete_AcceleratorTable", (PyCFunction)_wrap_delete_AcceleratorTable, METH_O, NULL},
53291 { (char *)"AcceleratorTable_Ok", (PyCFunction)_wrap_AcceleratorTable_Ok, METH_O, NULL},
53292 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
53293 { (char *)"AcceleratorTable_swiginit", AcceleratorTable_swiginit, METH_VARARGS, NULL},
53294 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
53295 { (char *)"new_VisualAttributes", (PyCFunction)_wrap_new_VisualAttributes, METH_NOARGS, NULL},
53296 { (char *)"delete_VisualAttributes", (PyCFunction)_wrap_delete_VisualAttributes, METH_O, NULL},
53297 { (char *)"VisualAttributes_font_set", _wrap_VisualAttributes_font_set, METH_VARARGS, NULL},
53298 { (char *)"VisualAttributes_font_get", (PyCFunction)_wrap_VisualAttributes_font_get, METH_O, NULL},
53299 { (char *)"VisualAttributes_colFg_set", _wrap_VisualAttributes_colFg_set, METH_VARARGS, NULL},
53300 { (char *)"VisualAttributes_colFg_get", (PyCFunction)_wrap_VisualAttributes_colFg_get, METH_O, NULL},
53301 { (char *)"VisualAttributes_colBg_set", _wrap_VisualAttributes_colBg_set, METH_VARARGS, NULL},
53302 { (char *)"VisualAttributes_colBg_get", (PyCFunction)_wrap_VisualAttributes_colBg_get, METH_O, NULL},
53303 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
53304 { (char *)"VisualAttributes_swiginit", VisualAttributes_swiginit, METH_VARARGS, NULL},
53305 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
53306 { (char *)"new_PreWindow", (PyCFunction)_wrap_new_PreWindow, METH_NOARGS, NULL},
53307 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
53308 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
53309 { (char *)"Window_Destroy", (PyCFunction)_wrap_Window_Destroy, METH_O, NULL},
53310 { (char *)"Window_DestroyChildren", (PyCFunction)_wrap_Window_DestroyChildren, METH_O, NULL},
53311 { (char *)"Window_IsBeingDeleted", (PyCFunction)_wrap_Window_IsBeingDeleted, METH_O, NULL},
53312 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53313 { (char *)"Window_GetLabel", (PyCFunction)_wrap_Window_GetLabel, METH_O, NULL},
53314 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
53315 { (char *)"Window_GetName", (PyCFunction)_wrap_Window_GetName, METH_O, NULL},
53316 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
53317 { (char *)"Window_GetWindowVariant", (PyCFunction)_wrap_Window_GetWindowVariant, METH_O, NULL},
53318 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53319 { (char *)"Window_GetId", (PyCFunction)_wrap_Window_GetId, METH_O, NULL},
53320 { (char *)"Window_NewControlId", (PyCFunction)_wrap_Window_NewControlId, METH_NOARGS, NULL},
53321 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
53322 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
53323 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
53324 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
53325 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53326 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53327 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
53328 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
53329 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
53330 { (char *)"Window_Raise", (PyCFunction)_wrap_Window_Raise, METH_O, NULL},
53331 { (char *)"Window_Lower", (PyCFunction)_wrap_Window_Lower, METH_O, NULL},
53332 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
53333 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53334 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
53335 { (char *)"Window_GetPosition", (PyCFunction)_wrap_Window_GetPosition, METH_O, NULL},
53336 { (char *)"Window_GetPositionTuple", (PyCFunction)_wrap_Window_GetPositionTuple, METH_O, NULL},
53337 { (char *)"Window_GetScreenPosition", (PyCFunction)_wrap_Window_GetScreenPosition, METH_O, NULL},
53338 { (char *)"Window_GetScreenPositionTuple", (PyCFunction)_wrap_Window_GetScreenPositionTuple, METH_O, NULL},
53339 { (char *)"Window_GetScreenRect", (PyCFunction)_wrap_Window_GetScreenRect, METH_O, NULL},
53340 { (char *)"Window_GetSize", (PyCFunction)_wrap_Window_GetSize, METH_O, NULL},
53341 { (char *)"Window_GetSizeTuple", (PyCFunction)_wrap_Window_GetSizeTuple, METH_O, NULL},
53342 { (char *)"Window_GetRect", (PyCFunction)_wrap_Window_GetRect, METH_O, NULL},
53343 { (char *)"Window_GetClientSize", (PyCFunction)_wrap_Window_GetClientSize, METH_O, NULL},
53344 { (char *)"Window_GetClientSizeTuple", (PyCFunction)_wrap_Window_GetClientSizeTuple, METH_O, NULL},
53345 { (char *)"Window_GetClientAreaOrigin", (PyCFunction)_wrap_Window_GetClientAreaOrigin, METH_O, NULL},
53346 { (char *)"Window_GetClientRect", (PyCFunction)_wrap_Window_GetClientRect, METH_O, NULL},
53347 { (char *)"Window_GetBestSize", (PyCFunction)_wrap_Window_GetBestSize, METH_O, NULL},
53348 { (char *)"Window_GetBestSizeTuple", (PyCFunction)_wrap_Window_GetBestSizeTuple, METH_O, NULL},
53349 { (char *)"Window_InvalidateBestSize", (PyCFunction)_wrap_Window_InvalidateBestSize, METH_O, NULL},
53350 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
53351 { (char *)"Window_GetBestFittingSize", (PyCFunction)_wrap_Window_GetBestFittingSize, METH_O, NULL},
53352 { (char *)"Window_GetAdjustedBestSize", (PyCFunction)_wrap_Window_GetAdjustedBestSize, METH_O, NULL},
53353 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
53354 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
53355 { (char *)"Window_Fit", (PyCFunction)_wrap_Window_Fit, METH_O, NULL},
53356 { (char *)"Window_FitInside", (PyCFunction)_wrap_Window_FitInside, METH_O, NULL},
53357 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53358 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
53359 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53360 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
53361 { (char *)"Window_GetMaxSize", (PyCFunction)_wrap_Window_GetMaxSize, METH_O, NULL},
53362 { (char *)"Window_GetMinSize", (PyCFunction)_wrap_Window_GetMinSize, METH_O, NULL},
53363 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
53364 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
53365 { (char *)"Window_GetMinWidth", (PyCFunction)_wrap_Window_GetMinWidth, METH_O, NULL},
53366 { (char *)"Window_GetMinHeight", (PyCFunction)_wrap_Window_GetMinHeight, METH_O, NULL},
53367 { (char *)"Window_GetMaxWidth", (PyCFunction)_wrap_Window_GetMaxWidth, METH_O, NULL},
53368 { (char *)"Window_GetMaxHeight", (PyCFunction)_wrap_Window_GetMaxHeight, METH_O, NULL},
53369 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
53370 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53371 { (char *)"Window_GetVirtualSize", (PyCFunction)_wrap_Window_GetVirtualSize, METH_O, NULL},
53372 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction)_wrap_Window_GetVirtualSizeTuple, METH_O, NULL},
53373 { (char *)"Window_GetBestVirtualSize", (PyCFunction)_wrap_Window_GetBestVirtualSize, METH_O, NULL},
53374 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53375 { (char *)"Window_Hide", (PyCFunction)_wrap_Window_Hide, METH_O, NULL},
53376 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53377 { (char *)"Window_Disable", (PyCFunction)_wrap_Window_Disable, METH_O, NULL},
53378 { (char *)"Window_IsShown", (PyCFunction)_wrap_Window_IsShown, METH_O, NULL},
53379 { (char *)"Window_IsEnabled", (PyCFunction)_wrap_Window_IsEnabled, METH_O, NULL},
53380 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53381 { (char *)"Window_GetWindowStyleFlag", (PyCFunction)_wrap_Window_GetWindowStyleFlag, METH_O, NULL},
53382 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53383 { (char *)"Window_IsRetained", (PyCFunction)_wrap_Window_IsRetained, METH_O, NULL},
53384 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
53385 { (char *)"Window_GetExtraStyle", (PyCFunction)_wrap_Window_GetExtraStyle, METH_O, NULL},
53386 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
53387 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53388 { (char *)"Window_GetThemeEnabled", (PyCFunction)_wrap_Window_GetThemeEnabled, METH_O, NULL},
53389 { (char *)"Window_SetFocus", (PyCFunction)_wrap_Window_SetFocus, METH_O, NULL},
53390 { (char *)"Window_SetFocusFromKbd", (PyCFunction)_wrap_Window_SetFocusFromKbd, METH_O, NULL},
53391 { (char *)"Window_FindFocus", (PyCFunction)_wrap_Window_FindFocus, METH_NOARGS, NULL},
53392 { (char *)"Window_AcceptsFocus", (PyCFunction)_wrap_Window_AcceptsFocus, METH_O, NULL},
53393 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction)_wrap_Window_AcceptsFocusFromKeyboard, METH_O, NULL},
53394 { (char *)"Window_GetDefaultItem", (PyCFunction)_wrap_Window_GetDefaultItem, METH_O, NULL},
53395 { (char *)"Window_SetDefaultItem", (PyCFunction) _wrap_Window_SetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
53396 { (char *)"Window_SetTmpDefaultItem", (PyCFunction) _wrap_Window_SetTmpDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
53397 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
53398 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
53399 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
53400 { (char *)"Window_GetChildren", (PyCFunction)_wrap_Window_GetChildren, METH_O, NULL},
53401 { (char *)"Window_GetParent", (PyCFunction)_wrap_Window_GetParent, METH_O, NULL},
53402 { (char *)"Window_GetGrandParent", (PyCFunction)_wrap_Window_GetGrandParent, METH_O, NULL},
53403 { (char *)"Window_IsTopLevel", (PyCFunction)_wrap_Window_IsTopLevel, METH_O, NULL},
53404 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
53405 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
53406 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
53407 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
53408 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
53409 { (char *)"Window_GetEventHandler", (PyCFunction)_wrap_Window_GetEventHandler, METH_O, NULL},
53410 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53411 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53412 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53413 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53414 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
53415 { (char *)"Window_GetValidator", (PyCFunction)_wrap_Window_GetValidator, METH_O, NULL},
53416 { (char *)"Window_Validate", (PyCFunction)_wrap_Window_Validate, METH_O, NULL},
53417 { (char *)"Window_TransferDataToWindow", (PyCFunction)_wrap_Window_TransferDataToWindow, METH_O, NULL},
53418 { (char *)"Window_TransferDataFromWindow", (PyCFunction)_wrap_Window_TransferDataFromWindow, METH_O, NULL},
53419 { (char *)"Window_InitDialog", (PyCFunction)_wrap_Window_InitDialog, METH_O, NULL},
53420 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
53421 { (char *)"Window_GetAcceleratorTable", (PyCFunction)_wrap_Window_GetAcceleratorTable, METH_O, NULL},
53422 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
53423 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
53424 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
53425 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
53426 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
53427 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
53428 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
53429 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
53430 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
53431 { (char *)"Window_CaptureMouse", (PyCFunction)_wrap_Window_CaptureMouse, METH_O, NULL},
53432 { (char *)"Window_ReleaseMouse", (PyCFunction)_wrap_Window_ReleaseMouse, METH_O, NULL},
53433 { (char *)"Window_GetCapture", (PyCFunction)_wrap_Window_GetCapture, METH_NOARGS, NULL},
53434 { (char *)"Window_HasCapture", (PyCFunction)_wrap_Window_HasCapture, METH_O, NULL},
53435 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
53436 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
53437 { (char *)"Window_Update", (PyCFunction)_wrap_Window_Update, METH_O, NULL},
53438 { (char *)"Window_ClearBackground", (PyCFunction)_wrap_Window_ClearBackground, METH_O, NULL},
53439 { (char *)"Window_Freeze", (PyCFunction)_wrap_Window_Freeze, METH_O, NULL},
53440 { (char *)"Window_Thaw", (PyCFunction)_wrap_Window_Thaw, METH_O, NULL},
53441 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
53442 { (char *)"Window_GetUpdateRegion", (PyCFunction)_wrap_Window_GetUpdateRegion, METH_O, NULL},
53443 { (char *)"Window_GetUpdateClientRect", (PyCFunction)_wrap_Window_GetUpdateClientRect, METH_O, NULL},
53444 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
53445 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53446 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
53447 { (char *)"Window_GetDefaultAttributes", (PyCFunction)_wrap_Window_GetDefaultAttributes, METH_O, NULL},
53448 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
53449 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53450 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53451 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53452 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53453 { (char *)"Window_GetBackgroundColour", (PyCFunction)_wrap_Window_GetBackgroundColour, METH_O, NULL},
53454 { (char *)"Window_GetForegroundColour", (PyCFunction)_wrap_Window_GetForegroundColour, METH_O, NULL},
53455 { (char *)"Window_InheritsBackgroundColour", (PyCFunction)_wrap_Window_InheritsBackgroundColour, METH_O, NULL},
53456 { (char *)"Window_UseBgCol", (PyCFunction)_wrap_Window_UseBgCol, METH_O, NULL},
53457 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
53458 { (char *)"Window_GetBackgroundStyle", (PyCFunction)_wrap_Window_GetBackgroundStyle, METH_O, NULL},
53459 { (char *)"Window_HasTransparentBackground", (PyCFunction)_wrap_Window_HasTransparentBackground, METH_O, NULL},
53460 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
53461 { (char *)"Window_GetCursor", (PyCFunction)_wrap_Window_GetCursor, METH_O, NULL},
53462 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
53463 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
53464 { (char *)"Window_GetFont", (PyCFunction)_wrap_Window_GetFont, METH_O, NULL},
53465 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
53466 { (char *)"Window_GetCaret", (PyCFunction)_wrap_Window_GetCaret, METH_O, NULL},
53467 { (char *)"Window_GetCharHeight", (PyCFunction)_wrap_Window_GetCharHeight, METH_O, NULL},
53468 { (char *)"Window_GetCharWidth", (PyCFunction)_wrap_Window_GetCharWidth, METH_O, NULL},
53469 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
53470 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
53471 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
53472 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
53473 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
53474 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
53475 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
53476 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
53477 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
53478 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
53479 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
53480 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53481 { (char *)"Window_GetHandle", (PyCFunction)_wrap_Window_GetHandle, METH_O, NULL},
53482 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
53483 { (char *)"Window_DissociateHandle", (PyCFunction)_wrap_Window_DissociateHandle, METH_O, NULL},
53484 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
53485 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
53486 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
53487 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
53488 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
53489 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
53490 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53491 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
53492 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
53493 { (char *)"Window_LineUp", (PyCFunction)_wrap_Window_LineUp, METH_O, NULL},
53494 { (char *)"Window_LineDown", (PyCFunction)_wrap_Window_LineDown, METH_O, NULL},
53495 { (char *)"Window_PageUp", (PyCFunction)_wrap_Window_PageUp, METH_O, NULL},
53496 { (char *)"Window_PageDown", (PyCFunction)_wrap_Window_PageDown, METH_O, NULL},
53497 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
53498 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
53499 { (char *)"Window_GetHelpText", (PyCFunction)_wrap_Window_GetHelpText, METH_O, NULL},
53500 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
53501 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
53502 { (char *)"Window_GetToolTip", (PyCFunction)_wrap_Window_GetToolTip, METH_O, NULL},
53503 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
53504 { (char *)"Window_GetDropTarget", (PyCFunction)_wrap_Window_GetDropTarget, METH_O, NULL},
53505 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
53506 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
53507 { (char *)"Window_GetConstraints", (PyCFunction)_wrap_Window_GetConstraints, METH_O, NULL},
53508 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
53509 { (char *)"Window_GetAutoLayout", (PyCFunction)_wrap_Window_GetAutoLayout, METH_O, NULL},
53510 { (char *)"Window_Layout", (PyCFunction)_wrap_Window_Layout, METH_O, NULL},
53511 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53512 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
53513 { (char *)"Window_GetSizer", (PyCFunction)_wrap_Window_GetSizer, METH_O, NULL},
53514 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53515 { (char *)"Window_GetContainingSizer", (PyCFunction)_wrap_Window_GetContainingSizer, METH_O, NULL},
53516 { (char *)"Window_InheritAttributes", (PyCFunction)_wrap_Window_InheritAttributes, METH_O, NULL},
53517 { (char *)"Window_ShouldInheritColours", (PyCFunction)_wrap_Window_ShouldInheritColours, METH_O, NULL},
53518 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
53519 { (char *)"Window_swiginit", Window_swiginit, METH_VARARGS, NULL},
53520 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
53521 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
53522 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53523 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
53524 { (char *)"GetTopLevelWindows", (PyCFunction)_wrap_GetTopLevelWindows, METH_NOARGS, NULL},
53525 { (char *)"new_Validator", (PyCFunction)_wrap_new_Validator, METH_NOARGS, NULL},
53526 { (char *)"Validator_Clone", (PyCFunction)_wrap_Validator_Clone, METH_O, NULL},
53527 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
53528 { (char *)"Validator_TransferToWindow", (PyCFunction)_wrap_Validator_TransferToWindow, METH_O, NULL},
53529 { (char *)"Validator_TransferFromWindow", (PyCFunction)_wrap_Validator_TransferFromWindow, METH_O, NULL},
53530 { (char *)"Validator_GetWindow", (PyCFunction)_wrap_Validator_GetWindow, METH_O, NULL},
53531 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53532 { (char *)"Validator_IsSilent", (PyCFunction)_wrap_Validator_IsSilent, METH_NOARGS, NULL},
53533 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
53534 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
53535 { (char *)"Validator_swiginit", Validator_swiginit, METH_VARARGS, NULL},
53536 { (char *)"new_PyValidator", (PyCFunction)_wrap_new_PyValidator, METH_NOARGS, NULL},
53537 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53538 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
53539 { (char *)"PyValidator_swiginit", PyValidator_swiginit, METH_VARARGS, NULL},
53540 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
53541 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
53542 { (char *)"Menu_AppendSeparator", (PyCFunction)_wrap_Menu_AppendSeparator, METH_O, NULL},
53543 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53544 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53545 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53546 { (char *)"Menu_AppendSubMenu", (PyCFunction) _wrap_Menu_AppendSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53547 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
53548 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
53549 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
53550 { (char *)"Menu_Break", (PyCFunction)_wrap_Menu_Break, METH_O, NULL},
53551 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53552 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
53553 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53554 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53555 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53556 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
53557 { (char *)"Menu_PrependSeparator", (PyCFunction)_wrap_Menu_PrependSeparator, METH_O, NULL},
53558 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53559 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53560 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53561 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
53562 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
53563 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
53564 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
53565 { (char *)"Menu_Destroy", (PyCFunction)_wrap_Menu_Destroy, METH_O, NULL},
53566 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
53567 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
53568 { (char *)"Menu_GetMenuItemCount", (PyCFunction)_wrap_Menu_GetMenuItemCount, METH_O, NULL},
53569 { (char *)"Menu_GetMenuItems", (PyCFunction)_wrap_Menu_GetMenuItems, METH_O, NULL},
53570 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
53571 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
53572 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53573 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53574 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53575 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53576 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
53577 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53578 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53579 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53580 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53581 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
53582 { (char *)"Menu_GetTitle", (PyCFunction)_wrap_Menu_GetTitle, METH_O, NULL},
53583 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53584 { (char *)"Menu_GetEventHandler", (PyCFunction)_wrap_Menu_GetEventHandler, METH_O, NULL},
53585 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53586 { (char *)"Menu_GetInvokingWindow", (PyCFunction)_wrap_Menu_GetInvokingWindow, METH_O, NULL},
53587 { (char *)"Menu_GetStyle", (PyCFunction)_wrap_Menu_GetStyle, METH_O, NULL},
53588 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
53589 { (char *)"Menu_GetMenuBar", (PyCFunction)_wrap_Menu_GetMenuBar, METH_O, NULL},
53590 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
53591 { (char *)"Menu_Detach", (PyCFunction)_wrap_Menu_Detach, METH_O, NULL},
53592 { (char *)"Menu_IsAttached", (PyCFunction)_wrap_Menu_IsAttached, METH_O, NULL},
53593 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
53594 { (char *)"Menu_GetParent", (PyCFunction)_wrap_Menu_GetParent, METH_O, NULL},
53595 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
53596 { (char *)"Menu_swiginit", Menu_swiginit, METH_VARARGS, NULL},
53597 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
53598 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
53599 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53600 { (char *)"MenuBar_GetMenuCount", (PyCFunction)_wrap_MenuBar_GetMenuCount, METH_O, NULL},
53601 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53602 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
53603 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
53604 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
53605 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
53606 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
53607 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
53608 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
53609 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
53610 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53611 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53612 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53613 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
53614 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53615 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53616 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53617 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53618 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53619 { (char *)"MenuBar_GetFrame", (PyCFunction)_wrap_MenuBar_GetFrame, METH_O, NULL},
53620 { (char *)"MenuBar_IsAttached", (PyCFunction)_wrap_MenuBar_IsAttached, METH_O, NULL},
53621 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
53622 { (char *)"MenuBar_Detach", (PyCFunction)_wrap_MenuBar_Detach, METH_O, NULL},
53623 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53624 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction)_wrap_MenuBar_GetAutoWindowMenu, METH_NOARGS, NULL},
53625 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
53626 { (char *)"MenuBar_swiginit", MenuBar_swiginit, METH_VARARGS, NULL},
53627 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
53628 { (char *)"delete_MenuItem", (PyCFunction)_wrap_delete_MenuItem, METH_O, NULL},
53629 { (char *)"MenuItem_GetMenu", (PyCFunction)_wrap_MenuItem_GetMenu, METH_O, NULL},
53630 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53631 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53632 { (char *)"MenuItem_GetId", (PyCFunction)_wrap_MenuItem_GetId, METH_O, NULL},
53633 { (char *)"MenuItem_IsSeparator", (PyCFunction)_wrap_MenuItem_IsSeparator, METH_O, NULL},
53634 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
53635 { (char *)"MenuItem_GetLabel", (PyCFunction)_wrap_MenuItem_GetLabel, METH_O, NULL},
53636 { (char *)"MenuItem_GetText", (PyCFunction)_wrap_MenuItem_GetText, METH_O, NULL},
53637 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
53638 { (char *)"MenuItem_GetKind", (PyCFunction)_wrap_MenuItem_GetKind, METH_O, NULL},
53639 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
53640 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
53641 { (char *)"MenuItem_IsCheckable", (PyCFunction)_wrap_MenuItem_IsCheckable, METH_O, NULL},
53642 { (char *)"MenuItem_IsSubMenu", (PyCFunction)_wrap_MenuItem_IsSubMenu, METH_O, NULL},
53643 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53644 { (char *)"MenuItem_GetSubMenu", (PyCFunction)_wrap_MenuItem_GetSubMenu, METH_O, NULL},
53645 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53646 { (char *)"MenuItem_IsEnabled", (PyCFunction)_wrap_MenuItem_IsEnabled, METH_O, NULL},
53647 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53648 { (char *)"MenuItem_IsChecked", (PyCFunction)_wrap_MenuItem_IsChecked, METH_O, NULL},
53649 { (char *)"MenuItem_Toggle", (PyCFunction)_wrap_MenuItem_Toggle, METH_O, NULL},
53650 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
53651 { (char *)"MenuItem_GetHelp", (PyCFunction)_wrap_MenuItem_GetHelp, METH_O, NULL},
53652 { (char *)"MenuItem_GetAccel", (PyCFunction)_wrap_MenuItem_GetAccel, METH_O, NULL},
53653 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
53654 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53655 { (char *)"MenuItem_GetBitmap", (PyCFunction)_wrap_MenuItem_GetBitmap, METH_O, NULL},
53656 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
53657 { (char *)"MenuItem_GetFont", (PyCFunction)_wrap_MenuItem_GetFont, METH_O, NULL},
53658 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
53659 { (char *)"MenuItem_GetTextColour", (PyCFunction)_wrap_MenuItem_GetTextColour, METH_O, NULL},
53660 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53661 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction)_wrap_MenuItem_GetBackgroundColour, METH_O, NULL},
53662 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
53663 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53664 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction)_wrap_MenuItem_GetDisabledBitmap, METH_O, NULL},
53665 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
53666 { (char *)"MenuItem_GetMarginWidth", (PyCFunction)_wrap_MenuItem_GetMarginWidth, METH_O, NULL},
53667 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction)_wrap_MenuItem_GetDefaultMarginWidth, METH_NOARGS, NULL},
53668 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction)_wrap_MenuItem_IsOwnerDrawn, METH_O, NULL},
53669 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
53670 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction)_wrap_MenuItem_ResetOwnerDrawn, METH_O, NULL},
53671 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
53672 { (char *)"MenuItem_swiginit", MenuItem_swiginit, METH_VARARGS, NULL},
53673 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
53674 { (char *)"new_PreControl", (PyCFunction)_wrap_new_PreControl, METH_NOARGS, NULL},
53675 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
53676 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
53677 { (char *)"Control_GetLabel", (PyCFunction)_wrap_Control_GetLabel, METH_O, NULL},
53678 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
53679 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
53680 { (char *)"Control_swiginit", Control_swiginit, METH_VARARGS, NULL},
53681 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
53682 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
53683 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53684 { (char *)"ItemContainer_Clear", (PyCFunction)_wrap_ItemContainer_Clear, METH_O, NULL},
53685 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
53686 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
53687 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
53688 { (char *)"ItemContainer_GetCount", (PyCFunction)_wrap_ItemContainer_GetCount, METH_O, NULL},
53689 { (char *)"ItemContainer_IsEmpty", (PyCFunction)_wrap_ItemContainer_IsEmpty, METH_O, NULL},
53690 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
53691 { (char *)"ItemContainer_GetStrings", (PyCFunction)_wrap_ItemContainer_GetStrings, METH_O, NULL},
53692 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
53693 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
53694 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
53695 { (char *)"ItemContainer_GetSelection", (PyCFunction)_wrap_ItemContainer_GetSelection, METH_O, NULL},
53696 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
53697 { (char *)"ItemContainer_GetStringSelection", (PyCFunction)_wrap_ItemContainer_GetStringSelection, METH_O, NULL},
53698 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
53699 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
53700 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
53701 { (char *)"new_SizerItem", (PyCFunction)_wrap_new_SizerItem, METH_NOARGS, NULL},
53702 { (char *)"delete_SizerItem", (PyCFunction)_wrap_delete_SizerItem, METH_O, NULL},
53703 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53704 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
53705 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53706 { (char *)"SizerItem_DeleteWindows", (PyCFunction)_wrap_SizerItem_DeleteWindows, METH_O, NULL},
53707 { (char *)"SizerItem_DetachSizer", (PyCFunction)_wrap_SizerItem_DetachSizer, METH_O, NULL},
53708 { (char *)"SizerItem_GetSize", (PyCFunction)_wrap_SizerItem_GetSize, METH_O, NULL},
53709 { (char *)"SizerItem_CalcMin", (PyCFunction)_wrap_SizerItem_CalcMin, METH_O, NULL},
53710 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
53711 { (char *)"SizerItem_GetMinSize", (PyCFunction)_wrap_SizerItem_GetMinSize, METH_O, NULL},
53712 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction)_wrap_SizerItem_GetMinSizeWithBorder, METH_O, NULL},
53713 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
53714 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
53715 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
53716 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
53717 { (char *)"SizerItem_GetRatio", (PyCFunction)_wrap_SizerItem_GetRatio, METH_O, NULL},
53718 { (char *)"SizerItem_GetRect", (PyCFunction)_wrap_SizerItem_GetRect, METH_O, NULL},
53719 { (char *)"SizerItem_IsWindow", (PyCFunction)_wrap_SizerItem_IsWindow, METH_O, NULL},
53720 { (char *)"SizerItem_IsSizer", (PyCFunction)_wrap_SizerItem_IsSizer, METH_O, NULL},
53721 { (char *)"SizerItem_IsSpacer", (PyCFunction)_wrap_SizerItem_IsSpacer, METH_O, NULL},
53722 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
53723 { (char *)"SizerItem_GetProportion", (PyCFunction)_wrap_SizerItem_GetProportion, METH_O, NULL},
53724 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53725 { (char *)"SizerItem_GetFlag", (PyCFunction)_wrap_SizerItem_GetFlag, METH_O, NULL},
53726 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
53727 { (char *)"SizerItem_GetBorder", (PyCFunction)_wrap_SizerItem_GetBorder, METH_O, NULL},
53728 { (char *)"SizerItem_GetWindow", (PyCFunction)_wrap_SizerItem_GetWindow, METH_O, NULL},
53729 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53730 { (char *)"SizerItem_GetSizer", (PyCFunction)_wrap_SizerItem_GetSizer, METH_O, NULL},
53731 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53732 { (char *)"SizerItem_GetSpacer", (PyCFunction)_wrap_SizerItem_GetSpacer, METH_O, NULL},
53733 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
53734 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53735 { (char *)"SizerItem_IsShown", (PyCFunction)_wrap_SizerItem_IsShown, METH_O, NULL},
53736 { (char *)"SizerItem_GetPosition", (PyCFunction)_wrap_SizerItem_GetPosition, METH_O, NULL},
53737 { (char *)"SizerItem_GetUserData", (PyCFunction)_wrap_SizerItem_GetUserData, METH_O, NULL},
53738 { (char *)"SizerItem_SetUserData", (PyCFunction) _wrap_SizerItem_SetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
53739 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
53740 { (char *)"SizerItem_swiginit", SizerItem_swiginit, METH_VARARGS, NULL},
53741 { (char *)"delete_Sizer", (PyCFunction)_wrap_delete_Sizer, METH_O, NULL},
53742 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53743 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
53744 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53745 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
53746 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
53747 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
53748 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
53749 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
53750 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
53751 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
53752 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
53753 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
53754 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
53755 { (char *)"Sizer_GetSize", (PyCFunction)_wrap_Sizer_GetSize, METH_O, NULL},
53756 { (char *)"Sizer_GetPosition", (PyCFunction)_wrap_Sizer_GetPosition, METH_O, NULL},
53757 { (char *)"Sizer_GetMinSize", (PyCFunction)_wrap_Sizer_GetMinSize, METH_O, NULL},
53758 { (char *)"Sizer_RecalcSizes", (PyCFunction)_wrap_Sizer_RecalcSizes, METH_O, NULL},
53759 { (char *)"Sizer_CalcMin", (PyCFunction)_wrap_Sizer_CalcMin, METH_O, NULL},
53760 { (char *)"Sizer_Layout", (PyCFunction)_wrap_Sizer_Layout, METH_O, NULL},
53761 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
53762 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
53763 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53764 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53765 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
53766 { (char *)"Sizer_DeleteWindows", (PyCFunction)_wrap_Sizer_DeleteWindows, METH_O, NULL},
53767 { (char *)"Sizer_GetChildren", (PyCFunction)_wrap_Sizer_GetChildren, METH_O, NULL},
53768 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53769 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
53770 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
53771 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
53772 { (char *)"new_PySizer", (PyCFunction)_wrap_new_PySizer, METH_NOARGS, NULL},
53773 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53774 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
53775 { (char *)"PySizer_swiginit", PySizer_swiginit, METH_VARARGS, NULL},
53776 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53777 { (char *)"BoxSizer_GetOrientation", (PyCFunction)_wrap_BoxSizer_GetOrientation, METH_O, NULL},
53778 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
53779 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
53780 { (char *)"BoxSizer_swiginit", BoxSizer_swiginit, METH_VARARGS, NULL},
53781 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53782 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction)_wrap_StaticBoxSizer_GetStaticBox, METH_O, NULL},
53783 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
53784 { (char *)"StaticBoxSizer_swiginit", StaticBoxSizer_swiginit, METH_VARARGS, NULL},
53785 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53786 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
53787 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
53788 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
53789 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
53790 { (char *)"GridSizer_GetCols", (PyCFunction)_wrap_GridSizer_GetCols, METH_O, NULL},
53791 { (char *)"GridSizer_GetRows", (PyCFunction)_wrap_GridSizer_GetRows, METH_O, NULL},
53792 { (char *)"GridSizer_GetVGap", (PyCFunction)_wrap_GridSizer_GetVGap, METH_O, NULL},
53793 { (char *)"GridSizer_GetHGap", (PyCFunction)_wrap_GridSizer_GetHGap, METH_O, NULL},
53794 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
53795 { (char *)"GridSizer_swiginit", GridSizer_swiginit, METH_VARARGS, NULL},
53796 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53797 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
53798 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
53799 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
53800 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
53801 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
53802 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction)_wrap_FlexGridSizer_GetFlexibleDirection, METH_O, NULL},
53803 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
53804 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction)_wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_O, NULL},
53805 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction)_wrap_FlexGridSizer_GetRowHeights, METH_O, NULL},
53806 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction)_wrap_FlexGridSizer_GetColWidths, METH_O, NULL},
53807 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
53808 { (char *)"FlexGridSizer_swiginit", FlexGridSizer_swiginit, METH_VARARGS, NULL},
53809 { (char *)"new_StdDialogButtonSizer", (PyCFunction)_wrap_new_StdDialogButtonSizer, METH_NOARGS, NULL},
53810 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
53811 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction)_wrap_StdDialogButtonSizer_Realize, METH_O, NULL},
53812 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
53813 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
53814 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
53815 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_O, NULL},
53816 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetApplyButton, METH_O, NULL},
53817 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetNegativeButton, METH_O, NULL},
53818 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetCancelButton, METH_O, NULL},
53819 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetHelpButton, METH_O, NULL},
53820 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
53821 { (char *)"StdDialogButtonSizer_swiginit", StdDialogButtonSizer_swiginit, METH_VARARGS, NULL},
53822 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53823 { (char *)"delete_GBPosition", (PyCFunction)_wrap_delete_GBPosition, METH_O, NULL},
53824 { (char *)"GBPosition_GetRow", (PyCFunction)_wrap_GBPosition_GetRow, METH_O, NULL},
53825 { (char *)"GBPosition_GetCol", (PyCFunction)_wrap_GBPosition_GetCol, METH_O, NULL},
53826 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
53827 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
53828 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53829 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53830 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53831 { (char *)"GBPosition_Get", (PyCFunction)_wrap_GBPosition_Get, METH_O, NULL},
53832 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
53833 { (char *)"GBPosition_swiginit", GBPosition_swiginit, METH_VARARGS, NULL},
53834 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
53835 { (char *)"delete_GBSpan", (PyCFunction)_wrap_delete_GBSpan, METH_O, NULL},
53836 { (char *)"GBSpan_GetRowspan", (PyCFunction)_wrap_GBSpan_GetRowspan, METH_O, NULL},
53837 { (char *)"GBSpan_GetColspan", (PyCFunction)_wrap_GBSpan_GetColspan, METH_O, NULL},
53838 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
53839 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
53840 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53841 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53842 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53843 { (char *)"GBSpan_Get", (PyCFunction)_wrap_GBSpan_Get, METH_O, NULL},
53844 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
53845 { (char *)"GBSpan_swiginit", GBSpan_swiginit, METH_VARARGS, NULL},
53846 { (char *)"new_GBSizerItem", (PyCFunction)_wrap_new_GBSizerItem, METH_NOARGS, NULL},
53847 { (char *)"delete_GBSizerItem", (PyCFunction)_wrap_delete_GBSizerItem, METH_O, NULL},
53848 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53849 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53850 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
53851 { (char *)"GBSizerItem_GetPos", (PyCFunction)_wrap_GBSizerItem_GetPos, METH_O, NULL},
53852 { (char *)"GBSizerItem_GetSpan", (PyCFunction)_wrap_GBSizerItem_GetSpan, METH_O, NULL},
53853 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
53854 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
53855 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
53856 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
53857 { (char *)"GBSizerItem_GetEndPos", (PyCFunction)_wrap_GBSizerItem_GetEndPos, METH_O, NULL},
53858 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction)_wrap_GBSizerItem_GetGBSizer, METH_O, NULL},
53859 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53860 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
53861 { (char *)"GBSizerItem_swiginit", GBSizerItem_swiginit, METH_VARARGS, NULL},
53862 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53863 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
53864 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
53865 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
53866 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction)_wrap_GridBagSizer_GetEmptyCellSize, METH_O, NULL},
53867 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
53868 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
53869 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
53870 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
53871 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
53872 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
53873 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53874 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53875 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
53876 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
53877 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
53878 { (char *)"GridBagSizer_swiginit", GridBagSizer_swiginit, METH_VARARGS, NULL},
53879 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53880 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
53881 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
53882 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
53883 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
53884 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
53885 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
53886 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
53887 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction)_wrap_IndividualLayoutConstraint_Unconstrained, METH_O, NULL},
53888 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction)_wrap_IndividualLayoutConstraint_AsIs, METH_O, NULL},
53889 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherWindow, METH_O, NULL},
53890 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMyEdge, METH_O, NULL},
53891 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
53892 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
53893 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMargin, METH_O, NULL},
53894 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
53895 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction)_wrap_IndividualLayoutConstraint_GetValue, METH_O, NULL},
53896 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction)_wrap_IndividualLayoutConstraint_GetPercent, METH_O, NULL},
53897 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherEdge, METH_O, NULL},
53898 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction)_wrap_IndividualLayoutConstraint_GetDone, METH_O, NULL},
53899 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
53900 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction)_wrap_IndividualLayoutConstraint_GetRelationship, METH_O, NULL},
53901 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
53902 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
53903 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
53904 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
53905 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
53906 { (char *)"LayoutConstraints_left_get", (PyCFunction)_wrap_LayoutConstraints_left_get, METH_O, NULL},
53907 { (char *)"LayoutConstraints_top_get", (PyCFunction)_wrap_LayoutConstraints_top_get, METH_O, NULL},
53908 { (char *)"LayoutConstraints_right_get", (PyCFunction)_wrap_LayoutConstraints_right_get, METH_O, NULL},
53909 { (char *)"LayoutConstraints_bottom_get", (PyCFunction)_wrap_LayoutConstraints_bottom_get, METH_O, NULL},
53910 { (char *)"LayoutConstraints_width_get", (PyCFunction)_wrap_LayoutConstraints_width_get, METH_O, NULL},
53911 { (char *)"LayoutConstraints_height_get", (PyCFunction)_wrap_LayoutConstraints_height_get, METH_O, NULL},
53912 { (char *)"LayoutConstraints_centreX_get", (PyCFunction)_wrap_LayoutConstraints_centreX_get, METH_O, NULL},
53913 { (char *)"LayoutConstraints_centreY_get", (PyCFunction)_wrap_LayoutConstraints_centreY_get, METH_O, NULL},
53914 { (char *)"new_LayoutConstraints", (PyCFunction)_wrap_new_LayoutConstraints, METH_NOARGS, NULL},
53915 { (char *)"delete_LayoutConstraints", (PyCFunction)_wrap_delete_LayoutConstraints, METH_O, NULL},
53916 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
53917 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction)_wrap_LayoutConstraints_AreSatisfied, METH_O, NULL},
53918 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
53919 { (char *)"LayoutConstraints_swiginit", LayoutConstraints_swiginit, METH_VARARGS, NULL},
53920 { NULL, NULL, 0, NULL }
53921 };
53922
53923
53924 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
53925
53926 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
53927 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
53928 }
53929 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
53930 return (void *)((wxSizer *) ((wxBoxSizer *) x));
53931 }
53932 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
53933 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
53934 }
53935 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
53936 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
53937 }
53938 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
53939 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
53940 }
53941 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
53942 return (void *)((wxSizer *) ((wxGridSizer *) x));
53943 }
53944 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
53945 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
53946 }
53947 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
53948 return (void *)((wxSizer *) ((wxPySizer *) x));
53949 }
53950 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
53951 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
53952 }
53953 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
53954 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
53955 }
53956 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
53957 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
53958 }
53959 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
53960 return (void *)((wxEvent *) ((wxMenuEvent *) x));
53961 }
53962 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
53963 return (void *)((wxEvent *) ((wxCloseEvent *) x));
53964 }
53965 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
53966 return (void *)((wxEvent *) ((wxMouseEvent *) x));
53967 }
53968 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
53969 return (void *)((wxEvent *) ((wxEraseEvent *) x));
53970 }
53971 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
53972 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
53973 }
53974 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
53975 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
53976 }
53977 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
53978 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
53979 }
53980 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
53981 return (void *)((wxEvent *) ((wxPyEvent *) x));
53982 }
53983 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
53984 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
53985 }
53986 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
53987 return (void *)((wxEvent *) ((wxIdleEvent *) x));
53988 }
53989 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
53990 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
53991 }
53992 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
53993 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
53994 }
53995 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
53996 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
53997 }
53998 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
53999 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
54000 }
54001 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
54002 return (void *)((wxEvent *) ((wxActivateEvent *) x));
54003 }
54004 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
54005 return (void *)((wxEvent *) ((wxSizeEvent *) x));
54006 }
54007 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
54008 return (void *)((wxEvent *) ((wxMoveEvent *) x));
54009 }
54010 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
54011 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
54012 }
54013 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
54014 return (void *)((wxEvent *) ((wxPaintEvent *) x));
54015 }
54016 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
54017 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
54018 }
54019 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
54020 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
54021 }
54022 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
54023 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
54024 }
54025 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
54026 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
54027 }
54028 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
54029 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
54030 }
54031 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
54032 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
54033 }
54034 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
54035 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
54036 }
54037 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
54038 return (void *)((wxEvent *) ((wxFocusEvent *) x));
54039 }
54040 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
54041 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
54042 }
54043 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
54044 return (void *)((wxEvent *) ((wxShowEvent *) x));
54045 }
54046 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
54047 return (void *)((wxEvent *) ((wxCommandEvent *) x));
54048 }
54049 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
54050 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
54051 }
54052 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
54053 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54054 }
54055 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
54056 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
54057 }
54058 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
54059 return (void *)((wxEvent *) ((wxKeyEvent *) x));
54060 }
54061 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
54062 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
54063 }
54064 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
54065 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
54066 }
54067 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
54068 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
54069 }
54070 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
54071 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
54072 }
54073 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
54074 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
54075 }
54076 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
54077 return (void *)((wxControl *) ((wxControlWithItems *) x));
54078 }
54079 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
54080 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
54081 }
54082 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
54083 return (void *)((wxEvtHandler *) ((wxWindow *) x));
54084 }
54085 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
54086 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
54087 }
54088 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
54089 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
54090 }
54091 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
54092 return (void *)((wxEvtHandler *) ((wxValidator *) x));
54093 }
54094 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
54095 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
54096 }
54097 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
54098 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
54099 }
54100 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
54101 return (void *)((wxEvtHandler *) ((wxMenu *) x));
54102 }
54103 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
54104 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
54105 }
54106 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
54107 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
54108 }
54109 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
54110 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
54111 }
54112 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
54113 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
54114 }
54115 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
54116 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
54117 }
54118 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
54119 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54120 }
54121 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
54122 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
54123 }
54124 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
54125 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
54126 }
54127 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
54128 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
54129 }
54130 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
54131 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
54132 }
54133 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
54134 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54135 }
54136 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
54137 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
54138 }
54139 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
54140 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
54141 }
54142 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
54143 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
54144 }
54145 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
54146 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
54147 }
54148 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
54149 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
54150 }
54151 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
54152 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
54153 }
54154 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
54155 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
54156 }
54157 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
54158 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
54159 }
54160 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
54161 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
54162 }
54163 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
54164 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
54165 }
54166 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
54167 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
54168 }
54169 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
54170 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
54171 }
54172 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
54173 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
54174 }
54175 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
54176 return (void *)((wxObject *) ((wxSizerItem *) x));
54177 }
54178 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
54179 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
54180 }
54181 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
54182 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
54183 }
54184 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
54185 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
54186 }
54187 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
54188 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
54189 }
54190 static void *_p_wxSizerTo_p_wxObject(void *x) {
54191 return (void *)((wxObject *) ((wxSizer *) x));
54192 }
54193 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
54194 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
54195 }
54196 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
54197 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
54198 }
54199 static void *_p_wxEventTo_p_wxObject(void *x) {
54200 return (void *)((wxObject *) ((wxEvent *) x));
54201 }
54202 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
54203 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
54204 }
54205 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
54206 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
54207 }
54208 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
54209 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
54210 }
54211 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
54212 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
54213 }
54214 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
54215 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
54216 }
54217 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
54218 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
54219 }
54220 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
54221 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
54222 }
54223 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
54224 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
54225 }
54226 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
54227 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
54228 }
54229 static void *_p_wxControlTo_p_wxObject(void *x) {
54230 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
54231 }
54232 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
54233 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
54234 }
54235 static void *_p_wxFSFileTo_p_wxObject(void *x) {
54236 return (void *)((wxObject *) ((wxFSFile *) x));
54237 }
54238 static void *_p_wxPySizerTo_p_wxObject(void *x) {
54239 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
54240 }
54241 static void *_p_wxPyEventTo_p_wxObject(void *x) {
54242 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
54243 }
54244 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
54245 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
54246 }
54247 static void *_p_wxShowEventTo_p_wxObject(void *x) {
54248 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
54249 }
54250 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
54251 return (void *)((wxObject *) ((wxMenuItem *) x));
54252 }
54253 static void *_p_wxDateEventTo_p_wxObject(void *x) {
54254 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
54255 }
54256 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
54257 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
54258 }
54259 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
54260 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
54261 }
54262 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
54263 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
54264 }
54265 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
54266 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
54267 }
54268 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
54269 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
54270 }
54271 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
54272 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
54273 }
54274 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
54275 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
54276 }
54277 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
54278 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
54279 }
54280 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
54281 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
54282 }
54283 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
54284 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
54285 }
54286 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
54287 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
54288 }
54289 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
54290 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
54291 }
54292 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
54293 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
54294 }
54295 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
54296 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54297 }
54298 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
54299 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
54300 }
54301 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
54302 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
54303 }
54304 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
54305 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
54306 }
54307 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
54308 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
54309 }
54310 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
54311 return (void *)((wxObject *) ((wxImageHandler *) x));
54312 }
54313 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
54314 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
54315 }
54316 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
54317 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
54318 }
54319 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
54320 return (void *)((wxObject *) ((wxEvtHandler *) x));
54321 }
54322 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
54323 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54324 }
54325 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
54326 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
54327 }
54328 static void *_p_wxImageTo_p_wxObject(void *x) {
54329 return (void *)((wxObject *) ((wxImage *) x));
54330 }
54331 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
54332 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
54333 }
54334 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
54335 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54336 }
54337 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
54338 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
54339 }
54340 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
54341 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
54342 }
54343 static void *_p_wxWindowTo_p_wxObject(void *x) {
54344 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
54345 }
54346 static void *_p_wxMenuTo_p_wxObject(void *x) {
54347 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
54348 }
54349 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
54350 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
54351 }
54352 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
54353 return (void *)((wxObject *) ((wxFileSystem *) x));
54354 }
54355 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
54356 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
54357 }
54358 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
54359 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
54360 }
54361 static void *_p_wxPyAppTo_p_wxObject(void *x) {
54362 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
54363 }
54364 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
54365 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
54366 }
54367 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
54368 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
54369 }
54370 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
54371 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
54372 }
54373 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
54374 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
54375 }
54376 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
54377 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
54378 }
54379 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
54380 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
54381 }
54382 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
54383 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
54384 }
54385 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
54386 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
54387 }
54388 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
54389 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
54390 }
54391 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
54392 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
54393 }
54394 static void *_p_wxValidatorTo_p_wxObject(void *x) {
54395 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
54396 }
54397 static void *_p_wxControlTo_p_wxWindow(void *x) {
54398 return (void *)((wxWindow *) ((wxControl *) x));
54399 }
54400 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
54401 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
54402 }
54403 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
54404 return (void *)((wxWindow *) ((wxMenuBar *) x));
54405 }
54406 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
54407 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
54408 }
54409 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
54410 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
54411 }
54412 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
54413 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
54414 }
54415 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
54416 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
54417 }
54418 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
54419 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
54420 }
54421 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
54422 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54423 }
54424 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
54425 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
54426 }
54427 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
54428 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
54429 }
54430 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
54431 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
54432 }
54433 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
54434 return (void *)((wxValidator *) ((wxPyValidator *) x));
54435 }
54436 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, (void*)0, 0};
54437 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
54438 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};
54439 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
54440 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
54441 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
54442 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
54443 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
54444 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", "wxANIHandler *", 0, 0, (void*)0, 0};
54445 static swig_type_info _swigt__p_wxAcceleratorEntry = {"_p_wxAcceleratorEntry", "wxAcceleratorEntry *", 0, 0, (void*)0, 0};
54446 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", "wxAcceleratorTable *", 0, 0, (void*)0, 0};
54447 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", "wxActivateEvent *", 0, 0, (void*)0, 0};
54448 static swig_type_info _swigt__p_wxAppTraits = {"_p_wxAppTraits", "wxAppTraits *", 0, 0, (void*)0, 0};
54449 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
54450 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", "wxBMPHandler *", 0, 0, (void*)0, 0};
54451 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
54452 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", "wxBoxSizer *", 0, 0, (void*)0, 0};
54453 static swig_type_info _swigt__p_wxButton = {"_p_wxButton", "wxButton *", 0, 0, (void*)0, 0};
54454 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", "wxCURHandler *", 0, 0, (void*)0, 0};
54455 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
54456 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", "wxChildFocusEvent *", 0, 0, (void*)0, 0};
54457 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", "wxCloseEvent *", 0, 0, (void*)0, 0};
54458 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
54459 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
54460 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", "wxContextMenuEvent *", 0, 0, (void*)0, 0};
54461 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
54462 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", "wxControlWithItems *", 0, 0, (void*)0, 0};
54463 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
54464 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
54465 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", "wxDateEvent *", 0, 0, (void*)0, 0};
54466 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
54467 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", "wxDisplayChangedEvent *", 0, 0, (void*)0, 0};
54468 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", "wxDropFilesEvent *", 0, 0, (void*)0, 0};
54469 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
54470 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", "wxEraseEvent *", 0, 0, (void*)0, 0};
54471 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
54472 static swig_type_info _swigt__p_wxEventLoop = {"_p_wxEventLoop", "wxEventLoop *", 0, 0, (void*)0, 0};
54473 static swig_type_info _swigt__p_wxEventLoopActivator = {"_p_wxEventLoopActivator", "wxEventLoopActivator *", 0, 0, (void*)0, 0};
54474 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
54475 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", "wxFSFile *", 0, 0, (void*)0, 0};
54476 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, (void*)0, 0};
54477 static swig_type_info _swigt__p_wxFileSystemHandler = {"_p_wxFileSystemHandler", "wxFileSystemHandler *", 0, 0, (void*)0, 0};
54478 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", "wxFlexGridSizer *", 0, 0, (void*)0, 0};
54479 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", "wxFocusEvent *", 0, 0, (void*)0, 0};
54480 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
54481 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
54482 static swig_type_info _swigt__p_wxGBPosition = {"_p_wxGBPosition", "wxGBPosition *", 0, 0, (void*)0, 0};
54483 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", "wxGBSizerItem *", 0, 0, (void*)0, 0};
54484 static swig_type_info _swigt__p_wxGBSpan = {"_p_wxGBSpan", "wxGBSpan *", 0, 0, (void*)0, 0};
54485 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", "wxGIFHandler *", 0, 0, (void*)0, 0};
54486 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", "wxGridBagSizer *", 0, 0, (void*)0, 0};
54487 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", "wxGridSizer *", 0, 0, (void*)0, 0};
54488 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", "wxICOHandler *", 0, 0, (void*)0, 0};
54489 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", "wxIconizeEvent *", 0, 0, (void*)0, 0};
54490 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", "wxIdleEvent *", 0, 0, (void*)0, 0};
54491 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, (void*)0, 0};
54492 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", "wxImageHandler *", 0, 0, (void*)0, 0};
54493 static swig_type_info _swigt__p_wxImageHistogram = {"_p_wxImageHistogram", "wxImageHistogram *", 0, 0, (void*)0, 0};
54494 static swig_type_info _swigt__p_wxImage_HSVValue = {"_p_wxImage_HSVValue", "wxImage_HSVValue *", 0, 0, (void*)0, 0};
54495 static swig_type_info _swigt__p_wxImage_RGBValue = {"_p_wxImage_RGBValue", "wxImage_RGBValue *", 0, 0, (void*)0, 0};
54496 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", "wxIndividualLayoutConstraint *", 0, 0, (void*)0, 0};
54497 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", "wxInitDialogEvent *", 0, 0, (void*)0, 0};
54498 static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, (void*)0, 0};
54499 static swig_type_info _swigt__p_wxInternetFSHandler = {"_p_wxInternetFSHandler", "wxInternetFSHandler *", 0, 0, (void*)0, 0};
54500 static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, (void*)0, 0};
54501 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", "wxJPEGHandler *", 0, 0, (void*)0, 0};
54502 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
54503 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", "wxLayoutConstraints *", 0, 0, (void*)0, 0};
54504 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", "wxMaximizeEvent *", 0, 0, (void*)0, 0};
54505 static swig_type_info _swigt__p_wxMemoryFSHandler = {"_p_wxMemoryFSHandler", "wxMemoryFSHandler *", 0, 0, (void*)0, 0};
54506 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
54507 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", "wxMenuBar *", 0, 0, (void*)0, 0};
54508 static swig_type_info _swigt__p_wxMenuBarBase = {"_p_wxMenuBarBase", "wxMenuBarBase *", 0, 0, (void*)0, 0};
54509 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", "wxMenuEvent *", 0, 0, (void*)0, 0};
54510 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", "wxMenuItem *", 0, 0, (void*)0, 0};
54511 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", "wxMouseCaptureChangedEvent *", 0, 0, (void*)0, 0};
54512 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", "wxMouseEvent *", 0, 0, (void*)0, 0};
54513 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", "wxMoveEvent *", 0, 0, (void*)0, 0};
54514 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", "wxNavigationKeyEvent *", 0, 0, (void*)0, 0};
54515 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", "wxNcPaintEvent *", 0, 0, (void*)0, 0};
54516 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
54517 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
54518 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
54519 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", "wxPCXHandler *", 0, 0, (void*)0, 0};
54520 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", "wxPNGHandler *", 0, 0, (void*)0, 0};
54521 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", "wxPNMHandler *", 0, 0, (void*)0, 0};
54522 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", "wxPaintEvent *", 0, 0, (void*)0, 0};
54523 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", "wxPaletteChangedEvent *", 0, 0, (void*)0, 0};
54524 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
54525 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
54526 static swig_type_info _swigt__p_wxPoint2D = {"_p_wxPoint2D", "wxPoint2D *", 0, 0, (void*)0, 0};
54527 static swig_type_info _swigt__p_wxPropagateOnce = {"_p_wxPropagateOnce", "wxPropagateOnce *", 0, 0, (void*)0, 0};
54528 static swig_type_info _swigt__p_wxPropagationDisabler = {"_p_wxPropagationDisabler", "wxPropagationDisabler *", 0, 0, (void*)0, 0};
54529 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", "wxPyApp *", 0, 0, (void*)0, 0};
54530 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", "wxPyCommandEvent *", 0, 0, (void*)0, 0};
54531 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
54532 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", "wxPyEvent *", 0, 0, (void*)0, 0};
54533 static swig_type_info _swigt__p_wxPyFileSystemHandler = {"_p_wxPyFileSystemHandler", "wxPyFileSystemHandler *", 0, 0, (void*)0, 0};
54534 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", "wxPyImageHandler *", 0, 0, (void*)0, 0};
54535 static swig_type_info _swigt__p_wxPyInputStream = {"_p_wxPyInputStream", "wxPyInputStream *", 0, 0, (void*)0, 0};
54536 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", "wxPySizer *", 0, 0, (void*)0, 0};
54537 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", "wxPyValidator *", 0, 0, (void*)0, 0};
54538 static swig_type_info _swigt__p_wxQuantize = {"_p_wxQuantize", "wxQuantize *", 0, 0, (void*)0, 0};
54539 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", "wxQueryNewPaletteEvent *", 0, 0, (void*)0, 0};
54540 static swig_type_info _swigt__p_wxRealPoint = {"_p_wxRealPoint", "wxRealPoint *", 0, 0, (void*)0, 0};
54541 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
54542 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, (void*)0, 0};
54543 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", "wxScrollEvent *", 0, 0, (void*)0, 0};
54544 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", "wxScrollWinEvent *", 0, 0, (void*)0, 0};
54545 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", "wxSetCursorEvent *", 0, 0, (void*)0, 0};
54546 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", "wxShowEvent *", 0, 0, (void*)0, 0};
54547 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
54548 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", "wxSizeEvent *", 0, 0, (void*)0, 0};
54549 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", "wxSizer *", 0, 0, (void*)0, 0};
54550 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", "wxSizerItem *", 0, 0, (void*)0, 0};
54551 static swig_type_info _swigt__p_wxStaticBox = {"_p_wxStaticBox", "wxStaticBox *", 0, 0, (void*)0, 0};
54552 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", "wxStaticBoxSizer *", 0, 0, (void*)0, 0};
54553 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", "wxStdDialogButtonSizer *", 0, 0, (void*)0, 0};
54554 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", "wxSysColourChangedEvent *", 0, 0, (void*)0, 0};
54555 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", "wxTIFFHandler *", 0, 0, (void*)0, 0};
54556 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
54557 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", "wxUpdateUIEvent *", 0, 0, (void*)0, 0};
54558 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, (void*)0, 0};
54559 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
54560 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
54561 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", "wxWindowCreateEvent *", 0, 0, (void*)0, 0};
54562 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", "wxWindowDestroyEvent *", 0, 0, (void*)0, 0};
54563 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", "wxXPMHandler *", 0, 0, (void*)0, 0};
54564 static swig_type_info _swigt__p_wxZipFSHandler = {"_p_wxZipFSHandler", "wxZipFSHandler *", 0, 0, (void*)0, 0};
54565
54566 static swig_type_info *swig_type_initial[] = {
54567 &_swigt__p_buffer,
54568 &_swigt__p_char,
54569 &_swigt__p_form_ops_t,
54570 &_swigt__p_int,
54571 &_swigt__p_long,
54572 &_swigt__p_unsigned_char,
54573 &_swigt__p_unsigned_int,
54574 &_swigt__p_unsigned_long,
54575 &_swigt__p_wxANIHandler,
54576 &_swigt__p_wxAcceleratorEntry,
54577 &_swigt__p_wxAcceleratorTable,
54578 &_swigt__p_wxActivateEvent,
54579 &_swigt__p_wxAppTraits,
54580 &_swigt__p_wxArrayString,
54581 &_swigt__p_wxBMPHandler,
54582 &_swigt__p_wxBitmap,
54583 &_swigt__p_wxBoxSizer,
54584 &_swigt__p_wxButton,
54585 &_swigt__p_wxCURHandler,
54586 &_swigt__p_wxCaret,
54587 &_swigt__p_wxChildFocusEvent,
54588 &_swigt__p_wxCloseEvent,
54589 &_swigt__p_wxColour,
54590 &_swigt__p_wxCommandEvent,
54591 &_swigt__p_wxContextMenuEvent,
54592 &_swigt__p_wxControl,
54593 &_swigt__p_wxControlWithItems,
54594 &_swigt__p_wxCursor,
54595 &_swigt__p_wxDC,
54596 &_swigt__p_wxDateEvent,
54597 &_swigt__p_wxDateTime,
54598 &_swigt__p_wxDisplayChangedEvent,
54599 &_swigt__p_wxDropFilesEvent,
54600 &_swigt__p_wxDuplexMode,
54601 &_swigt__p_wxEraseEvent,
54602 &_swigt__p_wxEvent,
54603 &_swigt__p_wxEventLoop,
54604 &_swigt__p_wxEventLoopActivator,
54605 &_swigt__p_wxEvtHandler,
54606 &_swigt__p_wxFSFile,
54607 &_swigt__p_wxFileSystem,
54608 &_swigt__p_wxFileSystemHandler,
54609 &_swigt__p_wxFlexGridSizer,
54610 &_swigt__p_wxFocusEvent,
54611 &_swigt__p_wxFont,
54612 &_swigt__p_wxFrame,
54613 &_swigt__p_wxGBPosition,
54614 &_swigt__p_wxGBSizerItem,
54615 &_swigt__p_wxGBSpan,
54616 &_swigt__p_wxGIFHandler,
54617 &_swigt__p_wxGridBagSizer,
54618 &_swigt__p_wxGridSizer,
54619 &_swigt__p_wxICOHandler,
54620 &_swigt__p_wxIconizeEvent,
54621 &_swigt__p_wxIdleEvent,
54622 &_swigt__p_wxImage,
54623 &_swigt__p_wxImageHandler,
54624 &_swigt__p_wxImageHistogram,
54625 &_swigt__p_wxImage_HSVValue,
54626 &_swigt__p_wxImage_RGBValue,
54627 &_swigt__p_wxIndividualLayoutConstraint,
54628 &_swigt__p_wxInitDialogEvent,
54629 &_swigt__p_wxInputStream,
54630 &_swigt__p_wxInternetFSHandler,
54631 &_swigt__p_wxItemContainer,
54632 &_swigt__p_wxJPEGHandler,
54633 &_swigt__p_wxKeyEvent,
54634 &_swigt__p_wxLayoutConstraints,
54635 &_swigt__p_wxMaximizeEvent,
54636 &_swigt__p_wxMemoryFSHandler,
54637 &_swigt__p_wxMenu,
54638 &_swigt__p_wxMenuBar,
54639 &_swigt__p_wxMenuBarBase,
54640 &_swigt__p_wxMenuEvent,
54641 &_swigt__p_wxMenuItem,
54642 &_swigt__p_wxMouseCaptureChangedEvent,
54643 &_swigt__p_wxMouseEvent,
54644 &_swigt__p_wxMoveEvent,
54645 &_swigt__p_wxNavigationKeyEvent,
54646 &_swigt__p_wxNcPaintEvent,
54647 &_swigt__p_wxNotifyEvent,
54648 &_swigt__p_wxObject,
54649 &_swigt__p_wxOutputStream,
54650 &_swigt__p_wxPCXHandler,
54651 &_swigt__p_wxPNGHandler,
54652 &_swigt__p_wxPNMHandler,
54653 &_swigt__p_wxPaintEvent,
54654 &_swigt__p_wxPaletteChangedEvent,
54655 &_swigt__p_wxPaperSize,
54656 &_swigt__p_wxPoint,
54657 &_swigt__p_wxPoint2D,
54658 &_swigt__p_wxPropagateOnce,
54659 &_swigt__p_wxPropagationDisabler,
54660 &_swigt__p_wxPyApp,
54661 &_swigt__p_wxPyCommandEvent,
54662 &_swigt__p_wxPyDropTarget,
54663 &_swigt__p_wxPyEvent,
54664 &_swigt__p_wxPyFileSystemHandler,
54665 &_swigt__p_wxPyImageHandler,
54666 &_swigt__p_wxPyInputStream,
54667 &_swigt__p_wxPySizer,
54668 &_swigt__p_wxPyValidator,
54669 &_swigt__p_wxQuantize,
54670 &_swigt__p_wxQueryNewPaletteEvent,
54671 &_swigt__p_wxRealPoint,
54672 &_swigt__p_wxRect,
54673 &_swigt__p_wxRegion,
54674 &_swigt__p_wxScrollEvent,
54675 &_swigt__p_wxScrollWinEvent,
54676 &_swigt__p_wxSetCursorEvent,
54677 &_swigt__p_wxShowEvent,
54678 &_swigt__p_wxSize,
54679 &_swigt__p_wxSizeEvent,
54680 &_swigt__p_wxSizer,
54681 &_swigt__p_wxSizerItem,
54682 &_swigt__p_wxStaticBox,
54683 &_swigt__p_wxStaticBoxSizer,
54684 &_swigt__p_wxStdDialogButtonSizer,
54685 &_swigt__p_wxSysColourChangedEvent,
54686 &_swigt__p_wxTIFFHandler,
54687 &_swigt__p_wxToolTip,
54688 &_swigt__p_wxUpdateUIEvent,
54689 &_swigt__p_wxValidator,
54690 &_swigt__p_wxVisualAttributes,
54691 &_swigt__p_wxWindow,
54692 &_swigt__p_wxWindowCreateEvent,
54693 &_swigt__p_wxWindowDestroyEvent,
54694 &_swigt__p_wxXPMHandler,
54695 &_swigt__p_wxZipFSHandler,
54696 };
54697
54698 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
54699 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
54700 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
54701 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
54702 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
54703 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
54704 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
54705 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
54706 static swig_cast_info _swigc__p_wxANIHandler[] = { {&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
54707 static swig_cast_info _swigc__p_wxAcceleratorEntry[] = { {&_swigt__p_wxAcceleratorEntry, 0, 0, 0},{0, 0, 0, 0}};
54708 static swig_cast_info _swigc__p_wxAcceleratorTable[] = { {&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
54709 static swig_cast_info _swigc__p_wxActivateEvent[] = { {&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
54710 static swig_cast_info _swigc__p_wxAppTraits[] = { {&_swigt__p_wxAppTraits, 0, 0, 0},{0, 0, 0, 0}};
54711 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
54712 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}};
54713 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
54714 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}};
54715 static swig_cast_info _swigc__p_wxButton[] = { {&_swigt__p_wxButton, 0, 0, 0},{0, 0, 0, 0}};
54716 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}};
54717 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
54718 static swig_cast_info _swigc__p_wxChildFocusEvent[] = { {&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
54719 static swig_cast_info _swigc__p_wxCloseEvent[] = { {&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
54720 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
54721 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_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}};
54722 static swig_cast_info _swigc__p_wxContextMenuEvent[] = { {&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
54723 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}};
54724 static swig_cast_info _swigc__p_wxControlWithItems[] = { {&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
54725 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
54726 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
54727 static swig_cast_info _swigc__p_wxDateEvent[] = { {&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
54728 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
54729 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = { {&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
54730 static swig_cast_info _swigc__p_wxDropFilesEvent[] = { {&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
54731 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
54732 static swig_cast_info _swigc__p_wxEraseEvent[] = { {&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
54733 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_wxPyEvent, _p_wxPyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_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_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}};
54734 static swig_cast_info _swigc__p_wxEventLoop[] = { {&_swigt__p_wxEventLoop, 0, 0, 0},{0, 0, 0, 0}};
54735 static swig_cast_info _swigc__p_wxEventLoopActivator[] = { {&_swigt__p_wxEventLoopActivator, 0, 0, 0},{0, 0, 0, 0}};
54736 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}};
54737 static swig_cast_info _swigc__p_wxFSFile[] = { {&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
54738 static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
54739 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}};
54740 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}};
54741 static swig_cast_info _swigc__p_wxFocusEvent[] = { {&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
54742 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
54743 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
54744 static swig_cast_info _swigc__p_wxGBPosition[] = { {&_swigt__p_wxGBPosition, 0, 0, 0},{0, 0, 0, 0}};
54745 static swig_cast_info _swigc__p_wxGBSizerItem[] = { {&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
54746 static swig_cast_info _swigc__p_wxGBSpan[] = { {&_swigt__p_wxGBSpan, 0, 0, 0},{0, 0, 0, 0}};
54747 static swig_cast_info _swigc__p_wxGIFHandler[] = { {&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
54748 static swig_cast_info _swigc__p_wxGridBagSizer[] = { {&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
54749 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}};
54750 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}};
54751 static swig_cast_info _swigc__p_wxIconizeEvent[] = { {&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
54752 static swig_cast_info _swigc__p_wxIdleEvent[] = { {&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
54753 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
54754 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}};
54755 static swig_cast_info _swigc__p_wxImageHistogram[] = { {&_swigt__p_wxImageHistogram, 0, 0, 0},{0, 0, 0, 0}};
54756 static swig_cast_info _swigc__p_wxImage_HSVValue[] = { {&_swigt__p_wxImage_HSVValue, 0, 0, 0},{0, 0, 0, 0}};
54757 static swig_cast_info _swigc__p_wxImage_RGBValue[] = { {&_swigt__p_wxImage_RGBValue, 0, 0, 0},{0, 0, 0, 0}};
54758 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = { {&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
54759 static swig_cast_info _swigc__p_wxInitDialogEvent[] = { {&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
54760 static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
54761 static swig_cast_info _swigc__p_wxInternetFSHandler[] = { {&_swigt__p_wxInternetFSHandler, 0, 0, 0},{0, 0, 0, 0}};
54762 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}};
54763 static swig_cast_info _swigc__p_wxJPEGHandler[] = { {&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
54764 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
54765 static swig_cast_info _swigc__p_wxLayoutConstraints[] = { {&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
54766 static swig_cast_info _swigc__p_wxMaximizeEvent[] = { {&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
54767 static swig_cast_info _swigc__p_wxMemoryFSHandler[] = { {&_swigt__p_wxMemoryFSHandler, 0, 0, 0},{0, 0, 0, 0}};
54768 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
54769 static swig_cast_info _swigc__p_wxMenuBar[] = { {&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
54770 static swig_cast_info _swigc__p_wxMenuBarBase[] = { {&_swigt__p_wxMenuBarBase, 0, 0, 0},{0, 0, 0, 0}};
54771 static swig_cast_info _swigc__p_wxMenuEvent[] = { {&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
54772 static swig_cast_info _swigc__p_wxMenuItem[] = { {&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
54773 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = { {&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
54774 static swig_cast_info _swigc__p_wxMouseEvent[] = { {&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
54775 static swig_cast_info _swigc__p_wxMoveEvent[] = { {&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
54776 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = { {&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
54777 static swig_cast_info _swigc__p_wxNcPaintEvent[] = { {&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
54778 static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
54779 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_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_wxPyEvent, _p_wxPyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_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_wxPNMHandler, _p_wxPNMHandlerTo_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_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}};
54780 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
54781 static swig_cast_info _swigc__p_wxPCXHandler[] = { {&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
54782 static swig_cast_info _swigc__p_wxPNGHandler[] = { {&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
54783 static swig_cast_info _swigc__p_wxPNMHandler[] = { {&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
54784 static swig_cast_info _swigc__p_wxPaintEvent[] = { {&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
54785 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = { {&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
54786 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
54787 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
54788 static swig_cast_info _swigc__p_wxPoint2D[] = { {&_swigt__p_wxPoint2D, 0, 0, 0},{0, 0, 0, 0}};
54789 static swig_cast_info _swigc__p_wxPropagateOnce[] = { {&_swigt__p_wxPropagateOnce, 0, 0, 0},{0, 0, 0, 0}};
54790 static swig_cast_info _swigc__p_wxPropagationDisabler[] = { {&_swigt__p_wxPropagationDisabler, 0, 0, 0},{0, 0, 0, 0}};
54791 static swig_cast_info _swigc__p_wxPyApp[] = { {&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
54792 static swig_cast_info _swigc__p_wxPyCommandEvent[] = { {&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
54793 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0},{0, 0, 0, 0}};
54794 static swig_cast_info _swigc__p_wxPyEvent[] = { {&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
54795 static swig_cast_info _swigc__p_wxPyFileSystemHandler[] = { {&_swigt__p_wxPyFileSystemHandler, 0, 0, 0},{0, 0, 0, 0}};
54796 static swig_cast_info _swigc__p_wxPyImageHandler[] = { {&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
54797 static swig_cast_info _swigc__p_wxPyInputStream[] = { {&_swigt__p_wxPyInputStream, 0, 0, 0},{0, 0, 0, 0}};
54798 static swig_cast_info _swigc__p_wxPySizer[] = { {&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
54799 static swig_cast_info _swigc__p_wxPyValidator[] = { {&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
54800 static swig_cast_info _swigc__p_wxQuantize[] = { {&_swigt__p_wxQuantize, 0, 0, 0},{0, 0, 0, 0}};
54801 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = { {&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
54802 static swig_cast_info _swigc__p_wxRealPoint[] = { {&_swigt__p_wxRealPoint, 0, 0, 0},{0, 0, 0, 0}};
54803 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
54804 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
54805 static swig_cast_info _swigc__p_wxScrollEvent[] = { {&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
54806 static swig_cast_info _swigc__p_wxScrollWinEvent[] = { {&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
54807 static swig_cast_info _swigc__p_wxSetCursorEvent[] = { {&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
54808 static swig_cast_info _swigc__p_wxShowEvent[] = { {&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
54809 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
54810 static swig_cast_info _swigc__p_wxSizeEvent[] = { {&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
54811 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}};
54812 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}};
54813 static swig_cast_info _swigc__p_wxStaticBox[] = { {&_swigt__p_wxStaticBox, 0, 0, 0},{0, 0, 0, 0}};
54814 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = { {&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
54815 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = { {&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
54816 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = { {&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
54817 static swig_cast_info _swigc__p_wxTIFFHandler[] = { {&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
54818 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
54819 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = { {&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
54820 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}};
54821 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
54822 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}};
54823 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = { {&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
54824 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = { {&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
54825 static swig_cast_info _swigc__p_wxXPMHandler[] = { {&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
54826 static swig_cast_info _swigc__p_wxZipFSHandler[] = { {&_swigt__p_wxZipFSHandler, 0, 0, 0},{0, 0, 0, 0}};
54827
54828 static swig_cast_info *swig_cast_initial[] = {
54829 _swigc__p_buffer,
54830 _swigc__p_char,
54831 _swigc__p_form_ops_t,
54832 _swigc__p_int,
54833 _swigc__p_long,
54834 _swigc__p_unsigned_char,
54835 _swigc__p_unsigned_int,
54836 _swigc__p_unsigned_long,
54837 _swigc__p_wxANIHandler,
54838 _swigc__p_wxAcceleratorEntry,
54839 _swigc__p_wxAcceleratorTable,
54840 _swigc__p_wxActivateEvent,
54841 _swigc__p_wxAppTraits,
54842 _swigc__p_wxArrayString,
54843 _swigc__p_wxBMPHandler,
54844 _swigc__p_wxBitmap,
54845 _swigc__p_wxBoxSizer,
54846 _swigc__p_wxButton,
54847 _swigc__p_wxCURHandler,
54848 _swigc__p_wxCaret,
54849 _swigc__p_wxChildFocusEvent,
54850 _swigc__p_wxCloseEvent,
54851 _swigc__p_wxColour,
54852 _swigc__p_wxCommandEvent,
54853 _swigc__p_wxContextMenuEvent,
54854 _swigc__p_wxControl,
54855 _swigc__p_wxControlWithItems,
54856 _swigc__p_wxCursor,
54857 _swigc__p_wxDC,
54858 _swigc__p_wxDateEvent,
54859 _swigc__p_wxDateTime,
54860 _swigc__p_wxDisplayChangedEvent,
54861 _swigc__p_wxDropFilesEvent,
54862 _swigc__p_wxDuplexMode,
54863 _swigc__p_wxEraseEvent,
54864 _swigc__p_wxEvent,
54865 _swigc__p_wxEventLoop,
54866 _swigc__p_wxEventLoopActivator,
54867 _swigc__p_wxEvtHandler,
54868 _swigc__p_wxFSFile,
54869 _swigc__p_wxFileSystem,
54870 _swigc__p_wxFileSystemHandler,
54871 _swigc__p_wxFlexGridSizer,
54872 _swigc__p_wxFocusEvent,
54873 _swigc__p_wxFont,
54874 _swigc__p_wxFrame,
54875 _swigc__p_wxGBPosition,
54876 _swigc__p_wxGBSizerItem,
54877 _swigc__p_wxGBSpan,
54878 _swigc__p_wxGIFHandler,
54879 _swigc__p_wxGridBagSizer,
54880 _swigc__p_wxGridSizer,
54881 _swigc__p_wxICOHandler,
54882 _swigc__p_wxIconizeEvent,
54883 _swigc__p_wxIdleEvent,
54884 _swigc__p_wxImage,
54885 _swigc__p_wxImageHandler,
54886 _swigc__p_wxImageHistogram,
54887 _swigc__p_wxImage_HSVValue,
54888 _swigc__p_wxImage_RGBValue,
54889 _swigc__p_wxIndividualLayoutConstraint,
54890 _swigc__p_wxInitDialogEvent,
54891 _swigc__p_wxInputStream,
54892 _swigc__p_wxInternetFSHandler,
54893 _swigc__p_wxItemContainer,
54894 _swigc__p_wxJPEGHandler,
54895 _swigc__p_wxKeyEvent,
54896 _swigc__p_wxLayoutConstraints,
54897 _swigc__p_wxMaximizeEvent,
54898 _swigc__p_wxMemoryFSHandler,
54899 _swigc__p_wxMenu,
54900 _swigc__p_wxMenuBar,
54901 _swigc__p_wxMenuBarBase,
54902 _swigc__p_wxMenuEvent,
54903 _swigc__p_wxMenuItem,
54904 _swigc__p_wxMouseCaptureChangedEvent,
54905 _swigc__p_wxMouseEvent,
54906 _swigc__p_wxMoveEvent,
54907 _swigc__p_wxNavigationKeyEvent,
54908 _swigc__p_wxNcPaintEvent,
54909 _swigc__p_wxNotifyEvent,
54910 _swigc__p_wxObject,
54911 _swigc__p_wxOutputStream,
54912 _swigc__p_wxPCXHandler,
54913 _swigc__p_wxPNGHandler,
54914 _swigc__p_wxPNMHandler,
54915 _swigc__p_wxPaintEvent,
54916 _swigc__p_wxPaletteChangedEvent,
54917 _swigc__p_wxPaperSize,
54918 _swigc__p_wxPoint,
54919 _swigc__p_wxPoint2D,
54920 _swigc__p_wxPropagateOnce,
54921 _swigc__p_wxPropagationDisabler,
54922 _swigc__p_wxPyApp,
54923 _swigc__p_wxPyCommandEvent,
54924 _swigc__p_wxPyDropTarget,
54925 _swigc__p_wxPyEvent,
54926 _swigc__p_wxPyFileSystemHandler,
54927 _swigc__p_wxPyImageHandler,
54928 _swigc__p_wxPyInputStream,
54929 _swigc__p_wxPySizer,
54930 _swigc__p_wxPyValidator,
54931 _swigc__p_wxQuantize,
54932 _swigc__p_wxQueryNewPaletteEvent,
54933 _swigc__p_wxRealPoint,
54934 _swigc__p_wxRect,
54935 _swigc__p_wxRegion,
54936 _swigc__p_wxScrollEvent,
54937 _swigc__p_wxScrollWinEvent,
54938 _swigc__p_wxSetCursorEvent,
54939 _swigc__p_wxShowEvent,
54940 _swigc__p_wxSize,
54941 _swigc__p_wxSizeEvent,
54942 _swigc__p_wxSizer,
54943 _swigc__p_wxSizerItem,
54944 _swigc__p_wxStaticBox,
54945 _swigc__p_wxStaticBoxSizer,
54946 _swigc__p_wxStdDialogButtonSizer,
54947 _swigc__p_wxSysColourChangedEvent,
54948 _swigc__p_wxTIFFHandler,
54949 _swigc__p_wxToolTip,
54950 _swigc__p_wxUpdateUIEvent,
54951 _swigc__p_wxValidator,
54952 _swigc__p_wxVisualAttributes,
54953 _swigc__p_wxWindow,
54954 _swigc__p_wxWindowCreateEvent,
54955 _swigc__p_wxWindowDestroyEvent,
54956 _swigc__p_wxXPMHandler,
54957 _swigc__p_wxZipFSHandler,
54958 };
54959
54960
54961 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
54962
54963 static swig_const_info swig_const_table[] = {
54964 {0, 0, 0, 0.0, 0, 0}};
54965
54966 #ifdef __cplusplus
54967 }
54968 #endif
54969 /* -----------------------------------------------------------------------------
54970 * Type initialization:
54971 * This problem is tough by the requirement that no dynamic
54972 * memory is used. Also, since swig_type_info structures store pointers to
54973 * swig_cast_info structures and swig_cast_info structures store pointers back
54974 * to swig_type_info structures, we need some lookup code at initialization.
54975 * The idea is that swig generates all the structures that are needed.
54976 * The runtime then collects these partially filled structures.
54977 * The SWIG_InitializeModule function takes these initial arrays out of
54978 * swig_module, and does all the lookup, filling in the swig_module.types
54979 * array with the correct data and linking the correct swig_cast_info
54980 * structures together.
54981 *
54982 * The generated swig_type_info structures are assigned staticly to an initial
54983 * array. We just loop though that array, and handle each type individually.
54984 * First we lookup if this type has been already loaded, and if so, use the
54985 * loaded structure instead of the generated one. Then we have to fill in the
54986 * cast linked list. The cast data is initially stored in something like a
54987 * two-dimensional array. Each row corresponds to a type (there are the same
54988 * number of rows as there are in the swig_type_initial array). Each entry in
54989 * a column is one of the swig_cast_info structures for that type.
54990 * The cast_initial array is actually an array of arrays, because each row has
54991 * a variable number of columns. So to actually build the cast linked list,
54992 * we find the array of casts associated with the type, and loop through it
54993 * adding the casts to the list. The one last trick we need to do is making
54994 * sure the type pointer in the swig_cast_info struct is correct.
54995 *
54996 * First off, we lookup the cast->type name to see if it is already loaded.
54997 * There are three cases to handle:
54998 * 1) If the cast->type has already been loaded AND the type we are adding
54999 * casting info to has not been loaded (it is in this module), THEN we
55000 * replace the cast->type pointer with the type pointer that has already
55001 * been loaded.
55002 * 2) If BOTH types (the one we are adding casting info to, and the
55003 * cast->type) are loaded, THEN the cast info has already been loaded by
55004 * the previous module so we just ignore it.
55005 * 3) Finally, if cast->type has not already been loaded, then we add that
55006 * swig_cast_info to the linked list (because the cast->type) pointer will
55007 * be correct.
55008 * ----------------------------------------------------------------------------- */
55009
55010 #ifdef __cplusplus
55011 extern "C" {
55012 #if 0
55013 } /* c-mode */
55014 #endif
55015 #endif
55016
55017 #if 0
55018 #define SWIGRUNTIME_DEBUG
55019 #endif
55020
55021 SWIGRUNTIME void
55022 SWIG_InitializeModule(void *clientdata) {
55023 size_t i;
55024 swig_module_info *module_head;
55025 static int init_run = 0;
55026
55027 clientdata = clientdata;
55028
55029 if (init_run) return;
55030 init_run = 1;
55031
55032 /* Initialize the swig_module */
55033 swig_module.type_initial = swig_type_initial;
55034 swig_module.cast_initial = swig_cast_initial;
55035
55036 /* Try and load any already created modules */
55037 module_head = SWIG_GetModule(clientdata);
55038 if (module_head) {
55039 swig_module.next = module_head->next;
55040 module_head->next = &swig_module;
55041 } else {
55042 /* This is the first module loaded */
55043 swig_module.next = &swig_module;
55044 SWIG_SetModule(clientdata, &swig_module);
55045 }
55046
55047 /* Now work on filling in swig_module.types */
55048 #ifdef SWIGRUNTIME_DEBUG
55049 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
55050 #endif
55051 for (i = 0; i < swig_module.size; ++i) {
55052 swig_type_info *type = 0;
55053 swig_type_info *ret;
55054 swig_cast_info *cast;
55055
55056 #ifdef SWIGRUNTIME_DEBUG
55057 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
55058 #endif
55059
55060 /* if there is another module already loaded */
55061 if (swig_module.next != &swig_module) {
55062 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
55063 }
55064 if (type) {
55065 /* Overwrite clientdata field */
55066 #ifdef SWIGRUNTIME_DEBUG
55067 printf("SWIG_InitializeModule: found type %s\n", type->name);
55068 #endif
55069 if (swig_module.type_initial[i]->clientdata) {
55070 type->clientdata = swig_module.type_initial[i]->clientdata;
55071 #ifdef SWIGRUNTIME_DEBUG
55072 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
55073 #endif
55074 }
55075 } else {
55076 type = swig_module.type_initial[i];
55077 }
55078
55079 /* Insert casting types */
55080 cast = swig_module.cast_initial[i];
55081 while (cast->type) {
55082 /* Don't need to add information already in the list */
55083 ret = 0;
55084 #ifdef SWIGRUNTIME_DEBUG
55085 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
55086 #endif
55087 if (swig_module.next != &swig_module) {
55088 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
55089 #ifdef SWIGRUNTIME_DEBUG
55090 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
55091 #endif
55092 }
55093 if (ret) {
55094 if (type == swig_module.type_initial[i]) {
55095 #ifdef SWIGRUNTIME_DEBUG
55096 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
55097 #endif
55098 cast->type = ret;
55099 ret = 0;
55100 } else {
55101 /* Check for casting already in the list */
55102 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
55103 #ifdef SWIGRUNTIME_DEBUG
55104 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
55105 #endif
55106 if (!ocast) ret = 0;
55107 }
55108 }
55109
55110 if (!ret) {
55111 #ifdef SWIGRUNTIME_DEBUG
55112 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
55113 #endif
55114 if (type->cast) {
55115 type->cast->prev = cast;
55116 cast->next = type->cast;
55117 }
55118 type->cast = cast;
55119 }
55120 cast++;
55121 }
55122 /* Set entry in modules->types array equal to the type */
55123 swig_module.types[i] = type;
55124 }
55125 swig_module.types[i] = 0;
55126
55127 #ifdef SWIGRUNTIME_DEBUG
55128 printf("**** SWIG_InitializeModule: Cast List ******\n");
55129 for (i = 0; i < swig_module.size; ++i) {
55130 int j = 0;
55131 swig_cast_info *cast = swig_module.cast_initial[i];
55132 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
55133 while (cast->type) {
55134 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
55135 cast++;
55136 ++j;
55137 }
55138 printf("---- Total casts: %d\n",j);
55139 }
55140 printf("**** SWIG_InitializeModule: Cast List ******\n");
55141 #endif
55142 }
55143
55144 /* This function will propagate the clientdata field of type to
55145 * any new swig_type_info structures that have been added into the list
55146 * of equivalent types. It is like calling
55147 * SWIG_TypeClientData(type, clientdata) a second time.
55148 */
55149 SWIGRUNTIME void
55150 SWIG_PropagateClientData(void) {
55151 size_t i;
55152 swig_cast_info *equiv;
55153 static int init_run = 0;
55154
55155 if (init_run) return;
55156 init_run = 1;
55157
55158 for (i = 0; i < swig_module.size; i++) {
55159 if (swig_module.types[i]->clientdata) {
55160 equiv = swig_module.types[i]->cast;
55161 while (equiv) {
55162 if (!equiv->converter) {
55163 if (equiv->type && !equiv->type->clientdata)
55164 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
55165 }
55166 equiv = equiv->next;
55167 }
55168 }
55169 }
55170 }
55171
55172 #ifdef __cplusplus
55173 #if 0
55174 {
55175 /* c-mode */
55176 #endif
55177 }
55178 #endif
55179
55180
55181
55182 #ifdef __cplusplus
55183 extern "C" {
55184 #endif
55185
55186 /* Python-specific SWIG API */
55187 #define SWIG_newvarlink() SWIG_Python_newvarlink()
55188 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
55189 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
55190
55191 /* -----------------------------------------------------------------------------
55192 * global variable support code.
55193 * ----------------------------------------------------------------------------- */
55194
55195 typedef struct swig_globalvar {
55196 char *name; /* Name of global variable */
55197 PyObject *(*get_attr)(void); /* Return the current value */
55198 int (*set_attr)(PyObject *); /* Set the value */
55199 struct swig_globalvar *next;
55200 } swig_globalvar;
55201
55202 typedef struct swig_varlinkobject {
55203 PyObject_HEAD
55204 swig_globalvar *vars;
55205 } swig_varlinkobject;
55206
55207 SWIGINTERN PyObject *
55208 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
55209 return PyString_FromString("<Swig global variables>");
55210 }
55211
55212 SWIGINTERN PyObject *
55213 swig_varlink_str(swig_varlinkobject *v) {
55214 PyObject *str = PyString_FromString("(");
55215 swig_globalvar *var;
55216 for (var = v->vars; var; var=var->next) {
55217 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
55218 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
55219 }
55220 PyString_ConcatAndDel(&str,PyString_FromString(")"));
55221 return str;
55222 }
55223
55224 SWIGINTERN int
55225 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
55226 PyObject *str = swig_varlink_str(v);
55227 fprintf(fp,"Swig global variables ");
55228 fprintf(fp,"%s\n", PyString_AsString(str));
55229 Py_DECREF(str);
55230 return 0;
55231 }
55232
55233 SWIGINTERN void
55234 swig_varlink_dealloc(swig_varlinkobject *v) {
55235 swig_globalvar *var = v->vars;
55236 while (var) {
55237 swig_globalvar *n = var->next;
55238 free(var->name);
55239 free(var);
55240 var = n;
55241 }
55242 }
55243
55244 SWIGINTERN PyObject *
55245 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
55246 PyObject *res = NULL;
55247 swig_globalvar *var = v->vars;
55248 while (var) {
55249 if (strcmp(var->name,n) == 0) {
55250 res = (*var->get_attr)();
55251 break;
55252 }
55253 var = var->next;
55254 }
55255 if (res == NULL && !PyErr_Occurred()) {
55256 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
55257 }
55258 return res;
55259 }
55260
55261 SWIGINTERN int
55262 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
55263 int res = 1;
55264 swig_globalvar *var = v->vars;
55265 while (var) {
55266 if (strcmp(var->name,n) == 0) {
55267 res = (*var->set_attr)(p);
55268 break;
55269 }
55270 var = var->next;
55271 }
55272 if (res == 1 && !PyErr_Occurred()) {
55273 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
55274 }
55275 return res;
55276 }
55277
55278 SWIGINTERN PyTypeObject*
55279 swig_varlink_type(void) {
55280 static char varlink__doc__[] = "Swig var link object";
55281 static PyTypeObject varlink_type;
55282 static int type_init = 0;
55283 if (!type_init) {
55284 const PyTypeObject tmp
55285 = {
55286 PyObject_HEAD_INIT(NULL)
55287 0, /* Number of items in variable part (ob_size) */
55288 (char *)"swigvarlink", /* Type name (tp_name) */
55289 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
55290 0, /* Itemsize (tp_itemsize) */
55291 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
55292 (printfunc) swig_varlink_print, /* Print (tp_print) */
55293 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
55294 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
55295 0, /* tp_compare */
55296 (reprfunc) swig_varlink_repr, /* tp_repr */
55297 0, /* tp_as_number */
55298 0, /* tp_as_sequence */
55299 0, /* tp_as_mapping */
55300 0, /* tp_hash */
55301 0, /* tp_call */
55302 (reprfunc)swig_varlink_str, /* tp_str */
55303 0, /* tp_getattro */
55304 0, /* tp_setattro */
55305 0, /* tp_as_buffer */
55306 0, /* tp_flags */
55307 varlink__doc__, /* tp_doc */
55308 0, /* tp_traverse */
55309 0, /* tp_clear */
55310 0, /* tp_richcompare */
55311 0, /* tp_weaklistoffset */
55312 #if PY_VERSION_HEX >= 0x02020000
55313 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
55314 #endif
55315 #if PY_VERSION_HEX >= 0x02030000
55316 0, /* tp_del */
55317 #endif
55318 #ifdef COUNT_ALLOCS
55319 0,0,0,0 /* tp_alloc -> tp_next */
55320 #endif
55321 };
55322 varlink_type = tmp;
55323 varlink_type.ob_type = &PyType_Type;
55324 type_init = 1;
55325 }
55326 return &varlink_type;
55327 }
55328
55329 /* Create a variable linking object for use later */
55330 SWIGINTERN PyObject *
55331 SWIG_Python_newvarlink(void) {
55332 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
55333 if (result) {
55334 result->vars = 0;
55335 }
55336 return ((PyObject*) result);
55337 }
55338
55339 SWIGINTERN void
55340 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
55341 swig_varlinkobject *v = (swig_varlinkobject *) p;
55342 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
55343 if (gv) {
55344 size_t size = strlen(name)+1;
55345 gv->name = (char *)malloc(size);
55346 if (gv->name) {
55347 strncpy(gv->name,name,size);
55348 gv->get_attr = get_attr;
55349 gv->set_attr = set_attr;
55350 gv->next = v->vars;
55351 }
55352 }
55353 v->vars = gv;
55354 }
55355
55356 SWIGINTERN PyObject *
55357 SWIG_globals() {
55358 static PyObject *_SWIG_globals = 0;
55359 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
55360 return _SWIG_globals;
55361 }
55362
55363 /* -----------------------------------------------------------------------------
55364 * constants/methods manipulation
55365 * ----------------------------------------------------------------------------- */
55366
55367 /* Install Constants */
55368 SWIGINTERN void
55369 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
55370 PyObject *obj = 0;
55371 size_t i;
55372 for (i = 0; constants[i].type; ++i) {
55373 switch(constants[i].type) {
55374 case SWIG_PY_POINTER:
55375 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
55376 break;
55377 case SWIG_PY_BINARY:
55378 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
55379 break;
55380 default:
55381 obj = 0;
55382 break;
55383 }
55384 if (obj) {
55385 PyDict_SetItemString(d, constants[i].name, obj);
55386 Py_DECREF(obj);
55387 }
55388 }
55389 }
55390
55391 /* -----------------------------------------------------------------------------*/
55392 /* Fix SwigMethods to carry the callback ptrs when needed */
55393 /* -----------------------------------------------------------------------------*/
55394
55395 SWIGINTERN void
55396 SWIG_Python_FixMethods(PyMethodDef *methods,
55397 swig_const_info *const_table,
55398 swig_type_info **types,
55399 swig_type_info **types_initial) {
55400 size_t i;
55401 for (i = 0; methods[i].ml_name; ++i) {
55402 char *c = methods[i].ml_doc;
55403 if (c && (c = strstr(c, "swig_ptr: "))) {
55404 int j;
55405 swig_const_info *ci = 0;
55406 char *name = c + 10;
55407 for (j = 0; const_table[j].type; ++j) {
55408 if (strncmp(const_table[j].name, name,
55409 strlen(const_table[j].name)) == 0) {
55410 ci = &(const_table[j]);
55411 break;
55412 }
55413 }
55414 if (ci) {
55415 size_t shift = (ci->ptype) - types;
55416 swig_type_info *ty = types_initial[shift];
55417 size_t ldoc = (c - methods[i].ml_doc);
55418 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
55419 char *ndoc = (char*)malloc(ldoc + lptr + 10);
55420 if (ndoc) {
55421 char *buff = ndoc;
55422 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
55423 if (ptr) {
55424 strncpy(buff, methods[i].ml_doc, ldoc);
55425 buff += ldoc;
55426 strncpy(buff, "swig_ptr: ", 10);
55427 buff += 10;
55428 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
55429 methods[i].ml_doc = ndoc;
55430 }
55431 }
55432 }
55433 }
55434 }
55435 }
55436
55437 #ifdef __cplusplus
55438 }
55439 #endif
55440
55441 /* -----------------------------------------------------------------------------*
55442 * Partial Init method
55443 * -----------------------------------------------------------------------------*/
55444
55445 #ifdef __cplusplus
55446 extern "C"
55447 #endif
55448 SWIGEXPORT void SWIG_init(void) {
55449 PyObject *m, *d;
55450
55451 /* Fix SwigMethods to carry the callback ptrs when needed */
55452 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
55453
55454 m = Py_InitModule((char *) SWIG_name, SwigMethods);
55455 d = PyModule_GetDict(m);
55456
55457 SWIG_InitializeModule(0);
55458 SWIG_InstallConstants(d,swig_const_table);
55459
55460
55461
55462 #ifndef wxPyUSE_EXPORT
55463 // Make our API structure a CObject so other modules can import it
55464 // from this module.
55465 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
55466 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
55467 Py_XDECREF(cobj);
55468 #endif
55469
55470 SWIG_Python_SetConstant(d, "NOT_FOUND",SWIG_From_int(static_cast< int >(wxNOT_FOUND)));
55471 SWIG_Python_SetConstant(d, "VSCROLL",SWIG_From_int(static_cast< int >(wxVSCROLL)));
55472 SWIG_Python_SetConstant(d, "HSCROLL",SWIG_From_int(static_cast< int >(wxHSCROLL)));
55473 SWIG_Python_SetConstant(d, "CAPTION",SWIG_From_int(static_cast< int >(wxCAPTION)));
55474 SWIG_Python_SetConstant(d, "DOUBLE_BORDER",SWIG_From_int(static_cast< int >(wxDOUBLE_BORDER)));
55475 SWIG_Python_SetConstant(d, "SUNKEN_BORDER",SWIG_From_int(static_cast< int >(wxSUNKEN_BORDER)));
55476 SWIG_Python_SetConstant(d, "RAISED_BORDER",SWIG_From_int(static_cast< int >(wxRAISED_BORDER)));
55477 SWIG_Python_SetConstant(d, "BORDER",SWIG_From_int(static_cast< int >(wxBORDER)));
55478 SWIG_Python_SetConstant(d, "SIMPLE_BORDER",SWIG_From_int(static_cast< int >(wxSIMPLE_BORDER)));
55479 SWIG_Python_SetConstant(d, "STATIC_BORDER",SWIG_From_int(static_cast< int >(wxSTATIC_BORDER)));
55480 SWIG_Python_SetConstant(d, "TRANSPARENT_WINDOW",SWIG_From_int(static_cast< int >(wxTRANSPARENT_WINDOW)));
55481 SWIG_Python_SetConstant(d, "NO_BORDER",SWIG_From_int(static_cast< int >(wxNO_BORDER)));
55482 SWIG_Python_SetConstant(d, "DEFAULT_CONTROL_BORDER",SWIG_From_int(static_cast< int >(wxDEFAULT_CONTROL_BORDER)));
55483 SWIG_Python_SetConstant(d, "DEFAULT_STATUSBAR_STYLE",SWIG_From_int(static_cast< int >(wxDEFAULT_STATUSBAR_STYLE)));
55484 SWIG_Python_SetConstant(d, "TAB_TRAVERSAL",SWIG_From_int(static_cast< int >(wxTAB_TRAVERSAL)));
55485 SWIG_Python_SetConstant(d, "WANTS_CHARS",SWIG_From_int(static_cast< int >(wxWANTS_CHARS)));
55486 SWIG_Python_SetConstant(d, "POPUP_WINDOW",SWIG_From_int(static_cast< int >(wxPOPUP_WINDOW)));
55487 SWIG_Python_SetConstant(d, "CENTER_FRAME",SWIG_From_int(static_cast< int >(wxCENTER_FRAME)));
55488 SWIG_Python_SetConstant(d, "CENTRE_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTRE_ON_SCREEN)));
55489 SWIG_Python_SetConstant(d, "CENTER_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTER_ON_SCREEN)));
55490 SWIG_Python_SetConstant(d, "CLIP_CHILDREN",SWIG_From_int(static_cast< int >(wxCLIP_CHILDREN)));
55491 SWIG_Python_SetConstant(d, "CLIP_SIBLINGS",SWIG_From_int(static_cast< int >(wxCLIP_SIBLINGS)));
55492 SWIG_Python_SetConstant(d, "ALWAYS_SHOW_SB",SWIG_From_int(static_cast< int >(wxALWAYS_SHOW_SB)));
55493 SWIG_Python_SetConstant(d, "RETAINED",SWIG_From_int(static_cast< int >(wxRETAINED)));
55494 SWIG_Python_SetConstant(d, "BACKINGSTORE",SWIG_From_int(static_cast< int >(wxBACKINGSTORE)));
55495 SWIG_Python_SetConstant(d, "COLOURED",SWIG_From_int(static_cast< int >(wxCOLOURED)));
55496 SWIG_Python_SetConstant(d, "FIXED_LENGTH",SWIG_From_int(static_cast< int >(wxFIXED_LENGTH)));
55497 SWIG_Python_SetConstant(d, "LB_NEEDED_SB",SWIG_From_int(static_cast< int >(wxLB_NEEDED_SB)));
55498 SWIG_Python_SetConstant(d, "LB_ALWAYS_SB",SWIG_From_int(static_cast< int >(wxLB_ALWAYS_SB)));
55499 SWIG_Python_SetConstant(d, "LB_SORT",SWIG_From_int(static_cast< int >(wxLB_SORT)));
55500 SWIG_Python_SetConstant(d, "LB_SINGLE",SWIG_From_int(static_cast< int >(wxLB_SINGLE)));
55501 SWIG_Python_SetConstant(d, "LB_MULTIPLE",SWIG_From_int(static_cast< int >(wxLB_MULTIPLE)));
55502 SWIG_Python_SetConstant(d, "LB_EXTENDED",SWIG_From_int(static_cast< int >(wxLB_EXTENDED)));
55503 SWIG_Python_SetConstant(d, "LB_OWNERDRAW",SWIG_From_int(static_cast< int >(wxLB_OWNERDRAW)));
55504 SWIG_Python_SetConstant(d, "LB_HSCROLL",SWIG_From_int(static_cast< int >(wxLB_HSCROLL)));
55505 SWIG_Python_SetConstant(d, "PROCESS_ENTER",SWIG_From_int(static_cast< int >(wxPROCESS_ENTER)));
55506 SWIG_Python_SetConstant(d, "PASSWORD",SWIG_From_int(static_cast< int >(wxPASSWORD)));
55507 SWIG_Python_SetConstant(d, "CB_SIMPLE",SWIG_From_int(static_cast< int >(wxCB_SIMPLE)));
55508 SWIG_Python_SetConstant(d, "CB_DROPDOWN",SWIG_From_int(static_cast< int >(wxCB_DROPDOWN)));
55509 SWIG_Python_SetConstant(d, "CB_SORT",SWIG_From_int(static_cast< int >(wxCB_SORT)));
55510 SWIG_Python_SetConstant(d, "CB_READONLY",SWIG_From_int(static_cast< int >(wxCB_READONLY)));
55511 SWIG_Python_SetConstant(d, "RA_HORIZONTAL",SWIG_From_int(static_cast< int >(wxRA_HORIZONTAL)));
55512 SWIG_Python_SetConstant(d, "RA_VERTICAL",SWIG_From_int(static_cast< int >(wxRA_VERTICAL)));
55513 SWIG_Python_SetConstant(d, "RA_SPECIFY_ROWS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_ROWS)));
55514 SWIG_Python_SetConstant(d, "RA_SPECIFY_COLS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_COLS)));
55515 SWIG_Python_SetConstant(d, "RA_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRA_USE_CHECKBOX)));
55516 SWIG_Python_SetConstant(d, "RB_GROUP",SWIG_From_int(static_cast< int >(wxRB_GROUP)));
55517 SWIG_Python_SetConstant(d, "RB_SINGLE",SWIG_From_int(static_cast< int >(wxRB_SINGLE)));
55518 SWIG_Python_SetConstant(d, "SB_HORIZONTAL",SWIG_From_int(static_cast< int >(wxSB_HORIZONTAL)));
55519 SWIG_Python_SetConstant(d, "SB_VERTICAL",SWIG_From_int(static_cast< int >(wxSB_VERTICAL)));
55520 SWIG_Python_SetConstant(d, "RB_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRB_USE_CHECKBOX)));
55521 SWIG_Python_SetConstant(d, "ST_SIZEGRIP",SWIG_From_int(static_cast< int >(wxST_SIZEGRIP)));
55522 SWIG_Python_SetConstant(d, "ST_NO_AUTORESIZE",SWIG_From_int(static_cast< int >(wxST_NO_AUTORESIZE)));
55523 SWIG_Python_SetConstant(d, "ST_DOTS_MIDDLE",SWIG_From_int(static_cast< int >(wxST_DOTS_MIDDLE)));
55524 SWIG_Python_SetConstant(d, "ST_DOTS_END",SWIG_From_int(static_cast< int >(wxST_DOTS_END)));
55525 SWIG_Python_SetConstant(d, "FLOOD_SURFACE",SWIG_From_int(static_cast< int >(wxFLOOD_SURFACE)));
55526 SWIG_Python_SetConstant(d, "FLOOD_BORDER",SWIG_From_int(static_cast< int >(wxFLOOD_BORDER)));
55527 SWIG_Python_SetConstant(d, "ODDEVEN_RULE",SWIG_From_int(static_cast< int >(wxODDEVEN_RULE)));
55528 SWIG_Python_SetConstant(d, "WINDING_RULE",SWIG_From_int(static_cast< int >(wxWINDING_RULE)));
55529 SWIG_Python_SetConstant(d, "TOOL_TOP",SWIG_From_int(static_cast< int >(wxTOOL_TOP)));
55530 SWIG_Python_SetConstant(d, "TOOL_BOTTOM",SWIG_From_int(static_cast< int >(wxTOOL_BOTTOM)));
55531 SWIG_Python_SetConstant(d, "TOOL_LEFT",SWIG_From_int(static_cast< int >(wxTOOL_LEFT)));
55532 SWIG_Python_SetConstant(d, "TOOL_RIGHT",SWIG_From_int(static_cast< int >(wxTOOL_RIGHT)));
55533 SWIG_Python_SetConstant(d, "OK",SWIG_From_int(static_cast< int >(wxOK)));
55534 SWIG_Python_SetConstant(d, "YES_NO",SWIG_From_int(static_cast< int >(wxYES_NO)));
55535 SWIG_Python_SetConstant(d, "CANCEL",SWIG_From_int(static_cast< int >(wxCANCEL)));
55536 SWIG_Python_SetConstant(d, "YES",SWIG_From_int(static_cast< int >(wxYES)));
55537 SWIG_Python_SetConstant(d, "NO",SWIG_From_int(static_cast< int >(wxNO)));
55538 SWIG_Python_SetConstant(d, "NO_DEFAULT",SWIG_From_int(static_cast< int >(wxNO_DEFAULT)));
55539 SWIG_Python_SetConstant(d, "YES_DEFAULT",SWIG_From_int(static_cast< int >(wxYES_DEFAULT)));
55540 SWIG_Python_SetConstant(d, "ICON_EXCLAMATION",SWIG_From_int(static_cast< int >(wxICON_EXCLAMATION)));
55541 SWIG_Python_SetConstant(d, "ICON_HAND",SWIG_From_int(static_cast< int >(wxICON_HAND)));
55542 SWIG_Python_SetConstant(d, "ICON_QUESTION",SWIG_From_int(static_cast< int >(wxICON_QUESTION)));
55543 SWIG_Python_SetConstant(d, "ICON_INFORMATION",SWIG_From_int(static_cast< int >(wxICON_INFORMATION)));
55544 SWIG_Python_SetConstant(d, "ICON_STOP",SWIG_From_int(static_cast< int >(wxICON_STOP)));
55545 SWIG_Python_SetConstant(d, "ICON_ASTERISK",SWIG_From_int(static_cast< int >(wxICON_ASTERISK)));
55546 SWIG_Python_SetConstant(d, "ICON_MASK",SWIG_From_int(static_cast< int >(wxICON_MASK)));
55547 SWIG_Python_SetConstant(d, "ICON_WARNING",SWIG_From_int(static_cast< int >(wxICON_WARNING)));
55548 SWIG_Python_SetConstant(d, "ICON_ERROR",SWIG_From_int(static_cast< int >(wxICON_ERROR)));
55549 SWIG_Python_SetConstant(d, "FORWARD",SWIG_From_int(static_cast< int >(wxFORWARD)));
55550 SWIG_Python_SetConstant(d, "BACKWARD",SWIG_From_int(static_cast< int >(wxBACKWARD)));
55551 SWIG_Python_SetConstant(d, "RESET",SWIG_From_int(static_cast< int >(wxRESET)));
55552 SWIG_Python_SetConstant(d, "HELP",SWIG_From_int(static_cast< int >(wxHELP)));
55553 SWIG_Python_SetConstant(d, "MORE",SWIG_From_int(static_cast< int >(wxMORE)));
55554 SWIG_Python_SetConstant(d, "SETUP",SWIG_From_int(static_cast< int >(wxSETUP)));
55555 SWIG_Python_SetConstant(d, "SIZE_AUTO_WIDTH",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_WIDTH)));
55556 SWIG_Python_SetConstant(d, "SIZE_AUTO_HEIGHT",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_HEIGHT)));
55557 SWIG_Python_SetConstant(d, "SIZE_AUTO",SWIG_From_int(static_cast< int >(wxSIZE_AUTO)));
55558 SWIG_Python_SetConstant(d, "SIZE_USE_EXISTING",SWIG_From_int(static_cast< int >(wxSIZE_USE_EXISTING)));
55559 SWIG_Python_SetConstant(d, "SIZE_ALLOW_MINUS_ONE",SWIG_From_int(static_cast< int >(wxSIZE_ALLOW_MINUS_ONE)));
55560 SWIG_Python_SetConstant(d, "SIZE_FORCE",SWIG_From_int(static_cast< int >(wxSIZE_FORCE)));
55561 SWIG_Python_SetConstant(d, "PORTRAIT",SWIG_From_int(static_cast< int >(wxPORTRAIT)));
55562 SWIG_Python_SetConstant(d, "LANDSCAPE",SWIG_From_int(static_cast< int >(wxLANDSCAPE)));
55563 SWIG_Python_SetConstant(d, "PRINT_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_HIGH)));
55564 SWIG_Python_SetConstant(d, "PRINT_QUALITY_MEDIUM",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_MEDIUM)));
55565 SWIG_Python_SetConstant(d, "PRINT_QUALITY_LOW",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_LOW)));
55566 SWIG_Python_SetConstant(d, "PRINT_QUALITY_DRAFT",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_DRAFT)));
55567 SWIG_Python_SetConstant(d, "ID_ANY",SWIG_From_int(static_cast< int >(wxID_ANY)));
55568 SWIG_Python_SetConstant(d, "ID_SEPARATOR",SWIG_From_int(static_cast< int >(wxID_SEPARATOR)));
55569 SWIG_Python_SetConstant(d, "ID_NONE",SWIG_From_int(static_cast< int >(wxID_NONE)));
55570 SWIG_Python_SetConstant(d, "ID_LOWEST",SWIG_From_int(static_cast< int >(wxID_LOWEST)));
55571 SWIG_Python_SetConstant(d, "ID_OPEN",SWIG_From_int(static_cast< int >(wxID_OPEN)));
55572 SWIG_Python_SetConstant(d, "ID_CLOSE",SWIG_From_int(static_cast< int >(wxID_CLOSE)));
55573 SWIG_Python_SetConstant(d, "ID_NEW",SWIG_From_int(static_cast< int >(wxID_NEW)));
55574 SWIG_Python_SetConstant(d, "ID_SAVE",SWIG_From_int(static_cast< int >(wxID_SAVE)));
55575 SWIG_Python_SetConstant(d, "ID_SAVEAS",SWIG_From_int(static_cast< int >(wxID_SAVEAS)));
55576 SWIG_Python_SetConstant(d, "ID_REVERT",SWIG_From_int(static_cast< int >(wxID_REVERT)));
55577 SWIG_Python_SetConstant(d, "ID_EXIT",SWIG_From_int(static_cast< int >(wxID_EXIT)));
55578 SWIG_Python_SetConstant(d, "ID_UNDO",SWIG_From_int(static_cast< int >(wxID_UNDO)));
55579 SWIG_Python_SetConstant(d, "ID_REDO",SWIG_From_int(static_cast< int >(wxID_REDO)));
55580 SWIG_Python_SetConstant(d, "ID_HELP",SWIG_From_int(static_cast< int >(wxID_HELP)));
55581 SWIG_Python_SetConstant(d, "ID_PRINT",SWIG_From_int(static_cast< int >(wxID_PRINT)));
55582 SWIG_Python_SetConstant(d, "ID_PRINT_SETUP",SWIG_From_int(static_cast< int >(wxID_PRINT_SETUP)));
55583 SWIG_Python_SetConstant(d, "ID_PREVIEW",SWIG_From_int(static_cast< int >(wxID_PREVIEW)));
55584 SWIG_Python_SetConstant(d, "ID_ABOUT",SWIG_From_int(static_cast< int >(wxID_ABOUT)));
55585 SWIG_Python_SetConstant(d, "ID_HELP_CONTENTS",SWIG_From_int(static_cast< int >(wxID_HELP_CONTENTS)));
55586 SWIG_Python_SetConstant(d, "ID_HELP_COMMANDS",SWIG_From_int(static_cast< int >(wxID_HELP_COMMANDS)));
55587 SWIG_Python_SetConstant(d, "ID_HELP_PROCEDURES",SWIG_From_int(static_cast< int >(wxID_HELP_PROCEDURES)));
55588 SWIG_Python_SetConstant(d, "ID_HELP_CONTEXT",SWIG_From_int(static_cast< int >(wxID_HELP_CONTEXT)));
55589 SWIG_Python_SetConstant(d, "ID_CLOSE_ALL",SWIG_From_int(static_cast< int >(wxID_CLOSE_ALL)));
55590 SWIG_Python_SetConstant(d, "ID_PREFERENCES",SWIG_From_int(static_cast< int >(wxID_PREFERENCES)));
55591 SWIG_Python_SetConstant(d, "ID_CUT",SWIG_From_int(static_cast< int >(wxID_CUT)));
55592 SWIG_Python_SetConstant(d, "ID_COPY",SWIG_From_int(static_cast< int >(wxID_COPY)));
55593 SWIG_Python_SetConstant(d, "ID_PASTE",SWIG_From_int(static_cast< int >(wxID_PASTE)));
55594 SWIG_Python_SetConstant(d, "ID_CLEAR",SWIG_From_int(static_cast< int >(wxID_CLEAR)));
55595 SWIG_Python_SetConstant(d, "ID_FIND",SWIG_From_int(static_cast< int >(wxID_FIND)));
55596 SWIG_Python_SetConstant(d, "ID_DUPLICATE",SWIG_From_int(static_cast< int >(wxID_DUPLICATE)));
55597 SWIG_Python_SetConstant(d, "ID_SELECTALL",SWIG_From_int(static_cast< int >(wxID_SELECTALL)));
55598 SWIG_Python_SetConstant(d, "ID_DELETE",SWIG_From_int(static_cast< int >(wxID_DELETE)));
55599 SWIG_Python_SetConstant(d, "ID_REPLACE",SWIG_From_int(static_cast< int >(wxID_REPLACE)));
55600 SWIG_Python_SetConstant(d, "ID_REPLACE_ALL",SWIG_From_int(static_cast< int >(wxID_REPLACE_ALL)));
55601 SWIG_Python_SetConstant(d, "ID_PROPERTIES",SWIG_From_int(static_cast< int >(wxID_PROPERTIES)));
55602 SWIG_Python_SetConstant(d, "ID_VIEW_DETAILS",SWIG_From_int(static_cast< int >(wxID_VIEW_DETAILS)));
55603 SWIG_Python_SetConstant(d, "ID_VIEW_LARGEICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_LARGEICONS)));
55604 SWIG_Python_SetConstant(d, "ID_VIEW_SMALLICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_SMALLICONS)));
55605 SWIG_Python_SetConstant(d, "ID_VIEW_LIST",SWIG_From_int(static_cast< int >(wxID_VIEW_LIST)));
55606 SWIG_Python_SetConstant(d, "ID_VIEW_SORTDATE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTDATE)));
55607 SWIG_Python_SetConstant(d, "ID_VIEW_SORTNAME",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTNAME)));
55608 SWIG_Python_SetConstant(d, "ID_VIEW_SORTSIZE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTSIZE)));
55609 SWIG_Python_SetConstant(d, "ID_VIEW_SORTTYPE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTTYPE)));
55610 SWIG_Python_SetConstant(d, "ID_FILE1",SWIG_From_int(static_cast< int >(wxID_FILE1)));
55611 SWIG_Python_SetConstant(d, "ID_FILE2",SWIG_From_int(static_cast< int >(wxID_FILE2)));
55612 SWIG_Python_SetConstant(d, "ID_FILE3",SWIG_From_int(static_cast< int >(wxID_FILE3)));
55613 SWIG_Python_SetConstant(d, "ID_FILE4",SWIG_From_int(static_cast< int >(wxID_FILE4)));
55614 SWIG_Python_SetConstant(d, "ID_FILE5",SWIG_From_int(static_cast< int >(wxID_FILE5)));
55615 SWIG_Python_SetConstant(d, "ID_FILE6",SWIG_From_int(static_cast< int >(wxID_FILE6)));
55616 SWIG_Python_SetConstant(d, "ID_FILE7",SWIG_From_int(static_cast< int >(wxID_FILE7)));
55617 SWIG_Python_SetConstant(d, "ID_FILE8",SWIG_From_int(static_cast< int >(wxID_FILE8)));
55618 SWIG_Python_SetConstant(d, "ID_FILE9",SWIG_From_int(static_cast< int >(wxID_FILE9)));
55619 SWIG_Python_SetConstant(d, "ID_OK",SWIG_From_int(static_cast< int >(wxID_OK)));
55620 SWIG_Python_SetConstant(d, "ID_CANCEL",SWIG_From_int(static_cast< int >(wxID_CANCEL)));
55621 SWIG_Python_SetConstant(d, "ID_APPLY",SWIG_From_int(static_cast< int >(wxID_APPLY)));
55622 SWIG_Python_SetConstant(d, "ID_YES",SWIG_From_int(static_cast< int >(wxID_YES)));
55623 SWIG_Python_SetConstant(d, "ID_NO",SWIG_From_int(static_cast< int >(wxID_NO)));
55624 SWIG_Python_SetConstant(d, "ID_STATIC",SWIG_From_int(static_cast< int >(wxID_STATIC)));
55625 SWIG_Python_SetConstant(d, "ID_FORWARD",SWIG_From_int(static_cast< int >(wxID_FORWARD)));
55626 SWIG_Python_SetConstant(d, "ID_BACKWARD",SWIG_From_int(static_cast< int >(wxID_BACKWARD)));
55627 SWIG_Python_SetConstant(d, "ID_DEFAULT",SWIG_From_int(static_cast< int >(wxID_DEFAULT)));
55628 SWIG_Python_SetConstant(d, "ID_MORE",SWIG_From_int(static_cast< int >(wxID_MORE)));
55629 SWIG_Python_SetConstant(d, "ID_SETUP",SWIG_From_int(static_cast< int >(wxID_SETUP)));
55630 SWIG_Python_SetConstant(d, "ID_RESET",SWIG_From_int(static_cast< int >(wxID_RESET)));
55631 SWIG_Python_SetConstant(d, "ID_CONTEXT_HELP",SWIG_From_int(static_cast< int >(wxID_CONTEXT_HELP)));
55632 SWIG_Python_SetConstant(d, "ID_YESTOALL",SWIG_From_int(static_cast< int >(wxID_YESTOALL)));
55633 SWIG_Python_SetConstant(d, "ID_NOTOALL",SWIG_From_int(static_cast< int >(wxID_NOTOALL)));
55634 SWIG_Python_SetConstant(d, "ID_ABORT",SWIG_From_int(static_cast< int >(wxID_ABORT)));
55635 SWIG_Python_SetConstant(d, "ID_RETRY",SWIG_From_int(static_cast< int >(wxID_RETRY)));
55636 SWIG_Python_SetConstant(d, "ID_IGNORE",SWIG_From_int(static_cast< int >(wxID_IGNORE)));
55637 SWIG_Python_SetConstant(d, "ID_ADD",SWIG_From_int(static_cast< int >(wxID_ADD)));
55638 SWIG_Python_SetConstant(d, "ID_REMOVE",SWIG_From_int(static_cast< int >(wxID_REMOVE)));
55639 SWIG_Python_SetConstant(d, "ID_UP",SWIG_From_int(static_cast< int >(wxID_UP)));
55640 SWIG_Python_SetConstant(d, "ID_DOWN",SWIG_From_int(static_cast< int >(wxID_DOWN)));
55641 SWIG_Python_SetConstant(d, "ID_HOME",SWIG_From_int(static_cast< int >(wxID_HOME)));
55642 SWIG_Python_SetConstant(d, "ID_REFRESH",SWIG_From_int(static_cast< int >(wxID_REFRESH)));
55643 SWIG_Python_SetConstant(d, "ID_STOP",SWIG_From_int(static_cast< int >(wxID_STOP)));
55644 SWIG_Python_SetConstant(d, "ID_INDEX",SWIG_From_int(static_cast< int >(wxID_INDEX)));
55645 SWIG_Python_SetConstant(d, "ID_BOLD",SWIG_From_int(static_cast< int >(wxID_BOLD)));
55646 SWIG_Python_SetConstant(d, "ID_ITALIC",SWIG_From_int(static_cast< int >(wxID_ITALIC)));
55647 SWIG_Python_SetConstant(d, "ID_JUSTIFY_CENTER",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_CENTER)));
55648 SWIG_Python_SetConstant(d, "ID_JUSTIFY_FILL",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_FILL)));
55649 SWIG_Python_SetConstant(d, "ID_JUSTIFY_RIGHT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_RIGHT)));
55650 SWIG_Python_SetConstant(d, "ID_JUSTIFY_LEFT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_LEFT)));
55651 SWIG_Python_SetConstant(d, "ID_UNDERLINE",SWIG_From_int(static_cast< int >(wxID_UNDERLINE)));
55652 SWIG_Python_SetConstant(d, "ID_INDENT",SWIG_From_int(static_cast< int >(wxID_INDENT)));
55653 SWIG_Python_SetConstant(d, "ID_UNINDENT",SWIG_From_int(static_cast< int >(wxID_UNINDENT)));
55654 SWIG_Python_SetConstant(d, "ID_ZOOM_100",SWIG_From_int(static_cast< int >(wxID_ZOOM_100)));
55655 SWIG_Python_SetConstant(d, "ID_ZOOM_FIT",SWIG_From_int(static_cast< int >(wxID_ZOOM_FIT)));
55656 SWIG_Python_SetConstant(d, "ID_ZOOM_IN",SWIG_From_int(static_cast< int >(wxID_ZOOM_IN)));
55657 SWIG_Python_SetConstant(d, "ID_ZOOM_OUT",SWIG_From_int(static_cast< int >(wxID_ZOOM_OUT)));
55658 SWIG_Python_SetConstant(d, "ID_UNDELETE",SWIG_From_int(static_cast< int >(wxID_UNDELETE)));
55659 SWIG_Python_SetConstant(d, "ID_REVERT_TO_SAVED",SWIG_From_int(static_cast< int >(wxID_REVERT_TO_SAVED)));
55660 SWIG_Python_SetConstant(d, "ID_HIGHEST",SWIG_From_int(static_cast< int >(wxID_HIGHEST)));
55661 SWIG_Python_SetConstant(d, "OPEN",SWIG_From_int(static_cast< int >(wxOPEN)));
55662 SWIG_Python_SetConstant(d, "SAVE",SWIG_From_int(static_cast< int >(wxSAVE)));
55663 SWIG_Python_SetConstant(d, "HIDE_READONLY",SWIG_From_int(static_cast< int >(wxHIDE_READONLY)));
55664 SWIG_Python_SetConstant(d, "OVERWRITE_PROMPT",SWIG_From_int(static_cast< int >(wxOVERWRITE_PROMPT)));
55665 SWIG_Python_SetConstant(d, "FILE_MUST_EXIST",SWIG_From_int(static_cast< int >(wxFILE_MUST_EXIST)));
55666 SWIG_Python_SetConstant(d, "MULTIPLE",SWIG_From_int(static_cast< int >(wxMULTIPLE)));
55667 SWIG_Python_SetConstant(d, "CHANGE_DIR",SWIG_From_int(static_cast< int >(wxCHANGE_DIR)));
55668 SWIG_Python_SetConstant(d, "ACCEL_ALT",SWIG_From_int(static_cast< int >(wxACCEL_ALT)));
55669 SWIG_Python_SetConstant(d, "ACCEL_CTRL",SWIG_From_int(static_cast< int >(wxACCEL_CTRL)));
55670 SWIG_Python_SetConstant(d, "ACCEL_SHIFT",SWIG_From_int(static_cast< int >(wxACCEL_SHIFT)));
55671 SWIG_Python_SetConstant(d, "ACCEL_NORMAL",SWIG_From_int(static_cast< int >(wxACCEL_NORMAL)));
55672 SWIG_Python_SetConstant(d, "PD_AUTO_HIDE",SWIG_From_int(static_cast< int >(wxPD_AUTO_HIDE)));
55673 SWIG_Python_SetConstant(d, "PD_APP_MODAL",SWIG_From_int(static_cast< int >(wxPD_APP_MODAL)));
55674 SWIG_Python_SetConstant(d, "PD_CAN_ABORT",SWIG_From_int(static_cast< int >(wxPD_CAN_ABORT)));
55675 SWIG_Python_SetConstant(d, "PD_ELAPSED_TIME",SWIG_From_int(static_cast< int >(wxPD_ELAPSED_TIME)));
55676 SWIG_Python_SetConstant(d, "PD_ESTIMATED_TIME",SWIG_From_int(static_cast< int >(wxPD_ESTIMATED_TIME)));
55677 SWIG_Python_SetConstant(d, "PD_REMAINING_TIME",SWIG_From_int(static_cast< int >(wxPD_REMAINING_TIME)));
55678 SWIG_Python_SetConstant(d, "PD_SMOOTH",SWIG_From_int(static_cast< int >(wxPD_SMOOTH)));
55679 SWIG_Python_SetConstant(d, "PD_CAN_SKIP",SWIG_From_int(static_cast< int >(wxPD_CAN_SKIP)));
55680 SWIG_Python_SetConstant(d, "DD_NEW_DIR_BUTTON",SWIG_From_int(static_cast< int >(wxDD_NEW_DIR_BUTTON)));
55681 SWIG_Python_SetConstant(d, "DD_DEFAULT_STYLE",SWIG_From_int(static_cast< int >(wxDD_DEFAULT_STYLE)));
55682 SWIG_Python_SetConstant(d, "DD_CHANGE_DIR",SWIG_From_int(static_cast< int >(wxDD_CHANGE_DIR)));
55683 SWIG_Python_SetConstant(d, "MENU_TEAROFF",SWIG_From_int(static_cast< int >(wxMENU_TEAROFF)));
55684 SWIG_Python_SetConstant(d, "MB_DOCKABLE",SWIG_From_int(static_cast< int >(wxMB_DOCKABLE)));
55685 SWIG_Python_SetConstant(d, "NO_FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxNO_FULL_REPAINT_ON_RESIZE)));
55686 SWIG_Python_SetConstant(d, "FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxFULL_REPAINT_ON_RESIZE)));
55687 SWIG_Python_SetConstant(d, "LI_HORIZONTAL",SWIG_From_int(static_cast< int >(wxLI_HORIZONTAL)));
55688 SWIG_Python_SetConstant(d, "LI_VERTICAL",SWIG_From_int(static_cast< int >(wxLI_VERTICAL)));
55689 SWIG_Python_SetConstant(d, "WS_EX_VALIDATE_RECURSIVELY",SWIG_From_int(static_cast< int >(wxWS_EX_VALIDATE_RECURSIVELY)));
55690 SWIG_Python_SetConstant(d, "WS_EX_BLOCK_EVENTS",SWIG_From_int(static_cast< int >(wxWS_EX_BLOCK_EVENTS)));
55691 SWIG_Python_SetConstant(d, "WS_EX_TRANSIENT",SWIG_From_int(static_cast< int >(wxWS_EX_TRANSIENT)));
55692 SWIG_Python_SetConstant(d, "WS_EX_THEMED_BACKGROUND",SWIG_From_int(static_cast< int >(wxWS_EX_THEMED_BACKGROUND)));
55693 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_IDLE",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_IDLE)));
55694 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_UI_UPDATES",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_UI_UPDATES)));
55695 SWIG_Python_SetConstant(d, "MM_TEXT",SWIG_From_int(static_cast< int >(wxMM_TEXT)));
55696 SWIG_Python_SetConstant(d, "MM_LOMETRIC",SWIG_From_int(static_cast< int >(wxMM_LOMETRIC)));
55697 SWIG_Python_SetConstant(d, "MM_HIMETRIC",SWIG_From_int(static_cast< int >(wxMM_HIMETRIC)));
55698 SWIG_Python_SetConstant(d, "MM_LOENGLISH",SWIG_From_int(static_cast< int >(wxMM_LOENGLISH)));
55699 SWIG_Python_SetConstant(d, "MM_HIENGLISH",SWIG_From_int(static_cast< int >(wxMM_HIENGLISH)));
55700 SWIG_Python_SetConstant(d, "MM_TWIPS",SWIG_From_int(static_cast< int >(wxMM_TWIPS)));
55701 SWIG_Python_SetConstant(d, "MM_ISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ISOTROPIC)));
55702 SWIG_Python_SetConstant(d, "MM_ANISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ANISOTROPIC)));
55703 SWIG_Python_SetConstant(d, "MM_POINTS",SWIG_From_int(static_cast< int >(wxMM_POINTS)));
55704 SWIG_Python_SetConstant(d, "MM_METRIC",SWIG_From_int(static_cast< int >(wxMM_METRIC)));
55705 SWIG_Python_SetConstant(d, "CENTRE",SWIG_From_int(static_cast< int >(wxCENTRE)));
55706 SWIG_Python_SetConstant(d, "CENTER",SWIG_From_int(static_cast< int >(wxCENTER)));
55707 SWIG_Python_SetConstant(d, "HORIZONTAL",SWIG_From_int(static_cast< int >(wxHORIZONTAL)));
55708 SWIG_Python_SetConstant(d, "VERTICAL",SWIG_From_int(static_cast< int >(wxVERTICAL)));
55709 SWIG_Python_SetConstant(d, "BOTH",SWIG_From_int(static_cast< int >(wxBOTH)));
55710 SWIG_Python_SetConstant(d, "LEFT",SWIG_From_int(static_cast< int >(wxLEFT)));
55711 SWIG_Python_SetConstant(d, "RIGHT",SWIG_From_int(static_cast< int >(wxRIGHT)));
55712 SWIG_Python_SetConstant(d, "UP",SWIG_From_int(static_cast< int >(wxUP)));
55713 SWIG_Python_SetConstant(d, "DOWN",SWIG_From_int(static_cast< int >(wxDOWN)));
55714 SWIG_Python_SetConstant(d, "TOP",SWIG_From_int(static_cast< int >(wxTOP)));
55715 SWIG_Python_SetConstant(d, "BOTTOM",SWIG_From_int(static_cast< int >(wxBOTTOM)));
55716 SWIG_Python_SetConstant(d, "NORTH",SWIG_From_int(static_cast< int >(wxNORTH)));
55717 SWIG_Python_SetConstant(d, "SOUTH",SWIG_From_int(static_cast< int >(wxSOUTH)));
55718 SWIG_Python_SetConstant(d, "WEST",SWIG_From_int(static_cast< int >(wxWEST)));
55719 SWIG_Python_SetConstant(d, "EAST",SWIG_From_int(static_cast< int >(wxEAST)));
55720 SWIG_Python_SetConstant(d, "ALL",SWIG_From_int(static_cast< int >(wxALL)));
55721 SWIG_Python_SetConstant(d, "ALIGN_NOT",SWIG_From_int(static_cast< int >(wxALIGN_NOT)));
55722 SWIG_Python_SetConstant(d, "ALIGN_CENTER_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_HORIZONTAL)));
55723 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_HORIZONTAL)));
55724 SWIG_Python_SetConstant(d, "ALIGN_LEFT",SWIG_From_int(static_cast< int >(wxALIGN_LEFT)));
55725 SWIG_Python_SetConstant(d, "ALIGN_TOP",SWIG_From_int(static_cast< int >(wxALIGN_TOP)));
55726 SWIG_Python_SetConstant(d, "ALIGN_RIGHT",SWIG_From_int(static_cast< int >(wxALIGN_RIGHT)));
55727 SWIG_Python_SetConstant(d, "ALIGN_BOTTOM",SWIG_From_int(static_cast< int >(wxALIGN_BOTTOM)));
55728 SWIG_Python_SetConstant(d, "ALIGN_CENTER_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_VERTICAL)));
55729 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_VERTICAL)));
55730 SWIG_Python_SetConstant(d, "ALIGN_CENTER",SWIG_From_int(static_cast< int >(wxALIGN_CENTER)));
55731 SWIG_Python_SetConstant(d, "ALIGN_CENTRE",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE)));
55732 SWIG_Python_SetConstant(d, "ALIGN_MASK",SWIG_From_int(static_cast< int >(wxALIGN_MASK)));
55733 SWIG_Python_SetConstant(d, "STRETCH_NOT",SWIG_From_int(static_cast< int >(wxSTRETCH_NOT)));
55734 SWIG_Python_SetConstant(d, "SHRINK",SWIG_From_int(static_cast< int >(wxSHRINK)));
55735 SWIG_Python_SetConstant(d, "GROW",SWIG_From_int(static_cast< int >(wxGROW)));
55736 SWIG_Python_SetConstant(d, "EXPAND",SWIG_From_int(static_cast< int >(wxEXPAND)));
55737 SWIG_Python_SetConstant(d, "SHAPED",SWIG_From_int(static_cast< int >(wxSHAPED)));
55738 SWIG_Python_SetConstant(d, "FIXED_MINSIZE",SWIG_From_int(static_cast< int >(wxFIXED_MINSIZE)));
55739 SWIG_Python_SetConstant(d, "TILE",SWIG_From_int(static_cast< int >(wxTILE)));
55740 SWIG_Python_SetConstant(d, "ADJUST_MINSIZE",SWIG_From_int(static_cast< int >(wxADJUST_MINSIZE)));
55741 SWIG_Python_SetConstant(d, "BORDER_DEFAULT",SWIG_From_int(static_cast< int >(wxBORDER_DEFAULT)));
55742 SWIG_Python_SetConstant(d, "BORDER_NONE",SWIG_From_int(static_cast< int >(wxBORDER_NONE)));
55743 SWIG_Python_SetConstant(d, "BORDER_STATIC",SWIG_From_int(static_cast< int >(wxBORDER_STATIC)));
55744 SWIG_Python_SetConstant(d, "BORDER_SIMPLE",SWIG_From_int(static_cast< int >(wxBORDER_SIMPLE)));
55745 SWIG_Python_SetConstant(d, "BORDER_RAISED",SWIG_From_int(static_cast< int >(wxBORDER_RAISED)));
55746 SWIG_Python_SetConstant(d, "BORDER_SUNKEN",SWIG_From_int(static_cast< int >(wxBORDER_SUNKEN)));
55747 SWIG_Python_SetConstant(d, "BORDER_DOUBLE",SWIG_From_int(static_cast< int >(wxBORDER_DOUBLE)));
55748 SWIG_Python_SetConstant(d, "BORDER_MASK",SWIG_From_int(static_cast< int >(wxBORDER_MASK)));
55749 SWIG_Python_SetConstant(d, "BG_STYLE_SYSTEM",SWIG_From_int(static_cast< int >(wxBG_STYLE_SYSTEM)));
55750 SWIG_Python_SetConstant(d, "BG_STYLE_COLOUR",SWIG_From_int(static_cast< int >(wxBG_STYLE_COLOUR)));
55751 SWIG_Python_SetConstant(d, "BG_STYLE_CUSTOM",SWIG_From_int(static_cast< int >(wxBG_STYLE_CUSTOM)));
55752 SWIG_Python_SetConstant(d, "DEFAULT",SWIG_From_int(static_cast< int >(wxDEFAULT)));
55753 SWIG_Python_SetConstant(d, "DECORATIVE",SWIG_From_int(static_cast< int >(wxDECORATIVE)));
55754 SWIG_Python_SetConstant(d, "ROMAN",SWIG_From_int(static_cast< int >(wxROMAN)));
55755 SWIG_Python_SetConstant(d, "SCRIPT",SWIG_From_int(static_cast< int >(wxSCRIPT)));
55756 SWIG_Python_SetConstant(d, "SWISS",SWIG_From_int(static_cast< int >(wxSWISS)));
55757 SWIG_Python_SetConstant(d, "MODERN",SWIG_From_int(static_cast< int >(wxMODERN)));
55758 SWIG_Python_SetConstant(d, "TELETYPE",SWIG_From_int(static_cast< int >(wxTELETYPE)));
55759 SWIG_Python_SetConstant(d, "VARIABLE",SWIG_From_int(static_cast< int >(wxVARIABLE)));
55760 SWIG_Python_SetConstant(d, "FIXED",SWIG_From_int(static_cast< int >(wxFIXED)));
55761 SWIG_Python_SetConstant(d, "NORMAL",SWIG_From_int(static_cast< int >(wxNORMAL)));
55762 SWIG_Python_SetConstant(d, "LIGHT",SWIG_From_int(static_cast< int >(wxLIGHT)));
55763 SWIG_Python_SetConstant(d, "BOLD",SWIG_From_int(static_cast< int >(wxBOLD)));
55764 SWIG_Python_SetConstant(d, "ITALIC",SWIG_From_int(static_cast< int >(wxITALIC)));
55765 SWIG_Python_SetConstant(d, "SLANT",SWIG_From_int(static_cast< int >(wxSLANT)));
55766 SWIG_Python_SetConstant(d, "SOLID",SWIG_From_int(static_cast< int >(wxSOLID)));
55767 SWIG_Python_SetConstant(d, "DOT",SWIG_From_int(static_cast< int >(wxDOT)));
55768 SWIG_Python_SetConstant(d, "LONG_DASH",SWIG_From_int(static_cast< int >(wxLONG_DASH)));
55769 SWIG_Python_SetConstant(d, "SHORT_DASH",SWIG_From_int(static_cast< int >(wxSHORT_DASH)));
55770 SWIG_Python_SetConstant(d, "DOT_DASH",SWIG_From_int(static_cast< int >(wxDOT_DASH)));
55771 SWIG_Python_SetConstant(d, "USER_DASH",SWIG_From_int(static_cast< int >(wxUSER_DASH)));
55772 SWIG_Python_SetConstant(d, "TRANSPARENT",SWIG_From_int(static_cast< int >(wxTRANSPARENT)));
55773 SWIG_Python_SetConstant(d, "STIPPLE",SWIG_From_int(static_cast< int >(wxSTIPPLE)));
55774 SWIG_Python_SetConstant(d, "STIPPLE_MASK",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK)));
55775 SWIG_Python_SetConstant(d, "STIPPLE_MASK_OPAQUE",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK_OPAQUE)));
55776 SWIG_Python_SetConstant(d, "BDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxBDIAGONAL_HATCH)));
55777 SWIG_Python_SetConstant(d, "CROSSDIAG_HATCH",SWIG_From_int(static_cast< int >(wxCROSSDIAG_HATCH)));
55778 SWIG_Python_SetConstant(d, "FDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxFDIAGONAL_HATCH)));
55779 SWIG_Python_SetConstant(d, "CROSS_HATCH",SWIG_From_int(static_cast< int >(wxCROSS_HATCH)));
55780 SWIG_Python_SetConstant(d, "HORIZONTAL_HATCH",SWIG_From_int(static_cast< int >(wxHORIZONTAL_HATCH)));
55781 SWIG_Python_SetConstant(d, "VERTICAL_HATCH",SWIG_From_int(static_cast< int >(wxVERTICAL_HATCH)));
55782 SWIG_Python_SetConstant(d, "JOIN_BEVEL",SWIG_From_int(static_cast< int >(wxJOIN_BEVEL)));
55783 SWIG_Python_SetConstant(d, "JOIN_MITER",SWIG_From_int(static_cast< int >(wxJOIN_MITER)));
55784 SWIG_Python_SetConstant(d, "JOIN_ROUND",SWIG_From_int(static_cast< int >(wxJOIN_ROUND)));
55785 SWIG_Python_SetConstant(d, "CAP_ROUND",SWIG_From_int(static_cast< int >(wxCAP_ROUND)));
55786 SWIG_Python_SetConstant(d, "CAP_PROJECTING",SWIG_From_int(static_cast< int >(wxCAP_PROJECTING)));
55787 SWIG_Python_SetConstant(d, "CAP_BUTT",SWIG_From_int(static_cast< int >(wxCAP_BUTT)));
55788 SWIG_Python_SetConstant(d, "CLEAR",SWIG_From_int(static_cast< int >(wxCLEAR)));
55789 SWIG_Python_SetConstant(d, "XOR",SWIG_From_int(static_cast< int >(wxXOR)));
55790 SWIG_Python_SetConstant(d, "INVERT",SWIG_From_int(static_cast< int >(wxINVERT)));
55791 SWIG_Python_SetConstant(d, "OR_REVERSE",SWIG_From_int(static_cast< int >(wxOR_REVERSE)));
55792 SWIG_Python_SetConstant(d, "AND_REVERSE",SWIG_From_int(static_cast< int >(wxAND_REVERSE)));
55793 SWIG_Python_SetConstant(d, "COPY",SWIG_From_int(static_cast< int >(wxCOPY)));
55794 SWIG_Python_SetConstant(d, "AND",SWIG_From_int(static_cast< int >(wxAND)));
55795 SWIG_Python_SetConstant(d, "AND_INVERT",SWIG_From_int(static_cast< int >(wxAND_INVERT)));
55796 SWIG_Python_SetConstant(d, "NO_OP",SWIG_From_int(static_cast< int >(wxNO_OP)));
55797 SWIG_Python_SetConstant(d, "NOR",SWIG_From_int(static_cast< int >(wxNOR)));
55798 SWIG_Python_SetConstant(d, "EQUIV",SWIG_From_int(static_cast< int >(wxEQUIV)));
55799 SWIG_Python_SetConstant(d, "SRC_INVERT",SWIG_From_int(static_cast< int >(wxSRC_INVERT)));
55800 SWIG_Python_SetConstant(d, "OR_INVERT",SWIG_From_int(static_cast< int >(wxOR_INVERT)));
55801 SWIG_Python_SetConstant(d, "NAND",SWIG_From_int(static_cast< int >(wxNAND)));
55802 SWIG_Python_SetConstant(d, "OR",SWIG_From_int(static_cast< int >(wxOR)));
55803 SWIG_Python_SetConstant(d, "SET",SWIG_From_int(static_cast< int >(wxSET)));
55804 SWIG_Python_SetConstant(d, "WXK_BACK",SWIG_From_int(static_cast< int >(WXK_BACK)));
55805 SWIG_Python_SetConstant(d, "WXK_TAB",SWIG_From_int(static_cast< int >(WXK_TAB)));
55806 SWIG_Python_SetConstant(d, "WXK_RETURN",SWIG_From_int(static_cast< int >(WXK_RETURN)));
55807 SWIG_Python_SetConstant(d, "WXK_ESCAPE",SWIG_From_int(static_cast< int >(WXK_ESCAPE)));
55808 SWIG_Python_SetConstant(d, "WXK_SPACE",SWIG_From_int(static_cast< int >(WXK_SPACE)));
55809 SWIG_Python_SetConstant(d, "WXK_DELETE",SWIG_From_int(static_cast< int >(WXK_DELETE)));
55810 SWIG_Python_SetConstant(d, "WXK_START",SWIG_From_int(static_cast< int >(WXK_START)));
55811 SWIG_Python_SetConstant(d, "WXK_LBUTTON",SWIG_From_int(static_cast< int >(WXK_LBUTTON)));
55812 SWIG_Python_SetConstant(d, "WXK_RBUTTON",SWIG_From_int(static_cast< int >(WXK_RBUTTON)));
55813 SWIG_Python_SetConstant(d, "WXK_CANCEL",SWIG_From_int(static_cast< int >(WXK_CANCEL)));
55814 SWIG_Python_SetConstant(d, "WXK_MBUTTON",SWIG_From_int(static_cast< int >(WXK_MBUTTON)));
55815 SWIG_Python_SetConstant(d, "WXK_CLEAR",SWIG_From_int(static_cast< int >(WXK_CLEAR)));
55816 SWIG_Python_SetConstant(d, "WXK_SHIFT",SWIG_From_int(static_cast< int >(WXK_SHIFT)));
55817 SWIG_Python_SetConstant(d, "WXK_ALT",SWIG_From_int(static_cast< int >(WXK_ALT)));
55818 SWIG_Python_SetConstant(d, "WXK_CONTROL",SWIG_From_int(static_cast< int >(WXK_CONTROL)));
55819 SWIG_Python_SetConstant(d, "WXK_MENU",SWIG_From_int(static_cast< int >(WXK_MENU)));
55820 SWIG_Python_SetConstant(d, "WXK_PAUSE",SWIG_From_int(static_cast< int >(WXK_PAUSE)));
55821 SWIG_Python_SetConstant(d, "WXK_CAPITAL",SWIG_From_int(static_cast< int >(WXK_CAPITAL)));
55822 SWIG_Python_SetConstant(d, "WXK_PRIOR",SWIG_From_int(static_cast< int >(WXK_PRIOR)));
55823 SWIG_Python_SetConstant(d, "WXK_NEXT",SWIG_From_int(static_cast< int >(WXK_NEXT)));
55824 SWIG_Python_SetConstant(d, "WXK_END",SWIG_From_int(static_cast< int >(WXK_END)));
55825 SWIG_Python_SetConstant(d, "WXK_HOME",SWIG_From_int(static_cast< int >(WXK_HOME)));
55826 SWIG_Python_SetConstant(d, "WXK_LEFT",SWIG_From_int(static_cast< int >(WXK_LEFT)));
55827 SWIG_Python_SetConstant(d, "WXK_UP",SWIG_From_int(static_cast< int >(WXK_UP)));
55828 SWIG_Python_SetConstant(d, "WXK_RIGHT",SWIG_From_int(static_cast< int >(WXK_RIGHT)));
55829 SWIG_Python_SetConstant(d, "WXK_DOWN",SWIG_From_int(static_cast< int >(WXK_DOWN)));
55830 SWIG_Python_SetConstant(d, "WXK_SELECT",SWIG_From_int(static_cast< int >(WXK_SELECT)));
55831 SWIG_Python_SetConstant(d, "WXK_PRINT",SWIG_From_int(static_cast< int >(WXK_PRINT)));
55832 SWIG_Python_SetConstant(d, "WXK_EXECUTE",SWIG_From_int(static_cast< int >(WXK_EXECUTE)));
55833 SWIG_Python_SetConstant(d, "WXK_SNAPSHOT",SWIG_From_int(static_cast< int >(WXK_SNAPSHOT)));
55834 SWIG_Python_SetConstant(d, "WXK_INSERT",SWIG_From_int(static_cast< int >(WXK_INSERT)));
55835 SWIG_Python_SetConstant(d, "WXK_HELP",SWIG_From_int(static_cast< int >(WXK_HELP)));
55836 SWIG_Python_SetConstant(d, "WXK_NUMPAD0",SWIG_From_int(static_cast< int >(WXK_NUMPAD0)));
55837 SWIG_Python_SetConstant(d, "WXK_NUMPAD1",SWIG_From_int(static_cast< int >(WXK_NUMPAD1)));
55838 SWIG_Python_SetConstant(d, "WXK_NUMPAD2",SWIG_From_int(static_cast< int >(WXK_NUMPAD2)));
55839 SWIG_Python_SetConstant(d, "WXK_NUMPAD3",SWIG_From_int(static_cast< int >(WXK_NUMPAD3)));
55840 SWIG_Python_SetConstant(d, "WXK_NUMPAD4",SWIG_From_int(static_cast< int >(WXK_NUMPAD4)));
55841 SWIG_Python_SetConstant(d, "WXK_NUMPAD5",SWIG_From_int(static_cast< int >(WXK_NUMPAD5)));
55842 SWIG_Python_SetConstant(d, "WXK_NUMPAD6",SWIG_From_int(static_cast< int >(WXK_NUMPAD6)));
55843 SWIG_Python_SetConstant(d, "WXK_NUMPAD7",SWIG_From_int(static_cast< int >(WXK_NUMPAD7)));
55844 SWIG_Python_SetConstant(d, "WXK_NUMPAD8",SWIG_From_int(static_cast< int >(WXK_NUMPAD8)));
55845 SWIG_Python_SetConstant(d, "WXK_NUMPAD9",SWIG_From_int(static_cast< int >(WXK_NUMPAD9)));
55846 SWIG_Python_SetConstant(d, "WXK_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_MULTIPLY)));
55847 SWIG_Python_SetConstant(d, "WXK_ADD",SWIG_From_int(static_cast< int >(WXK_ADD)));
55848 SWIG_Python_SetConstant(d, "WXK_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_SEPARATOR)));
55849 SWIG_Python_SetConstant(d, "WXK_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_SUBTRACT)));
55850 SWIG_Python_SetConstant(d, "WXK_DECIMAL",SWIG_From_int(static_cast< int >(WXK_DECIMAL)));
55851 SWIG_Python_SetConstant(d, "WXK_DIVIDE",SWIG_From_int(static_cast< int >(WXK_DIVIDE)));
55852 SWIG_Python_SetConstant(d, "WXK_F1",SWIG_From_int(static_cast< int >(WXK_F1)));
55853 SWIG_Python_SetConstant(d, "WXK_F2",SWIG_From_int(static_cast< int >(WXK_F2)));
55854 SWIG_Python_SetConstant(d, "WXK_F3",SWIG_From_int(static_cast< int >(WXK_F3)));
55855 SWIG_Python_SetConstant(d, "WXK_F4",SWIG_From_int(static_cast< int >(WXK_F4)));
55856 SWIG_Python_SetConstant(d, "WXK_F5",SWIG_From_int(static_cast< int >(WXK_F5)));
55857 SWIG_Python_SetConstant(d, "WXK_F6",SWIG_From_int(static_cast< int >(WXK_F6)));
55858 SWIG_Python_SetConstant(d, "WXK_F7",SWIG_From_int(static_cast< int >(WXK_F7)));
55859 SWIG_Python_SetConstant(d, "WXK_F8",SWIG_From_int(static_cast< int >(WXK_F8)));
55860 SWIG_Python_SetConstant(d, "WXK_F9",SWIG_From_int(static_cast< int >(WXK_F9)));
55861 SWIG_Python_SetConstant(d, "WXK_F10",SWIG_From_int(static_cast< int >(WXK_F10)));
55862 SWIG_Python_SetConstant(d, "WXK_F11",SWIG_From_int(static_cast< int >(WXK_F11)));
55863 SWIG_Python_SetConstant(d, "WXK_F12",SWIG_From_int(static_cast< int >(WXK_F12)));
55864 SWIG_Python_SetConstant(d, "WXK_F13",SWIG_From_int(static_cast< int >(WXK_F13)));
55865 SWIG_Python_SetConstant(d, "WXK_F14",SWIG_From_int(static_cast< int >(WXK_F14)));
55866 SWIG_Python_SetConstant(d, "WXK_F15",SWIG_From_int(static_cast< int >(WXK_F15)));
55867 SWIG_Python_SetConstant(d, "WXK_F16",SWIG_From_int(static_cast< int >(WXK_F16)));
55868 SWIG_Python_SetConstant(d, "WXK_F17",SWIG_From_int(static_cast< int >(WXK_F17)));
55869 SWIG_Python_SetConstant(d, "WXK_F18",SWIG_From_int(static_cast< int >(WXK_F18)));
55870 SWIG_Python_SetConstant(d, "WXK_F19",SWIG_From_int(static_cast< int >(WXK_F19)));
55871 SWIG_Python_SetConstant(d, "WXK_F20",SWIG_From_int(static_cast< int >(WXK_F20)));
55872 SWIG_Python_SetConstant(d, "WXK_F21",SWIG_From_int(static_cast< int >(WXK_F21)));
55873 SWIG_Python_SetConstant(d, "WXK_F22",SWIG_From_int(static_cast< int >(WXK_F22)));
55874 SWIG_Python_SetConstant(d, "WXK_F23",SWIG_From_int(static_cast< int >(WXK_F23)));
55875 SWIG_Python_SetConstant(d, "WXK_F24",SWIG_From_int(static_cast< int >(WXK_F24)));
55876 SWIG_Python_SetConstant(d, "WXK_NUMLOCK",SWIG_From_int(static_cast< int >(WXK_NUMLOCK)));
55877 SWIG_Python_SetConstant(d, "WXK_SCROLL",SWIG_From_int(static_cast< int >(WXK_SCROLL)));
55878 SWIG_Python_SetConstant(d, "WXK_PAGEUP",SWIG_From_int(static_cast< int >(WXK_PAGEUP)));
55879 SWIG_Python_SetConstant(d, "WXK_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_PAGEDOWN)));
55880 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SPACE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SPACE)));
55881 SWIG_Python_SetConstant(d, "WXK_NUMPAD_TAB",SWIG_From_int(static_cast< int >(WXK_NUMPAD_TAB)));
55882 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ENTER",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ENTER)));
55883 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F1",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F1)));
55884 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F2",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F2)));
55885 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F3",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F3)));
55886 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F4",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F4)));
55887 SWIG_Python_SetConstant(d, "WXK_NUMPAD_HOME",SWIG_From_int(static_cast< int >(WXK_NUMPAD_HOME)));
55888 SWIG_Python_SetConstant(d, "WXK_NUMPAD_LEFT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_LEFT)));
55889 SWIG_Python_SetConstant(d, "WXK_NUMPAD_UP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_UP)));
55890 SWIG_Python_SetConstant(d, "WXK_NUMPAD_RIGHT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_RIGHT)));
55891 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DOWN)));
55892 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PRIOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PRIOR)));
55893 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEUP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEUP)));
55894 SWIG_Python_SetConstant(d, "WXK_NUMPAD_NEXT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_NEXT)));
55895 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEDOWN)));
55896 SWIG_Python_SetConstant(d, "WXK_NUMPAD_END",SWIG_From_int(static_cast< int >(WXK_NUMPAD_END)));
55897 SWIG_Python_SetConstant(d, "WXK_NUMPAD_BEGIN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_BEGIN)));
55898 SWIG_Python_SetConstant(d, "WXK_NUMPAD_INSERT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_INSERT)));
55899 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DELETE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DELETE)));
55900 SWIG_Python_SetConstant(d, "WXK_NUMPAD_EQUAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_EQUAL)));
55901 SWIG_Python_SetConstant(d, "WXK_NUMPAD_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_NUMPAD_MULTIPLY)));
55902 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ADD",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ADD)));
55903 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SEPARATOR)));
55904 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SUBTRACT)));
55905 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DECIMAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DECIMAL)));
55906 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DIVIDE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DIVIDE)));
55907 SWIG_Python_SetConstant(d, "WXK_WINDOWS_LEFT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_LEFT)));
55908 SWIG_Python_SetConstant(d, "WXK_WINDOWS_RIGHT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_RIGHT)));
55909 SWIG_Python_SetConstant(d, "WXK_WINDOWS_MENU",SWIG_From_int(static_cast< int >(WXK_WINDOWS_MENU)));
55910 SWIG_Python_SetConstant(d, "WXK_COMMAND",SWIG_From_int(static_cast< int >(WXK_COMMAND)));
55911 SWIG_Python_SetConstant(d, "WXK_SPECIAL1",SWIG_From_int(static_cast< int >(WXK_SPECIAL1)));
55912 SWIG_Python_SetConstant(d, "WXK_SPECIAL2",SWIG_From_int(static_cast< int >(WXK_SPECIAL2)));
55913 SWIG_Python_SetConstant(d, "WXK_SPECIAL3",SWIG_From_int(static_cast< int >(WXK_SPECIAL3)));
55914 SWIG_Python_SetConstant(d, "WXK_SPECIAL4",SWIG_From_int(static_cast< int >(WXK_SPECIAL4)));
55915 SWIG_Python_SetConstant(d, "WXK_SPECIAL5",SWIG_From_int(static_cast< int >(WXK_SPECIAL5)));
55916 SWIG_Python_SetConstant(d, "WXK_SPECIAL6",SWIG_From_int(static_cast< int >(WXK_SPECIAL6)));
55917 SWIG_Python_SetConstant(d, "WXK_SPECIAL7",SWIG_From_int(static_cast< int >(WXK_SPECIAL7)));
55918 SWIG_Python_SetConstant(d, "WXK_SPECIAL8",SWIG_From_int(static_cast< int >(WXK_SPECIAL8)));
55919 SWIG_Python_SetConstant(d, "WXK_SPECIAL9",SWIG_From_int(static_cast< int >(WXK_SPECIAL9)));
55920 SWIG_Python_SetConstant(d, "WXK_SPECIAL10",SWIG_From_int(static_cast< int >(WXK_SPECIAL10)));
55921 SWIG_Python_SetConstant(d, "WXK_SPECIAL11",SWIG_From_int(static_cast< int >(WXK_SPECIAL11)));
55922 SWIG_Python_SetConstant(d, "WXK_SPECIAL12",SWIG_From_int(static_cast< int >(WXK_SPECIAL12)));
55923 SWIG_Python_SetConstant(d, "WXK_SPECIAL13",SWIG_From_int(static_cast< int >(WXK_SPECIAL13)));
55924 SWIG_Python_SetConstant(d, "WXK_SPECIAL14",SWIG_From_int(static_cast< int >(WXK_SPECIAL14)));
55925 SWIG_Python_SetConstant(d, "WXK_SPECIAL15",SWIG_From_int(static_cast< int >(WXK_SPECIAL15)));
55926 SWIG_Python_SetConstant(d, "WXK_SPECIAL16",SWIG_From_int(static_cast< int >(WXK_SPECIAL16)));
55927 SWIG_Python_SetConstant(d, "WXK_SPECIAL17",SWIG_From_int(static_cast< int >(WXK_SPECIAL17)));
55928 SWIG_Python_SetConstant(d, "WXK_SPECIAL18",SWIG_From_int(static_cast< int >(WXK_SPECIAL18)));
55929 SWIG_Python_SetConstant(d, "WXK_SPECIAL19",SWIG_From_int(static_cast< int >(WXK_SPECIAL19)));
55930 SWIG_Python_SetConstant(d, "WXK_SPECIAL20",SWIG_From_int(static_cast< int >(WXK_SPECIAL20)));
55931 SWIG_Python_SetConstant(d, "PAPER_NONE",SWIG_From_int(static_cast< int >(wxPAPER_NONE)));
55932 SWIG_Python_SetConstant(d, "PAPER_LETTER",SWIG_From_int(static_cast< int >(wxPAPER_LETTER)));
55933 SWIG_Python_SetConstant(d, "PAPER_LEGAL",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL)));
55934 SWIG_Python_SetConstant(d, "PAPER_A4",SWIG_From_int(static_cast< int >(wxPAPER_A4)));
55935 SWIG_Python_SetConstant(d, "PAPER_CSHEET",SWIG_From_int(static_cast< int >(wxPAPER_CSHEET)));
55936 SWIG_Python_SetConstant(d, "PAPER_DSHEET",SWIG_From_int(static_cast< int >(wxPAPER_DSHEET)));
55937 SWIG_Python_SetConstant(d, "PAPER_ESHEET",SWIG_From_int(static_cast< int >(wxPAPER_ESHEET)));
55938 SWIG_Python_SetConstant(d, "PAPER_LETTERSMALL",SWIG_From_int(static_cast< int >(wxPAPER_LETTERSMALL)));
55939 SWIG_Python_SetConstant(d, "PAPER_TABLOID",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID)));
55940 SWIG_Python_SetConstant(d, "PAPER_LEDGER",SWIG_From_int(static_cast< int >(wxPAPER_LEDGER)));
55941 SWIG_Python_SetConstant(d, "PAPER_STATEMENT",SWIG_From_int(static_cast< int >(wxPAPER_STATEMENT)));
55942 SWIG_Python_SetConstant(d, "PAPER_EXECUTIVE",SWIG_From_int(static_cast< int >(wxPAPER_EXECUTIVE)));
55943 SWIG_Python_SetConstant(d, "PAPER_A3",SWIG_From_int(static_cast< int >(wxPAPER_A3)));
55944 SWIG_Python_SetConstant(d, "PAPER_A4SMALL",SWIG_From_int(static_cast< int >(wxPAPER_A4SMALL)));
55945 SWIG_Python_SetConstant(d, "PAPER_A5",SWIG_From_int(static_cast< int >(wxPAPER_A5)));
55946 SWIG_Python_SetConstant(d, "PAPER_B4",SWIG_From_int(static_cast< int >(wxPAPER_B4)));
55947 SWIG_Python_SetConstant(d, "PAPER_B5",SWIG_From_int(static_cast< int >(wxPAPER_B5)));
55948 SWIG_Python_SetConstant(d, "PAPER_FOLIO",SWIG_From_int(static_cast< int >(wxPAPER_FOLIO)));
55949 SWIG_Python_SetConstant(d, "PAPER_QUARTO",SWIG_From_int(static_cast< int >(wxPAPER_QUARTO)));
55950 SWIG_Python_SetConstant(d, "PAPER_10X14",SWIG_From_int(static_cast< int >(wxPAPER_10X14)));
55951 SWIG_Python_SetConstant(d, "PAPER_11X17",SWIG_From_int(static_cast< int >(wxPAPER_11X17)));
55952 SWIG_Python_SetConstant(d, "PAPER_NOTE",SWIG_From_int(static_cast< int >(wxPAPER_NOTE)));
55953 SWIG_Python_SetConstant(d, "PAPER_ENV_9",SWIG_From_int(static_cast< int >(wxPAPER_ENV_9)));
55954 SWIG_Python_SetConstant(d, "PAPER_ENV_10",SWIG_From_int(static_cast< int >(wxPAPER_ENV_10)));
55955 SWIG_Python_SetConstant(d, "PAPER_ENV_11",SWIG_From_int(static_cast< int >(wxPAPER_ENV_11)));
55956 SWIG_Python_SetConstant(d, "PAPER_ENV_12",SWIG_From_int(static_cast< int >(wxPAPER_ENV_12)));
55957 SWIG_Python_SetConstant(d, "PAPER_ENV_14",SWIG_From_int(static_cast< int >(wxPAPER_ENV_14)));
55958 SWIG_Python_SetConstant(d, "PAPER_ENV_DL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_DL)));
55959 SWIG_Python_SetConstant(d, "PAPER_ENV_C5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C5)));
55960 SWIG_Python_SetConstant(d, "PAPER_ENV_C3",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C3)));
55961 SWIG_Python_SetConstant(d, "PAPER_ENV_C4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C4)));
55962 SWIG_Python_SetConstant(d, "PAPER_ENV_C6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C6)));
55963 SWIG_Python_SetConstant(d, "PAPER_ENV_C65",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C65)));
55964 SWIG_Python_SetConstant(d, "PAPER_ENV_B4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B4)));
55965 SWIG_Python_SetConstant(d, "PAPER_ENV_B5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B5)));
55966 SWIG_Python_SetConstant(d, "PAPER_ENV_B6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B6)));
55967 SWIG_Python_SetConstant(d, "PAPER_ENV_ITALY",SWIG_From_int(static_cast< int >(wxPAPER_ENV_ITALY)));
55968 SWIG_Python_SetConstant(d, "PAPER_ENV_MONARCH",SWIG_From_int(static_cast< int >(wxPAPER_ENV_MONARCH)));
55969 SWIG_Python_SetConstant(d, "PAPER_ENV_PERSONAL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_PERSONAL)));
55970 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_US",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_US)));
55971 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_STD_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_STD_GERMAN)));
55972 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_LGL_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_LGL_GERMAN)));
55973 SWIG_Python_SetConstant(d, "PAPER_ISO_B4",SWIG_From_int(static_cast< int >(wxPAPER_ISO_B4)));
55974 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD)));
55975 SWIG_Python_SetConstant(d, "PAPER_9X11",SWIG_From_int(static_cast< int >(wxPAPER_9X11)));
55976 SWIG_Python_SetConstant(d, "PAPER_10X11",SWIG_From_int(static_cast< int >(wxPAPER_10X11)));
55977 SWIG_Python_SetConstant(d, "PAPER_15X11",SWIG_From_int(static_cast< int >(wxPAPER_15X11)));
55978 SWIG_Python_SetConstant(d, "PAPER_ENV_INVITE",SWIG_From_int(static_cast< int >(wxPAPER_ENV_INVITE)));
55979 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA)));
55980 SWIG_Python_SetConstant(d, "PAPER_LEGAL_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL_EXTRA)));
55981 SWIG_Python_SetConstant(d, "PAPER_TABLOID_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID_EXTRA)));
55982 SWIG_Python_SetConstant(d, "PAPER_A4_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A4_EXTRA)));
55983 SWIG_Python_SetConstant(d, "PAPER_LETTER_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_TRANSVERSE)));
55984 SWIG_Python_SetConstant(d, "PAPER_A4_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A4_TRANSVERSE)));
55985 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
55986 SWIG_Python_SetConstant(d, "PAPER_A_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A_PLUS)));
55987 SWIG_Python_SetConstant(d, "PAPER_B_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_B_PLUS)));
55988 SWIG_Python_SetConstant(d, "PAPER_LETTER_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_PLUS)));
55989 SWIG_Python_SetConstant(d, "PAPER_A4_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A4_PLUS)));
55990 SWIG_Python_SetConstant(d, "PAPER_A5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A5_TRANSVERSE)));
55991 SWIG_Python_SetConstant(d, "PAPER_B5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_B5_TRANSVERSE)));
55992 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA)));
55993 SWIG_Python_SetConstant(d, "PAPER_A5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A5_EXTRA)));
55994 SWIG_Python_SetConstant(d, "PAPER_B5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_B5_EXTRA)));
55995 SWIG_Python_SetConstant(d, "PAPER_A2",SWIG_From_int(static_cast< int >(wxPAPER_A2)));
55996 SWIG_Python_SetConstant(d, "PAPER_A3_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_TRANSVERSE)));
55997 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA_TRANSVERSE)));
55998 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD)));
55999 SWIG_Python_SetConstant(d, "PAPER_A6",SWIG_From_int(static_cast< int >(wxPAPER_A6)));
56000 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2)));
56001 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3)));
56002 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3)));
56003 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4)));
56004 SWIG_Python_SetConstant(d, "PAPER_LETTER_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_ROTATED)));
56005 SWIG_Python_SetConstant(d, "PAPER_A3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A3_ROTATED)));
56006 SWIG_Python_SetConstant(d, "PAPER_A4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A4_ROTATED)));
56007 SWIG_Python_SetConstant(d, "PAPER_A5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A5_ROTATED)));
56008 SWIG_Python_SetConstant(d, "PAPER_B4_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B4_JIS_ROTATED)));
56009 SWIG_Python_SetConstant(d, "PAPER_B5_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B5_JIS_ROTATED)));
56010 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
56011 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
56012 SWIG_Python_SetConstant(d, "PAPER_A6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A6_ROTATED)));
56013 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2_ROTATED)));
56014 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3_ROTATED)));
56015 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3_ROTATED)));
56016 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4_ROTATED)));
56017 SWIG_Python_SetConstant(d, "PAPER_B6_JIS",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS)));
56018 SWIG_Python_SetConstant(d, "PAPER_B6_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS_ROTATED)));
56019 SWIG_Python_SetConstant(d, "PAPER_12X11",SWIG_From_int(static_cast< int >(wxPAPER_12X11)));
56020 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4)));
56021 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4_ROTATED)));
56022 SWIG_Python_SetConstant(d, "PAPER_P16K",SWIG_From_int(static_cast< int >(wxPAPER_P16K)));
56023 SWIG_Python_SetConstant(d, "PAPER_P32K",SWIG_From_int(static_cast< int >(wxPAPER_P32K)));
56024 SWIG_Python_SetConstant(d, "PAPER_P32KBIG",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG)));
56025 SWIG_Python_SetConstant(d, "PAPER_PENV_1",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1)));
56026 SWIG_Python_SetConstant(d, "PAPER_PENV_2",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2)));
56027 SWIG_Python_SetConstant(d, "PAPER_PENV_3",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3)));
56028 SWIG_Python_SetConstant(d, "PAPER_PENV_4",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4)));
56029 SWIG_Python_SetConstant(d, "PAPER_PENV_5",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5)));
56030 SWIG_Python_SetConstant(d, "PAPER_PENV_6",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6)));
56031 SWIG_Python_SetConstant(d, "PAPER_PENV_7",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7)));
56032 SWIG_Python_SetConstant(d, "PAPER_PENV_8",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8)));
56033 SWIG_Python_SetConstant(d, "PAPER_PENV_9",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9)));
56034 SWIG_Python_SetConstant(d, "PAPER_PENV_10",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10)));
56035 SWIG_Python_SetConstant(d, "PAPER_P16K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P16K_ROTATED)));
56036 SWIG_Python_SetConstant(d, "PAPER_P32K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32K_ROTATED)));
56037 SWIG_Python_SetConstant(d, "PAPER_P32KBIG_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG_ROTATED)));
56038 SWIG_Python_SetConstant(d, "PAPER_PENV_1_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1_ROTATED)));
56039 SWIG_Python_SetConstant(d, "PAPER_PENV_2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2_ROTATED)));
56040 SWIG_Python_SetConstant(d, "PAPER_PENV_3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3_ROTATED)));
56041 SWIG_Python_SetConstant(d, "PAPER_PENV_4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4_ROTATED)));
56042 SWIG_Python_SetConstant(d, "PAPER_PENV_5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5_ROTATED)));
56043 SWIG_Python_SetConstant(d, "PAPER_PENV_6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6_ROTATED)));
56044 SWIG_Python_SetConstant(d, "PAPER_PENV_7_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7_ROTATED)));
56045 SWIG_Python_SetConstant(d, "PAPER_PENV_8_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8_ROTATED)));
56046 SWIG_Python_SetConstant(d, "PAPER_PENV_9_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9_ROTATED)));
56047 SWIG_Python_SetConstant(d, "PAPER_PENV_10_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10_ROTATED)));
56048 SWIG_Python_SetConstant(d, "DUPLEX_SIMPLEX",SWIG_From_int(static_cast< int >(wxDUPLEX_SIMPLEX)));
56049 SWIG_Python_SetConstant(d, "DUPLEX_HORIZONTAL",SWIG_From_int(static_cast< int >(wxDUPLEX_HORIZONTAL)));
56050 SWIG_Python_SetConstant(d, "DUPLEX_VERTICAL",SWIG_From_int(static_cast< int >(wxDUPLEX_VERTICAL)));
56051 SWIG_Python_SetConstant(d, "ITEM_SEPARATOR",SWIG_From_int(static_cast< int >(wxITEM_SEPARATOR)));
56052 SWIG_Python_SetConstant(d, "ITEM_NORMAL",SWIG_From_int(static_cast< int >(wxITEM_NORMAL)));
56053 SWIG_Python_SetConstant(d, "ITEM_CHECK",SWIG_From_int(static_cast< int >(wxITEM_CHECK)));
56054 SWIG_Python_SetConstant(d, "ITEM_RADIO",SWIG_From_int(static_cast< int >(wxITEM_RADIO)));
56055 SWIG_Python_SetConstant(d, "ITEM_MAX",SWIG_From_int(static_cast< int >(wxITEM_MAX)));
56056 SWIG_Python_SetConstant(d, "HT_NOWHERE",SWIG_From_int(static_cast< int >(wxHT_NOWHERE)));
56057 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_FIRST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_FIRST)));
56058 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_1)));
56059 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_2)));
56060 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_1)));
56061 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_2)));
56062 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_THUMB",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_THUMB)));
56063 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_1)));
56064 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_2)));
56065 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_LAST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_LAST)));
56066 SWIG_Python_SetConstant(d, "HT_WINDOW_OUTSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_OUTSIDE)));
56067 SWIG_Python_SetConstant(d, "HT_WINDOW_INSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_INSIDE)));
56068 SWIG_Python_SetConstant(d, "HT_WINDOW_VERT_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_VERT_SCROLLBAR)));
56069 SWIG_Python_SetConstant(d, "HT_WINDOW_HORZ_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_HORZ_SCROLLBAR)));
56070 SWIG_Python_SetConstant(d, "HT_WINDOW_CORNER",SWIG_From_int(static_cast< int >(wxHT_WINDOW_CORNER)));
56071 SWIG_Python_SetConstant(d, "HT_MAX",SWIG_From_int(static_cast< int >(wxHT_MAX)));
56072 SWIG_Python_SetConstant(d, "MOD_NONE",SWIG_From_int(static_cast< int >(wxMOD_NONE)));
56073 SWIG_Python_SetConstant(d, "MOD_ALT",SWIG_From_int(static_cast< int >(wxMOD_ALT)));
56074 SWIG_Python_SetConstant(d, "MOD_CONTROL",SWIG_From_int(static_cast< int >(wxMOD_CONTROL)));
56075 SWIG_Python_SetConstant(d, "MOD_ALTGR",SWIG_From_int(static_cast< int >(wxMOD_ALTGR)));
56076 SWIG_Python_SetConstant(d, "MOD_SHIFT",SWIG_From_int(static_cast< int >(wxMOD_SHIFT)));
56077 SWIG_Python_SetConstant(d, "MOD_META",SWIG_From_int(static_cast< int >(wxMOD_META)));
56078 SWIG_Python_SetConstant(d, "MOD_WIN",SWIG_From_int(static_cast< int >(wxMOD_WIN)));
56079 SWIG_Python_SetConstant(d, "MOD_CMD",SWIG_From_int(static_cast< int >(wxMOD_CMD)));
56080 SWIG_Python_SetConstant(d, "MOD_ALL",SWIG_From_int(static_cast< int >(wxMOD_ALL)));
56081 SWIG_Python_SetConstant(d, "UPDATE_UI_NONE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_NONE)));
56082 SWIG_Python_SetConstant(d, "UPDATE_UI_RECURSE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_RECURSE)));
56083 SWIG_Python_SetConstant(d, "UPDATE_UI_FROMIDLE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_FROMIDLE)));
56084 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
56085 SWIG_addvarlink(SWIG_globals(),(char*)"EmptyString",EmptyString_get, EmptyString_set);
56086 SWIG_Python_SetConstant(d, "BITMAP_TYPE_INVALID",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_INVALID)));
56087 SWIG_Python_SetConstant(d, "BITMAP_TYPE_BMP",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_BMP)));
56088 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICO",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICO)));
56089 SWIG_Python_SetConstant(d, "BITMAP_TYPE_CUR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_CUR)));
56090 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM)));
56091 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM_DATA)));
56092 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM)));
56093 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM_DATA)));
56094 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TIF)));
56095 SWIG_Python_SetConstant(d, "BITMAP_TYPE_GIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_GIF)));
56096 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNG)));
56097 SWIG_Python_SetConstant(d, "BITMAP_TYPE_JPEG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_JPEG)));
56098 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNM)));
56099 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PCX",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PCX)));
56100 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PICT",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PICT)));
56101 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICON",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICON)));
56102 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANI",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANI)));
56103 SWIG_Python_SetConstant(d, "BITMAP_TYPE_IFF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_IFF)));
56104 SWIG_Python_SetConstant(d, "BITMAP_TYPE_MACCURSOR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_MACCURSOR)));
56105 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANY",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANY)));
56106 SWIG_Python_SetConstant(d, "CURSOR_NONE",SWIG_From_int(static_cast< int >(wxCURSOR_NONE)));
56107 SWIG_Python_SetConstant(d, "CURSOR_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_ARROW)));
56108 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_ARROW)));
56109 SWIG_Python_SetConstant(d, "CURSOR_BULLSEYE",SWIG_From_int(static_cast< int >(wxCURSOR_BULLSEYE)));
56110 SWIG_Python_SetConstant(d, "CURSOR_CHAR",SWIG_From_int(static_cast< int >(wxCURSOR_CHAR)));
56111 SWIG_Python_SetConstant(d, "CURSOR_CROSS",SWIG_From_int(static_cast< int >(wxCURSOR_CROSS)));
56112 SWIG_Python_SetConstant(d, "CURSOR_HAND",SWIG_From_int(static_cast< int >(wxCURSOR_HAND)));
56113 SWIG_Python_SetConstant(d, "CURSOR_IBEAM",SWIG_From_int(static_cast< int >(wxCURSOR_IBEAM)));
56114 SWIG_Python_SetConstant(d, "CURSOR_LEFT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_LEFT_BUTTON)));
56115 SWIG_Python_SetConstant(d, "CURSOR_MAGNIFIER",SWIG_From_int(static_cast< int >(wxCURSOR_MAGNIFIER)));
56116 SWIG_Python_SetConstant(d, "CURSOR_MIDDLE_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_MIDDLE_BUTTON)));
56117 SWIG_Python_SetConstant(d, "CURSOR_NO_ENTRY",SWIG_From_int(static_cast< int >(wxCURSOR_NO_ENTRY)));
56118 SWIG_Python_SetConstant(d, "CURSOR_PAINT_BRUSH",SWIG_From_int(static_cast< int >(wxCURSOR_PAINT_BRUSH)));
56119 SWIG_Python_SetConstant(d, "CURSOR_PENCIL",SWIG_From_int(static_cast< int >(wxCURSOR_PENCIL)));
56120 SWIG_Python_SetConstant(d, "CURSOR_POINT_LEFT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_LEFT)));
56121 SWIG_Python_SetConstant(d, "CURSOR_POINT_RIGHT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_RIGHT)));
56122 SWIG_Python_SetConstant(d, "CURSOR_QUESTION_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_QUESTION_ARROW)));
56123 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_BUTTON)));
56124 SWIG_Python_SetConstant(d, "CURSOR_SIZENESW",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENESW)));
56125 SWIG_Python_SetConstant(d, "CURSOR_SIZENS",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENS)));
56126 SWIG_Python_SetConstant(d, "CURSOR_SIZENWSE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENWSE)));
56127 SWIG_Python_SetConstant(d, "CURSOR_SIZEWE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZEWE)));
56128 SWIG_Python_SetConstant(d, "CURSOR_SIZING",SWIG_From_int(static_cast< int >(wxCURSOR_SIZING)));
56129 SWIG_Python_SetConstant(d, "CURSOR_SPRAYCAN",SWIG_From_int(static_cast< int >(wxCURSOR_SPRAYCAN)));
56130 SWIG_Python_SetConstant(d, "CURSOR_WAIT",SWIG_From_int(static_cast< int >(wxCURSOR_WAIT)));
56131 SWIG_Python_SetConstant(d, "CURSOR_WATCH",SWIG_From_int(static_cast< int >(wxCURSOR_WATCH)));
56132 SWIG_Python_SetConstant(d, "CURSOR_BLANK",SWIG_From_int(static_cast< int >(wxCURSOR_BLANK)));
56133 SWIG_Python_SetConstant(d, "CURSOR_DEFAULT",SWIG_From_int(static_cast< int >(wxCURSOR_DEFAULT)));
56134 SWIG_Python_SetConstant(d, "CURSOR_COPY_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_COPY_ARROW)));
56135 SWIG_Python_SetConstant(d, "CURSOR_ARROWWAIT",SWIG_From_int(static_cast< int >(wxCURSOR_ARROWWAIT)));
56136 SWIG_Python_SetConstant(d, "CURSOR_MAX",SWIG_From_int(static_cast< int >(wxCURSOR_MAX)));
56137 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultPosition",DefaultPosition_get, DefaultPosition_set);
56138 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSize",DefaultSize_get, DefaultSize_set);
56139 SWIG_Python_SetConstant(d, "FromStart",SWIG_From_int(static_cast< int >(wxFromStart)));
56140 SWIG_Python_SetConstant(d, "FromCurrent",SWIG_From_int(static_cast< int >(wxFromCurrent)));
56141 SWIG_Python_SetConstant(d, "FromEnd",SWIG_From_int(static_cast< int >(wxFromEnd)));
56142
56143 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
56144
56145
56146 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
56147
56148 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_TRANSPARENT",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_TRANSPARENT)));
56149 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_THRESHOLD",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_THRESHOLD)));
56150 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_OPAQUE",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_OPAQUE)));
56151 SWIG_addvarlink(SWIG_globals(),(char*)"NullImage",NullImage_get, NullImage_set);
56152 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_FILENAME",IMAGE_OPTION_FILENAME_get, IMAGE_OPTION_FILENAME_set);
56153 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BMP_FORMAT",IMAGE_OPTION_BMP_FORMAT_get, IMAGE_OPTION_BMP_FORMAT_set);
56154 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",IMAGE_OPTION_CUR_HOTSPOT_X_get, IMAGE_OPTION_CUR_HOTSPOT_X_set);
56155 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",IMAGE_OPTION_CUR_HOTSPOT_Y_get, IMAGE_OPTION_CUR_HOTSPOT_Y_set);
56156 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTION",IMAGE_OPTION_RESOLUTION_get, IMAGE_OPTION_RESOLUTION_set);
56157 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONX",IMAGE_OPTION_RESOLUTIONX_get, IMAGE_OPTION_RESOLUTIONX_set);
56158 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONY",IMAGE_OPTION_RESOLUTIONY_get, IMAGE_OPTION_RESOLUTIONY_set);
56159 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONUNIT",IMAGE_OPTION_RESOLUTIONUNIT_get, IMAGE_OPTION_RESOLUTIONUNIT_set);
56160 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_QUALITY",IMAGE_OPTION_QUALITY_get, IMAGE_OPTION_QUALITY_set);
56161 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_INCHES",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_INCHES)));
56162 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_CM",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_CM)));
56163 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BITSPERSAMPLE",IMAGE_OPTION_BITSPERSAMPLE_get, IMAGE_OPTION_BITSPERSAMPLE_set);
56164 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",IMAGE_OPTION_SAMPLESPERPIXEL_get, IMAGE_OPTION_SAMPLESPERPIXEL_set);
56165 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_COMPRESSION",IMAGE_OPTION_COMPRESSION_get, IMAGE_OPTION_COMPRESSION_set);
56166 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",IMAGE_OPTION_IMAGEDESCRIPTOR_get, IMAGE_OPTION_IMAGEDESCRIPTOR_set);
56167 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_FORMAT",IMAGE_OPTION_PNG_FORMAT_get, IMAGE_OPTION_PNG_FORMAT_set);
56168 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_BITDEPTH",IMAGE_OPTION_PNG_BITDEPTH_get, IMAGE_OPTION_PNG_BITDEPTH_set);
56169 SWIG_Python_SetConstant(d, "PNG_TYPE_COLOUR",SWIG_From_int(static_cast< int >(wxPNG_TYPE_COLOUR)));
56170 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY)));
56171 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY_RED",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY_RED)));
56172 SWIG_Python_SetConstant(d, "BMP_24BPP",SWIG_From_int(static_cast< int >(wxBMP_24BPP)));
56173 SWIG_Python_SetConstant(d, "BMP_8BPP",SWIG_From_int(static_cast< int >(wxBMP_8BPP)));
56174 SWIG_Python_SetConstant(d, "BMP_8BPP_GREY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GREY)));
56175 SWIG_Python_SetConstant(d, "BMP_8BPP_GRAY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GRAY)));
56176 SWIG_Python_SetConstant(d, "BMP_8BPP_RED",SWIG_From_int(static_cast< int >(wxBMP_8BPP_RED)));
56177 SWIG_Python_SetConstant(d, "BMP_8BPP_PALETTE",SWIG_From_int(static_cast< int >(wxBMP_8BPP_PALETTE)));
56178 SWIG_Python_SetConstant(d, "BMP_4BPP",SWIG_From_int(static_cast< int >(wxBMP_4BPP)));
56179 SWIG_Python_SetConstant(d, "BMP_1BPP",SWIG_From_int(static_cast< int >(wxBMP_1BPP)));
56180 SWIG_Python_SetConstant(d, "BMP_1BPP_BW",SWIG_From_int(static_cast< int >(wxBMP_1BPP_BW)));
56181 SWIG_Python_SetConstant(d, "QUANTIZE_INCLUDE_WINDOWS_COLOURS",SWIG_From_int(static_cast< int >(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
56182 SWIG_Python_SetConstant(d, "QUANTIZE_FILL_DESTINATION_IMAGE",SWIG_From_int(static_cast< int >(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
56183 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_NONE",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_NONE)));
56184 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_MAX",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_MAX)));
56185 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
56186 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
56187 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
56188 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
56189 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
56190 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
56191 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
56192 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
56193 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
56194 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
56195 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
56196 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
56197 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
56198 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
56199 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
56200 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
56201 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
56202 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
56203 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
56204 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
56205 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
56206 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
56207 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
56208 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
56209 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
56210 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
56211 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
56212 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
56213 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
56214 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
56215 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
56216 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
56217 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
56218 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
56219 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
56220 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
56221 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
56222 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
56223 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
56224 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
56225 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
56226 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
56227 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
56228 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
56229 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
56230 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
56231 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
56232 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
56233 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
56234 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
56235 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
56236 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
56237 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
56238 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
56239 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
56240 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
56241 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
56242 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
56243 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
56244 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
56245 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
56246 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
56247 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
56248 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
56249 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
56250 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
56251 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
56252 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
56253 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
56254 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
56255 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
56256 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
56257 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
56258 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
56259 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
56260 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
56261 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
56262 PyDict_SetItemString(d, "wxEVT_POWER", PyInt_FromLong(wxEVT_POWER));
56263 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
56264 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
56265 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
56266 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
56267 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
56268 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
56269 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
56270 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
56271 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
56272 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
56273 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
56274 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
56275 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
56276 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
56277 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
56278 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
56279 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
56280 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
56281 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
56282 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
56283 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
56284 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
56285 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
56286 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
56287 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
56288 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
56289 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
56290 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
56291 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
56292 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
56293 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
56294 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
56295 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
56296 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
56297 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
56298 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
56299 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
56300 SWIG_Python_SetConstant(d, "MOUSE_BTN_ANY",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_ANY)));
56301 SWIG_Python_SetConstant(d, "MOUSE_BTN_NONE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_NONE)));
56302 SWIG_Python_SetConstant(d, "MOUSE_BTN_LEFT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_LEFT)));
56303 SWIG_Python_SetConstant(d, "MOUSE_BTN_MIDDLE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_MIDDLE)));
56304 SWIG_Python_SetConstant(d, "MOUSE_BTN_RIGHT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_RIGHT)));
56305 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_ALL)));
56306 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_SPECIFIED)));
56307 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsBackward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsBackward)));
56308 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsForward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsForward)));
56309 SWIG_Python_SetConstant(d, "NavigationKeyEvent_WinChange",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::WinChange)));
56310 SWIG_Python_SetConstant(d, "NavigationKeyEvent_FromTab",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::FromTab)));
56311 SWIG_Python_SetConstant(d, "IDLE_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_ALL)));
56312 SWIG_Python_SetConstant(d, "IDLE_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_SPECIFIED)));
56313 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
56314 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_SUPPRESS",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_SUPPRESS)));
56315 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_EXCEPTION",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_EXCEPTION)));
56316 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_DIALOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_DIALOG)));
56317 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_LOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_LOG)));
56318 SWIG_Python_SetConstant(d, "PRINT_WINDOWS",SWIG_From_int(static_cast< int >(wxPRINT_WINDOWS)));
56319 SWIG_Python_SetConstant(d, "PRINT_POSTSCRIPT",SWIG_From_int(static_cast< int >(wxPRINT_POSTSCRIPT)));
56320 SWIG_addvarlink(SWIG_globals(),(char*)"NullAcceleratorTable",NullAcceleratorTable_get, NullAcceleratorTable_set);
56321 SWIG_addvarlink(SWIG_globals(),(char*)"PanelNameStr",PanelNameStr_get, PanelNameStr_set);
56322 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_NORMAL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_NORMAL)));
56323 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_SMALL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_SMALL)));
56324 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MINI",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MINI)));
56325 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_LARGE",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_LARGE)));
56326 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MAX",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MAX)));
56327 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultValidator",DefaultValidator_get, DefaultValidator_set);
56328 SWIG_addvarlink(SWIG_globals(),(char*)"ControlNameStr",ControlNameStr_get, ControlNameStr_set);
56329 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_NONE",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_NONE)));
56330 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_SPECIFIED",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_SPECIFIED)));
56331 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_ALL",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_ALL)));
56332 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSpan",DefaultSpan_get, DefaultSpan_set);
56333 SWIG_Python_SetConstant(d, "Left",SWIG_From_int(static_cast< int >(wxLeft)));
56334 SWIG_Python_SetConstant(d, "Top",SWIG_From_int(static_cast< int >(wxTop)));
56335 SWIG_Python_SetConstant(d, "Right",SWIG_From_int(static_cast< int >(wxRight)));
56336 SWIG_Python_SetConstant(d, "Bottom",SWIG_From_int(static_cast< int >(wxBottom)));
56337 SWIG_Python_SetConstant(d, "Width",SWIG_From_int(static_cast< int >(wxWidth)));
56338 SWIG_Python_SetConstant(d, "Height",SWIG_From_int(static_cast< int >(wxHeight)));
56339 SWIG_Python_SetConstant(d, "Centre",SWIG_From_int(static_cast< int >(wxCentre)));
56340 SWIG_Python_SetConstant(d, "Center",SWIG_From_int(static_cast< int >(wxCenter)));
56341 SWIG_Python_SetConstant(d, "CentreX",SWIG_From_int(static_cast< int >(wxCentreX)));
56342 SWIG_Python_SetConstant(d, "CentreY",SWIG_From_int(static_cast< int >(wxCentreY)));
56343 SWIG_Python_SetConstant(d, "Unconstrained",SWIG_From_int(static_cast< int >(wxUnconstrained)));
56344 SWIG_Python_SetConstant(d, "AsIs",SWIG_From_int(static_cast< int >(wxAsIs)));
56345 SWIG_Python_SetConstant(d, "PercentOf",SWIG_From_int(static_cast< int >(wxPercentOf)));
56346 SWIG_Python_SetConstant(d, "Above",SWIG_From_int(static_cast< int >(wxAbove)));
56347 SWIG_Python_SetConstant(d, "Below",SWIG_From_int(static_cast< int >(wxBelow)));
56348 SWIG_Python_SetConstant(d, "LeftOf",SWIG_From_int(static_cast< int >(wxLeftOf)));
56349 SWIG_Python_SetConstant(d, "RightOf",SWIG_From_int(static_cast< int >(wxRightOf)));
56350 SWIG_Python_SetConstant(d, "SameAs",SWIG_From_int(static_cast< int >(wxSameAs)));
56351 SWIG_Python_SetConstant(d, "Absolute",SWIG_From_int(static_cast< int >(wxAbsolute)));
56352
56353 // Initialize threading, some globals and such
56354 __wxPyPreStart(d);
56355
56356
56357 // Although these are defined in __version__ they need to be here too so
56358 // that an assert can be done to ensure that the wxPython and the wxWindows
56359 // versions match.
56360 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
56361 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
56362 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
56363
56364 }
56365
wxWidgets (Impactor)