]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/msw/_core_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
compilation fixes after recent wxFontEnumerator changes in USE_NATIVE_FONT_DIALOG_FOR...
[wxWidgets.git] / wxPython / src / msw / _core_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.29
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
13
14 #ifdef __cplusplus
15 template<class T> class SwigValueWrapper {
16 T *tt;
17 public:
18 SwigValueWrapper() : tt(0) { }
19 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
20 SwigValueWrapper(const T& t) : tt(new T(t)) { }
21 ~SwigValueWrapper() { delete tt; }
22 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
23 operator T&() const { return *tt; }
24 T *operator&() { return tt; }
25 private:
26 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
27 };
28 #endif
29
30 /* -----------------------------------------------------------------------------
31 * This section contains generic SWIG labels for method/variable
32 * declarations/attributes, and other compiler dependent labels.
33 * ----------------------------------------------------------------------------- */
34
35 /* template workaround for compilers that cannot correctly implement the C++ standard */
36 #ifndef SWIGTEMPLATEDISAMBIGUATOR
37 # if defined(__SUNPRO_CC)
38 # if (__SUNPRO_CC <= 0x560)
39 # define SWIGTEMPLATEDISAMBIGUATOR template
40 # else
41 # define SWIGTEMPLATEDISAMBIGUATOR
42 # endif
43 # else
44 # define SWIGTEMPLATEDISAMBIGUATOR
45 # endif
46 #endif
47
48 /* inline attribute */
49 #ifndef SWIGINLINE
50 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
51 # define SWIGINLINE inline
52 # else
53 # define SWIGINLINE
54 # endif
55 #endif
56
57 /* attribute recognised by some compilers to avoid 'unused' warnings */
58 #ifndef SWIGUNUSED
59 # if defined(__GNUC__)
60 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
61 # define SWIGUNUSED __attribute__ ((__unused__))
62 # else
63 # define SWIGUNUSED
64 # endif
65 # elif defined(__ICC)
66 # define SWIGUNUSED __attribute__ ((__unused__))
67 # else
68 # define SWIGUNUSED
69 # endif
70 #endif
71
72 #ifndef SWIGUNUSEDPARM
73 # ifdef __cplusplus
74 # define SWIGUNUSEDPARM(p)
75 # else
76 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
77 # endif
78 #endif
79
80 /* internal SWIG method */
81 #ifndef SWIGINTERN
82 # define SWIGINTERN static SWIGUNUSED
83 #endif
84
85 /* internal inline SWIG method */
86 #ifndef SWIGINTERNINLINE
87 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
88 #endif
89
90 /* exporting methods */
91 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
92 # ifndef GCC_HASCLASSVISIBILITY
93 # define GCC_HASCLASSVISIBILITY
94 # endif
95 #endif
96
97 #ifndef SWIGEXPORT
98 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
99 # if defined(STATIC_LINKED)
100 # define SWIGEXPORT
101 # else
102 # define SWIGEXPORT __declspec(dllexport)
103 # endif
104 # else
105 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
106 # define SWIGEXPORT __attribute__ ((visibility("default")))
107 # else
108 # define SWIGEXPORT
109 # endif
110 # endif
111 #endif
112
113 /* calling conventions for Windows */
114 #ifndef SWIGSTDCALL
115 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
116 # define SWIGSTDCALL __stdcall
117 # else
118 # define SWIGSTDCALL
119 # endif
120 #endif
121
122 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
123 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
124 # define _CRT_SECURE_NO_DEPRECATE
125 #endif
126
127
128 /* Python.h has to appear first */
129 #include <Python.h>
130
131 /* -----------------------------------------------------------------------------
132 * swigrun.swg
133 *
134 * This file contains generic CAPI SWIG runtime support for pointer
135 * type checking.
136 * ----------------------------------------------------------------------------- */
137
138 /* This should only be incremented when either the layout of swig_type_info changes,
139 or for whatever reason, the runtime changes incompatibly */
140 #define SWIG_RUNTIME_VERSION "2"
141
142 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
143 #ifdef SWIG_TYPE_TABLE
144 # define SWIG_QUOTE_STRING(x) #x
145 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
146 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
147 #else
148 # define SWIG_TYPE_TABLE_NAME
149 #endif
150
151 /*
152 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
153 creating a static or dynamic library from the swig runtime code.
154 In 99.9% of the cases, swig just needs to declare them as 'static'.
155
156 But only do this if is strictly necessary, ie, if you have problems
157 with your compiler or so.
158 */
159
160 #ifndef SWIGRUNTIME
161 # define SWIGRUNTIME SWIGINTERN
162 #endif
163
164 #ifndef SWIGRUNTIMEINLINE
165 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
166 #endif
167
168 /* Generic buffer size */
169 #ifndef SWIG_BUFFER_SIZE
170 # define SWIG_BUFFER_SIZE 1024
171 #endif
172
173 /* Flags for pointer conversions */
174 #define SWIG_POINTER_DISOWN 0x1
175
176 /* Flags for new pointer objects */
177 #define SWIG_POINTER_OWN 0x1
178
179
180 /*
181 Flags/methods for returning states.
182
183 The swig conversion methods, as ConvertPtr, return and integer
184 that tells if the conversion was successful or not. And if not,
185 an error code can be returned (see swigerrors.swg for the codes).
186
187 Use the following macros/flags to set or process the returning
188 states.
189
190 In old swig versions, you usually write code as:
191
192 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
193 // success code
194 } else {
195 //fail code
196 }
197
198 Now you can be more explicit as:
199
200 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
201 if (SWIG_IsOK(res)) {
202 // success code
203 } else {
204 // fail code
205 }
206
207 that seems to be the same, but now you can also do
208
209 Type *ptr;
210 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
211 if (SWIG_IsOK(res)) {
212 // success code
213 if (SWIG_IsNewObj(res) {
214 ...
215 delete *ptr;
216 } else {
217 ...
218 }
219 } else {
220 // fail code
221 }
222
223 I.e., now SWIG_ConvertPtr can return new objects and you can
224 identify the case and take care of the deallocation. Of course that
225 requires also to SWIG_ConvertPtr to return new result values, as
226
227 int SWIG_ConvertPtr(obj, ptr,...) {
228 if (<obj is ok>) {
229 if (<need new object>) {
230 *ptr = <ptr to new allocated object>;
231 return SWIG_NEWOBJ;
232 } else {
233 *ptr = <ptr to old object>;
234 return SWIG_OLDOBJ;
235 }
236 } else {
237 return SWIG_BADOBJ;
238 }
239 }
240
241 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
242 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
243 swig errors code.
244
245 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
246 allows to return the 'cast rank', for example, if you have this
247
248 int food(double)
249 int fooi(int);
250
251 and you call
252
253 food(1) // cast rank '1' (1 -> 1.0)
254 fooi(1) // cast rank '0'
255
256 just use the SWIG_AddCast()/SWIG_CheckState()
257
258
259 */
260 #define SWIG_OK (0)
261 #define SWIG_ERROR (-1)
262 #define SWIG_IsOK(r) (r >= 0)
263 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
264
265 /* The CastRankLimit says how many bits are used for the cast rank */
266 #define SWIG_CASTRANKLIMIT (1 << 8)
267 /* The NewMask denotes the object was created (using new/malloc) */
268 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
269 /* The TmpMask is for in/out typemaps that use temporal objects */
270 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
271 /* Simple returning values */
272 #define SWIG_BADOBJ (SWIG_ERROR)
273 #define SWIG_OLDOBJ (SWIG_OK)
274 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
275 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
276 /* Check, add and del mask methods */
277 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
278 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
279 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
280 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
281 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
282 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
283
284
285 /* Cast-Rank Mode */
286 #if defined(SWIG_CASTRANK_MODE)
287 # ifndef SWIG_TypeRank
288 # define SWIG_TypeRank unsigned long
289 # endif
290 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
291 # define SWIG_MAXCASTRANK (2)
292 # endif
293 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
294 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
295 SWIGINTERNINLINE int SWIG_AddCast(int r) {
296 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
297 }
298 SWIGINTERNINLINE int SWIG_CheckState(int r) {
299 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
300 }
301 #else /* no cast-rank mode */
302 # define SWIG_AddCast
303 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
304 #endif
305
306
307
308
309 #include <string.h>
310
311 #ifdef __cplusplus
312 extern "C" {
313 #endif
314
315 typedef void *(*swig_converter_func)(void *);
316 typedef struct swig_type_info *(*swig_dycast_func)(void **);
317
318 /* Structure to store inforomation on one type */
319 typedef struct swig_type_info {
320 const char *name; /* mangled name of this type */
321 const char *str; /* human readable name of this type */
322 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
323 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
324 void *clientdata; /* language specific type data */
325 int owndata; /* flag if the structure owns the clientdata */
326 } swig_type_info;
327
328 /* Structure to store a type and conversion function used for casting */
329 typedef struct swig_cast_info {
330 swig_type_info *type; /* pointer to type that is equivalent to this type */
331 swig_converter_func converter; /* function to cast the void pointers */
332 struct swig_cast_info *next; /* pointer to next cast in linked list */
333 struct swig_cast_info *prev; /* pointer to the previous cast */
334 } swig_cast_info;
335
336 /* Structure used to store module information
337 * Each module generates one structure like this, and the runtime collects
338 * all of these structures and stores them in a circularly linked list.*/
339 typedef struct swig_module_info {
340 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
341 size_t size; /* Number of types in this module */
342 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
343 swig_type_info **type_initial; /* Array of initially generated type structures */
344 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
345 void *clientdata; /* Language specific module data */
346 } swig_module_info;
347
348 /*
349 Compare two type names skipping the space characters, therefore
350 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
351
352 Return 0 when the two name types are equivalent, as in
353 strncmp, but skipping ' '.
354 */
355 SWIGRUNTIME int
356 SWIG_TypeNameComp(const char *f1, const char *l1,
357 const char *f2, const char *l2) {
358 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
359 while ((*f1 == ' ') && (f1 != l1)) ++f1;
360 while ((*f2 == ' ') && (f2 != l2)) ++f2;
361 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
362 }
363 return (l1 - f1) - (l2 - f2);
364 }
365
366 /*
367 Check type equivalence in a name list like <name1>|<name2>|...
368 Return 0 if not equal, 1 if equal
369 */
370 SWIGRUNTIME int
371 SWIG_TypeEquiv(const char *nb, const char *tb) {
372 int equiv = 0;
373 const char* te = tb + strlen(tb);
374 const char* ne = nb;
375 while (!equiv && *ne) {
376 for (nb = ne; *ne; ++ne) {
377 if (*ne == '|') break;
378 }
379 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
380 if (*ne) ++ne;
381 }
382 return equiv;
383 }
384
385 /*
386 Check type equivalence in a name list like <name1>|<name2>|...
387 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
388 */
389 SWIGRUNTIME int
390 SWIG_TypeCompare(const char *nb, const char *tb) {
391 int equiv = 0;
392 const char* te = tb + strlen(tb);
393 const char* ne = nb;
394 while (!equiv && *ne) {
395 for (nb = ne; *ne; ++ne) {
396 if (*ne == '|') break;
397 }
398 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
399 if (*ne) ++ne;
400 }
401 return equiv;
402 }
403
404
405 /* think of this as a c++ template<> or a scheme macro */
406 #define SWIG_TypeCheck_Template(comparison, ty) \
407 if (ty) { \
408 swig_cast_info *iter = ty->cast; \
409 while (iter) { \
410 if (comparison) { \
411 if (iter == ty->cast) return iter; \
412 /* Move iter to the top of the linked list */ \
413 iter->prev->next = iter->next; \
414 if (iter->next) \
415 iter->next->prev = iter->prev; \
416 iter->next = ty->cast; \
417 iter->prev = 0; \
418 if (ty->cast) ty->cast->prev = iter; \
419 ty->cast = iter; \
420 return iter; \
421 } \
422 iter = iter->next; \
423 } \
424 } \
425 return 0
426
427 /*
428 Check the typename
429 */
430 SWIGRUNTIME swig_cast_info *
431 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
432 SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
433 }
434
435 /* Same as previous function, except strcmp is replaced with a pointer comparison */
436 SWIGRUNTIME swig_cast_info *
437 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
438 SWIG_TypeCheck_Template(iter->type == from, into);
439 }
440
441 /*
442 Cast a pointer up an inheritance hierarchy
443 */
444 SWIGRUNTIMEINLINE void *
445 SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
446 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
447 }
448
449 /*
450 Dynamic pointer casting. Down an inheritance hierarchy
451 */
452 SWIGRUNTIME swig_type_info *
453 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
454 swig_type_info *lastty = ty;
455 if (!ty || !ty->dcast) return ty;
456 while (ty && (ty->dcast)) {
457 ty = (*ty->dcast)(ptr);
458 if (ty) lastty = ty;
459 }
460 return lastty;
461 }
462
463 /*
464 Return the name associated with this type
465 */
466 SWIGRUNTIMEINLINE const char *
467 SWIG_TypeName(const swig_type_info *ty) {
468 return ty->name;
469 }
470
471 /*
472 Return the pretty name associated with this type,
473 that is an unmangled type name in a form presentable to the user.
474 */
475 SWIGRUNTIME const char *
476 SWIG_TypePrettyName(const swig_type_info *type) {
477 /* The "str" field contains the equivalent pretty names of the
478 type, separated by vertical-bar characters. We choose
479 to print the last name, as it is often (?) the most
480 specific. */
481 if (!type) return NULL;
482 if (type->str != NULL) {
483 const char *last_name = type->str;
484 const char *s;
485 for (s = type->str; *s; s++)
486 if (*s == '|') last_name = s+1;
487 return last_name;
488 }
489 else
490 return type->name;
491 }
492
493 /*
494 Set the clientdata field for a type
495 */
496 SWIGRUNTIME void
497 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
498 swig_cast_info *cast = ti->cast;
499 /* if (ti->clientdata == clientdata) return; */
500 ti->clientdata = clientdata;
501
502 while (cast) {
503 if (!cast->converter) {
504 swig_type_info *tc = cast->type;
505 if (!tc->clientdata) {
506 SWIG_TypeClientData(tc, clientdata);
507 }
508 }
509 cast = cast->next;
510 }
511 }
512 SWIGRUNTIME void
513 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
514 SWIG_TypeClientData(ti, clientdata);
515 ti->owndata = 1;
516 }
517
518 /*
519 Search for a swig_type_info structure only by mangled name
520 Search is a O(log #types)
521
522 We start searching at module start, and finish searching when start == end.
523 Note: if start == end at the beginning of the function, we go all the way around
524 the circular list.
525 */
526 SWIGRUNTIME swig_type_info *
527 SWIG_MangledTypeQueryModule(swig_module_info *start,
528 swig_module_info *end,
529 const char *name) {
530 swig_module_info *iter = start;
531 do {
532 if (iter->size) {
533 register size_t l = 0;
534 register size_t r = iter->size - 1;
535 do {
536 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
537 register size_t i = (l + r) >> 1;
538 const char *iname = iter->types[i]->name;
539 if (iname) {
540 register int compare = strcmp(name, iname);
541 if (compare == 0) {
542 return iter->types[i];
543 } else if (compare < 0) {
544 if (i) {
545 r = i - 1;
546 } else {
547 break;
548 }
549 } else if (compare > 0) {
550 l = i + 1;
551 }
552 } else {
553 break; /* should never happen */
554 }
555 } while (l <= r);
556 }
557 iter = iter->next;
558 } while (iter != end);
559 return 0;
560 }
561
562 /*
563 Search for a swig_type_info structure for either a mangled name or a human readable name.
564 It first searches the mangled names of the types, which is a O(log #types)
565 If a type is not found it then searches the human readable names, which is O(#types).
566
567 We start searching at module start, and finish searching when start == end.
568 Note: if start == end at the beginning of the function, we go all the way around
569 the circular list.
570 */
571 SWIGRUNTIME swig_type_info *
572 SWIG_TypeQueryModule(swig_module_info *start,
573 swig_module_info *end,
574 const char *name) {
575 /* STEP 1: Search the name field using binary search */
576 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
577 if (ret) {
578 return ret;
579 } else {
580 /* STEP 2: If the type hasn't been found, do a complete search
581 of the str field (the human readable name) */
582 swig_module_info *iter = start;
583 do {
584 register size_t i = 0;
585 for (; i < iter->size; ++i) {
586 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
587 return iter->types[i];
588 }
589 iter = iter->next;
590 } while (iter != end);
591 }
592
593 /* neither found a match */
594 return 0;
595 }
596
597 /*
598 Pack binary data into a string
599 */
600 SWIGRUNTIME char *
601 SWIG_PackData(char *c, void *ptr, size_t sz) {
602 static const char hex[17] = "0123456789abcdef";
603 register const unsigned char *u = (unsigned char *) ptr;
604 register const unsigned char *eu = u + sz;
605 for (; u != eu; ++u) {
606 register unsigned char uu = *u;
607 *(c++) = hex[(uu & 0xf0) >> 4];
608 *(c++) = hex[uu & 0xf];
609 }
610 return c;
611 }
612
613 /*
614 Unpack binary data from a string
615 */
616 SWIGRUNTIME const char *
617 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
618 register unsigned char *u = (unsigned char *) ptr;
619 register const unsigned char *eu = u + sz;
620 for (; u != eu; ++u) {
621 register char d = *(c++);
622 register unsigned char uu;
623 if ((d >= '0') && (d <= '9'))
624 uu = ((d - '0') << 4);
625 else if ((d >= 'a') && (d <= 'f'))
626 uu = ((d - ('a'-10)) << 4);
627 else
628 return (char *) 0;
629 d = *(c++);
630 if ((d >= '0') && (d <= '9'))
631 uu |= (d - '0');
632 else if ((d >= 'a') && (d <= 'f'))
633 uu |= (d - ('a'-10));
634 else
635 return (char *) 0;
636 *u = uu;
637 }
638 return c;
639 }
640
641 /*
642 Pack 'void *' into a string buffer.
643 */
644 SWIGRUNTIME char *
645 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
646 char *r = buff;
647 if ((2*sizeof(void *) + 2) > bsz) return 0;
648 *(r++) = '_';
649 r = SWIG_PackData(r,&ptr,sizeof(void *));
650 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
651 strcpy(r,name);
652 return buff;
653 }
654
655 SWIGRUNTIME const char *
656 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
657 if (*c != '_') {
658 if (strcmp(c,"NULL") == 0) {
659 *ptr = (void *) 0;
660 return name;
661 } else {
662 return 0;
663 }
664 }
665 return SWIG_UnpackData(++c,ptr,sizeof(void *));
666 }
667
668 SWIGRUNTIME char *
669 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
670 char *r = buff;
671 size_t lname = (name ? strlen(name) : 0);
672 if ((2*sz + 2 + lname) > bsz) return 0;
673 *(r++) = '_';
674 r = SWIG_PackData(r,ptr,sz);
675 if (lname) {
676 strncpy(r,name,lname+1);
677 } else {
678 *r = 0;
679 }
680 return buff;
681 }
682
683 SWIGRUNTIME const char *
684 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
685 if (*c != '_') {
686 if (strcmp(c,"NULL") == 0) {
687 memset(ptr,0,sz);
688 return name;
689 } else {
690 return 0;
691 }
692 }
693 return SWIG_UnpackData(++c,ptr,sz);
694 }
695
696 #ifdef __cplusplus
697 }
698 #endif
699
700 /* Errors in SWIG */
701 #define SWIG_UnknownError -1
702 #define SWIG_IOError -2
703 #define SWIG_RuntimeError -3
704 #define SWIG_IndexError -4
705 #define SWIG_TypeError -5
706 #define SWIG_DivisionByZero -6
707 #define SWIG_OverflowError -7
708 #define SWIG_SyntaxError -8
709 #define SWIG_ValueError -9
710 #define SWIG_SystemError -10
711 #define SWIG_AttributeError -11
712 #define SWIG_MemoryError -12
713 #define SWIG_NullReferenceError -13
714
715
716
717 /* Python.h has to appear first */
718 #include <Python.h>
719
720 /* Add PyOS_snprintf for old Pythons */
721 #if PY_VERSION_HEX < 0x02020000
722 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
723 # define PyOS_snprintf _snprintf
724 # else
725 # define PyOS_snprintf snprintf
726 # endif
727 #endif
728
729 /* A crude PyString_FromFormat implementation for old Pythons */
730 #if PY_VERSION_HEX < 0x02020000
731
732 #ifndef SWIG_PYBUFFER_SIZE
733 # define SWIG_PYBUFFER_SIZE 1024
734 #endif
735
736 static PyObject *
737 PyString_FromFormat(const char *fmt, ...) {
738 va_list ap;
739 char buf[SWIG_PYBUFFER_SIZE * 2];
740 int res;
741 va_start(ap, fmt);
742 res = vsnprintf(buf, sizeof(buf), fmt, ap);
743 va_end(ap);
744 return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
745 }
746 #endif
747
748 /* Add PyObject_Del for old Pythons */
749 #if PY_VERSION_HEX < 0x01060000
750 # define PyObject_Del(op) PyMem_DEL((op))
751 #endif
752 #ifndef PyObject_DEL
753 # define PyObject_DEL PyObject_Del
754 #endif
755
756 /* A crude PyExc_StopIteration exception for old Pythons */
757 #if PY_VERSION_HEX < 0x02020000
758 # ifndef PyExc_StopIteration
759 # define PyExc_StopIteration PyExc_RuntimeError
760 # endif
761 # ifndef PyObject_GenericGetAttr
762 # define PyObject_GenericGetAttr 0
763 # endif
764 #endif
765 /* Py_NotImplemented is defined in 2.1 and up. */
766 #if PY_VERSION_HEX < 0x02010000
767 # ifndef Py_NotImplemented
768 # define Py_NotImplemented PyExc_RuntimeError
769 # endif
770 #endif
771
772
773 /* A crude PyString_AsStringAndSize implementation for old Pythons */
774 #if PY_VERSION_HEX < 0x02010000
775 # ifndef PyString_AsStringAndSize
776 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
777 # endif
778 #endif
779
780 /* PySequence_Size for old Pythons */
781 #if PY_VERSION_HEX < 0x02000000
782 # ifndef PySequence_Size
783 # define PySequence_Size PySequence_Length
784 # endif
785 #endif
786
787
788 /* PyBool_FromLong for old Pythons */
789 #if PY_VERSION_HEX < 0x02030000
790 static
791 PyObject *PyBool_FromLong(long ok)
792 {
793 PyObject *result = ok ? Py_True : Py_False;
794 Py_INCREF(result);
795 return result;
796 }
797 #endif
798
799
800 /* -----------------------------------------------------------------------------
801 * error manipulation
802 * ----------------------------------------------------------------------------- */
803
804 SWIGRUNTIME PyObject*
805 SWIG_Python_ErrorType(int code) {
806 PyObject* type = 0;
807 switch(code) {
808 case SWIG_MemoryError:
809 type = PyExc_MemoryError;
810 break;
811 case SWIG_IOError:
812 type = PyExc_IOError;
813 break;
814 case SWIG_RuntimeError:
815 type = PyExc_RuntimeError;
816 break;
817 case SWIG_IndexError:
818 type = PyExc_IndexError;
819 break;
820 case SWIG_TypeError:
821 type = PyExc_TypeError;
822 break;
823 case SWIG_DivisionByZero:
824 type = PyExc_ZeroDivisionError;
825 break;
826 case SWIG_OverflowError:
827 type = PyExc_OverflowError;
828 break;
829 case SWIG_SyntaxError:
830 type = PyExc_SyntaxError;
831 break;
832 case SWIG_ValueError:
833 type = PyExc_ValueError;
834 break;
835 case SWIG_SystemError:
836 type = PyExc_SystemError;
837 break;
838 case SWIG_AttributeError:
839 type = PyExc_AttributeError;
840 break;
841 default:
842 type = PyExc_RuntimeError;
843 }
844 return type;
845 }
846
847
848 SWIGRUNTIME void
849 SWIG_Python_AddErrorMsg(const char* mesg)
850 {
851 PyObject *type = 0;
852 PyObject *value = 0;
853 PyObject *traceback = 0;
854
855 if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
856 if (value) {
857 PyObject *old_str = PyObject_Str(value);
858 PyErr_Clear();
859 Py_XINCREF(type);
860 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
861 Py_DECREF(old_str);
862 Py_DECREF(value);
863 } else {
864 PyErr_Format(PyExc_RuntimeError, mesg);
865 }
866 }
867
868
869
870 #if defined(SWIG_PYTHON_NO_THREADS)
871 # if defined(SWIG_PYTHON_THREADS)
872 # undef SWIG_PYTHON_THREADS
873 # endif
874 #endif
875 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
876 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
877 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
878 # define SWIG_PYTHON_USE_GIL
879 # endif
880 # endif
881 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
882 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
883 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
884 # endif
885 # ifdef __cplusplus /* C++ code */
886 class SWIG_Python_Thread_Block {
887 bool status;
888 PyGILState_STATE state;
889 public:
890 void end() { if (status) { PyGILState_Release(state); status = false;} }
891 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
892 ~SWIG_Python_Thread_Block() { end(); }
893 };
894 class SWIG_Python_Thread_Allow {
895 bool status;
896 PyThreadState *save;
897 public:
898 void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
899 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
900 ~SWIG_Python_Thread_Allow() { end(); }
901 };
902 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
903 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
904 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
905 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
906 # else /* C code */
907 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
908 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
909 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
910 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
911 # endif
912 # else /* Old thread way, not implemented, user must provide it */
913 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
914 # define SWIG_PYTHON_INITIALIZE_THREADS
915 # endif
916 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
917 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
918 # endif
919 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
920 # define SWIG_PYTHON_THREAD_END_BLOCK
921 # endif
922 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
923 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
924 # endif
925 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
926 # define SWIG_PYTHON_THREAD_END_ALLOW
927 # endif
928 # endif
929 #else /* No thread support */
930 # define SWIG_PYTHON_INITIALIZE_THREADS
931 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
932 # define SWIG_PYTHON_THREAD_END_BLOCK
933 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
934 # define SWIG_PYTHON_THREAD_END_ALLOW
935 #endif
936
937 /* -----------------------------------------------------------------------------
938 * Python API portion that goes into the runtime
939 * ----------------------------------------------------------------------------- */
940
941 #ifdef __cplusplus
942 extern "C" {
943 #if 0
944 } /* cc-mode */
945 #endif
946 #endif
947
948 /* -----------------------------------------------------------------------------
949 * Constant declarations
950 * ----------------------------------------------------------------------------- */
951
952 /* Constant Types */
953 #define SWIG_PY_POINTER 4
954 #define SWIG_PY_BINARY 5
955
956 /* Constant information structure */
957 typedef struct swig_const_info {
958 int type;
959 char *name;
960 long lvalue;
961 double dvalue;
962 void *pvalue;
963 swig_type_info **ptype;
964 } swig_const_info;
965
966 #ifdef __cplusplus
967 #if 0
968 { /* cc-mode */
969 #endif
970 }
971 #endif
972
973
974 /* -----------------------------------------------------------------------------
975 * See the LICENSE file for information on copyright, usage and redistribution
976 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
977 *
978 * pyrun.swg
979 *
980 * This file contains the runtime support for Python modules
981 * and includes code for managing global variables and pointer
982 * type checking.
983 *
984 * ----------------------------------------------------------------------------- */
985
986 /* Common SWIG API */
987
988 #if PY_VERSION_HEX < 0x02050000
989 typedef int Py_ssize_t;
990 #endif
991
992 /* for raw pointers */
993 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
994 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
995 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
996 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
997 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
998 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
999 #define swig_owntype int
1000
1001 /* for raw packed data */
1002 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1003 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1004
1005 /* for class or struct pointers */
1006 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1007 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1008
1009 /* for C or C++ function pointers */
1010 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1011 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
1012
1013 /* for C++ member pointers, ie, member methods */
1014 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1015 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1016
1017
1018 /* Runtime API */
1019
1020 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1021 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1022 #define SWIG_NewClientData(obj) PySwigClientData_New(obj)
1023
1024 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1025 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1026 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1027 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1028 #define SWIG_fail goto fail
1029
1030
1031 /* Runtime API implementation */
1032
1033 /* Error manipulation */
1034
1035 SWIGINTERN void
1036 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1037 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1038 PyErr_SetObject(errtype, obj);
1039 Py_DECREF(obj);
1040 SWIG_PYTHON_THREAD_END_BLOCK;
1041 }
1042
1043 SWIGINTERN void
1044 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1045 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1046 PyErr_SetString(errtype, (char *) msg);
1047 SWIG_PYTHON_THREAD_END_BLOCK;
1048 }
1049
1050 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1051
1052 /* Set a constant value */
1053
1054 SWIGINTERN void
1055 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1056 PyDict_SetItemString(d, (char*) name, obj);
1057 Py_DECREF(obj);
1058 }
1059
1060 /* Append a value to the result obj */
1061
1062 SWIGINTERN PyObject*
1063 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1064 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1065 if (!result) {
1066 result = obj;
1067 } else if (result == Py_None) {
1068 Py_DECREF(result);
1069 result = obj;
1070 } else {
1071 if (!PyList_Check(result)) {
1072 PyObject *o2 = result;
1073 result = PyList_New(1);
1074 PyList_SetItem(result, 0, o2);
1075 }
1076 PyList_Append(result,obj);
1077 Py_DECREF(obj);
1078 }
1079 return result;
1080 #else
1081 PyObject* o2;
1082 PyObject* o3;
1083 if (!result) {
1084 result = obj;
1085 } else if (result == Py_None) {
1086 Py_DECREF(result);
1087 result = obj;
1088 } else {
1089 if (!PyTuple_Check(result)) {
1090 o2 = result;
1091 result = PyTuple_New(1);
1092 PyTuple_SET_ITEM(result, 0, o2);
1093 }
1094 o3 = PyTuple_New(1);
1095 PyTuple_SET_ITEM(o3, 0, obj);
1096 o2 = result;
1097 result = PySequence_Concat(o2, o3);
1098 Py_DECREF(o2);
1099 Py_DECREF(o3);
1100 }
1101 return result;
1102 #endif
1103 }
1104
1105 /* Unpack the argument tuple */
1106
1107 SWIGINTERN int
1108 SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs)
1109 {
1110 if (!args) {
1111 if (!min && !max) {
1112 return 1;
1113 } else {
1114 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1115 name, (min == max ? "" : "at least "), min);
1116 return 0;
1117 }
1118 }
1119 if (!PyTuple_Check(args)) {
1120 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1121 return 0;
1122 } else {
1123 register int l = PyTuple_GET_SIZE(args);
1124 if (l < min) {
1125 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1126 name, (min == max ? "" : "at least "), min, l);
1127 return 0;
1128 } else if (l > max) {
1129 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1130 name, (min == max ? "" : "at most "), max, l);
1131 return 0;
1132 } else {
1133 register int i;
1134 for (i = 0; i < l; ++i) {
1135 objs[i] = PyTuple_GET_ITEM(args, i);
1136 }
1137 for (; l < max; ++l) {
1138 objs[l] = 0;
1139 }
1140 return i + 1;
1141 }
1142 }
1143 }
1144
1145 /* A functor is a function object with one single object argument */
1146 #if PY_VERSION_HEX >= 0x02020000
1147 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1148 #else
1149 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1150 #endif
1151
1152 /*
1153 Helper for static pointer initialization for both C and C++ code, for example
1154 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1155 */
1156 #ifdef __cplusplus
1157 #define SWIG_STATIC_POINTER(var) var
1158 #else
1159 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1160 #endif
1161
1162 /* -----------------------------------------------------------------------------
1163 * Pointer declarations
1164 * ----------------------------------------------------------------------------- */
1165
1166 /* Flags for new pointer objects */
1167 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1168 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1169
1170 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1171
1172 #ifdef __cplusplus
1173 extern "C" {
1174 #if 0
1175 } /* cc-mode */
1176 #endif
1177 #endif
1178
1179 /* How to access Py_None */
1180 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1181 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1182 # ifndef SWIG_PYTHON_BUILD_NONE
1183 # define SWIG_PYTHON_BUILD_NONE
1184 # endif
1185 # endif
1186 #endif
1187
1188 #ifdef SWIG_PYTHON_BUILD_NONE
1189 # ifdef Py_None
1190 # undef Py_None
1191 # define Py_None SWIG_Py_None()
1192 # endif
1193 SWIGRUNTIMEINLINE PyObject *
1194 _SWIG_Py_None(void)
1195 {
1196 PyObject *none = Py_BuildValue("");
1197 Py_DECREF(none);
1198 return none;
1199 }
1200 SWIGRUNTIME PyObject *
1201 SWIG_Py_None(void)
1202 {
1203 static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1204 return none;
1205 }
1206 #endif
1207
1208 /* The python void return value */
1209
1210 SWIGRUNTIMEINLINE PyObject *
1211 SWIG_Py_Void(void)
1212 {
1213 PyObject *none = Py_None;
1214 Py_INCREF(none);
1215 return none;
1216 }
1217
1218 /* PySwigClientData */
1219
1220 typedef struct {
1221 PyObject *klass;
1222 PyObject *newraw;
1223 PyObject *newargs;
1224 PyObject *destroy;
1225 int delargs;
1226 int implicitconv;
1227 } PySwigClientData;
1228
1229 SWIGRUNTIMEINLINE int
1230 SWIG_Python_CheckImplicit(swig_type_info *ty)
1231 {
1232 PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1233 return data ? data->implicitconv : 0;
1234 }
1235
1236 SWIGRUNTIMEINLINE PyObject *
1237 SWIG_Python_ExceptionType(swig_type_info *desc) {
1238 PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1239 PyObject *klass = data ? data->klass : 0;
1240 return (klass ? klass : PyExc_RuntimeError);
1241 }
1242
1243
1244 SWIGRUNTIME PySwigClientData *
1245 PySwigClientData_New(PyObject* obj)
1246 {
1247 if (!obj) {
1248 return 0;
1249 } else {
1250 PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1251 /* the klass element */
1252 data->klass = obj;
1253 Py_INCREF(data->klass);
1254 /* the newraw method and newargs arguments used to create a new raw instance */
1255 if (PyClass_Check(obj)) {
1256 data->newraw = 0;
1257 data->newargs = obj;
1258 Py_INCREF(obj);
1259 } else {
1260 #if (PY_VERSION_HEX < 0x02020000)
1261 data->newraw = 0;
1262 #else
1263 data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1264 #endif
1265 if (data->newraw) {
1266 Py_INCREF(data->newraw);
1267 data->newargs = PyTuple_New(1);
1268 PyTuple_SetItem(data->newargs, 0, obj);
1269 } else {
1270 data->newargs = obj;
1271 }
1272 Py_INCREF(data->newargs);
1273 }
1274 /* the destroy method, aka as the C++ delete method */
1275 data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1276 if (PyErr_Occurred()) {
1277 PyErr_Clear();
1278 data->destroy = 0;
1279 }
1280 if (data->destroy) {
1281 int flags;
1282 Py_INCREF(data->destroy);
1283 flags = PyCFunction_GET_FLAGS(data->destroy);
1284 #ifdef METH_O
1285 data->delargs = !(flags & (METH_O));
1286 #else
1287 data->delargs = 0;
1288 #endif
1289 } else {
1290 data->delargs = 0;
1291 }
1292 data->implicitconv = 0;
1293 return data;
1294 }
1295 }
1296
1297 SWIGRUNTIME void
1298 PySwigClientData_Del(PySwigClientData* data)
1299 {
1300 Py_XDECREF(data->newraw);
1301 Py_XDECREF(data->newargs);
1302 Py_XDECREF(data->destroy);
1303 }
1304
1305 /* =============== PySwigObject =====================*/
1306
1307 typedef struct {
1308 PyObject_HEAD
1309 void *ptr;
1310 swig_type_info *ty;
1311 int own;
1312 PyObject *next;
1313 } PySwigObject;
1314
1315 SWIGRUNTIME PyObject *
1316 PySwigObject_long(PySwigObject *v)
1317 {
1318 return PyLong_FromVoidPtr(v->ptr);
1319 }
1320
1321 SWIGRUNTIME PyObject *
1322 PySwigObject_format(const char* fmt, PySwigObject *v)
1323 {
1324 PyObject *res = NULL;
1325 PyObject *args = PyTuple_New(1);
1326 if (args) {
1327 if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1328 PyObject *ofmt = PyString_FromString(fmt);
1329 if (ofmt) {
1330 res = PyString_Format(ofmt,args);
1331 Py_DECREF(ofmt);
1332 }
1333 Py_DECREF(args);
1334 }
1335 }
1336 return res;
1337 }
1338
1339 SWIGRUNTIME PyObject *
1340 PySwigObject_oct(PySwigObject *v)
1341 {
1342 return PySwigObject_format("%o",v);
1343 }
1344
1345 SWIGRUNTIME PyObject *
1346 PySwigObject_hex(PySwigObject *v)
1347 {
1348 return PySwigObject_format("%x",v);
1349 }
1350
1351 SWIGRUNTIME PyObject *
1352 #ifdef METH_NOARGS
1353 PySwigObject_repr(PySwigObject *v)
1354 #else
1355 PySwigObject_repr(PySwigObject *v, PyObject *args)
1356 #endif
1357 {
1358 const char *name = SWIG_TypePrettyName(v->ty);
1359 PyObject *hex = PySwigObject_hex(v);
1360 PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1361 Py_DECREF(hex);
1362 if (v->next) {
1363 #ifdef METH_NOARGS
1364 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1365 #else
1366 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1367 #endif
1368 PyString_ConcatAndDel(&repr,nrep);
1369 }
1370 return repr;
1371 }
1372
1373 SWIGRUNTIME int
1374 PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1375 {
1376 #ifdef METH_NOARGS
1377 PyObject *repr = PySwigObject_repr(v);
1378 #else
1379 PyObject *repr = PySwigObject_repr(v, NULL);
1380 #endif
1381 if (repr) {
1382 fputs(PyString_AsString(repr), fp);
1383 Py_DECREF(repr);
1384 return 0;
1385 } else {
1386 return 1;
1387 }
1388 }
1389
1390 SWIGRUNTIME PyObject *
1391 PySwigObject_str(PySwigObject *v)
1392 {
1393 char result[SWIG_BUFFER_SIZE];
1394 return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1395 PyString_FromString(result) : 0;
1396 }
1397
1398 SWIGRUNTIME int
1399 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1400 {
1401 void *i = v->ptr;
1402 void *j = w->ptr;
1403 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1404 }
1405
1406 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1407
1408 SWIGRUNTIME PyTypeObject*
1409 PySwigObject_type(void) {
1410 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1411 return type;
1412 }
1413
1414 SWIGRUNTIMEINLINE int
1415 PySwigObject_Check(PyObject *op) {
1416 return ((op)->ob_type == PySwigObject_type())
1417 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1418 }
1419
1420 SWIGRUNTIME PyObject *
1421 PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1422
1423 SWIGRUNTIME void
1424 PySwigObject_dealloc(PyObject *v)
1425 {
1426 PySwigObject *sobj = (PySwigObject *) v;
1427 PyObject *next = sobj->next;
1428 if (sobj->own) {
1429 swig_type_info *ty = sobj->ty;
1430 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1431 PyObject *destroy = data ? data->destroy : 0;
1432 if (destroy) {
1433 /* destroy is always a VARARGS method */
1434 PyObject *res;
1435 if (data->delargs) {
1436 /* we need to create a temporal object to carry the destroy operation */
1437 PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1438 res = SWIG_Python_CallFunctor(destroy, tmp);
1439 Py_DECREF(tmp);
1440 } else {
1441 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1442 PyObject *mself = PyCFunction_GET_SELF(destroy);
1443 res = ((*meth)(mself, v));
1444 }
1445 Py_XDECREF(res);
1446 } else {
1447 const char *name = SWIG_TypePrettyName(ty);
1448 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1449 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
1450 #endif
1451 }
1452 }
1453 Py_XDECREF(next);
1454 PyObject_DEL(v);
1455 }
1456
1457 SWIGRUNTIME PyObject*
1458 PySwigObject_append(PyObject* v, PyObject* next)
1459 {
1460 PySwigObject *sobj = (PySwigObject *) v;
1461 #ifndef METH_O
1462 PyObject *tmp = 0;
1463 if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1464 next = tmp;
1465 #endif
1466 if (!PySwigObject_Check(next)) {
1467 return NULL;
1468 }
1469 sobj->next = next;
1470 Py_INCREF(next);
1471 return SWIG_Py_Void();
1472 }
1473
1474 SWIGRUNTIME PyObject*
1475 #ifdef METH_NOARGS
1476 PySwigObject_next(PyObject* v)
1477 #else
1478 PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1479 #endif
1480 {
1481 PySwigObject *sobj = (PySwigObject *) v;
1482 if (sobj->next) {
1483 Py_INCREF(sobj->next);
1484 return sobj->next;
1485 } else {
1486 return SWIG_Py_Void();
1487 }
1488 }
1489
1490 SWIGINTERN PyObject*
1491 #ifdef METH_NOARGS
1492 PySwigObject_disown(PyObject *v)
1493 #else
1494 PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1495 #endif
1496 {
1497 PySwigObject *sobj = (PySwigObject *)v;
1498 sobj->own = 0;
1499 return SWIG_Py_Void();
1500 }
1501
1502 SWIGINTERN PyObject*
1503 #ifdef METH_NOARGS
1504 PySwigObject_acquire(PyObject *v)
1505 #else
1506 PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1507 #endif
1508 {
1509 PySwigObject *sobj = (PySwigObject *)v;
1510 sobj->own = SWIG_POINTER_OWN;
1511 return SWIG_Py_Void();
1512 }
1513
1514 SWIGINTERN PyObject*
1515 PySwigObject_own(PyObject *v, PyObject *args)
1516 {
1517 PyObject *val = 0;
1518 #if (PY_VERSION_HEX < 0x02020000)
1519 if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1520 #else
1521 if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1522 #endif
1523 {
1524 return NULL;
1525 }
1526 else
1527 {
1528 PySwigObject *sobj = (PySwigObject *)v;
1529 PyObject *obj = PyBool_FromLong(sobj->own);
1530 if (val) {
1531 #ifdef METH_NOARGS
1532 if (PyObject_IsTrue(val)) {
1533 PySwigObject_acquire(v);
1534 } else {
1535 PySwigObject_disown(v);
1536 }
1537 #else
1538 if (PyObject_IsTrue(val)) {
1539 PySwigObject_acquire(v,args);
1540 } else {
1541 PySwigObject_disown(v,args);
1542 }
1543 #endif
1544 }
1545 return obj;
1546 }
1547 }
1548
1549 #ifdef METH_O
1550 static PyMethodDef
1551 swigobject_methods[] = {
1552 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1553 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
1554 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1555 {(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"},
1556 {(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1557 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"},
1558 {0, 0, 0, 0}
1559 };
1560 #else
1561 static PyMethodDef
1562 swigobject_methods[] = {
1563 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1564 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1565 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1566 {(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1567 {(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1568 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"},
1569 {0, 0, 0, 0}
1570 };
1571 #endif
1572
1573 #if PY_VERSION_HEX < 0x02020000
1574 SWIGINTERN PyObject *
1575 PySwigObject_getattr(PySwigObject *sobj,char *name)
1576 {
1577 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1578 }
1579 #endif
1580
1581 SWIGRUNTIME PyTypeObject*
1582 _PySwigObject_type(void) {
1583 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1584
1585 static PyNumberMethods PySwigObject_as_number = {
1586 (binaryfunc)0, /*nb_add*/
1587 (binaryfunc)0, /*nb_subtract*/
1588 (binaryfunc)0, /*nb_multiply*/
1589 (binaryfunc)0, /*nb_divide*/
1590 (binaryfunc)0, /*nb_remainder*/
1591 (binaryfunc)0, /*nb_divmod*/
1592 (ternaryfunc)0,/*nb_power*/
1593 (unaryfunc)0, /*nb_negative*/
1594 (unaryfunc)0, /*nb_positive*/
1595 (unaryfunc)0, /*nb_absolute*/
1596 (inquiry)0, /*nb_nonzero*/
1597 0, /*nb_invert*/
1598 0, /*nb_lshift*/
1599 0, /*nb_rshift*/
1600 0, /*nb_and*/
1601 0, /*nb_xor*/
1602 0, /*nb_or*/
1603 (coercion)0, /*nb_coerce*/
1604 (unaryfunc)PySwigObject_long, /*nb_int*/
1605 (unaryfunc)PySwigObject_long, /*nb_long*/
1606 (unaryfunc)0, /*nb_float*/
1607 (unaryfunc)PySwigObject_oct, /*nb_oct*/
1608 (unaryfunc)PySwigObject_hex, /*nb_hex*/
1609 #if PY_VERSION_HEX >= 0x02020000
1610 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1611 #elif PY_VERSION_HEX >= 0x02000000
1612 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1613 #endif
1614 };
1615
1616 static PyTypeObject pyswigobject_type;
1617 static int type_init = 0;
1618 if (!type_init) {
1619 const PyTypeObject tmp
1620 = {
1621 PyObject_HEAD_INIT(NULL)
1622 0, /* ob_size */
1623 (char *)"PySwigObject", /* tp_name */
1624 sizeof(PySwigObject), /* tp_basicsize */
1625 0, /* tp_itemsize */
1626 (destructor)PySwigObject_dealloc, /* tp_dealloc */
1627 (printfunc)PySwigObject_print, /* tp_print */
1628 #if PY_VERSION_HEX < 0x02020000
1629 (getattrfunc)PySwigObject_getattr, /* tp_getattr */
1630 #else
1631 (getattrfunc)0, /* tp_getattr */
1632 #endif
1633 (setattrfunc)0, /* tp_setattr */
1634 (cmpfunc)PySwigObject_compare, /* tp_compare */
1635 (reprfunc)PySwigObject_repr, /* tp_repr */
1636 &PySwigObject_as_number, /* tp_as_number */
1637 0, /* tp_as_sequence */
1638 0, /* tp_as_mapping */
1639 (hashfunc)0, /* tp_hash */
1640 (ternaryfunc)0, /* tp_call */
1641 (reprfunc)PySwigObject_str, /* tp_str */
1642 PyObject_GenericGetAttr, /* tp_getattro */
1643 0, /* tp_setattro */
1644 0, /* tp_as_buffer */
1645 Py_TPFLAGS_DEFAULT, /* tp_flags */
1646 swigobject_doc, /* tp_doc */
1647 0, /* tp_traverse */
1648 0, /* tp_clear */
1649 0, /* tp_richcompare */
1650 0, /* tp_weaklistoffset */
1651 #if PY_VERSION_HEX >= 0x02020000
1652 0, /* tp_iter */
1653 0, /* tp_iternext */
1654 swigobject_methods, /* tp_methods */
1655 0, /* tp_members */
1656 0, /* tp_getset */
1657 0, /* tp_base */
1658 0, /* tp_dict */
1659 0, /* tp_descr_get */
1660 0, /* tp_descr_set */
1661 0, /* tp_dictoffset */
1662 0, /* tp_init */
1663 0, /* tp_alloc */
1664 0, /* tp_new */
1665 0, /* tp_free */
1666 0, /* tp_is_gc */
1667 0, /* tp_bases */
1668 0, /* tp_mro */
1669 0, /* tp_cache */
1670 0, /* tp_subclasses */
1671 0, /* tp_weaklist */
1672 #endif
1673 #if PY_VERSION_HEX >= 0x02030000
1674 0, /* tp_del */
1675 #endif
1676 #ifdef COUNT_ALLOCS
1677 0,0,0,0 /* tp_alloc -> tp_next */
1678 #endif
1679 };
1680 pyswigobject_type = tmp;
1681 pyswigobject_type.ob_type = &PyType_Type;
1682 type_init = 1;
1683 }
1684 return &pyswigobject_type;
1685 }
1686
1687 SWIGRUNTIME PyObject *
1688 PySwigObject_New(void *ptr, swig_type_info *ty, int own)
1689 {
1690 PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1691 if (sobj) {
1692 sobj->ptr = ptr;
1693 sobj->ty = ty;
1694 sobj->own = own;
1695 sobj->next = 0;
1696 }
1697 return (PyObject *)sobj;
1698 }
1699
1700 /* -----------------------------------------------------------------------------
1701 * Implements a simple Swig Packed type, and use it instead of string
1702 * ----------------------------------------------------------------------------- */
1703
1704 typedef struct {
1705 PyObject_HEAD
1706 void *pack;
1707 swig_type_info *ty;
1708 size_t size;
1709 } PySwigPacked;
1710
1711 SWIGRUNTIME int
1712 PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1713 {
1714 char result[SWIG_BUFFER_SIZE];
1715 fputs("<Swig Packed ", fp);
1716 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1717 fputs("at ", fp);
1718 fputs(result, fp);
1719 }
1720 fputs(v->ty->name,fp);
1721 fputs(">", fp);
1722 return 0;
1723 }
1724
1725 SWIGRUNTIME PyObject *
1726 PySwigPacked_repr(PySwigPacked *v)
1727 {
1728 char result[SWIG_BUFFER_SIZE];
1729 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1730 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1731 } else {
1732 return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
1733 }
1734 }
1735
1736 SWIGRUNTIME PyObject *
1737 PySwigPacked_str(PySwigPacked *v)
1738 {
1739 char result[SWIG_BUFFER_SIZE];
1740 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1741 return PyString_FromFormat("%s%s", result, v->ty->name);
1742 } else {
1743 return PyString_FromString(v->ty->name);
1744 }
1745 }
1746
1747 SWIGRUNTIME int
1748 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
1749 {
1750 size_t i = v->size;
1751 size_t j = w->size;
1752 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1753 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1754 }
1755
1756 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1757
1758 SWIGRUNTIME PyTypeObject*
1759 PySwigPacked_type(void) {
1760 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1761 return type;
1762 }
1763
1764 SWIGRUNTIMEINLINE int
1765 PySwigPacked_Check(PyObject *op) {
1766 return ((op)->ob_type == _PySwigPacked_type())
1767 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1768 }
1769
1770 SWIGRUNTIME void
1771 PySwigPacked_dealloc(PyObject *v)
1772 {
1773 if (PySwigPacked_Check(v)) {
1774 PySwigPacked *sobj = (PySwigPacked *) v;
1775 free(sobj->pack);
1776 }
1777 PyObject_DEL(v);
1778 }
1779
1780 SWIGRUNTIME PyTypeObject*
1781 _PySwigPacked_type(void) {
1782 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1783 static PyTypeObject pyswigpacked_type;
1784 static int type_init = 0;
1785 if (!type_init) {
1786 const PyTypeObject tmp
1787 = {
1788 PyObject_HEAD_INIT(NULL)
1789 0, /* ob_size */
1790 (char *)"PySwigPacked", /* tp_name */
1791 sizeof(PySwigPacked), /* tp_basicsize */
1792 0, /* tp_itemsize */
1793 (destructor)PySwigPacked_dealloc, /* tp_dealloc */
1794 (printfunc)PySwigPacked_print, /* tp_print */
1795 (getattrfunc)0, /* tp_getattr */
1796 (setattrfunc)0, /* tp_setattr */
1797 (cmpfunc)PySwigPacked_compare, /* tp_compare */
1798 (reprfunc)PySwigPacked_repr, /* tp_repr */
1799 0, /* tp_as_number */
1800 0, /* tp_as_sequence */
1801 0, /* tp_as_mapping */
1802 (hashfunc)0, /* tp_hash */
1803 (ternaryfunc)0, /* tp_call */
1804 (reprfunc)PySwigPacked_str, /* tp_str */
1805 PyObject_GenericGetAttr, /* tp_getattro */
1806 0, /* tp_setattro */
1807 0, /* tp_as_buffer */
1808 Py_TPFLAGS_DEFAULT, /* tp_flags */
1809 swigpacked_doc, /* tp_doc */
1810 0, /* tp_traverse */
1811 0, /* tp_clear */
1812 0, /* tp_richcompare */
1813 0, /* tp_weaklistoffset */
1814 #if PY_VERSION_HEX >= 0x02020000
1815 0, /* tp_iter */
1816 0, /* tp_iternext */
1817 0, /* tp_methods */
1818 0, /* tp_members */
1819 0, /* tp_getset */
1820 0, /* tp_base */
1821 0, /* tp_dict */
1822 0, /* tp_descr_get */
1823 0, /* tp_descr_set */
1824 0, /* tp_dictoffset */
1825 0, /* tp_init */
1826 0, /* tp_alloc */
1827 0, /* tp_new */
1828 0, /* tp_free */
1829 0, /* tp_is_gc */
1830 0, /* tp_bases */
1831 0, /* tp_mro */
1832 0, /* tp_cache */
1833 0, /* tp_subclasses */
1834 0, /* tp_weaklist */
1835 #endif
1836 #if PY_VERSION_HEX >= 0x02030000
1837 0, /* tp_del */
1838 #endif
1839 #ifdef COUNT_ALLOCS
1840 0,0,0,0 /* tp_alloc -> tp_next */
1841 #endif
1842 };
1843 pyswigpacked_type = tmp;
1844 pyswigpacked_type.ob_type = &PyType_Type;
1845 type_init = 1;
1846 }
1847 return &pyswigpacked_type;
1848 }
1849
1850 SWIGRUNTIME PyObject *
1851 PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
1852 {
1853 PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1854 if (sobj) {
1855 void *pack = malloc(size);
1856 if (pack) {
1857 memcpy(pack, ptr, size);
1858 sobj->pack = pack;
1859 sobj->ty = ty;
1860 sobj->size = size;
1861 } else {
1862 PyObject_DEL((PyObject *) sobj);
1863 sobj = 0;
1864 }
1865 }
1866 return (PyObject *) sobj;
1867 }
1868
1869 SWIGRUNTIME swig_type_info *
1870 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1871 {
1872 if (PySwigPacked_Check(obj)) {
1873 PySwigPacked *sobj = (PySwigPacked *)obj;
1874 if (sobj->size != size) return 0;
1875 memcpy(ptr, sobj->pack, size);
1876 return sobj->ty;
1877 } else {
1878 return 0;
1879 }
1880 }
1881
1882 /* -----------------------------------------------------------------------------
1883 * pointers/data manipulation
1884 * ----------------------------------------------------------------------------- */
1885
1886 SWIGRUNTIMEINLINE PyObject *
1887 _SWIG_This(void)
1888 {
1889 return PyString_FromString("this");
1890 }
1891
1892 SWIGRUNTIME PyObject *
1893 SWIG_This(void)
1894 {
1895 static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1896 return swig_this;
1897 }
1898
1899 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1900
1901 SWIGRUNTIME PySwigObject *
1902 SWIG_Python_GetSwigThis(PyObject *pyobj)
1903 {
1904 if (PySwigObject_Check(pyobj)) {
1905 return (PySwigObject *) pyobj;
1906 } else {
1907 PyObject *obj = 0;
1908 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1909 if (PyInstance_Check(pyobj)) {
1910 obj = _PyInstance_Lookup(pyobj, SWIG_This());
1911 } else {
1912 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1913 if (dictptr != NULL) {
1914 PyObject *dict = *dictptr;
1915 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1916 } else {
1917 #ifdef PyWeakref_CheckProxy
1918 if (PyWeakref_CheckProxy(pyobj)) {
1919 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1920 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1921 }
1922 #endif
1923 obj = PyObject_GetAttr(pyobj,SWIG_This());
1924 if (obj) {
1925 Py_DECREF(obj);
1926 } else {
1927 if (PyErr_Occurred()) PyErr_Clear();
1928 return 0;
1929 }
1930 }
1931 }
1932 #else
1933 obj = PyObject_GetAttr(pyobj,SWIG_This());
1934 if (obj) {
1935 Py_DECREF(obj);
1936 } else {
1937 if (PyErr_Occurred()) PyErr_Clear();
1938 return 0;
1939 }
1940 #endif
1941 if (obj && !PySwigObject_Check(obj)) {
1942 /* a PyObject is called 'this', try to get the 'real this'
1943 PySwigObject from it */
1944 return SWIG_Python_GetSwigThis(obj);
1945 }
1946 return (PySwigObject *)obj;
1947 }
1948 }
1949
1950 /* Acquire a pointer value */
1951
1952 SWIGRUNTIME int
1953 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1954 if (own) {
1955 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1956 if (sobj) {
1957 int oldown = sobj->own;
1958 sobj->own = own;
1959 return oldown;
1960 }
1961 }
1962 return 0;
1963 }
1964
1965 /* Convert a pointer value */
1966
1967 SWIGRUNTIME int
1968 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1969 if (!obj) return SWIG_ERROR;
1970 if (obj == Py_None) {
1971 if (ptr) *ptr = 0;
1972 return SWIG_OK;
1973 } else {
1974 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1975 while (sobj) {
1976 void *vptr = sobj->ptr;
1977 if (ty) {
1978 swig_type_info *to = sobj->ty;
1979 if (to == ty) {
1980 /* no type cast needed */
1981 if (ptr) *ptr = vptr;
1982 break;
1983 } else {
1984 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1985 if (!tc) {
1986 sobj = (PySwigObject *)sobj->next;
1987 } else {
1988 if (ptr) *ptr = SWIG_TypeCast(tc,vptr);
1989 break;
1990 }
1991 }
1992 } else {
1993 if (ptr) *ptr = vptr;
1994 break;
1995 }
1996 }
1997 if (sobj) {
1998 if (own) *own = sobj->own;
1999 if (flags & SWIG_POINTER_DISOWN) {
2000 sobj->own = 0;
2001 }
2002 return SWIG_OK;
2003 } else {
2004 int res = SWIG_ERROR;
2005 if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2006 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2007 if (data && !data->implicitconv) {
2008 PyObject *klass = data->klass;
2009 if (klass) {
2010 PyObject *impconv;
2011 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2012 impconv = SWIG_Python_CallFunctor(klass, obj);
2013 data->implicitconv = 0;
2014 if (PyErr_Occurred()) {
2015 PyErr_Clear();
2016 impconv = 0;
2017 }
2018 if (impconv) {
2019 PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2020 if (iobj) {
2021 void *vptr;
2022 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2023 if (SWIG_IsOK(res)) {
2024 if (ptr) {
2025 *ptr = vptr;
2026 /* transfer the ownership to 'ptr' */
2027 iobj->own = 0;
2028 res = SWIG_AddCast(res);
2029 res = SWIG_AddNewMask(res);
2030 } else {
2031 res = SWIG_AddCast(res);
2032 }
2033 }
2034 }
2035 Py_DECREF(impconv);
2036 }
2037 }
2038 }
2039 }
2040 return res;
2041 }
2042 }
2043 }
2044
2045 /* Convert a function ptr value */
2046
2047 SWIGRUNTIME int
2048 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2049 if (!PyCFunction_Check(obj)) {
2050 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2051 } else {
2052 void *vptr = 0;
2053
2054 /* here we get the method pointer for callbacks */
2055 const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2056 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2057 if (desc) {
2058 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2059 if (!desc) return SWIG_ERROR;
2060 }
2061 if (ty) {
2062 swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2063 if (!tc) return SWIG_ERROR;
2064 *ptr = SWIG_TypeCast(tc,vptr);
2065 } else {
2066 *ptr = vptr;
2067 }
2068 return SWIG_OK;
2069 }
2070 }
2071
2072 /* Convert a packed value value */
2073
2074 SWIGRUNTIME int
2075 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2076 swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2077 if (!to) return SWIG_ERROR;
2078 if (ty) {
2079 if (to != ty) {
2080 /* check type cast? */
2081 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2082 if (!tc) return SWIG_ERROR;
2083 }
2084 }
2085 return SWIG_OK;
2086 }
2087
2088 /* -----------------------------------------------------------------------------
2089 * Create a new pointer object
2090 * ----------------------------------------------------------------------------- */
2091
2092 /*
2093 Create a new instance object, whitout calling __init__, and set the
2094 'this' attribute.
2095 */
2096
2097 SWIGRUNTIME PyObject*
2098 SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2099 {
2100 #if (PY_VERSION_HEX >= 0x02020000)
2101 PyObject *inst = 0;
2102 PyObject *newraw = data->newraw;
2103 if (newraw) {
2104 inst = PyObject_Call(newraw, data->newargs, NULL);
2105 if (inst) {
2106 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2107 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2108 if (dictptr != NULL) {
2109 PyObject *dict = *dictptr;
2110 if (dict == NULL) {
2111 dict = PyDict_New();
2112 *dictptr = dict;
2113 PyDict_SetItem(dict, SWIG_This(), swig_this);
2114 }
2115 }
2116 #else
2117 PyObject *key = SWIG_This();
2118 PyObject_SetAttr(inst, key, swig_this);
2119 #endif
2120 }
2121 } else {
2122 PyObject *dict = PyDict_New();
2123 PyDict_SetItem(dict, SWIG_This(), swig_this);
2124 inst = PyInstance_NewRaw(data->newargs, dict);
2125 Py_DECREF(dict);
2126 }
2127 return inst;
2128 #else
2129 #if (PY_VERSION_HEX >= 0x02010000)
2130 PyObject *inst;
2131 PyObject *dict = PyDict_New();
2132 PyDict_SetItem(dict, SWIG_This(), swig_this);
2133 inst = PyInstance_NewRaw(data->newargs, dict);
2134 Py_DECREF(dict);
2135 return (PyObject *) inst;
2136 #else
2137 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2138 if (inst == NULL) {
2139 return NULL;
2140 }
2141 inst->in_class = (PyClassObject *)data->newargs;
2142 Py_INCREF(inst->in_class);
2143 inst->in_dict = PyDict_New();
2144 if (inst->in_dict == NULL) {
2145 Py_DECREF(inst);
2146 return NULL;
2147 }
2148 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2149 inst->in_weakreflist = NULL;
2150 #endif
2151 #ifdef Py_TPFLAGS_GC
2152 PyObject_GC_Init(inst);
2153 #endif
2154 PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2155 return (PyObject *) inst;
2156 #endif
2157 #endif
2158 }
2159
2160 SWIGRUNTIME void
2161 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2162 {
2163 PyObject *dict;
2164 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2165 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2166 if (dictptr != NULL) {
2167 dict = *dictptr;
2168 if (dict == NULL) {
2169 dict = PyDict_New();
2170 *dictptr = dict;
2171 }
2172 PyDict_SetItem(dict, SWIG_This(), swig_this);
2173 return;
2174 }
2175 #endif
2176 dict = PyObject_GetAttrString(inst, "__dict__");
2177 PyDict_SetItem(dict, SWIG_This(), swig_this);
2178 Py_DECREF(dict);
2179 }
2180
2181
2182 SWIGINTERN PyObject *
2183 SWIG_Python_InitShadowInstance(PyObject *args) {
2184 PyObject *obj[2];
2185 if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2186 return NULL;
2187 } else {
2188 PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2189 if (sthis) {
2190 PySwigObject_append((PyObject*) sthis, obj[1]);
2191 } else {
2192 SWIG_Python_SetSwigThis(obj[0], obj[1]);
2193 }
2194 return SWIG_Py_Void();
2195 }
2196 }
2197
2198 /* Create a new pointer object */
2199
2200 SWIGRUNTIME PyObject *
2201 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2202 if (!ptr) {
2203 return SWIG_Py_Void();
2204 } else {
2205 int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2206 PyObject *robj = PySwigObject_New(ptr, type, own);
2207 PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2208 if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2209 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2210 if (inst) {
2211 Py_DECREF(robj);
2212 robj = inst;
2213 }
2214 }
2215 return robj;
2216 }
2217 }
2218
2219 /* Create a new packed object */
2220
2221 SWIGRUNTIMEINLINE PyObject *
2222 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2223 return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2224 }
2225
2226 /* -----------------------------------------------------------------------------*
2227 * Get type list
2228 * -----------------------------------------------------------------------------*/
2229
2230 #ifdef SWIG_LINK_RUNTIME
2231 void *SWIG_ReturnGlobalTypeList(void *);
2232 #endif
2233
2234 SWIGRUNTIME swig_module_info *
2235 SWIG_Python_GetModule(void) {
2236 static void *type_pointer = (void *)0;
2237 /* first check if module already created */
2238 if (!type_pointer) {
2239 #ifdef SWIG_LINK_RUNTIME
2240 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2241 #else
2242 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2243 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2244 if (PyErr_Occurred()) {
2245 PyErr_Clear();
2246 type_pointer = (void *)0;
2247 }
2248 #endif
2249 }
2250 return (swig_module_info *) type_pointer;
2251 }
2252
2253 #if PY_MAJOR_VERSION < 2
2254 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2255 is copied out of Python/modsupport.c in python version 2.3.4 */
2256 SWIGINTERN int
2257 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2258 {
2259 PyObject *dict;
2260 if (!PyModule_Check(m)) {
2261 PyErr_SetString(PyExc_TypeError,
2262 "PyModule_AddObject() needs module as first arg");
2263 return SWIG_ERROR;
2264 }
2265 if (!o) {
2266 PyErr_SetString(PyExc_TypeError,
2267 "PyModule_AddObject() needs non-NULL value");
2268 return SWIG_ERROR;
2269 }
2270
2271 dict = PyModule_GetDict(m);
2272 if (dict == NULL) {
2273 /* Internal error -- modules must have a dict! */
2274 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2275 PyModule_GetName(m));
2276 return SWIG_ERROR;
2277 }
2278 if (PyDict_SetItemString(dict, name, o))
2279 return SWIG_ERROR;
2280 Py_DECREF(o);
2281 return SWIG_OK;
2282 }
2283 #endif
2284
2285 SWIGRUNTIME void
2286 SWIG_Python_DestroyModule(void *vptr)
2287 {
2288 swig_module_info *swig_module = (swig_module_info *) vptr;
2289 swig_type_info **types = swig_module->types;
2290 size_t i;
2291 for (i =0; i < swig_module->size; ++i) {
2292 swig_type_info *ty = types[i];
2293 if (ty->owndata) {
2294 PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2295 if (data) PySwigClientData_Del(data);
2296 }
2297 }
2298 Py_DECREF(SWIG_This());
2299 }
2300
2301 SWIGRUNTIME void
2302 SWIG_Python_SetModule(swig_module_info *swig_module) {
2303 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2304
2305 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2306 swig_empty_runtime_method_table);
2307 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2308 if (pointer && module) {
2309 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2310 } else {
2311 Py_XDECREF(pointer);
2312 }
2313 }
2314
2315 /* The python cached type query */
2316 SWIGRUNTIME PyObject *
2317 SWIG_Python_TypeCache() {
2318 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2319 return cache;
2320 }
2321
2322 SWIGRUNTIME swig_type_info *
2323 SWIG_Python_TypeQuery(const char *type)
2324 {
2325 PyObject *cache = SWIG_Python_TypeCache();
2326 PyObject *key = PyString_FromString(type);
2327 PyObject *obj = PyDict_GetItem(cache, key);
2328 swig_type_info *descriptor;
2329 if (obj) {
2330 descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2331 } else {
2332 swig_module_info *swig_module = SWIG_Python_GetModule();
2333 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2334 if (descriptor) {
2335 obj = PyCObject_FromVoidPtr(descriptor, NULL);
2336 PyDict_SetItem(cache, key, obj);
2337 Py_DECREF(obj);
2338 }
2339 }
2340 Py_DECREF(key);
2341 return descriptor;
2342 }
2343
2344 /*
2345 For backward compatibility only
2346 */
2347 #define SWIG_POINTER_EXCEPTION 0
2348 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2349 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2350
2351 SWIGRUNTIME int
2352 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2353 {
2354 if (PyErr_Occurred()) {
2355 PyObject *type = 0;
2356 PyObject *value = 0;
2357 PyObject *traceback = 0;
2358 PyErr_Fetch(&type, &value, &traceback);
2359 if (value) {
2360 PyObject *old_str = PyObject_Str(value);
2361 Py_XINCREF(type);
2362 PyErr_Clear();
2363 if (infront) {
2364 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2365 } else {
2366 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2367 }
2368 Py_DECREF(old_str);
2369 }
2370 return 1;
2371 } else {
2372 return 0;
2373 }
2374 }
2375
2376 SWIGRUNTIME int
2377 SWIG_Python_ArgFail(int argnum)
2378 {
2379 if (PyErr_Occurred()) {
2380 /* add information about failing argument */
2381 char mesg[256];
2382 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2383 return SWIG_Python_AddErrMesg(mesg, 1);
2384 } else {
2385 return 0;
2386 }
2387 }
2388
2389 SWIGRUNTIMEINLINE const char *
2390 PySwigObject_GetDesc(PyObject *self)
2391 {
2392 PySwigObject *v = (PySwigObject *)self;
2393 swig_type_info *ty = v ? v->ty : 0;
2394 return ty ? ty->str : (char*)"";
2395 }
2396
2397 SWIGRUNTIME void
2398 SWIG_Python_TypeError(const char *type, PyObject *obj)
2399 {
2400 if (type) {
2401 #if defined(SWIG_COBJECT_TYPES)
2402 if (obj && PySwigObject_Check(obj)) {
2403 const char *otype = (const char *) PySwigObject_GetDesc(obj);
2404 if (otype) {
2405 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2406 type, otype);
2407 return;
2408 }
2409 } else
2410 #endif
2411 {
2412 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2413 if (otype) {
2414 PyObject *str = PyObject_Str(obj);
2415 const char *cstr = str ? PyString_AsString(str) : 0;
2416 if (cstr) {
2417 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2418 type, otype, cstr);
2419 } else {
2420 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2421 type, otype);
2422 }
2423 Py_XDECREF(str);
2424 return;
2425 }
2426 }
2427 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2428 } else {
2429 PyErr_Format(PyExc_TypeError, "unexpected type is received");
2430 }
2431 }
2432
2433
2434 /* Convert a pointer value, signal an exception on a type mismatch */
2435 SWIGRUNTIME void *
2436 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2437 void *result;
2438 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2439 PyErr_Clear();
2440 if (flags & SWIG_POINTER_EXCEPTION) {
2441 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2442 SWIG_Python_ArgFail(argnum);
2443 }
2444 }
2445 return result;
2446 }
2447
2448
2449 #ifdef __cplusplus
2450 #if 0
2451 { /* cc-mode */
2452 #endif
2453 }
2454 #endif
2455
2456
2457
2458 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2459
2460 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2461
2462
2463
2464 /* -------- TYPES TABLE (BEGIN) -------- */
2465
2466 #define SWIGTYPE_p_buffer swig_types[0]
2467 #define SWIGTYPE_p_char swig_types[1]
2468 #define SWIGTYPE_p_form_ops_t swig_types[2]
2469 #define SWIGTYPE_p_int swig_types[3]
2470 #define SWIGTYPE_p_long swig_types[4]
2471 #define SWIGTYPE_p_unsigned_char swig_types[5]
2472 #define SWIGTYPE_p_unsigned_int swig_types[6]
2473 #define SWIGTYPE_p_unsigned_long swig_types[7]
2474 #define SWIGTYPE_p_wxANIHandler swig_types[8]
2475 #define SWIGTYPE_p_wxAcceleratorEntry swig_types[9]
2476 #define SWIGTYPE_p_wxAcceleratorTable swig_types[10]
2477 #define SWIGTYPE_p_wxActivateEvent swig_types[11]
2478 #define SWIGTYPE_p_wxAppTraits swig_types[12]
2479 #define SWIGTYPE_p_wxArrayString swig_types[13]
2480 #define SWIGTYPE_p_wxBMPHandler swig_types[14]
2481 #define SWIGTYPE_p_wxBitmap swig_types[15]
2482 #define SWIGTYPE_p_wxBoxSizer swig_types[16]
2483 #define SWIGTYPE_p_wxButton swig_types[17]
2484 #define SWIGTYPE_p_wxCURHandler swig_types[18]
2485 #define SWIGTYPE_p_wxCaret swig_types[19]
2486 #define SWIGTYPE_p_wxChildFocusEvent swig_types[20]
2487 #define SWIGTYPE_p_wxClipboardTextEvent swig_types[21]
2488 #define SWIGTYPE_p_wxCloseEvent swig_types[22]
2489 #define SWIGTYPE_p_wxColour swig_types[23]
2490 #define SWIGTYPE_p_wxCommandEvent swig_types[24]
2491 #define SWIGTYPE_p_wxContextMenuEvent swig_types[25]
2492 #define SWIGTYPE_p_wxControl swig_types[26]
2493 #define SWIGTYPE_p_wxControlWithItems swig_types[27]
2494 #define SWIGTYPE_p_wxCursor swig_types[28]
2495 #define SWIGTYPE_p_wxDC swig_types[29]
2496 #define SWIGTYPE_p_wxDateEvent swig_types[30]
2497 #define SWIGTYPE_p_wxDateTime swig_types[31]
2498 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[32]
2499 #define SWIGTYPE_p_wxDropFilesEvent swig_types[33]
2500 #define SWIGTYPE_p_wxDuplexMode swig_types[34]
2501 #define SWIGTYPE_p_wxEraseEvent swig_types[35]
2502 #define SWIGTYPE_p_wxEvent swig_types[36]
2503 #define SWIGTYPE_p_wxEventLoop swig_types[37]
2504 #define SWIGTYPE_p_wxEventLoopActivator swig_types[38]
2505 #define SWIGTYPE_p_wxEvtHandler swig_types[39]
2506 #define SWIGTYPE_p_wxFSFile swig_types[40]
2507 #define SWIGTYPE_p_wxFileSystem swig_types[41]
2508 #define SWIGTYPE_p_wxFileSystemHandler swig_types[42]
2509 #define SWIGTYPE_p_wxFlexGridSizer swig_types[43]
2510 #define SWIGTYPE_p_wxFocusEvent swig_types[44]
2511 #define SWIGTYPE_p_wxFont swig_types[45]
2512 #define SWIGTYPE_p_wxFrame swig_types[46]
2513 #define SWIGTYPE_p_wxGBPosition swig_types[47]
2514 #define SWIGTYPE_p_wxGBSizerItem swig_types[48]
2515 #define SWIGTYPE_p_wxGBSpan swig_types[49]
2516 #define SWIGTYPE_p_wxGIFHandler swig_types[50]
2517 #define SWIGTYPE_p_wxGridBagSizer swig_types[51]
2518 #define SWIGTYPE_p_wxGridSizer swig_types[52]
2519 #define SWIGTYPE_p_wxHelpEvent__Origin swig_types[53]
2520 #define SWIGTYPE_p_wxICOHandler swig_types[54]
2521 #define SWIGTYPE_p_wxIconizeEvent swig_types[55]
2522 #define SWIGTYPE_p_wxIdleEvent swig_types[56]
2523 #define SWIGTYPE_p_wxImage swig_types[57]
2524 #define SWIGTYPE_p_wxImageHandler swig_types[58]
2525 #define SWIGTYPE_p_wxImageHistogram swig_types[59]
2526 #define SWIGTYPE_p_wxImage_HSVValue swig_types[60]
2527 #define SWIGTYPE_p_wxImage_RGBValue swig_types[61]
2528 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[62]
2529 #define SWIGTYPE_p_wxInitDialogEvent swig_types[63]
2530 #define SWIGTYPE_p_wxInputStream swig_types[64]
2531 #define SWIGTYPE_p_wxInternetFSHandler swig_types[65]
2532 #define SWIGTYPE_p_wxItemContainer swig_types[66]
2533 #define SWIGTYPE_p_wxJPEGHandler swig_types[67]
2534 #define SWIGTYPE_p_wxKeyEvent swig_types[68]
2535 #define SWIGTYPE_p_wxLayoutConstraints swig_types[69]
2536 #define SWIGTYPE_p_wxMaximizeEvent swig_types[70]
2537 #define SWIGTYPE_p_wxMemoryFSHandler swig_types[71]
2538 #define SWIGTYPE_p_wxMenu swig_types[72]
2539 #define SWIGTYPE_p_wxMenuBar swig_types[73]
2540 #define SWIGTYPE_p_wxMenuBarBase swig_types[74]
2541 #define SWIGTYPE_p_wxMenuEvent swig_types[75]
2542 #define SWIGTYPE_p_wxMenuItem swig_types[76]
2543 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[77]
2544 #define SWIGTYPE_p_wxMouseCaptureLostEvent swig_types[78]
2545 #define SWIGTYPE_p_wxMouseEvent swig_types[79]
2546 #define SWIGTYPE_p_wxMoveEvent swig_types[80]
2547 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[81]
2548 #define SWIGTYPE_p_wxNcPaintEvent swig_types[82]
2549 #define SWIGTYPE_p_wxNotifyEvent swig_types[83]
2550 #define SWIGTYPE_p_wxObject swig_types[84]
2551 #define SWIGTYPE_p_wxOutputStream swig_types[85]
2552 #define SWIGTYPE_p_wxPCXHandler swig_types[86]
2553 #define SWIGTYPE_p_wxPNGHandler swig_types[87]
2554 #define SWIGTYPE_p_wxPNMHandler swig_types[88]
2555 #define SWIGTYPE_p_wxPaintEvent swig_types[89]
2556 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[90]
2557 #define SWIGTYPE_p_wxPaperSize swig_types[91]
2558 #define SWIGTYPE_p_wxPoint swig_types[92]
2559 #define SWIGTYPE_p_wxPoint2D swig_types[93]
2560 #define SWIGTYPE_p_wxPropagateOnce swig_types[94]
2561 #define SWIGTYPE_p_wxPropagationDisabler swig_types[95]
2562 #define SWIGTYPE_p_wxPyApp swig_types[96]
2563 #define SWIGTYPE_p_wxPyCommandEvent swig_types[97]
2564 #define SWIGTYPE_p_wxPyDropTarget swig_types[98]
2565 #define SWIGTYPE_p_wxPyEvent swig_types[99]
2566 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[100]
2567 #define SWIGTYPE_p_wxPyImageHandler swig_types[101]
2568 #define SWIGTYPE_p_wxPyInputStream swig_types[102]
2569 #define SWIGTYPE_p_wxPySizer swig_types[103]
2570 #define SWIGTYPE_p_wxPyValidator swig_types[104]
2571 #define SWIGTYPE_p_wxQuantize swig_types[105]
2572 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[106]
2573 #define SWIGTYPE_p_wxRealPoint swig_types[107]
2574 #define SWIGTYPE_p_wxRect swig_types[108]
2575 #define SWIGTYPE_p_wxRegion swig_types[109]
2576 #define SWIGTYPE_p_wxScrollEvent swig_types[110]
2577 #define SWIGTYPE_p_wxScrollWinEvent swig_types[111]
2578 #define SWIGTYPE_p_wxSetCursorEvent swig_types[112]
2579 #define SWIGTYPE_p_wxShowEvent swig_types[113]
2580 #define SWIGTYPE_p_wxSize swig_types[114]
2581 #define SWIGTYPE_p_wxSizeEvent swig_types[115]
2582 #define SWIGTYPE_p_wxSizer swig_types[116]
2583 #define SWIGTYPE_p_wxSizerItem swig_types[117]
2584 #define SWIGTYPE_p_wxStaticBox swig_types[118]
2585 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[119]
2586 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[120]
2587 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[121]
2588 #define SWIGTYPE_p_wxTIFFHandler swig_types[122]
2589 #define SWIGTYPE_p_wxToolTip swig_types[123]
2590 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[124]
2591 #define SWIGTYPE_p_wxValidator swig_types[125]
2592 #define SWIGTYPE_p_wxVisualAttributes swig_types[126]
2593 #define SWIGTYPE_p_wxWindow swig_types[127]
2594 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[128]
2595 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[129]
2596 #define SWIGTYPE_p_wxXPMHandler swig_types[130]
2597 #define SWIGTYPE_p_wxZipFSHandler swig_types[131]
2598 static swig_type_info *swig_types[133];
2599 static swig_module_info swig_module = {swig_types, 132, 0, 0, 0, 0};
2600 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2601 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2602
2603 /* -------- TYPES TABLE (END) -------- */
2604
2605 #if (PY_VERSION_HEX <= 0x02000000)
2606 # if !defined(SWIG_PYTHON_CLASSIC)
2607 # error "This python version requires to use swig with the '-classic' option"
2608 # endif
2609 #endif
2610 #if (PY_VERSION_HEX <= 0x02020000)
2611 # error "This python version requires to use swig with the '-nomodern' option"
2612 #endif
2613 #if (PY_VERSION_HEX <= 0x02020000)
2614 # error "This python version requires to use swig with the '-nomodernargs' option"
2615 #endif
2616 #ifndef METH_O
2617 # error "This python version requires to use swig with the '-nofastunpack' option"
2618 #endif
2619
2620 /*-----------------------------------------------
2621 @(target):= _core_.so
2622 ------------------------------------------------*/
2623 #define SWIG_init init_core_
2624
2625 #define SWIG_name "_core_"
2626
2627 #define SWIGVERSION 0x010329
2628
2629
2630 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2631 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2632
2633
2634 #include <stdexcept>
2635
2636
2637 namespace swig {
2638 class PyObject_ptr {
2639 protected:
2640 PyObject *_obj;
2641
2642 public:
2643 PyObject_ptr() :_obj(0)
2644 {
2645 }
2646
2647 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2648 {
2649 Py_XINCREF(_obj);
2650 }
2651
2652 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2653 {
2654 if (initial_ref) Py_XINCREF(_obj);
2655 }
2656
2657 PyObject_ptr & operator=(const PyObject_ptr& item)
2658 {
2659 Py_XINCREF(item._obj);
2660 Py_XDECREF(_obj);
2661 _obj = item._obj;
2662 return *this;
2663 }
2664
2665 ~PyObject_ptr()
2666 {
2667 Py_XDECREF(_obj);
2668 }
2669
2670 operator PyObject *() const
2671 {
2672 return _obj;
2673 }
2674
2675 PyObject *operator->() const
2676 {
2677 return _obj;
2678 }
2679 };
2680 }
2681
2682
2683 namespace swig {
2684 struct PyObject_var : PyObject_ptr {
2685 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2686
2687 PyObject_var & operator = (PyObject* obj)
2688 {
2689 Py_XDECREF(_obj);
2690 _obj = obj;
2691 return *this;
2692 }
2693 };
2694 }
2695
2696
2697 #include "wx/wxPython/wxPython_int.h"
2698 #include "wx/wxPython/pyclasses.h"
2699 #include "wx/wxPython/twoitem.h"
2700
2701
2702 #ifndef wxPyUSE_EXPORT
2703 // Helper functions for dealing with SWIG objects and such. These are
2704 // located here so they know about the SWIG types and functions declared
2705 // in the wrapper code.
2706
2707 #include <wx/hashmap.h>
2708 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
2709
2710
2711 // Maintains a hashmap of className to swig_type_info pointers. Given the
2712 // name of a class either looks up the type info in the cache, or scans the
2713 // SWIG tables for it.
2714 extern PyObject* wxPyPtrTypeMap;
2715 static
2716 swig_type_info* wxPyFindSwigType(const wxChar* className) {
2717
2718 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
2719
2720 if (typeInfoCache == NULL)
2721 typeInfoCache = new wxPyTypeInfoHashMap;
2722
2723 wxString name(className);
2724 swig_type_info* swigType = (*typeInfoCache)[name];
2725
2726 if (! swigType) {
2727 // it wasn't in the cache, so look it up from SWIG
2728 name.Append(wxT(" *"));
2729 swigType = SWIG_TypeQuery(name.mb_str());
2730
2731 // if it still wasn't found, try looking for a mapped name
2732 if (!swigType) {
2733 PyObject* item;
2734 name = className;
2735
2736 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
2737 (char*)(const char*)name.mbc_str())) != NULL) {
2738 name = wxString(PyString_AsString(item), *wxConvCurrent);
2739 name.Append(wxT(" *"));
2740 swigType = SWIG_TypeQuery(name.mb_str());
2741 }
2742 }
2743 if (swigType) {
2744 // and add it to the map if found
2745 (*typeInfoCache)[className] = swigType;
2746 }
2747 }
2748 return swigType;
2749 }
2750
2751
2752 // Check if a class name is a type known to SWIG
2753 bool wxPyCheckSwigType(const wxChar* className) {
2754
2755 swig_type_info* swigType = wxPyFindSwigType(className);
2756 return swigType != NULL;
2757 }
2758
2759
2760 // Given a pointer to a C++ object and a class name, construct a Python proxy
2761 // object for it.
2762 PyObject* wxPyConstructObject(void* ptr,
2763 const wxChar* className,
2764 int setThisOwn) {
2765
2766 swig_type_info* swigType = wxPyFindSwigType(className);
2767 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
2768
2769 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
2770 }
2771
2772
2773 // Extract a pointer to the wrapped C++ object from a Python proxy object.
2774 // Ensures that the proxy object is of the specified (or derived) type. If
2775 // not able to perform the conversion then a Python exception is set and the
2776 // error should be handled properly in the caller. Returns True on success.
2777 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
2778 const wxChar* className) {
2779
2780 swig_type_info* swigType = wxPyFindSwigType(className);
2781 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
2782
2783 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
2784 }
2785
2786
2787
2788 // Make a SWIGified pointer object suitable for a .this attribute
2789 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
2790
2791 PyObject* robj = NULL;
2792
2793 swig_type_info* swigType = wxPyFindSwigType(className);
2794 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyMakeSwigPtr"));
2795
2796 robj = PySwigObject_New(ptr, swigType, 0);
2797 return robj;
2798 }
2799
2800
2801 // Python's PyInstance_Check does not return True for instances of new-style
2802 // classes. This should get close enough for both new and old classes but I
2803 // should re-evaluate the need for doing instance checks...
2804 bool wxPyInstance_Check(PyObject* obj) {
2805 return PyObject_HasAttrString(obj, "__class__") != 0;
2806 }
2807
2808
2809 // This one checks if the object is an instance of a SWIG proxy class (it has
2810 // a .this attribute, and the .this attribute is a PySwigObject.)
2811 bool wxPySwigInstance_Check(PyObject* obj) {
2812 static PyObject* this_str = NULL;
2813 if (this_str == NULL)
2814 this_str = PyString_FromString("this");
2815
2816 PyObject* this_attr = PyObject_GetAttr(obj, this_str);
2817 if (this_attr) {
2818 bool retval = (PySwigObject_Check(this_attr) != 0);
2819 Py_DECREF(this_attr);
2820 return retval;
2821 }
2822
2823 PyErr_Clear();
2824 return false;
2825 }
2826
2827
2828 // Export a C API in a struct. Other modules will be able to load this from
2829 // the wx._core_ module and will then have safe access to these functions,
2830 // even if they are located in another shared library.
2831 static wxPyCoreAPI API = {
2832
2833 wxPyCheckSwigType,
2834 wxPyConstructObject,
2835 wxPyConvertSwigPtr,
2836 wxPyMakeSwigPtr,
2837
2838 wxPyBeginAllowThreads,
2839 wxPyEndAllowThreads,
2840 wxPyBeginBlockThreads,
2841 wxPyEndBlockThreads,
2842
2843 wxPy_ConvertList,
2844
2845 wxString_in_helper,
2846 Py2wxString,
2847 wx2PyString,
2848
2849 byte_LIST_helper,
2850 int_LIST_helper,
2851 long_LIST_helper,
2852 string_LIST_helper,
2853 wxPoint_LIST_helper,
2854 wxBitmap_LIST_helper,
2855 wxString_LIST_helper,
2856 wxAcceleratorEntry_LIST_helper,
2857
2858 wxSize_helper,
2859 wxPoint_helper,
2860 wxRealPoint_helper,
2861 wxRect_helper,
2862 wxColour_helper,
2863 wxPoint2D_helper,
2864
2865 wxPySimple_typecheck,
2866 wxColour_typecheck,
2867
2868 wxPyCBH_setCallbackInfo,
2869 wxPyCBH_findCallback,
2870 wxPyCBH_callCallback,
2871 wxPyCBH_callCallbackObj,
2872 wxPyCBH_delete,
2873
2874 wxPyMake_wxObject,
2875 wxPyMake_wxSizer,
2876 wxPyPtrTypeMap_Add,
2877 wxPy2int_seq_helper,
2878 wxPy4int_seq_helper,
2879 wxArrayString2PyList_helper,
2880 wxArrayInt2PyList_helper,
2881
2882 wxPyClientData_dtor,
2883 wxPyUserData_dtor,
2884 wxPyOORClientData_dtor,
2885
2886 wxPyCBInputStream_create,
2887 wxPyCBInputStream_copy,
2888
2889 wxPyInstance_Check,
2890 wxPySwigInstance_Check,
2891
2892 wxPyCheckForApp
2893
2894 };
2895
2896 #endif
2897
2898
2899 #if !WXWIN_COMPATIBILITY_2_4
2900 #define wxHIDE_READONLY 0
2901 #endif
2902
2903
2904 #define SWIG_From_long PyInt_FromLong
2905
2906
2907 SWIGINTERNINLINE PyObject *
2908 SWIG_From_int (int value)
2909 {
2910 return SWIG_From_long (value);
2911 }
2912
2913 static const wxString wxPyEmptyString(wxEmptyString);
2914 SWIGINTERN wxString wxObject_GetClassName(wxObject *self){
2915 return self->GetClassInfo()->GetClassName();
2916 }
2917 SWIGINTERN void wxObject_Destroy(wxObject *self){
2918 delete self;
2919 }
2920
2921 #ifndef __WXMAC__
2922 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
2923 #endif
2924
2925
2926 #include <limits.h>
2927 #ifndef LLONG_MIN
2928 # define LLONG_MIN LONG_LONG_MIN
2929 #endif
2930 #ifndef LLONG_MAX
2931 # define LLONG_MAX LONG_LONG_MAX
2932 #endif
2933 #ifndef ULLONG_MAX
2934 # define ULLONG_MAX ULONG_LONG_MAX
2935 #endif
2936
2937
2938 SWIGINTERN int
2939 SWIG_AsVal_long (PyObject* obj, long* val)
2940 {
2941 if (PyNumber_Check(obj)) {
2942 if (val) *val = PyInt_AsLong(obj);
2943 return SWIG_OK;
2944 }
2945 return SWIG_TypeError;
2946 }
2947
2948
2949 SWIGINTERN int
2950 SWIG_AsVal_int (PyObject * obj, int *val)
2951 {
2952 long v;
2953 int res = SWIG_AsVal_long (obj, &v);
2954 if (SWIG_IsOK(res)) {
2955 if ((v < INT_MIN || v > INT_MAX)) {
2956 return SWIG_OverflowError;
2957 } else {
2958 if (val) *val = static_cast< int >(v);
2959 }
2960 }
2961 return res;
2962 }
2963
2964 SWIGINTERN bool wxSize___eq__(wxSize *self,PyObject *other){
2965 wxSize temp, *obj = &temp;
2966 if ( other == Py_None ) return false;
2967 if ( ! wxSize_helper(other, &obj) ) {
2968 PyErr_Clear();
2969 return false;
2970 }
2971 return self->operator==(*obj);
2972 }
2973 SWIGINTERN bool wxSize___ne__(wxSize *self,PyObject *other){
2974 wxSize temp, *obj = &temp;
2975 if ( other == Py_None ) return true;
2976 if ( ! wxSize_helper(other, &obj)) {
2977 PyErr_Clear();
2978 return true;
2979 }
2980 return self->operator!=(*obj);
2981 }
2982
2983 #include <float.h>
2984
2985
2986 SWIGINTERN int
2987 SWIG_AsVal_double (PyObject *obj, double* val)
2988 {
2989 if (PyNumber_Check(obj)) {
2990 if (val) *val = PyFloat_AsDouble(obj);
2991 return SWIG_OK;
2992 }
2993 return SWIG_TypeError;
2994 }
2995
2996
2997 SWIGINTERN int
2998 SWIG_AsVal_float (PyObject * obj, float *val)
2999 {
3000 double v;
3001 int res = SWIG_AsVal_double (obj, &v);
3002 if (SWIG_IsOK(res)) {
3003 if ((v < -FLT_MAX || v > FLT_MAX)) {
3004 return SWIG_OverflowError;
3005 } else {
3006 if (val) *val = static_cast< float >(v);
3007 }
3008 }
3009 return res;
3010 }
3011
3012 SWIGINTERN PyObject *wxSize_Get(wxSize *self){
3013 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3014 PyObject* tup = PyTuple_New(2);
3015 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3016 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3017 wxPyEndBlockThreads(blocked);
3018 return tup;
3019 }
3020
3021 #define SWIG_From_double PyFloat_FromDouble
3022
3023 SWIGINTERN bool wxRealPoint___eq__(wxRealPoint *self,PyObject *other){
3024 wxRealPoint temp, *obj = &temp;
3025 if ( other == Py_None ) return false;
3026 if ( ! wxRealPoint_helper(other, &obj) ) {
3027 PyErr_Clear();
3028 return false;
3029 }
3030 return self->operator==(*obj);
3031 }
3032 SWIGINTERN bool wxRealPoint___ne__(wxRealPoint *self,PyObject *other){
3033 wxRealPoint temp, *obj = &temp;
3034 if ( other == Py_None ) return true;
3035 if ( ! wxRealPoint_helper(other, &obj)) {
3036 PyErr_Clear();
3037 return true;
3038 }
3039 return self->operator!=(*obj);
3040 }
3041 SWIGINTERN void wxRealPoint_Set(wxRealPoint *self,double x,double y){
3042 self->x = x;
3043 self->y = y;
3044 }
3045 SWIGINTERN PyObject *wxRealPoint_Get(wxRealPoint *self){
3046 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3047 PyObject* tup = PyTuple_New(2);
3048 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
3049 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
3050 wxPyEndBlockThreads(blocked);
3051 return tup;
3052 }
3053 SWIGINTERN bool wxPoint___eq__(wxPoint *self,PyObject *other){
3054 wxPoint temp, *obj = &temp;
3055 if ( other == Py_None ) return false;
3056 if ( ! wxPoint_helper(other, &obj) ) {
3057 PyErr_Clear();
3058 return false;
3059 }
3060 return self->operator==(*obj);
3061 }
3062 SWIGINTERN bool wxPoint___ne__(wxPoint *self,PyObject *other){
3063 wxPoint temp, *obj = &temp;
3064 if ( other == Py_None ) return true;
3065 if ( ! wxPoint_helper(other, &obj)) {
3066 PyErr_Clear();
3067 return true;
3068 }
3069 return self->operator!=(*obj);
3070 }
3071 SWIGINTERN void wxPoint_Set(wxPoint *self,long x,long y){
3072 self->x = x;
3073 self->y = y;
3074 }
3075 SWIGINTERN PyObject *wxPoint_Get(wxPoint *self){
3076 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3077 PyObject* tup = PyTuple_New(2);
3078 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3079 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3080 wxPyEndBlockThreads(blocked);
3081 return tup;
3082 }
3083 SWIGINTERN bool wxRect___eq__(wxRect *self,PyObject *other){
3084 wxRect temp, *obj = &temp;
3085 if ( other == Py_None ) return false;
3086 if ( ! wxRect_helper(other, &obj) ) {
3087 PyErr_Clear();
3088 return false;
3089 }
3090 return self->operator==(*obj);
3091 }
3092 SWIGINTERN bool wxRect___ne__(wxRect *self,PyObject *other){
3093 wxRect temp, *obj = &temp;
3094 if ( other == Py_None ) return true;
3095 if ( ! wxRect_helper(other, &obj)) {
3096 PyErr_Clear();
3097 return true;
3098 }
3099 return self->operator!=(*obj);
3100 }
3101 SWIGINTERN void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
3102 self->x = x;
3103 self->y = y;
3104 self->width = width;
3105 self->height = height;
3106 }
3107 SWIGINTERN PyObject *wxRect_Get(wxRect *self){
3108 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3109 PyObject* tup = PyTuple_New(4);
3110 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3111 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3112 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
3113 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
3114 wxPyEndBlockThreads(blocked);
3115 return tup;
3116 }
3117
3118 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
3119 wxRegion reg1(*r1);
3120 wxRegion reg2(*r2);
3121 wxRect dest(0,0,0,0);
3122 PyObject* obj;
3123
3124 reg1.Intersect(reg2);
3125 dest = reg1.GetBox();
3126
3127 if (dest != wxRect(0,0,0,0)) {
3128 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3129 wxRect* newRect = new wxRect(dest);
3130 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
3131 wxPyEndBlockThreads(blocked);
3132 return obj;
3133 }
3134 Py_INCREF(Py_None);
3135 return Py_None;
3136 }
3137
3138 SWIGINTERN bool wxPoint2D___eq__(wxPoint2D *self,PyObject *other){
3139 wxPoint2D temp, *obj = &temp;
3140 if ( other == Py_None ) return false;
3141 if ( ! wxPoint2D_helper(other, &obj) ) {
3142 PyErr_Clear();
3143 return false;
3144 }
3145 return self->operator==(*obj);
3146 }
3147 SWIGINTERN bool wxPoint2D___ne__(wxPoint2D *self,PyObject *other){
3148 wxPoint2D temp, *obj = &temp;
3149 if ( other == Py_None ) return true;
3150 if ( ! wxPoint2D_helper(other, &obj)) {
3151 PyErr_Clear();
3152 return true;
3153 }
3154 return self->operator!=(*obj);
3155 }
3156 SWIGINTERN void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
3157 self->m_x = x;
3158 self->m_y = y;
3159 }
3160 SWIGINTERN PyObject *wxPoint2D_Get(wxPoint2D *self){
3161 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3162 PyObject* tup = PyTuple_New(2);
3163 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
3164 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
3165 wxPyEndBlockThreads(blocked);
3166 return tup;
3167 }
3168
3169 #include "wx/wxPython/pyistream.h"
3170
3171 SWIGINTERN wxPyInputStream *new_wxPyInputStream(PyObject *p){
3172 wxInputStream* wxis = wxPyCBInputStream::create(p);
3173 if (wxis)
3174 return new wxPyInputStream(wxis);
3175 else
3176 return NULL;
3177 }
3178
3179 SWIGINTERN swig_type_info*
3180 SWIG_pchar_descriptor()
3181 {
3182 static int init = 0;
3183 static swig_type_info* info = 0;
3184 if (!init) {
3185 info = SWIG_TypeQuery("_p_char");
3186 init = 1;
3187 }
3188 return info;
3189 }
3190
3191
3192 SWIGINTERNINLINE PyObject *
3193 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3194 {
3195 if (carray) {
3196 if (size > INT_MAX) {
3197 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3198 return pchar_descriptor ?
3199 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3200 } else {
3201 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3202 }
3203 } else {
3204 return SWIG_Py_Void();
3205 }
3206 }
3207
3208
3209 SWIGINTERNINLINE PyObject *
3210 SWIG_From_char (char c)
3211 {
3212 return SWIG_FromCharPtrAndSize(&c,1);
3213 }
3214
3215
3216 SWIGINTERNINLINE PyObject*
3217 SWIG_From_unsigned_SS_long (unsigned long value)
3218 {
3219 return (value > LONG_MAX) ?
3220 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
3221 }
3222
3223
3224 SWIGINTERNINLINE PyObject *
3225 SWIG_From_size_t (size_t value)
3226 {
3227 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
3228 }
3229
3230
3231 SWIGINTERN int
3232 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
3233 {
3234 if (PyString_Check(obj)) {
3235 char *cstr; Py_ssize_t len;
3236 PyString_AsStringAndSize(obj, &cstr, &len);
3237 if (cptr) {
3238 if (alloc) {
3239 /*
3240 In python the user should not be able to modify the inner
3241 string representation. To warranty that, if you define
3242 SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
3243 buffer is always returned.
3244
3245 The default behavior is just to return the pointer value,
3246 so, be careful.
3247 */
3248 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
3249 if (*alloc != SWIG_OLDOBJ)
3250 #else
3251 if (*alloc == SWIG_NEWOBJ)
3252 #endif
3253 {
3254 *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
3255 *alloc = SWIG_NEWOBJ;
3256 }
3257 else {
3258 *cptr = cstr;
3259 *alloc = SWIG_OLDOBJ;
3260 }
3261 } else {
3262 *cptr = PyString_AsString(obj);
3263 }
3264 }
3265 if (psize) *psize = len + 1;
3266 return SWIG_OK;
3267 } else {
3268 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3269 if (pchar_descriptor) {
3270 void* vptr = 0;
3271 if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3272 if (cptr) *cptr = (char *) vptr;
3273 if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3274 if (alloc) *alloc = SWIG_OLDOBJ;
3275 return SWIG_OK;
3276 }
3277 }
3278 }
3279 return SWIG_TypeError;
3280 }
3281
3282
3283 SWIGINTERN int
3284 SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
3285 {
3286 char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3287 int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3288 if (SWIG_IsOK(res)) {
3289 if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
3290 if (csize <= size) {
3291 if (val) {
3292 if (csize) memcpy(val, cptr, csize*sizeof(char));
3293 if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3294 }
3295 if (alloc == SWIG_NEWOBJ) {
3296 delete[] cptr;
3297 res = SWIG_DelNewMask(res);
3298 }
3299 return res;
3300 }
3301 if (alloc == SWIG_NEWOBJ) delete[] cptr;
3302 }
3303 return SWIG_TypeError;
3304 }
3305
3306
3307 SWIGINTERN int
3308 SWIG_AsVal_char (PyObject * obj, char *val)
3309 {
3310 int res = SWIG_AsCharArray(obj, val, 1);
3311 if (!SWIG_IsOK(res)) {
3312 long v;
3313 res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3314 if (SWIG_IsOK(res)) {
3315 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3316 if (val) *val = static_cast< char >(v);
3317 } else {
3318 res = SWIG_OverflowError;
3319 }
3320 }
3321 }
3322 return res;
3323 }
3324
3325 SWIGINTERN void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
3326 // We use only strings for the streams, not unicode
3327 PyObject* str = PyObject_Str(obj);
3328 if (! str) {
3329 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
3330 return;
3331 }
3332 self->Write(PyString_AS_STRING(str),
3333 PyString_GET_SIZE(str));
3334 Py_DECREF(str);
3335 }
3336
3337 #include "wx/wxPython/pyistream.h"
3338
3339
3340 class wxPyFileSystemHandler : public wxFileSystemHandler
3341 {
3342 public:
3343 wxPyFileSystemHandler() : wxFileSystemHandler() {}
3344
3345 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
3346 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
3347 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
3348 DEC_PYCALLBACK_STRING__pure(FindNext);
3349
3350 wxString GetProtocol(const wxString& location) {
3351 return wxFileSystemHandler::GetProtocol(location);
3352 }
3353
3354 wxString GetLeftLocation(const wxString& location) {
3355 return wxFileSystemHandler::GetLeftLocation(location);
3356 }
3357
3358 wxString GetAnchor(const wxString& location) {
3359 return wxFileSystemHandler::GetAnchor(location);
3360 }
3361
3362 wxString GetRightLocation(const wxString& location) {
3363 return wxFileSystemHandler::GetRightLocation(location);
3364 }
3365
3366 wxString GetMimeTypeFromExt(const wxString& location) {
3367 return wxFileSystemHandler::GetMimeTypeFromExt(location);
3368 }
3369
3370 PYPRIVATE;
3371 };
3372
3373
3374 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
3375 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
3376 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
3377 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
3378
3379
3380 SWIGINTERN int
3381 SWIG_AsVal_bool (PyObject *obj, bool *val)
3382 {
3383 if (obj == Py_True) {
3384 if (val) *val = true;
3385 return SWIG_OK;
3386 } else if (obj == Py_False) {
3387 if (val) *val = false;
3388 return SWIG_OK;
3389 } else {
3390 long v = 0;
3391 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
3392 if (SWIG_IsOK(res) && val) *val = v ? true : false;
3393 return res;
3394 }
3395 }
3396
3397 SWIGINTERN wxString wxFileSystem_URLToFileName(wxString const &url){
3398 wxFileName fname = wxFileSystem::URLToFileName(url);
3399 return fname.GetFullPath();
3400 }
3401
3402 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
3403 wxImage& image,
3404 long type) {
3405 wxMemoryFSHandler::AddFile(filename, image, type);
3406 }
3407
3408 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
3409 const wxBitmap& bitmap,
3410 long type) {
3411 wxMemoryFSHandler::AddFile(filename, bitmap, type);
3412 }
3413
3414 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
3415 PyObject* data) {
3416 if (! PyString_Check(data)) {
3417 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
3418 "Expected string object"));
3419 return;
3420 }
3421
3422 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3423 void* ptr = (void*)PyString_AsString(data);
3424 size_t size = PyString_Size(data);
3425 wxPyEndBlockThreads(blocked);
3426
3427 wxMemoryFSHandler::AddFile(filename, ptr, size);
3428 }
3429
3430
3431 #include "wx/wxPython/pyistream.h"
3432
3433
3434 SWIGINTERN int
3435 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
3436 {
3437 long v = 0;
3438 if (SWIG_AsVal_long(obj, &v) && v < 0) {
3439 return SWIG_TypeError;
3440 }
3441 else if (val)
3442 *val = (unsigned long)v;
3443 return SWIG_OK;
3444 }
3445
3446
3447 SWIGINTERN int
3448 SWIG_AsVal_unsigned_SS_char (PyObject * obj, unsigned char *val)
3449 {
3450 unsigned long v;
3451 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3452 if (SWIG_IsOK(res)) {
3453 if ((v > UCHAR_MAX)) {
3454 return SWIG_OverflowError;
3455 } else {
3456 if (val) *val = static_cast< unsigned char >(v);
3457 }
3458 }
3459 return res;
3460 }
3461
3462
3463 SWIGINTERNINLINE PyObject *
3464 SWIG_From_unsigned_SS_char (unsigned char value)
3465 {
3466 return SWIG_From_unsigned_SS_long (value);
3467 }
3468
3469 SWIGINTERN unsigned long wxImageHistogram_GetCount(wxImageHistogram *self,unsigned long key){
3470 wxImageHistogramEntry e = (*self)[key];
3471 return e.value;
3472 }
3473 SWIGINTERN unsigned long wxImageHistogram_GetCountRGB(wxImageHistogram *self,byte r,byte g,byte b){
3474 unsigned long key = wxImageHistogram::MakeKey(r, g, b);
3475 wxImageHistogramEntry e = (*self)[key];
3476 return e.value;
3477 }
3478 SWIGINTERN unsigned long wxImageHistogram_GetCountColour(wxImageHistogram *self,wxColour const &colour){
3479 unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
3480 colour.Green(),
3481 colour.Blue());
3482 wxImageHistogramEntry e = (*self)[key];
3483 return e.value;
3484 }
3485
3486 typedef unsigned char* buffer;
3487
3488
3489 // Pull the nested class out to the top level for SWIG's sake
3490 #define wxImage_RGBValue wxImage::RGBValue
3491 #define wxImage_HSVValue wxImage::HSVValue
3492
3493 SWIGINTERN wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
3494 if (width > 0 && height > 0)
3495 return new wxImage(width, height, clear);
3496 else
3497 return new wxImage;
3498 }
3499 SWIGINTERN wxImage *new_wxImage(wxBitmap const &bitmap){
3500 return new wxImage(bitmap.ConvertToImage());
3501 }
3502 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE){
3503 if (DATASIZE != width*height*3) {
3504 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3505 return NULL;
3506 }
3507
3508 // Copy the source data so the wxImage can clean it up later
3509 buffer copy = (buffer)malloc(DATASIZE);
3510 if (copy == NULL) {
3511 wxPyBLOCK_THREADS(PyErr_NoMemory());
3512 return NULL;
3513 }
3514 memcpy(copy, data, DATASIZE);
3515 return new wxImage(width, height, copy, false);
3516 }
3517 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE,buffer alpha,int ALPHASIZE){
3518 if (DATASIZE != width*height*3) {
3519 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3520 return NULL;
3521 }
3522 if (ALPHASIZE != width*height) {
3523 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3524 return NULL;
3525 }
3526
3527 // Copy the source data so the wxImage can clean it up later
3528 buffer dcopy = (buffer)malloc(DATASIZE);
3529 if (dcopy == NULL) {
3530 wxPyBLOCK_THREADS(PyErr_NoMemory());
3531 return NULL;
3532 }
3533 memcpy(dcopy, data, DATASIZE);
3534
3535 buffer acopy = (buffer)malloc(ALPHASIZE);
3536 if (acopy == NULL) {
3537 wxPyBLOCK_THREADS(PyErr_NoMemory());
3538 return NULL;
3539 }
3540 memcpy(acopy, alpha, ALPHASIZE);
3541
3542 return new wxImage(width, height, dcopy, acopy, false);
3543 }
3544 SWIGINTERN wxSize wxImage_GetSize(wxImage *self){
3545 wxSize size(self->GetWidth(), self->GetHeight());
3546 return size;
3547 }
3548 SWIGINTERN PyObject *wxImage_GetData(wxImage *self){
3549 buffer data = self->GetData();
3550 int len = self->GetWidth() * self->GetHeight() * 3;
3551 PyObject* rv;
3552 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
3553 return rv;
3554 }
3555 SWIGINTERN void wxImage_SetData(wxImage *self,buffer data,int DATASIZE){
3556 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3557 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3558 return;
3559 }
3560 buffer copy = (buffer)malloc(DATASIZE);
3561 if (copy == NULL) {
3562 wxPyBLOCK_THREADS(PyErr_NoMemory());
3563 return;
3564 }
3565 memcpy(copy, data, DATASIZE);
3566 self->SetData(copy, false);
3567 // wxImage takes ownership of copy...
3568 }
3569 SWIGINTERN PyObject *wxImage_GetDataBuffer(wxImage *self){
3570 buffer data = self->GetData();
3571 int len = self->GetWidth() * self->GetHeight() * 3;
3572 PyObject* rv;
3573 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3574 return rv;
3575 }
3576 SWIGINTERN void wxImage_SetDataBuffer(wxImage *self,buffer data,int DATASIZE){
3577 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3578 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3579 return;
3580 }
3581 self->SetData(data, true);
3582 }
3583 SWIGINTERN PyObject *wxImage_GetAlphaData(wxImage *self){
3584 buffer data = self->GetAlpha();
3585 if (! data) {
3586 RETURN_NONE();
3587 } else {
3588 int len = self->GetWidth() * self->GetHeight();
3589 PyObject* rv;
3590 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
3591 return rv;
3592 }
3593 }
3594 SWIGINTERN void wxImage_SetAlphaData(wxImage *self,buffer alpha,int ALPHASIZE){
3595 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3596 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3597 return;
3598 }
3599 buffer acopy = (buffer)malloc(ALPHASIZE);
3600 if (acopy == NULL) {
3601 wxPyBLOCK_THREADS(PyErr_NoMemory());
3602 return;
3603 }
3604 memcpy(acopy, alpha, ALPHASIZE);
3605 self->SetAlpha(acopy, false);
3606 // wxImage takes ownership of acopy...
3607 }
3608 SWIGINTERN PyObject *wxImage_GetAlphaBuffer(wxImage *self){
3609 buffer data = self->GetAlpha();
3610 int len = self->GetWidth() * self->GetHeight();
3611 PyObject* rv;
3612 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3613 return rv;
3614 }
3615 SWIGINTERN void wxImage_SetAlphaBuffer(wxImage *self,buffer alpha,int ALPHASIZE){
3616 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3617 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3618 return;
3619 }
3620 self->SetAlpha(alpha, true);
3621 }
3622 SWIGINTERN PyObject *wxImage_GetHandlers(){
3623 wxList& list = wxImage::GetHandlers();
3624 return wxPy_ConvertList(&list);
3625 }
3626 SWIGINTERN wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
3627 wxBitmap bitmap(*self, depth);
3628 return bitmap;
3629 }
3630 SWIGINTERN wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,byte red,byte green,byte blue){
3631 wxImage mono = self->ConvertToMono( red, green, blue );
3632 wxBitmap bitmap( mono, 1 );
3633 return bitmap;
3634 }
3635 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
3636 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
3637 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
3638 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
3639 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
3640 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
3641 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
3642 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
3643 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
3644 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
3645 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
3646 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
3647 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
3648 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
3649 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
3650
3651 #include <wx/quantize.h>
3652
3653 SWIGINTERN bool wxQuantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
3654 return wxQuantize::Quantize(src, dest,
3655 //NULL, // palette
3656 desiredNoColours,
3657 NULL, // eightBitData
3658 flags);
3659 }
3660 SWIGINTERN void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
3661 if (PyCallable_Check(func)) {
3662 self->Connect(id, lastId, eventType,
3663 (wxObjectEventFunction) &wxPyCallback::EventThunker,
3664 new wxPyCallback(func));
3665 }
3666 else if (func == Py_None) {
3667 self->Disconnect(id, lastId, eventType,
3668 (wxObjectEventFunction)
3669 &wxPyCallback::EventThunker);
3670 }
3671 else {
3672 wxPyBLOCK_THREADS(
3673 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
3674 }
3675 }
3676 SWIGINTERN bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
3677 return self->Disconnect(id, lastId, eventType,
3678 (wxObjectEventFunction)
3679 &wxPyCallback::EventThunker);
3680 }
3681 SWIGINTERN void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
3682 if (_self && _self != Py_None) {
3683 self->SetClientObject(new wxPyOORClientData(_self, incref));
3684 }
3685 else {
3686 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
3687 if (data) {
3688 self->SetClientObject(NULL); // This will delete it too
3689 }
3690 }
3691 }
3692
3693 #if ! wxUSE_HOTKEY
3694 #define wxEVT_HOTKEY -9999
3695 #endif
3696
3697 SWIGINTERN PyObject *wxCommandEvent_GetClientData(wxCommandEvent *self){
3698 wxPyClientData* data = (wxPyClientData*)self->GetClientObject();
3699 if (data) {
3700 Py_INCREF(data->m_obj);
3701 return data->m_obj;
3702 } else {
3703 Py_INCREF(Py_None);
3704 return Py_None;
3705 }
3706 }
3707 SWIGINTERN void wxCommandEvent_SetClientData(wxCommandEvent *self,PyObject *clientData){
3708 wxPyClientData* data = new wxPyClientData(clientData);
3709 self->SetClientObject(data);
3710 }
3711 SWIGINTERN int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
3712 #if wxUSE_UNICODE
3713 return self->GetUnicodeKey();
3714 #else
3715 return 0;
3716 #endif
3717 }
3718 SWIGINTERN void wxKeyEvent_SetUnicodeKey(wxKeyEvent *self,int uniChar){
3719 #if wxUSE_UNICODE
3720 self->m_uniChar = uniChar;
3721 #endif
3722 }
3723
3724 SWIGINTERNINLINE PyObject *
3725 SWIG_From_unsigned_SS_int (unsigned int value)
3726 {
3727 return SWIG_From_unsigned_SS_long (value);
3728 }
3729
3730
3731 SWIGINTERN int
3732 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3733 {
3734 unsigned long v;
3735 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3736 if (SWIG_IsOK(res)) {
3737 if ((v > UINT_MAX)) {
3738 return SWIG_OverflowError;
3739 } else {
3740 if (val) *val = static_cast< unsigned int >(v);
3741 }
3742 }
3743 return res;
3744 }
3745
3746 SWIGINTERN void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
3747 self->m_size = size;
3748 }
3749 SWIGINTERN PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
3750 int count = self->GetNumberOfFiles();
3751 wxString* files = self->GetFiles();
3752 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3753 PyObject* list = PyList_New(count);
3754
3755 if (!list) {
3756 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
3757 wxPyEndBlockThreads(blocked);
3758 return NULL;
3759 }
3760
3761 for (int i=0; i<count; i++) {
3762 PyList_SetItem(list, i, wx2PyString(files[i]));
3763 }
3764 wxPyEndBlockThreads(blocked);
3765 return list;
3766 }
3767
3768
3769 SWIGINTERN wxPyApp *new_wxPyApp(){
3770 wxPythonApp = new wxPyApp();
3771 return wxPythonApp;
3772 }
3773
3774 void wxApp_CleanUp() {
3775 __wxPyCleanup();
3776 }
3777
3778
3779 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
3780
3781
3782
3783
3784
3785 SWIGINTERNINLINE PyObject *
3786 SWIG_FromCharPtr(const char *cptr)
3787 {
3788 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3789 }
3790
3791
3792 #if 0 // #ifdef __WXMAC__
3793
3794 // A dummy class that raises an exception if used...
3795 class wxEventLoop
3796 {
3797 public:
3798 wxEventLoop() { wxPyRaiseNotImplemented(); }
3799 int Run() { return 0; }
3800 void Exit(int rc = 0) {}
3801 bool Pending() const { return false; }
3802 bool Dispatch() { return false; }
3803 bool IsRunning() const { return false; }
3804 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
3805 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
3806 };
3807
3808 #else
3809
3810 #include <wx/evtloop.h>
3811
3812 #endif
3813
3814
3815
3816 static const wxString wxPyPanelNameStr(wxPanelNameStr);
3817 SWIGINTERN wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
3818 SWIGINTERN void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
3819 SWIGINTERN PyObject *wxWindow_GetChildren(wxWindow *self){
3820 wxWindowList& list = self->GetChildren();
3821 return wxPy_ConvertList(&list);
3822 }
3823 SWIGINTERN void wxWindow_SetDoubleBuffered(wxWindow *self,bool on){}
3824 SWIGINTERN bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
3825 #if wxUSE_HOTKEY
3826 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
3827 #else
3828 return false;
3829 #endif
3830 }
3831 SWIGINTERN bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
3832
3833
3834
3835 return false;
3836
3837 }
3838 SWIGINTERN long wxWindow_GetHandle(wxWindow *self){
3839 return wxPyGetWinHandle(self);
3840 }
3841 SWIGINTERN void wxWindow_AssociateHandle(wxWindow *self,long handle){
3842 self->AssociateHandle((WXWidget)handle);
3843 }
3844
3845 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
3846 return wxWindow::FindWindowById(id, parent);
3847 }
3848
3849 wxWindow* wxFindWindowByName( const wxString& name,
3850 const wxWindow *parent = NULL ) {
3851 return wxWindow::FindWindowByName(name, parent);
3852 }
3853
3854 wxWindow* wxFindWindowByLabel( const wxString& label,
3855 const wxWindow *parent = NULL ) {
3856 return wxWindow::FindWindowByLabel(label, parent);
3857 }
3858
3859
3860 #ifdef __WXMSW__
3861 #include <wx/msw/private.h> // to get wxGetWindowId
3862 #endif
3863
3864
3865 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
3866 #ifdef __WXMSW__
3867 WXHWND hWnd = (WXHWND)_hWnd;
3868 long id = wxGetWindowId(hWnd);
3869 wxWindow* win = new wxWindow;
3870 if (parent)
3871 parent->AddChild(win);
3872 win->SetEventHandler(win);
3873 win->SetHWND(hWnd);
3874 win->SetId(id);
3875 win->SubclassWin(hWnd);
3876 win->AdoptAttributesFromHWND();
3877 win->SetupColours();
3878 return win;
3879 #else
3880 wxPyRaiseNotImplemented();
3881 return NULL;
3882 #endif
3883 }
3884
3885
3886 PyObject* GetTopLevelWindows() {
3887 return wxPy_ConvertList(&wxTopLevelWindows);
3888 }
3889
3890
3891 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
3892 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
3893 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
3894
3895 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
3896
3897
3898 SWIGINTERNINLINE int
3899 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3900 {
3901 unsigned long v;
3902 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3903 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3904 return res;
3905 }
3906
3907 SWIGINTERN void wxMenu_Destroy(wxMenu *self){ delete self; }
3908 SWIGINTERN PyObject *wxMenu_GetMenuItems(wxMenu *self){
3909 wxMenuItemList& list = self->GetMenuItems();
3910 return wxPy_ConvertList(&list);
3911 }
3912 SWIGINTERN void wxMenuBar_SetAutoWindowMenu(bool enable){}
3913 SWIGINTERN bool wxMenuBar_GetAutoWindowMenu(){ return false; }
3914 static const wxString wxPyControlNameStr(wxControlNameStr);
3915 SWIGINTERN int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
3916 if (clientData) {
3917 wxPyClientData* data = new wxPyClientData(clientData);
3918 return self->Append(item, data);
3919 } else
3920 return self->Append(item);
3921 }
3922 SWIGINTERN int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,unsigned int pos,PyObject *clientData=NULL){
3923 if (clientData) {
3924 wxPyClientData* data = new wxPyClientData(clientData);
3925 return self->Insert(item, pos, data);
3926 } else
3927 return self->Insert(item, pos);
3928 }
3929 SWIGINTERN PyObject *wxItemContainer_GetClientData(wxItemContainer *self,unsigned int n){
3930 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
3931 if (data) {
3932 Py_INCREF(data->m_obj);
3933 return data->m_obj;
3934 } else {
3935 Py_INCREF(Py_None);
3936 return Py_None;
3937 }
3938 }
3939 SWIGINTERN void wxItemContainer_SetClientData(wxItemContainer *self,unsigned int n,PyObject *clientData){
3940 wxPyClientData* data = new wxPyClientData(clientData);
3941 self->SetClientObject(n, data);
3942 }
3943
3944
3945 SWIGINTERN wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
3946 wxPyUserData* data = NULL;
3947 if ( userData ) {
3948 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3949 data = new wxPyUserData(userData);
3950 wxPyEndBlockThreads(blocked);
3951 }
3952 return new wxSizerItem(window, proportion, flag, border, data);
3953 }
3954 SWIGINTERN wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
3955 wxPyUserData* data = NULL;
3956 if ( userData ) {
3957 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3958 data = new wxPyUserData(userData);
3959 wxPyEndBlockThreads(blocked);
3960 }
3961 return new wxSizerItem(width, height, proportion, flag, border, data);
3962 }
3963 SWIGINTERN wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
3964 wxPyUserData* data = NULL;
3965 if ( userData ) {
3966 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3967 data = new wxPyUserData(userData);
3968 wxPyEndBlockThreads(blocked);
3969 }
3970 return new wxSizerItem(sizer, proportion, flag, border, data);
3971 }
3972
3973 SWIGINTERNINLINE PyObject *
3974 SWIG_From_float (float value)
3975 {
3976 return SWIG_From_double (value);
3977 }
3978
3979 SWIGINTERN PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
3980 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
3981 if (data) {
3982 Py_INCREF(data->m_obj);
3983 return data->m_obj;
3984 } else {
3985 Py_INCREF(Py_None);
3986 return Py_None;
3987 }
3988 }
3989 SWIGINTERN void wxSizerItem_SetUserData(wxSizerItem *self,PyObject *userData){
3990 wxPyUserData* data = NULL;
3991 if ( userData ) {
3992 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3993 data = new wxPyUserData(userData);
3994 wxPyEndBlockThreads(blocked);
3995 }
3996 self->SetUserData(data);
3997 }
3998
3999 // Figure out the type of the sizer item
4000
4001 struct wxPySizerItemInfo {
4002 wxPySizerItemInfo()
4003 : window(NULL), sizer(NULL), gotSize(false),
4004 size(wxDefaultSize), gotPos(false), pos(-1)
4005 {}
4006
4007 wxWindow* window;
4008 wxSizer* sizer;
4009 bool gotSize;
4010 wxSize size;
4011 bool gotPos;
4012 int pos;
4013 };
4014
4015 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
4016
4017 wxPySizerItemInfo info;
4018 wxSize size;
4019 wxSize* sizePtr = &size;
4020
4021 // Find out what the type of the item is
4022 // try wxWindow
4023 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
4024 PyErr_Clear();
4025 info.window = NULL;
4026
4027 // try wxSizer
4028 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
4029 PyErr_Clear();
4030 info.sizer = NULL;
4031
4032 // try wxSize or (w,h)
4033 if ( checkSize && wxSize_helper(item, &sizePtr)) {
4034 info.size = *sizePtr;
4035 info.gotSize = true;
4036 }
4037
4038 // or a single int
4039 if (checkIdx && PyInt_Check(item)) {
4040 info.pos = PyInt_AsLong(item);
4041 info.gotPos = true;
4042 }
4043 }
4044 }
4045
4046 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
4047 // no expected type, figure out what kind of error message to generate
4048 if ( !checkSize && !checkIdx )
4049 PyErr_SetString(PyExc_TypeError, "wx.Window or wx.Sizer expected for item");
4050 else if ( checkSize && !checkIdx )
4051 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) expected for item");
4052 else if ( !checkSize && checkIdx)
4053 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer or int (position) expected for item");
4054 else
4055 // can this one happen?
4056 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) or int (position) expected for item");
4057 }
4058
4059 return info;
4060 }
4061
4062 SWIGINTERN void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
4063 if (!self->GetClientObject())
4064 self->SetClientObject(new wxPyOORClientData(_self));
4065 }
4066 SWIGINTERN wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4067
4068 wxPyUserData* data = NULL;
4069 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4070 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4071 if ( userData && (info.window || info.sizer || info.gotSize) )
4072 data = new wxPyUserData(userData);
4073 if ( info.sizer )
4074 PyObject_SetAttrString(item,"thisown",Py_False);
4075 wxPyEndBlockThreads(blocked);
4076
4077 // Now call the real Add method if a valid item type was found
4078 if ( info.window )
4079 return self->Add(info.window, proportion, flag, border, data);
4080 else if ( info.sizer )
4081 return self->Add(info.sizer, proportion, flag, border, data);
4082 else if (info.gotSize)
4083 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
4084 proportion, flag, border, data);
4085 else
4086 return NULL;
4087 }
4088 SWIGINTERN wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4089
4090 wxPyUserData* data = NULL;
4091 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4092 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4093 if ( userData && (info.window || info.sizer || info.gotSize) )
4094 data = new wxPyUserData(userData);
4095 if ( info.sizer )
4096 PyObject_SetAttrString(item,"thisown",Py_False);
4097 wxPyEndBlockThreads(blocked);
4098
4099 // Now call the real Insert method if a valid item type was found
4100 if ( info.window )
4101 return self->Insert(before, info.window, proportion, flag, border, data);
4102 else if ( info.sizer )
4103 return self->Insert(before, info.sizer, proportion, flag, border, data);
4104 else if (info.gotSize)
4105 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
4106 proportion, flag, border, data);
4107 else
4108 return NULL;
4109 }
4110 SWIGINTERN wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4111
4112 wxPyUserData* data = NULL;
4113 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4114 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4115 if ( userData && (info.window || info.sizer || info.gotSize) )
4116 data = new wxPyUserData(userData);
4117 if ( info.sizer )
4118 PyObject_SetAttrString(item,"thisown",Py_False);
4119 wxPyEndBlockThreads(blocked);
4120
4121 // Now call the real Prepend method if a valid item type was found
4122 if ( info.window )
4123 return self->Prepend(info.window, proportion, flag, border, data);
4124 else if ( info.sizer )
4125 return self->Prepend(info.sizer, proportion, flag, border, data);
4126 else if (info.gotSize)
4127 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
4128 proportion, flag, border, data);
4129 else
4130 return NULL;
4131 }
4132 SWIGINTERN bool wxSizer_Remove(wxSizer *self,PyObject *item){
4133 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4134 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4135 wxPyEndBlockThreads(blocked);
4136 if ( info.window )
4137 return self->Remove(info.window);
4138 else if ( info.sizer )
4139 return self->Remove(info.sizer);
4140 else if ( info.gotPos )
4141 return self->Remove(info.pos);
4142 else
4143 return false;
4144 }
4145 SWIGINTERN bool wxSizer_Detach(wxSizer *self,PyObject *item){
4146 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4147 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4148 wxPyEndBlockThreads(blocked);
4149 if ( info.window )
4150 return self->Detach(info.window);
4151 else if ( info.sizer )
4152 return self->Detach(info.sizer);
4153 else if ( info.gotPos )
4154 return self->Detach(info.pos);
4155 else
4156 return false;
4157 }
4158 SWIGINTERN wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
4159 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4160 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4161 wxPyEndBlockThreads(blocked);
4162 if ( info.window )
4163 return self->GetItem(info.window);
4164 else if ( info.sizer )
4165 return self->GetItem(info.sizer);
4166 else if ( info.gotPos )
4167 return self->GetItem(info.pos);
4168 else
4169 return NULL;
4170 }
4171 SWIGINTERN void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
4172 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4173 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4174 wxPyEndBlockThreads(blocked);
4175 if ( info.window )
4176 self->SetItemMinSize(info.window, size);
4177 else if ( info.sizer )
4178 self->SetItemMinSize(info.sizer, size);
4179 else if ( info.gotPos )
4180 self->SetItemMinSize(info.pos, size);
4181 }
4182 SWIGINTERN PyObject *wxSizer_GetChildren(wxSizer *self){
4183 wxSizerItemList& list = self->GetChildren();
4184 return wxPy_ConvertList(&list);
4185 }
4186 SWIGINTERN bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
4187 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4188 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4189 wxPyEndBlockThreads(blocked);
4190 if ( info.window )
4191 return self->Show(info.window, show, recursive);
4192 else if ( info.sizer )
4193 return self->Show(info.sizer, show, recursive);
4194 else if ( info.gotPos )
4195 return self->Show(info.pos, show);
4196 else
4197 return false;
4198 }
4199 SWIGINTERN bool wxSizer_IsShown(wxSizer *self,PyObject *item){
4200 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4201 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
4202 wxPyEndBlockThreads(blocked);
4203 if ( info.window )
4204 return self->IsShown(info.window);
4205 else if ( info.sizer )
4206 return self->IsShown(info.sizer);
4207 else if ( info.gotPos )
4208 return self->IsShown(info.pos);
4209 else
4210 return false;
4211 }
4212
4213 // See pyclasses.h
4214 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
4215 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
4216 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
4217
4218
4219
4220
4221 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
4222 {
4223 if (source == Py_None) {
4224 **obj = wxGBPosition(-1,-1);
4225 return true;
4226 }
4227 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
4228 }
4229
4230 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
4231 {
4232 if (source == Py_None) {
4233 **obj = wxGBSpan(-1,-1);
4234 return true;
4235 }
4236 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
4237 }
4238
4239
4240 SWIGINTERN bool wxGBPosition___eq__(wxGBPosition *self,PyObject *other){
4241 wxGBPosition temp, *obj = &temp;
4242 if ( other == Py_None ) return false;
4243 if ( ! wxGBPosition_helper(other, &obj) ) {
4244 PyErr_Clear();
4245 return false;
4246 }
4247 return self->operator==(*obj);
4248 }
4249 SWIGINTERN bool wxGBPosition___ne__(wxGBPosition *self,PyObject *other){
4250 wxGBPosition temp, *obj = &temp;
4251 if ( other == Py_None ) return true;
4252 if ( ! wxGBPosition_helper(other, &obj)) {
4253 PyErr_Clear();
4254 return true;
4255 }
4256 return self->operator!=(*obj);
4257 }
4258 SWIGINTERN void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
4259 self->SetRow(row);
4260 self->SetCol(col);
4261 }
4262 SWIGINTERN PyObject *wxGBPosition_Get(wxGBPosition *self){
4263 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4264 PyObject* tup = PyTuple_New(2);
4265 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
4266 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
4267 wxPyEndBlockThreads(blocked);
4268 return tup;
4269 }
4270 SWIGINTERN bool wxGBSpan___eq__(wxGBSpan *self,PyObject *other){
4271 wxGBSpan temp, *obj = &temp;
4272 if ( other == Py_None ) return false;
4273 if ( ! wxGBSpan_helper(other, &obj) ) {
4274 PyErr_Clear();
4275 return false;
4276 }
4277 return self->operator==(*obj);
4278 }
4279 SWIGINTERN bool wxGBSpan___ne__(wxGBSpan *self,PyObject *other){
4280 wxGBSpan temp, *obj = &temp;
4281 if ( other == Py_None ) return true;
4282 if ( ! wxGBSpan_helper(other, &obj)) {
4283 PyErr_Clear();
4284 return true;
4285 }
4286 return self->operator!=(*obj);
4287 }
4288 SWIGINTERN void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
4289 self->SetRowspan(rowspan);
4290 self->SetColspan(colspan);
4291 }
4292 SWIGINTERN PyObject *wxGBSpan_Get(wxGBSpan *self){
4293 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4294 PyObject* tup = PyTuple_New(2);
4295 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
4296 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
4297 wxPyEndBlockThreads(blocked);
4298 return tup;
4299 }
4300 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4301 wxPyUserData* data = NULL;
4302 if ( userData ) {
4303 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4304 data = new wxPyUserData(userData);
4305 wxPyEndBlockThreads(blocked);
4306 }
4307 return new wxGBSizerItem(window, pos, span, flag, border, data);
4308 }
4309 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4310 wxPyUserData* data = NULL;
4311 if ( userData ) {
4312 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4313 data = new wxPyUserData(userData);
4314 wxPyEndBlockThreads(blocked);
4315 }
4316 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
4317 }
4318 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4319 wxPyUserData* data = NULL;
4320 if ( userData ) {
4321 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4322 data = new wxPyUserData(userData);
4323 wxPyEndBlockThreads(blocked);
4324 }
4325 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
4326 }
4327 SWIGINTERN wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
4328 int row, col;
4329 self->GetEndPos(row, col);
4330 return wxGBPosition(row, col);
4331 }
4332 SWIGINTERN wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
4333
4334 wxPyUserData* data = NULL;
4335 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4336 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4337 if ( userData && (info.window || info.sizer || info.gotSize) )
4338 data = new wxPyUserData(userData);
4339 if ( info.sizer )
4340 PyObject_SetAttrString(item,"thisown",Py_False);
4341 wxPyEndBlockThreads(blocked);
4342
4343 // Now call the real Add method if a valid item type was found
4344 if ( info.window )
4345 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
4346 else if ( info.sizer )
4347 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
4348 else if (info.gotSize)
4349 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
4350 pos, span, flag, border, data);
4351 return NULL;
4352 }
4353
4354
4355 #ifdef __cplusplus
4356 extern "C" {
4357 #endif
4358 SWIGINTERN int EmptyString_set(PyObject *) {
4359 SWIG_Error(SWIG_AttributeError,"Variable EmptyString is read-only.");
4360 return 1;
4361 }
4362
4363
4364 SWIGINTERN PyObject *EmptyString_get(void) {
4365 PyObject *pyobj = 0;
4366
4367 {
4368 #if wxUSE_UNICODE
4369 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4370 #else
4371 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4372 #endif
4373 }
4374 return pyobj;
4375 }
4376
4377
4378 SWIGINTERN PyObject *_wrap_Object_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4379 PyObject *resultobj = 0;
4380 wxObject *arg1 = (wxObject *) 0 ;
4381 wxString result;
4382 void *argp1 = 0 ;
4383 int res1 = 0 ;
4384 PyObject *swig_obj[1] ;
4385
4386 if (!args) SWIG_fail;
4387 swig_obj[0] = args;
4388 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4389 if (!SWIG_IsOK(res1)) {
4390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_GetClassName" "', expected argument " "1"" of type '" "wxObject *""'");
4391 }
4392 arg1 = reinterpret_cast< wxObject * >(argp1);
4393 {
4394 PyThreadState* __tstate = wxPyBeginAllowThreads();
4395 result = wxObject_GetClassName(arg1);
4396 wxPyEndAllowThreads(__tstate);
4397 if (PyErr_Occurred()) SWIG_fail;
4398 }
4399 {
4400 #if wxUSE_UNICODE
4401 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4402 #else
4403 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4404 #endif
4405 }
4406 return resultobj;
4407 fail:
4408 return NULL;
4409 }
4410
4411
4412 SWIGINTERN PyObject *_wrap_Object_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4413 PyObject *resultobj = 0;
4414 wxObject *arg1 = (wxObject *) 0 ;
4415 void *argp1 = 0 ;
4416 int res1 = 0 ;
4417 PyObject *swig_obj[1] ;
4418
4419 if (!args) SWIG_fail;
4420 swig_obj[0] = args;
4421 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4422 if (!SWIG_IsOK(res1)) {
4423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_Destroy" "', expected argument " "1"" of type '" "wxObject *""'");
4424 }
4425 arg1 = reinterpret_cast< wxObject * >(argp1);
4426 {
4427 PyThreadState* __tstate = wxPyBeginAllowThreads();
4428 wxObject_Destroy(arg1);
4429 wxPyEndAllowThreads(__tstate);
4430 if (PyErr_Occurred()) SWIG_fail;
4431 }
4432 resultobj = SWIG_Py_Void();
4433 return resultobj;
4434 fail:
4435 return NULL;
4436 }
4437
4438
4439 SWIGINTERN PyObject *Object_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4440 PyObject *obj;
4441 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4442 SWIG_TypeNewClientData(SWIGTYPE_p_wxObject, SWIG_NewClientData(obj));
4443 return SWIG_Py_Void();
4444 }
4445
4446 SWIGINTERN PyObject *_wrap_Size_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4447 PyObject *resultobj = 0;
4448 wxSize *arg1 = (wxSize *) 0 ;
4449 int arg2 ;
4450 void *argp1 = 0 ;
4451 int res1 = 0 ;
4452 int val2 ;
4453 int ecode2 = 0 ;
4454 PyObject *swig_obj[2] ;
4455
4456 if (!SWIG_Python_UnpackTuple(args,"Size_width_set",2,2,swig_obj)) SWIG_fail;
4457 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4458 if (!SWIG_IsOK(res1)) {
4459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_set" "', expected argument " "1"" of type '" "wxSize *""'");
4460 }
4461 arg1 = reinterpret_cast< wxSize * >(argp1);
4462 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4463 if (!SWIG_IsOK(ecode2)) {
4464 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_width_set" "', expected argument " "2"" of type '" "int""'");
4465 }
4466 arg2 = static_cast< int >(val2);
4467 if (arg1) (arg1)->x = arg2;
4468
4469 resultobj = SWIG_Py_Void();
4470 return resultobj;
4471 fail:
4472 return NULL;
4473 }
4474
4475
4476 SWIGINTERN PyObject *_wrap_Size_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4477 PyObject *resultobj = 0;
4478 wxSize *arg1 = (wxSize *) 0 ;
4479 int result;
4480 void *argp1 = 0 ;
4481 int res1 = 0 ;
4482 PyObject *swig_obj[1] ;
4483
4484 if (!args) SWIG_fail;
4485 swig_obj[0] = args;
4486 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4487 if (!SWIG_IsOK(res1)) {
4488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_get" "', expected argument " "1"" of type '" "wxSize *""'");
4489 }
4490 arg1 = reinterpret_cast< wxSize * >(argp1);
4491 result = (int) ((arg1)->x);
4492 resultobj = SWIG_From_int(static_cast< int >(result));
4493 return resultobj;
4494 fail:
4495 return NULL;
4496 }
4497
4498
4499 SWIGINTERN PyObject *_wrap_Size_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4500 PyObject *resultobj = 0;
4501 wxSize *arg1 = (wxSize *) 0 ;
4502 int arg2 ;
4503 void *argp1 = 0 ;
4504 int res1 = 0 ;
4505 int val2 ;
4506 int ecode2 = 0 ;
4507 PyObject *swig_obj[2] ;
4508
4509 if (!SWIG_Python_UnpackTuple(args,"Size_height_set",2,2,swig_obj)) SWIG_fail;
4510 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4511 if (!SWIG_IsOK(res1)) {
4512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_set" "', expected argument " "1"" of type '" "wxSize *""'");
4513 }
4514 arg1 = reinterpret_cast< wxSize * >(argp1);
4515 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4516 if (!SWIG_IsOK(ecode2)) {
4517 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_height_set" "', expected argument " "2"" of type '" "int""'");
4518 }
4519 arg2 = static_cast< int >(val2);
4520 if (arg1) (arg1)->y = arg2;
4521
4522 resultobj = SWIG_Py_Void();
4523 return resultobj;
4524 fail:
4525 return NULL;
4526 }
4527
4528
4529 SWIGINTERN PyObject *_wrap_Size_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4530 PyObject *resultobj = 0;
4531 wxSize *arg1 = (wxSize *) 0 ;
4532 int result;
4533 void *argp1 = 0 ;
4534 int res1 = 0 ;
4535 PyObject *swig_obj[1] ;
4536
4537 if (!args) SWIG_fail;
4538 swig_obj[0] = args;
4539 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4540 if (!SWIG_IsOK(res1)) {
4541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_get" "', expected argument " "1"" of type '" "wxSize *""'");
4542 }
4543 arg1 = reinterpret_cast< wxSize * >(argp1);
4544 result = (int) ((arg1)->y);
4545 resultobj = SWIG_From_int(static_cast< int >(result));
4546 return resultobj;
4547 fail:
4548 return NULL;
4549 }
4550
4551
4552 SWIGINTERN PyObject *_wrap_new_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4553 PyObject *resultobj = 0;
4554 int arg1 = (int) 0 ;
4555 int arg2 = (int) 0 ;
4556 wxSize *result = 0 ;
4557 int val1 ;
4558 int ecode1 = 0 ;
4559 int val2 ;
4560 int ecode2 = 0 ;
4561 PyObject * obj0 = 0 ;
4562 PyObject * obj1 = 0 ;
4563 char * kwnames[] = {
4564 (char *) "w",(char *) "h", NULL
4565 };
4566
4567 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) SWIG_fail;
4568 if (obj0) {
4569 ecode1 = SWIG_AsVal_int(obj0, &val1);
4570 if (!SWIG_IsOK(ecode1)) {
4571 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Size" "', expected argument " "1"" of type '" "int""'");
4572 }
4573 arg1 = static_cast< int >(val1);
4574 }
4575 if (obj1) {
4576 ecode2 = SWIG_AsVal_int(obj1, &val2);
4577 if (!SWIG_IsOK(ecode2)) {
4578 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Size" "', expected argument " "2"" of type '" "int""'");
4579 }
4580 arg2 = static_cast< int >(val2);
4581 }
4582 {
4583 PyThreadState* __tstate = wxPyBeginAllowThreads();
4584 result = (wxSize *)new wxSize(arg1,arg2);
4585 wxPyEndAllowThreads(__tstate);
4586 if (PyErr_Occurred()) SWIG_fail;
4587 }
4588 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, SWIG_POINTER_NEW | 0 );
4589 return resultobj;
4590 fail:
4591 return NULL;
4592 }
4593
4594
4595 SWIGINTERN PyObject *_wrap_delete_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4596 PyObject *resultobj = 0;
4597 wxSize *arg1 = (wxSize *) 0 ;
4598 void *argp1 = 0 ;
4599 int res1 = 0 ;
4600 PyObject *swig_obj[1] ;
4601
4602 if (!args) SWIG_fail;
4603 swig_obj[0] = args;
4604 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, SWIG_POINTER_DISOWN | 0 );
4605 if (!SWIG_IsOK(res1)) {
4606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Size" "', expected argument " "1"" of type '" "wxSize *""'");
4607 }
4608 arg1 = reinterpret_cast< wxSize * >(argp1);
4609 {
4610 PyThreadState* __tstate = wxPyBeginAllowThreads();
4611 delete arg1;
4612
4613 wxPyEndAllowThreads(__tstate);
4614 if (PyErr_Occurred()) SWIG_fail;
4615 }
4616 resultobj = SWIG_Py_Void();
4617 return resultobj;
4618 fail:
4619 return NULL;
4620 }
4621
4622
4623 SWIGINTERN PyObject *_wrap_Size___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4624 PyObject *resultobj = 0;
4625 wxSize *arg1 = (wxSize *) 0 ;
4626 PyObject *arg2 = (PyObject *) 0 ;
4627 bool result;
4628 void *argp1 = 0 ;
4629 int res1 = 0 ;
4630 PyObject * obj0 = 0 ;
4631 PyObject * obj1 = 0 ;
4632 char * kwnames[] = {
4633 (char *) "self",(char *) "other", NULL
4634 };
4635
4636 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
4637 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4638 if (!SWIG_IsOK(res1)) {
4639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___eq__" "', expected argument " "1"" of type '" "wxSize *""'");
4640 }
4641 arg1 = reinterpret_cast< wxSize * >(argp1);
4642 arg2 = obj1;
4643 {
4644 result = (bool)wxSize___eq__(arg1,arg2);
4645 if (PyErr_Occurred()) SWIG_fail;
4646 }
4647 {
4648 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4649 }
4650 return resultobj;
4651 fail:
4652 return NULL;
4653 }
4654
4655
4656 SWIGINTERN PyObject *_wrap_Size___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4657 PyObject *resultobj = 0;
4658 wxSize *arg1 = (wxSize *) 0 ;
4659 PyObject *arg2 = (PyObject *) 0 ;
4660 bool result;
4661 void *argp1 = 0 ;
4662 int res1 = 0 ;
4663 PyObject * obj0 = 0 ;
4664 PyObject * obj1 = 0 ;
4665 char * kwnames[] = {
4666 (char *) "self",(char *) "other", NULL
4667 };
4668
4669 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
4670 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4671 if (!SWIG_IsOK(res1)) {
4672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___ne__" "', expected argument " "1"" of type '" "wxSize *""'");
4673 }
4674 arg1 = reinterpret_cast< wxSize * >(argp1);
4675 arg2 = obj1;
4676 {
4677 result = (bool)wxSize___ne__(arg1,arg2);
4678 if (PyErr_Occurred()) SWIG_fail;
4679 }
4680 {
4681 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4682 }
4683 return resultobj;
4684 fail:
4685 return NULL;
4686 }
4687
4688
4689 SWIGINTERN PyObject *_wrap_Size___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4690 PyObject *resultobj = 0;
4691 wxSize *arg1 = (wxSize *) 0 ;
4692 wxSize *arg2 = 0 ;
4693 wxSize result;
4694 void *argp1 = 0 ;
4695 int res1 = 0 ;
4696 wxSize temp2 ;
4697 PyObject * obj0 = 0 ;
4698 PyObject * obj1 = 0 ;
4699 char * kwnames[] = {
4700 (char *) "self",(char *) "sz", NULL
4701 };
4702
4703 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) SWIG_fail;
4704 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4705 if (!SWIG_IsOK(res1)) {
4706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___add__" "', expected argument " "1"" of type '" "wxSize *""'");
4707 }
4708 arg1 = reinterpret_cast< wxSize * >(argp1);
4709 {
4710 arg2 = &temp2;
4711 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4712 }
4713 {
4714 PyThreadState* __tstate = wxPyBeginAllowThreads();
4715 result = (arg1)->operator +((wxSize const &)*arg2);
4716 wxPyEndAllowThreads(__tstate);
4717 if (PyErr_Occurred()) SWIG_fail;
4718 }
4719 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4720 return resultobj;
4721 fail:
4722 return NULL;
4723 }
4724
4725
4726 SWIGINTERN PyObject *_wrap_Size___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4727 PyObject *resultobj = 0;
4728 wxSize *arg1 = (wxSize *) 0 ;
4729 wxSize *arg2 = 0 ;
4730 wxSize result;
4731 void *argp1 = 0 ;
4732 int res1 = 0 ;
4733 wxSize temp2 ;
4734 PyObject * obj0 = 0 ;
4735 PyObject * obj1 = 0 ;
4736 char * kwnames[] = {
4737 (char *) "self",(char *) "sz", NULL
4738 };
4739
4740 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
4741 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4742 if (!SWIG_IsOK(res1)) {
4743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___sub__" "', expected argument " "1"" of type '" "wxSize *""'");
4744 }
4745 arg1 = reinterpret_cast< wxSize * >(argp1);
4746 {
4747 arg2 = &temp2;
4748 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4749 }
4750 {
4751 PyThreadState* __tstate = wxPyBeginAllowThreads();
4752 result = (arg1)->operator -((wxSize const &)*arg2);
4753 wxPyEndAllowThreads(__tstate);
4754 if (PyErr_Occurred()) SWIG_fail;
4755 }
4756 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4757 return resultobj;
4758 fail:
4759 return NULL;
4760 }
4761
4762
4763 SWIGINTERN PyObject *_wrap_Size_IncTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4764 PyObject *resultobj = 0;
4765 wxSize *arg1 = (wxSize *) 0 ;
4766 wxSize *arg2 = 0 ;
4767 void *argp1 = 0 ;
4768 int res1 = 0 ;
4769 wxSize temp2 ;
4770 PyObject * obj0 = 0 ;
4771 PyObject * obj1 = 0 ;
4772 char * kwnames[] = {
4773 (char *) "self",(char *) "sz", NULL
4774 };
4775
4776 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) SWIG_fail;
4777 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4778 if (!SWIG_IsOK(res1)) {
4779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncTo" "', expected argument " "1"" of type '" "wxSize *""'");
4780 }
4781 arg1 = reinterpret_cast< wxSize * >(argp1);
4782 {
4783 arg2 = &temp2;
4784 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4785 }
4786 {
4787 PyThreadState* __tstate = wxPyBeginAllowThreads();
4788 (arg1)->IncTo((wxSize const &)*arg2);
4789 wxPyEndAllowThreads(__tstate);
4790 if (PyErr_Occurred()) SWIG_fail;
4791 }
4792 resultobj = SWIG_Py_Void();
4793 return resultobj;
4794 fail:
4795 return NULL;
4796 }
4797
4798
4799 SWIGINTERN PyObject *_wrap_Size_DecTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4800 PyObject *resultobj = 0;
4801 wxSize *arg1 = (wxSize *) 0 ;
4802 wxSize *arg2 = 0 ;
4803 void *argp1 = 0 ;
4804 int res1 = 0 ;
4805 wxSize temp2 ;
4806 PyObject * obj0 = 0 ;
4807 PyObject * obj1 = 0 ;
4808 char * kwnames[] = {
4809 (char *) "self",(char *) "sz", NULL
4810 };
4811
4812 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) SWIG_fail;
4813 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4814 if (!SWIG_IsOK(res1)) {
4815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecTo" "', expected argument " "1"" of type '" "wxSize *""'");
4816 }
4817 arg1 = reinterpret_cast< wxSize * >(argp1);
4818 {
4819 arg2 = &temp2;
4820 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4821 }
4822 {
4823 PyThreadState* __tstate = wxPyBeginAllowThreads();
4824 (arg1)->DecTo((wxSize const &)*arg2);
4825 wxPyEndAllowThreads(__tstate);
4826 if (PyErr_Occurred()) SWIG_fail;
4827 }
4828 resultobj = SWIG_Py_Void();
4829 return resultobj;
4830 fail:
4831 return NULL;
4832 }
4833
4834
4835 SWIGINTERN PyObject *_wrap_Size_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4836 PyObject *resultobj = 0;
4837 wxSize *arg1 = (wxSize *) 0 ;
4838 float arg2 ;
4839 float arg3 ;
4840 void *argp1 = 0 ;
4841 int res1 = 0 ;
4842 float val2 ;
4843 int ecode2 = 0 ;
4844 float val3 ;
4845 int ecode3 = 0 ;
4846 PyObject * obj0 = 0 ;
4847 PyObject * obj1 = 0 ;
4848 PyObject * obj2 = 0 ;
4849 char * kwnames[] = {
4850 (char *) "self",(char *) "xscale",(char *) "yscale", NULL
4851 };
4852
4853 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4854 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4855 if (!SWIG_IsOK(res1)) {
4856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Scale" "', expected argument " "1"" of type '" "wxSize *""'");
4857 }
4858 arg1 = reinterpret_cast< wxSize * >(argp1);
4859 ecode2 = SWIG_AsVal_float(obj1, &val2);
4860 if (!SWIG_IsOK(ecode2)) {
4861 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Scale" "', expected argument " "2"" of type '" "float""'");
4862 }
4863 arg2 = static_cast< float >(val2);
4864 ecode3 = SWIG_AsVal_float(obj2, &val3);
4865 if (!SWIG_IsOK(ecode3)) {
4866 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Scale" "', expected argument " "3"" of type '" "float""'");
4867 }
4868 arg3 = static_cast< float >(val3);
4869 {
4870 PyThreadState* __tstate = wxPyBeginAllowThreads();
4871 (arg1)->Scale(arg2,arg3);
4872 wxPyEndAllowThreads(__tstate);
4873 if (PyErr_Occurred()) SWIG_fail;
4874 }
4875 resultobj = SWIG_Py_Void();
4876 return resultobj;
4877 fail:
4878 return NULL;
4879 }
4880
4881
4882 SWIGINTERN PyObject *_wrap_Size_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4883 PyObject *resultobj = 0;
4884 wxSize *arg1 = (wxSize *) 0 ;
4885 int arg2 ;
4886 int arg3 ;
4887 void *argp1 = 0 ;
4888 int res1 = 0 ;
4889 int val2 ;
4890 int ecode2 = 0 ;
4891 int val3 ;
4892 int ecode3 = 0 ;
4893 PyObject * obj0 = 0 ;
4894 PyObject * obj1 = 0 ;
4895 PyObject * obj2 = 0 ;
4896 char * kwnames[] = {
4897 (char *) "self",(char *) "w",(char *) "h", NULL
4898 };
4899
4900 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) 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_Set" "', 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_Set" "', expected argument " "2"" of type '" "int""'");
4909 }
4910 arg2 = static_cast< int >(val2);
4911 ecode3 = SWIG_AsVal_int(obj2, &val3);
4912 if (!SWIG_IsOK(ecode3)) {
4913 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Set" "', expected argument " "3"" of type '" "int""'");
4914 }
4915 arg3 = static_cast< int >(val3);
4916 {
4917 PyThreadState* __tstate = wxPyBeginAllowThreads();
4918 (arg1)->Set(arg2,arg3);
4919 wxPyEndAllowThreads(__tstate);
4920 if (PyErr_Occurred()) SWIG_fail;
4921 }
4922 resultobj = SWIG_Py_Void();
4923 return resultobj;
4924 fail:
4925 return NULL;
4926 }
4927
4928
4929 SWIGINTERN PyObject *_wrap_Size_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4930 PyObject *resultobj = 0;
4931 wxSize *arg1 = (wxSize *) 0 ;
4932 int arg2 ;
4933 void *argp1 = 0 ;
4934 int res1 = 0 ;
4935 int val2 ;
4936 int ecode2 = 0 ;
4937 PyObject * obj0 = 0 ;
4938 PyObject * obj1 = 0 ;
4939 char * kwnames[] = {
4940 (char *) "self",(char *) "w", NULL
4941 };
4942
4943 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
4944 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4945 if (!SWIG_IsOK(res1)) {
4946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetWidth" "', expected argument " "1"" of type '" "wxSize *""'");
4947 }
4948 arg1 = reinterpret_cast< wxSize * >(argp1);
4949 ecode2 = SWIG_AsVal_int(obj1, &val2);
4950 if (!SWIG_IsOK(ecode2)) {
4951 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetWidth" "', expected argument " "2"" of type '" "int""'");
4952 }
4953 arg2 = static_cast< int >(val2);
4954 {
4955 PyThreadState* __tstate = wxPyBeginAllowThreads();
4956 (arg1)->SetWidth(arg2);
4957 wxPyEndAllowThreads(__tstate);
4958 if (PyErr_Occurred()) SWIG_fail;
4959 }
4960 resultobj = SWIG_Py_Void();
4961 return resultobj;
4962 fail:
4963 return NULL;
4964 }
4965
4966
4967 SWIGINTERN PyObject *_wrap_Size_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4968 PyObject *resultobj = 0;
4969 wxSize *arg1 = (wxSize *) 0 ;
4970 int arg2 ;
4971 void *argp1 = 0 ;
4972 int res1 = 0 ;
4973 int val2 ;
4974 int ecode2 = 0 ;
4975 PyObject * obj0 = 0 ;
4976 PyObject * obj1 = 0 ;
4977 char * kwnames[] = {
4978 (char *) "self",(char *) "h", NULL
4979 };
4980
4981 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
4982 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4983 if (!SWIG_IsOK(res1)) {
4984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetHeight" "', expected argument " "1"" of type '" "wxSize *""'");
4985 }
4986 arg1 = reinterpret_cast< wxSize * >(argp1);
4987 ecode2 = SWIG_AsVal_int(obj1, &val2);
4988 if (!SWIG_IsOK(ecode2)) {
4989 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetHeight" "', expected argument " "2"" of type '" "int""'");
4990 }
4991 arg2 = static_cast< int >(val2);
4992 {
4993 PyThreadState* __tstate = wxPyBeginAllowThreads();
4994 (arg1)->SetHeight(arg2);
4995 wxPyEndAllowThreads(__tstate);
4996 if (PyErr_Occurred()) SWIG_fail;
4997 }
4998 resultobj = SWIG_Py_Void();
4999 return resultobj;
5000 fail:
5001 return NULL;
5002 }
5003
5004
5005 SWIGINTERN PyObject *_wrap_Size_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5006 PyObject *resultobj = 0;
5007 wxSize *arg1 = (wxSize *) 0 ;
5008 int result;
5009 void *argp1 = 0 ;
5010 int res1 = 0 ;
5011 PyObject *swig_obj[1] ;
5012
5013 if (!args) SWIG_fail;
5014 swig_obj[0] = args;
5015 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5016 if (!SWIG_IsOK(res1)) {
5017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetWidth" "', expected argument " "1"" of type '" "wxSize const *""'");
5018 }
5019 arg1 = reinterpret_cast< wxSize * >(argp1);
5020 {
5021 PyThreadState* __tstate = wxPyBeginAllowThreads();
5022 result = (int)((wxSize const *)arg1)->GetWidth();
5023 wxPyEndAllowThreads(__tstate);
5024 if (PyErr_Occurred()) SWIG_fail;
5025 }
5026 resultobj = SWIG_From_int(static_cast< int >(result));
5027 return resultobj;
5028 fail:
5029 return NULL;
5030 }
5031
5032
5033 SWIGINTERN PyObject *_wrap_Size_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5034 PyObject *resultobj = 0;
5035 wxSize *arg1 = (wxSize *) 0 ;
5036 int result;
5037 void *argp1 = 0 ;
5038 int res1 = 0 ;
5039 PyObject *swig_obj[1] ;
5040
5041 if (!args) SWIG_fail;
5042 swig_obj[0] = args;
5043 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5044 if (!SWIG_IsOK(res1)) {
5045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetHeight" "', expected argument " "1"" of type '" "wxSize const *""'");
5046 }
5047 arg1 = reinterpret_cast< wxSize * >(argp1);
5048 {
5049 PyThreadState* __tstate = wxPyBeginAllowThreads();
5050 result = (int)((wxSize const *)arg1)->GetHeight();
5051 wxPyEndAllowThreads(__tstate);
5052 if (PyErr_Occurred()) SWIG_fail;
5053 }
5054 resultobj = SWIG_From_int(static_cast< int >(result));
5055 return resultobj;
5056 fail:
5057 return NULL;
5058 }
5059
5060
5061 SWIGINTERN PyObject *_wrap_Size_IsFullySpecified(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5062 PyObject *resultobj = 0;
5063 wxSize *arg1 = (wxSize *) 0 ;
5064 bool result;
5065 void *argp1 = 0 ;
5066 int res1 = 0 ;
5067 PyObject *swig_obj[1] ;
5068
5069 if (!args) SWIG_fail;
5070 swig_obj[0] = args;
5071 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5072 if (!SWIG_IsOK(res1)) {
5073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IsFullySpecified" "', expected argument " "1"" of type '" "wxSize const *""'");
5074 }
5075 arg1 = reinterpret_cast< wxSize * >(argp1);
5076 {
5077 PyThreadState* __tstate = wxPyBeginAllowThreads();
5078 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
5079 wxPyEndAllowThreads(__tstate);
5080 if (PyErr_Occurred()) SWIG_fail;
5081 }
5082 {
5083 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5084 }
5085 return resultobj;
5086 fail:
5087 return NULL;
5088 }
5089
5090
5091 SWIGINTERN PyObject *_wrap_Size_SetDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5092 PyObject *resultobj = 0;
5093 wxSize *arg1 = (wxSize *) 0 ;
5094 wxSize *arg2 = 0 ;
5095 void *argp1 = 0 ;
5096 int res1 = 0 ;
5097 wxSize temp2 ;
5098 PyObject * obj0 = 0 ;
5099 PyObject * obj1 = 0 ;
5100 char * kwnames[] = {
5101 (char *) "self",(char *) "size", NULL
5102 };
5103
5104 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
5105 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5106 if (!SWIG_IsOK(res1)) {
5107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetDefaults" "', expected argument " "1"" of type '" "wxSize *""'");
5108 }
5109 arg1 = reinterpret_cast< wxSize * >(argp1);
5110 {
5111 arg2 = &temp2;
5112 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5113 }
5114 {
5115 PyThreadState* __tstate = wxPyBeginAllowThreads();
5116 (arg1)->SetDefaults((wxSize const &)*arg2);
5117 wxPyEndAllowThreads(__tstate);
5118 if (PyErr_Occurred()) SWIG_fail;
5119 }
5120 resultobj = SWIG_Py_Void();
5121 return resultobj;
5122 fail:
5123 return NULL;
5124 }
5125
5126
5127 SWIGINTERN PyObject *_wrap_Size_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5128 PyObject *resultobj = 0;
5129 wxSize *arg1 = (wxSize *) 0 ;
5130 PyObject *result = 0 ;
5131 void *argp1 = 0 ;
5132 int res1 = 0 ;
5133 PyObject *swig_obj[1] ;
5134
5135 if (!args) SWIG_fail;
5136 swig_obj[0] = args;
5137 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5138 if (!SWIG_IsOK(res1)) {
5139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Get" "', expected argument " "1"" of type '" "wxSize *""'");
5140 }
5141 arg1 = reinterpret_cast< wxSize * >(argp1);
5142 {
5143 PyThreadState* __tstate = wxPyBeginAllowThreads();
5144 result = (PyObject *)wxSize_Get(arg1);
5145 wxPyEndAllowThreads(__tstate);
5146 if (PyErr_Occurred()) SWIG_fail;
5147 }
5148 resultobj = result;
5149 return resultobj;
5150 fail:
5151 return NULL;
5152 }
5153
5154
5155 SWIGINTERN PyObject *Size_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5156 PyObject *obj;
5157 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5158 SWIG_TypeNewClientData(SWIGTYPE_p_wxSize, SWIG_NewClientData(obj));
5159 return SWIG_Py_Void();
5160 }
5161
5162 SWIGINTERN PyObject *Size_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5163 return SWIG_Python_InitShadowInstance(args);
5164 }
5165
5166 SWIGINTERN PyObject *_wrap_RealPoint_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5167 PyObject *resultobj = 0;
5168 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5169 double arg2 ;
5170 void *argp1 = 0 ;
5171 int res1 = 0 ;
5172 double val2 ;
5173 int ecode2 = 0 ;
5174 PyObject *swig_obj[2] ;
5175
5176 if (!SWIG_Python_UnpackTuple(args,"RealPoint_x_set",2,2,swig_obj)) SWIG_fail;
5177 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5178 if (!SWIG_IsOK(res1)) {
5179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5180 }
5181 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5182 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5183 if (!SWIG_IsOK(ecode2)) {
5184 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_x_set" "', expected argument " "2"" of type '" "double""'");
5185 }
5186 arg2 = static_cast< double >(val2);
5187 if (arg1) (arg1)->x = arg2;
5188
5189 resultobj = SWIG_Py_Void();
5190 return resultobj;
5191 fail:
5192 return NULL;
5193 }
5194
5195
5196 SWIGINTERN PyObject *_wrap_RealPoint_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5197 PyObject *resultobj = 0;
5198 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5199 double result;
5200 void *argp1 = 0 ;
5201 int res1 = 0 ;
5202 PyObject *swig_obj[1] ;
5203
5204 if (!args) SWIG_fail;
5205 swig_obj[0] = args;
5206 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5207 if (!SWIG_IsOK(res1)) {
5208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5209 }
5210 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5211 result = (double) ((arg1)->x);
5212 resultobj = SWIG_From_double(static_cast< double >(result));
5213 return resultobj;
5214 fail:
5215 return NULL;
5216 }
5217
5218
5219 SWIGINTERN PyObject *_wrap_RealPoint_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5220 PyObject *resultobj = 0;
5221 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5222 double arg2 ;
5223 void *argp1 = 0 ;
5224 int res1 = 0 ;
5225 double val2 ;
5226 int ecode2 = 0 ;
5227 PyObject *swig_obj[2] ;
5228
5229 if (!SWIG_Python_UnpackTuple(args,"RealPoint_y_set",2,2,swig_obj)) SWIG_fail;
5230 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5231 if (!SWIG_IsOK(res1)) {
5232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5233 }
5234 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5235 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5236 if (!SWIG_IsOK(ecode2)) {
5237 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_y_set" "', expected argument " "2"" of type '" "double""'");
5238 }
5239 arg2 = static_cast< double >(val2);
5240 if (arg1) (arg1)->y = arg2;
5241
5242 resultobj = SWIG_Py_Void();
5243 return resultobj;
5244 fail:
5245 return NULL;
5246 }
5247
5248
5249 SWIGINTERN PyObject *_wrap_RealPoint_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5250 PyObject *resultobj = 0;
5251 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5252 double result;
5253 void *argp1 = 0 ;
5254 int res1 = 0 ;
5255 PyObject *swig_obj[1] ;
5256
5257 if (!args) SWIG_fail;
5258 swig_obj[0] = args;
5259 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5260 if (!SWIG_IsOK(res1)) {
5261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5262 }
5263 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5264 result = (double) ((arg1)->y);
5265 resultobj = SWIG_From_double(static_cast< double >(result));
5266 return resultobj;
5267 fail:
5268 return NULL;
5269 }
5270
5271
5272 SWIGINTERN PyObject *_wrap_new_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5273 PyObject *resultobj = 0;
5274 double arg1 = (double) 0.0 ;
5275 double arg2 = (double) 0.0 ;
5276 wxRealPoint *result = 0 ;
5277 double val1 ;
5278 int ecode1 = 0 ;
5279 double val2 ;
5280 int ecode2 = 0 ;
5281 PyObject * obj0 = 0 ;
5282 PyObject * obj1 = 0 ;
5283 char * kwnames[] = {
5284 (char *) "x",(char *) "y", NULL
5285 };
5286
5287 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) SWIG_fail;
5288 if (obj0) {
5289 ecode1 = SWIG_AsVal_double(obj0, &val1);
5290 if (!SWIG_IsOK(ecode1)) {
5291 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RealPoint" "', expected argument " "1"" of type '" "double""'");
5292 }
5293 arg1 = static_cast< double >(val1);
5294 }
5295 if (obj1) {
5296 ecode2 = SWIG_AsVal_double(obj1, &val2);
5297 if (!SWIG_IsOK(ecode2)) {
5298 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RealPoint" "', expected argument " "2"" of type '" "double""'");
5299 }
5300 arg2 = static_cast< double >(val2);
5301 }
5302 {
5303 PyThreadState* __tstate = wxPyBeginAllowThreads();
5304 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
5305 wxPyEndAllowThreads(__tstate);
5306 if (PyErr_Occurred()) SWIG_fail;
5307 }
5308 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_NEW | 0 );
5309 return resultobj;
5310 fail:
5311 return NULL;
5312 }
5313
5314
5315 SWIGINTERN PyObject *_wrap_delete_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5316 PyObject *resultobj = 0;
5317 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5318 void *argp1 = 0 ;
5319 int res1 = 0 ;
5320 PyObject *swig_obj[1] ;
5321
5322 if (!args) SWIG_fail;
5323 swig_obj[0] = args;
5324 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, SWIG_POINTER_DISOWN | 0 );
5325 if (!SWIG_IsOK(res1)) {
5326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RealPoint" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5327 }
5328 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5329 {
5330 PyThreadState* __tstate = wxPyBeginAllowThreads();
5331 delete arg1;
5332
5333 wxPyEndAllowThreads(__tstate);
5334 if (PyErr_Occurred()) SWIG_fail;
5335 }
5336 resultobj = SWIG_Py_Void();
5337 return resultobj;
5338 fail:
5339 return NULL;
5340 }
5341
5342
5343 SWIGINTERN PyObject *_wrap_RealPoint___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5344 PyObject *resultobj = 0;
5345 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5346 PyObject *arg2 = (PyObject *) 0 ;
5347 bool result;
5348 void *argp1 = 0 ;
5349 int res1 = 0 ;
5350 PyObject * obj0 = 0 ;
5351 PyObject * obj1 = 0 ;
5352 char * kwnames[] = {
5353 (char *) "self",(char *) "other", NULL
5354 };
5355
5356 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5357 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5358 if (!SWIG_IsOK(res1)) {
5359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___eq__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5360 }
5361 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5362 arg2 = obj1;
5363 {
5364 result = (bool)wxRealPoint___eq__(arg1,arg2);
5365 if (PyErr_Occurred()) SWIG_fail;
5366 }
5367 {
5368 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5369 }
5370 return resultobj;
5371 fail:
5372 return NULL;
5373 }
5374
5375
5376 SWIGINTERN PyObject *_wrap_RealPoint___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5377 PyObject *resultobj = 0;
5378 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5379 PyObject *arg2 = (PyObject *) 0 ;
5380 bool result;
5381 void *argp1 = 0 ;
5382 int res1 = 0 ;
5383 PyObject * obj0 = 0 ;
5384 PyObject * obj1 = 0 ;
5385 char * kwnames[] = {
5386 (char *) "self",(char *) "other", NULL
5387 };
5388
5389 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5390 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5391 if (!SWIG_IsOK(res1)) {
5392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___ne__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5393 }
5394 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5395 arg2 = obj1;
5396 {
5397 result = (bool)wxRealPoint___ne__(arg1,arg2);
5398 if (PyErr_Occurred()) SWIG_fail;
5399 }
5400 {
5401 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5402 }
5403 return resultobj;
5404 fail:
5405 return NULL;
5406 }
5407
5408
5409 SWIGINTERN PyObject *_wrap_RealPoint___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5410 PyObject *resultobj = 0;
5411 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5412 wxRealPoint *arg2 = 0 ;
5413 wxRealPoint result;
5414 void *argp1 = 0 ;
5415 int res1 = 0 ;
5416 wxRealPoint temp2 ;
5417 PyObject * obj0 = 0 ;
5418 PyObject * obj1 = 0 ;
5419 char * kwnames[] = {
5420 (char *) "self",(char *) "pt", NULL
5421 };
5422
5423 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5424 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5425 if (!SWIG_IsOK(res1)) {
5426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___add__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5427 }
5428 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5429 {
5430 arg2 = &temp2;
5431 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5432 }
5433 {
5434 PyThreadState* __tstate = wxPyBeginAllowThreads();
5435 result = (arg1)->operator +((wxRealPoint const &)*arg2);
5436 wxPyEndAllowThreads(__tstate);
5437 if (PyErr_Occurred()) SWIG_fail;
5438 }
5439 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5440 return resultobj;
5441 fail:
5442 return NULL;
5443 }
5444
5445
5446 SWIGINTERN PyObject *_wrap_RealPoint___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5447 PyObject *resultobj = 0;
5448 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5449 wxRealPoint *arg2 = 0 ;
5450 wxRealPoint result;
5451 void *argp1 = 0 ;
5452 int res1 = 0 ;
5453 wxRealPoint temp2 ;
5454 PyObject * obj0 = 0 ;
5455 PyObject * obj1 = 0 ;
5456 char * kwnames[] = {
5457 (char *) "self",(char *) "pt", NULL
5458 };
5459
5460 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5461 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5462 if (!SWIG_IsOK(res1)) {
5463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___sub__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5464 }
5465 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5466 {
5467 arg2 = &temp2;
5468 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5469 }
5470 {
5471 PyThreadState* __tstate = wxPyBeginAllowThreads();
5472 result = (arg1)->operator -((wxRealPoint const &)*arg2);
5473 wxPyEndAllowThreads(__tstate);
5474 if (PyErr_Occurred()) SWIG_fail;
5475 }
5476 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5477 return resultobj;
5478 fail:
5479 return NULL;
5480 }
5481
5482
5483 SWIGINTERN PyObject *_wrap_RealPoint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5484 PyObject *resultobj = 0;
5485 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5486 double arg2 ;
5487 double arg3 ;
5488 void *argp1 = 0 ;
5489 int res1 = 0 ;
5490 double val2 ;
5491 int ecode2 = 0 ;
5492 double val3 ;
5493 int ecode3 = 0 ;
5494 PyObject * obj0 = 0 ;
5495 PyObject * obj1 = 0 ;
5496 PyObject * obj2 = 0 ;
5497 char * kwnames[] = {
5498 (char *) "self",(char *) "x",(char *) "y", NULL
5499 };
5500
5501 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5502 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5503 if (!SWIG_IsOK(res1)) {
5504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5505 }
5506 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5507 ecode2 = SWIG_AsVal_double(obj1, &val2);
5508 if (!SWIG_IsOK(ecode2)) {
5509 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_Set" "', expected argument " "2"" of type '" "double""'");
5510 }
5511 arg2 = static_cast< double >(val2);
5512 ecode3 = SWIG_AsVal_double(obj2, &val3);
5513 if (!SWIG_IsOK(ecode3)) {
5514 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RealPoint_Set" "', expected argument " "3"" of type '" "double""'");
5515 }
5516 arg3 = static_cast< double >(val3);
5517 {
5518 PyThreadState* __tstate = wxPyBeginAllowThreads();
5519 wxRealPoint_Set(arg1,arg2,arg3);
5520 wxPyEndAllowThreads(__tstate);
5521 if (PyErr_Occurred()) SWIG_fail;
5522 }
5523 resultobj = SWIG_Py_Void();
5524 return resultobj;
5525 fail:
5526 return NULL;
5527 }
5528
5529
5530 SWIGINTERN PyObject *_wrap_RealPoint_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5531 PyObject *resultobj = 0;
5532 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5533 PyObject *result = 0 ;
5534 void *argp1 = 0 ;
5535 int res1 = 0 ;
5536 PyObject *swig_obj[1] ;
5537
5538 if (!args) SWIG_fail;
5539 swig_obj[0] = args;
5540 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5541 if (!SWIG_IsOK(res1)) {
5542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5543 }
5544 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5545 {
5546 PyThreadState* __tstate = wxPyBeginAllowThreads();
5547 result = (PyObject *)wxRealPoint_Get(arg1);
5548 wxPyEndAllowThreads(__tstate);
5549 if (PyErr_Occurred()) SWIG_fail;
5550 }
5551 resultobj = result;
5552 return resultobj;
5553 fail:
5554 return NULL;
5555 }
5556
5557
5558 SWIGINTERN PyObject *RealPoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5559 PyObject *obj;
5560 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5561 SWIG_TypeNewClientData(SWIGTYPE_p_wxRealPoint, SWIG_NewClientData(obj));
5562 return SWIG_Py_Void();
5563 }
5564
5565 SWIGINTERN PyObject *RealPoint_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5566 return SWIG_Python_InitShadowInstance(args);
5567 }
5568
5569 SWIGINTERN PyObject *_wrap_Point_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5570 PyObject *resultobj = 0;
5571 wxPoint *arg1 = (wxPoint *) 0 ;
5572 int arg2 ;
5573 void *argp1 = 0 ;
5574 int res1 = 0 ;
5575 int val2 ;
5576 int ecode2 = 0 ;
5577 PyObject *swig_obj[2] ;
5578
5579 if (!SWIG_Python_UnpackTuple(args,"Point_x_set",2,2,swig_obj)) SWIG_fail;
5580 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5581 if (!SWIG_IsOK(res1)) {
5582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5583 }
5584 arg1 = reinterpret_cast< wxPoint * >(argp1);
5585 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5586 if (!SWIG_IsOK(ecode2)) {
5587 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_x_set" "', expected argument " "2"" of type '" "int""'");
5588 }
5589 arg2 = static_cast< int >(val2);
5590 if (arg1) (arg1)->x = arg2;
5591
5592 resultobj = SWIG_Py_Void();
5593 return resultobj;
5594 fail:
5595 return NULL;
5596 }
5597
5598
5599 SWIGINTERN PyObject *_wrap_Point_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5600 PyObject *resultobj = 0;
5601 wxPoint *arg1 = (wxPoint *) 0 ;
5602 int result;
5603 void *argp1 = 0 ;
5604 int res1 = 0 ;
5605 PyObject *swig_obj[1] ;
5606
5607 if (!args) SWIG_fail;
5608 swig_obj[0] = args;
5609 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5610 if (!SWIG_IsOK(res1)) {
5611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5612 }
5613 arg1 = reinterpret_cast< wxPoint * >(argp1);
5614 result = (int) ((arg1)->x);
5615 resultobj = SWIG_From_int(static_cast< int >(result));
5616 return resultobj;
5617 fail:
5618 return NULL;
5619 }
5620
5621
5622 SWIGINTERN PyObject *_wrap_Point_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5623 PyObject *resultobj = 0;
5624 wxPoint *arg1 = (wxPoint *) 0 ;
5625 int arg2 ;
5626 void *argp1 = 0 ;
5627 int res1 = 0 ;
5628 int val2 ;
5629 int ecode2 = 0 ;
5630 PyObject *swig_obj[2] ;
5631
5632 if (!SWIG_Python_UnpackTuple(args,"Point_y_set",2,2,swig_obj)) SWIG_fail;
5633 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5634 if (!SWIG_IsOK(res1)) {
5635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5636 }
5637 arg1 = reinterpret_cast< wxPoint * >(argp1);
5638 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5639 if (!SWIG_IsOK(ecode2)) {
5640 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_y_set" "', expected argument " "2"" of type '" "int""'");
5641 }
5642 arg2 = static_cast< int >(val2);
5643 if (arg1) (arg1)->y = arg2;
5644
5645 resultobj = SWIG_Py_Void();
5646 return resultobj;
5647 fail:
5648 return NULL;
5649 }
5650
5651
5652 SWIGINTERN PyObject *_wrap_Point_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5653 PyObject *resultobj = 0;
5654 wxPoint *arg1 = (wxPoint *) 0 ;
5655 int result;
5656 void *argp1 = 0 ;
5657 int res1 = 0 ;
5658 PyObject *swig_obj[1] ;
5659
5660 if (!args) SWIG_fail;
5661 swig_obj[0] = args;
5662 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5663 if (!SWIG_IsOK(res1)) {
5664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5665 }
5666 arg1 = reinterpret_cast< wxPoint * >(argp1);
5667 result = (int) ((arg1)->y);
5668 resultobj = SWIG_From_int(static_cast< int >(result));
5669 return resultobj;
5670 fail:
5671 return NULL;
5672 }
5673
5674
5675 SWIGINTERN PyObject *_wrap_new_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5676 PyObject *resultobj = 0;
5677 int arg1 = (int) 0 ;
5678 int arg2 = (int) 0 ;
5679 wxPoint *result = 0 ;
5680 int val1 ;
5681 int ecode1 = 0 ;
5682 int val2 ;
5683 int ecode2 = 0 ;
5684 PyObject * obj0 = 0 ;
5685 PyObject * obj1 = 0 ;
5686 char * kwnames[] = {
5687 (char *) "x",(char *) "y", NULL
5688 };
5689
5690 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) SWIG_fail;
5691 if (obj0) {
5692 ecode1 = SWIG_AsVal_int(obj0, &val1);
5693 if (!SWIG_IsOK(ecode1)) {
5694 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point" "', expected argument " "1"" of type '" "int""'");
5695 }
5696 arg1 = static_cast< int >(val1);
5697 }
5698 if (obj1) {
5699 ecode2 = SWIG_AsVal_int(obj1, &val2);
5700 if (!SWIG_IsOK(ecode2)) {
5701 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point" "', expected argument " "2"" of type '" "int""'");
5702 }
5703 arg2 = static_cast< int >(val2);
5704 }
5705 {
5706 PyThreadState* __tstate = wxPyBeginAllowThreads();
5707 result = (wxPoint *)new wxPoint(arg1,arg2);
5708 wxPyEndAllowThreads(__tstate);
5709 if (PyErr_Occurred()) SWIG_fail;
5710 }
5711 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_NEW | 0 );
5712 return resultobj;
5713 fail:
5714 return NULL;
5715 }
5716
5717
5718 SWIGINTERN PyObject *_wrap_delete_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5719 PyObject *resultobj = 0;
5720 wxPoint *arg1 = (wxPoint *) 0 ;
5721 void *argp1 = 0 ;
5722 int res1 = 0 ;
5723 PyObject *swig_obj[1] ;
5724
5725 if (!args) SWIG_fail;
5726 swig_obj[0] = args;
5727 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5728 if (!SWIG_IsOK(res1)) {
5729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point" "', expected argument " "1"" of type '" "wxPoint *""'");
5730 }
5731 arg1 = reinterpret_cast< wxPoint * >(argp1);
5732 {
5733 PyThreadState* __tstate = wxPyBeginAllowThreads();
5734 delete arg1;
5735
5736 wxPyEndAllowThreads(__tstate);
5737 if (PyErr_Occurred()) SWIG_fail;
5738 }
5739 resultobj = SWIG_Py_Void();
5740 return resultobj;
5741 fail:
5742 return NULL;
5743 }
5744
5745
5746 SWIGINTERN PyObject *_wrap_Point___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5747 PyObject *resultobj = 0;
5748 wxPoint *arg1 = (wxPoint *) 0 ;
5749 PyObject *arg2 = (PyObject *) 0 ;
5750 bool result;
5751 void *argp1 = 0 ;
5752 int res1 = 0 ;
5753 PyObject * obj0 = 0 ;
5754 PyObject * obj1 = 0 ;
5755 char * kwnames[] = {
5756 (char *) "self",(char *) "other", NULL
5757 };
5758
5759 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5760 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5761 if (!SWIG_IsOK(res1)) {
5762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___eq__" "', expected argument " "1"" of type '" "wxPoint *""'");
5763 }
5764 arg1 = reinterpret_cast< wxPoint * >(argp1);
5765 arg2 = obj1;
5766 {
5767 result = (bool)wxPoint___eq__(arg1,arg2);
5768 if (PyErr_Occurred()) SWIG_fail;
5769 }
5770 {
5771 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5772 }
5773 return resultobj;
5774 fail:
5775 return NULL;
5776 }
5777
5778
5779 SWIGINTERN PyObject *_wrap_Point___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5780 PyObject *resultobj = 0;
5781 wxPoint *arg1 = (wxPoint *) 0 ;
5782 PyObject *arg2 = (PyObject *) 0 ;
5783 bool result;
5784 void *argp1 = 0 ;
5785 int res1 = 0 ;
5786 PyObject * obj0 = 0 ;
5787 PyObject * obj1 = 0 ;
5788 char * kwnames[] = {
5789 (char *) "self",(char *) "other", NULL
5790 };
5791
5792 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5793 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5794 if (!SWIG_IsOK(res1)) {
5795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___ne__" "', expected argument " "1"" of type '" "wxPoint *""'");
5796 }
5797 arg1 = reinterpret_cast< wxPoint * >(argp1);
5798 arg2 = obj1;
5799 {
5800 result = (bool)wxPoint___ne__(arg1,arg2);
5801 if (PyErr_Occurred()) SWIG_fail;
5802 }
5803 {
5804 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5805 }
5806 return resultobj;
5807 fail:
5808 return NULL;
5809 }
5810
5811
5812 SWIGINTERN PyObject *_wrap_Point___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5813 PyObject *resultobj = 0;
5814 wxPoint *arg1 = (wxPoint *) 0 ;
5815 wxPoint *arg2 = 0 ;
5816 wxPoint result;
5817 void *argp1 = 0 ;
5818 int res1 = 0 ;
5819 wxPoint temp2 ;
5820 PyObject * obj0 = 0 ;
5821 PyObject * obj1 = 0 ;
5822 char * kwnames[] = {
5823 (char *) "self",(char *) "pt", NULL
5824 };
5825
5826 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5827 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5828 if (!SWIG_IsOK(res1)) {
5829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___add__" "', expected argument " "1"" of type '" "wxPoint *""'");
5830 }
5831 arg1 = reinterpret_cast< wxPoint * >(argp1);
5832 {
5833 arg2 = &temp2;
5834 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5835 }
5836 {
5837 PyThreadState* __tstate = wxPyBeginAllowThreads();
5838 result = (arg1)->operator +((wxPoint const &)*arg2);
5839 wxPyEndAllowThreads(__tstate);
5840 if (PyErr_Occurred()) SWIG_fail;
5841 }
5842 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5843 return resultobj;
5844 fail:
5845 return NULL;
5846 }
5847
5848
5849 SWIGINTERN PyObject *_wrap_Point___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5850 PyObject *resultobj = 0;
5851 wxPoint *arg1 = (wxPoint *) 0 ;
5852 wxPoint *arg2 = 0 ;
5853 wxPoint result;
5854 void *argp1 = 0 ;
5855 int res1 = 0 ;
5856 wxPoint temp2 ;
5857 PyObject * obj0 = 0 ;
5858 PyObject * obj1 = 0 ;
5859 char * kwnames[] = {
5860 (char *) "self",(char *) "pt", NULL
5861 };
5862
5863 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5864 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5865 if (!SWIG_IsOK(res1)) {
5866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___sub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5867 }
5868 arg1 = reinterpret_cast< wxPoint * >(argp1);
5869 {
5870 arg2 = &temp2;
5871 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5872 }
5873 {
5874 PyThreadState* __tstate = wxPyBeginAllowThreads();
5875 result = (arg1)->operator -((wxPoint const &)*arg2);
5876 wxPyEndAllowThreads(__tstate);
5877 if (PyErr_Occurred()) SWIG_fail;
5878 }
5879 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5880 return resultobj;
5881 fail:
5882 return NULL;
5883 }
5884
5885
5886 SWIGINTERN PyObject *_wrap_Point___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5887 PyObject *resultobj = 0;
5888 wxPoint *arg1 = (wxPoint *) 0 ;
5889 wxPoint *arg2 = 0 ;
5890 wxPoint *result = 0 ;
5891 void *argp1 = 0 ;
5892 int res1 = 0 ;
5893 wxPoint temp2 ;
5894 PyObject * obj0 = 0 ;
5895 PyObject * obj1 = 0 ;
5896 char * kwnames[] = {
5897 (char *) "self",(char *) "pt", NULL
5898 };
5899
5900 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
5901 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5902 if (!SWIG_IsOK(res1)) {
5903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___iadd__" "', expected argument " "1"" of type '" "wxPoint *""'");
5904 }
5905 arg1 = reinterpret_cast< wxPoint * >(argp1);
5906 {
5907 arg2 = &temp2;
5908 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5909 }
5910 {
5911 PyThreadState* __tstate = wxPyBeginAllowThreads();
5912 {
5913 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
5914 result = (wxPoint *) &_result_ref;
5915 }
5916 wxPyEndAllowThreads(__tstate);
5917 if (PyErr_Occurred()) SWIG_fail;
5918 }
5919 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5920 return resultobj;
5921 fail:
5922 return NULL;
5923 }
5924
5925
5926 SWIGINTERN PyObject *_wrap_Point___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5927 PyObject *resultobj = 0;
5928 wxPoint *arg1 = (wxPoint *) 0 ;
5929 wxPoint *arg2 = 0 ;
5930 wxPoint *result = 0 ;
5931 void *argp1 = 0 ;
5932 int res1 = 0 ;
5933 wxPoint temp2 ;
5934 PyObject * obj0 = 0 ;
5935 PyObject * obj1 = 0 ;
5936 char * kwnames[] = {
5937 (char *) "self",(char *) "pt", NULL
5938 };
5939
5940 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
5941 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5942 if (!SWIG_IsOK(res1)) {
5943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___isub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5944 }
5945 arg1 = reinterpret_cast< wxPoint * >(argp1);
5946 {
5947 arg2 = &temp2;
5948 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5949 }
5950 {
5951 PyThreadState* __tstate = wxPyBeginAllowThreads();
5952 {
5953 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
5954 result = (wxPoint *) &_result_ref;
5955 }
5956 wxPyEndAllowThreads(__tstate);
5957 if (PyErr_Occurred()) SWIG_fail;
5958 }
5959 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5960 return resultobj;
5961 fail:
5962 return NULL;
5963 }
5964
5965
5966 SWIGINTERN PyObject *_wrap_Point_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5967 PyObject *resultobj = 0;
5968 wxPoint *arg1 = (wxPoint *) 0 ;
5969 long arg2 ;
5970 long arg3 ;
5971 void *argp1 = 0 ;
5972 int res1 = 0 ;
5973 long val2 ;
5974 int ecode2 = 0 ;
5975 long val3 ;
5976 int ecode3 = 0 ;
5977 PyObject * obj0 = 0 ;
5978 PyObject * obj1 = 0 ;
5979 PyObject * obj2 = 0 ;
5980 char * kwnames[] = {
5981 (char *) "self",(char *) "x",(char *) "y", NULL
5982 };
5983
5984 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5985 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5986 if (!SWIG_IsOK(res1)) {
5987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Set" "', expected argument " "1"" of type '" "wxPoint *""'");
5988 }
5989 arg1 = reinterpret_cast< wxPoint * >(argp1);
5990 ecode2 = SWIG_AsVal_long(obj1, &val2);
5991 if (!SWIG_IsOK(ecode2)) {
5992 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_Set" "', expected argument " "2"" of type '" "long""'");
5993 }
5994 arg2 = static_cast< long >(val2);
5995 ecode3 = SWIG_AsVal_long(obj2, &val3);
5996 if (!SWIG_IsOK(ecode3)) {
5997 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point_Set" "', expected argument " "3"" of type '" "long""'");
5998 }
5999 arg3 = static_cast< long >(val3);
6000 {
6001 PyThreadState* __tstate = wxPyBeginAllowThreads();
6002 wxPoint_Set(arg1,arg2,arg3);
6003 wxPyEndAllowThreads(__tstate);
6004 if (PyErr_Occurred()) SWIG_fail;
6005 }
6006 resultobj = SWIG_Py_Void();
6007 return resultobj;
6008 fail:
6009 return NULL;
6010 }
6011
6012
6013 SWIGINTERN PyObject *_wrap_Point_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6014 PyObject *resultobj = 0;
6015 wxPoint *arg1 = (wxPoint *) 0 ;
6016 PyObject *result = 0 ;
6017 void *argp1 = 0 ;
6018 int res1 = 0 ;
6019 PyObject *swig_obj[1] ;
6020
6021 if (!args) SWIG_fail;
6022 swig_obj[0] = args;
6023 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6024 if (!SWIG_IsOK(res1)) {
6025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Get" "', expected argument " "1"" of type '" "wxPoint *""'");
6026 }
6027 arg1 = reinterpret_cast< wxPoint * >(argp1);
6028 {
6029 PyThreadState* __tstate = wxPyBeginAllowThreads();
6030 result = (PyObject *)wxPoint_Get(arg1);
6031 wxPyEndAllowThreads(__tstate);
6032 if (PyErr_Occurred()) SWIG_fail;
6033 }
6034 resultobj = result;
6035 return resultobj;
6036 fail:
6037 return NULL;
6038 }
6039
6040
6041 SWIGINTERN PyObject *Point_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6042 PyObject *obj;
6043 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
6044 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint, SWIG_NewClientData(obj));
6045 return SWIG_Py_Void();
6046 }
6047
6048 SWIGINTERN PyObject *Point_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6049 return SWIG_Python_InitShadowInstance(args);
6050 }
6051
6052 SWIGINTERN PyObject *_wrap_new_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6053 PyObject *resultobj = 0;
6054 int arg1 = (int) 0 ;
6055 int arg2 = (int) 0 ;
6056 int arg3 = (int) 0 ;
6057 int arg4 = (int) 0 ;
6058 wxRect *result = 0 ;
6059 int val1 ;
6060 int ecode1 = 0 ;
6061 int val2 ;
6062 int ecode2 = 0 ;
6063 int val3 ;
6064 int ecode3 = 0 ;
6065 int val4 ;
6066 int ecode4 = 0 ;
6067 PyObject * obj0 = 0 ;
6068 PyObject * obj1 = 0 ;
6069 PyObject * obj2 = 0 ;
6070 PyObject * obj3 = 0 ;
6071 char * kwnames[] = {
6072 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6073 };
6074
6075 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6076 if (obj0) {
6077 ecode1 = SWIG_AsVal_int(obj0, &val1);
6078 if (!SWIG_IsOK(ecode1)) {
6079 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Rect" "', expected argument " "1"" of type '" "int""'");
6080 }
6081 arg1 = static_cast< int >(val1);
6082 }
6083 if (obj1) {
6084 ecode2 = SWIG_AsVal_int(obj1, &val2);
6085 if (!SWIG_IsOK(ecode2)) {
6086 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Rect" "', expected argument " "2"" of type '" "int""'");
6087 }
6088 arg2 = static_cast< int >(val2);
6089 }
6090 if (obj2) {
6091 ecode3 = SWIG_AsVal_int(obj2, &val3);
6092 if (!SWIG_IsOK(ecode3)) {
6093 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Rect" "', expected argument " "3"" of type '" "int""'");
6094 }
6095 arg3 = static_cast< int >(val3);
6096 }
6097 if (obj3) {
6098 ecode4 = SWIG_AsVal_int(obj3, &val4);
6099 if (!SWIG_IsOK(ecode4)) {
6100 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Rect" "', expected argument " "4"" of type '" "int""'");
6101 }
6102 arg4 = static_cast< int >(val4);
6103 }
6104 {
6105 PyThreadState* __tstate = wxPyBeginAllowThreads();
6106 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
6107 wxPyEndAllowThreads(__tstate);
6108 if (PyErr_Occurred()) SWIG_fail;
6109 }
6110 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_NEW | 0 );
6111 return resultobj;
6112 fail:
6113 return NULL;
6114 }
6115
6116
6117 SWIGINTERN PyObject *_wrap_new_RectPP(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6118 PyObject *resultobj = 0;
6119 wxPoint *arg1 = 0 ;
6120 wxPoint *arg2 = 0 ;
6121 wxRect *result = 0 ;
6122 wxPoint temp1 ;
6123 wxPoint temp2 ;
6124 PyObject * obj0 = 0 ;
6125 PyObject * obj1 = 0 ;
6126 char * kwnames[] = {
6127 (char *) "topLeft",(char *) "bottomRight", NULL
6128 };
6129
6130 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) SWIG_fail;
6131 {
6132 arg1 = &temp1;
6133 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6134 }
6135 {
6136 arg2 = &temp2;
6137 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6138 }
6139 {
6140 PyThreadState* __tstate = wxPyBeginAllowThreads();
6141 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
6142 wxPyEndAllowThreads(__tstate);
6143 if (PyErr_Occurred()) SWIG_fail;
6144 }
6145 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6146 return resultobj;
6147 fail:
6148 return NULL;
6149 }
6150
6151
6152 SWIGINTERN PyObject *_wrap_new_RectPS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6153 PyObject *resultobj = 0;
6154 wxPoint *arg1 = 0 ;
6155 wxSize *arg2 = 0 ;
6156 wxRect *result = 0 ;
6157 wxPoint temp1 ;
6158 wxSize temp2 ;
6159 PyObject * obj0 = 0 ;
6160 PyObject * obj1 = 0 ;
6161 char * kwnames[] = {
6162 (char *) "pos",(char *) "size", NULL
6163 };
6164
6165 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) SWIG_fail;
6166 {
6167 arg1 = &temp1;
6168 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6169 }
6170 {
6171 arg2 = &temp2;
6172 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6173 }
6174 {
6175 PyThreadState* __tstate = wxPyBeginAllowThreads();
6176 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
6177 wxPyEndAllowThreads(__tstate);
6178 if (PyErr_Occurred()) SWIG_fail;
6179 }
6180 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6181 return resultobj;
6182 fail:
6183 return NULL;
6184 }
6185
6186
6187 SWIGINTERN PyObject *_wrap_new_RectS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6188 PyObject *resultobj = 0;
6189 wxSize *arg1 = 0 ;
6190 wxRect *result = 0 ;
6191 wxSize temp1 ;
6192 PyObject * obj0 = 0 ;
6193 char * kwnames[] = {
6194 (char *) "size", NULL
6195 };
6196
6197 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) SWIG_fail;
6198 {
6199 arg1 = &temp1;
6200 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
6201 }
6202 {
6203 PyThreadState* __tstate = wxPyBeginAllowThreads();
6204 result = (wxRect *)new wxRect((wxSize const &)*arg1);
6205 wxPyEndAllowThreads(__tstate);
6206 if (PyErr_Occurred()) SWIG_fail;
6207 }
6208 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6209 return resultobj;
6210 fail:
6211 return NULL;
6212 }
6213
6214
6215 SWIGINTERN PyObject *_wrap_delete_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6216 PyObject *resultobj = 0;
6217 wxRect *arg1 = (wxRect *) 0 ;
6218 void *argp1 = 0 ;
6219 int res1 = 0 ;
6220 PyObject *swig_obj[1] ;
6221
6222 if (!args) SWIG_fail;
6223 swig_obj[0] = args;
6224 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
6225 if (!SWIG_IsOK(res1)) {
6226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect" "', expected argument " "1"" of type '" "wxRect *""'");
6227 }
6228 arg1 = reinterpret_cast< wxRect * >(argp1);
6229 {
6230 PyThreadState* __tstate = wxPyBeginAllowThreads();
6231 delete arg1;
6232
6233 wxPyEndAllowThreads(__tstate);
6234 if (PyErr_Occurred()) SWIG_fail;
6235 }
6236 resultobj = SWIG_Py_Void();
6237 return resultobj;
6238 fail:
6239 return NULL;
6240 }
6241
6242
6243 SWIGINTERN PyObject *_wrap_Rect_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6244 PyObject *resultobj = 0;
6245 wxRect *arg1 = (wxRect *) 0 ;
6246 int result;
6247 void *argp1 = 0 ;
6248 int res1 = 0 ;
6249 PyObject *swig_obj[1] ;
6250
6251 if (!args) SWIG_fail;
6252 swig_obj[0] = args;
6253 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6254 if (!SWIG_IsOK(res1)) {
6255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetX" "', expected argument " "1"" of type '" "wxRect const *""'");
6256 }
6257 arg1 = reinterpret_cast< wxRect * >(argp1);
6258 {
6259 PyThreadState* __tstate = wxPyBeginAllowThreads();
6260 result = (int)((wxRect const *)arg1)->GetX();
6261 wxPyEndAllowThreads(__tstate);
6262 if (PyErr_Occurred()) SWIG_fail;
6263 }
6264 resultobj = SWIG_From_int(static_cast< int >(result));
6265 return resultobj;
6266 fail:
6267 return NULL;
6268 }
6269
6270
6271 SWIGINTERN PyObject *_wrap_Rect_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6272 PyObject *resultobj = 0;
6273 wxRect *arg1 = (wxRect *) 0 ;
6274 int arg2 ;
6275 void *argp1 = 0 ;
6276 int res1 = 0 ;
6277 int val2 ;
6278 int ecode2 = 0 ;
6279 PyObject * obj0 = 0 ;
6280 PyObject * obj1 = 0 ;
6281 char * kwnames[] = {
6282 (char *) "self",(char *) "x", NULL
6283 };
6284
6285 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
6286 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6287 if (!SWIG_IsOK(res1)) {
6288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetX" "', expected argument " "1"" of type '" "wxRect *""'");
6289 }
6290 arg1 = reinterpret_cast< wxRect * >(argp1);
6291 ecode2 = SWIG_AsVal_int(obj1, &val2);
6292 if (!SWIG_IsOK(ecode2)) {
6293 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetX" "', expected argument " "2"" of type '" "int""'");
6294 }
6295 arg2 = static_cast< int >(val2);
6296 {
6297 PyThreadState* __tstate = wxPyBeginAllowThreads();
6298 (arg1)->SetX(arg2);
6299 wxPyEndAllowThreads(__tstate);
6300 if (PyErr_Occurred()) SWIG_fail;
6301 }
6302 resultobj = SWIG_Py_Void();
6303 return resultobj;
6304 fail:
6305 return NULL;
6306 }
6307
6308
6309 SWIGINTERN PyObject *_wrap_Rect_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6310 PyObject *resultobj = 0;
6311 wxRect *arg1 = (wxRect *) 0 ;
6312 int result;
6313 void *argp1 = 0 ;
6314 int res1 = 0 ;
6315 PyObject *swig_obj[1] ;
6316
6317 if (!args) SWIG_fail;
6318 swig_obj[0] = args;
6319 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6320 if (!SWIG_IsOK(res1)) {
6321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetY" "', expected argument " "1"" of type '" "wxRect *""'");
6322 }
6323 arg1 = reinterpret_cast< wxRect * >(argp1);
6324 {
6325 PyThreadState* __tstate = wxPyBeginAllowThreads();
6326 result = (int)(arg1)->GetY();
6327 wxPyEndAllowThreads(__tstate);
6328 if (PyErr_Occurred()) SWIG_fail;
6329 }
6330 resultobj = SWIG_From_int(static_cast< int >(result));
6331 return resultobj;
6332 fail:
6333 return NULL;
6334 }
6335
6336
6337 SWIGINTERN PyObject *_wrap_Rect_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6338 PyObject *resultobj = 0;
6339 wxRect *arg1 = (wxRect *) 0 ;
6340 int arg2 ;
6341 void *argp1 = 0 ;
6342 int res1 = 0 ;
6343 int val2 ;
6344 int ecode2 = 0 ;
6345 PyObject * obj0 = 0 ;
6346 PyObject * obj1 = 0 ;
6347 char * kwnames[] = {
6348 (char *) "self",(char *) "y", NULL
6349 };
6350
6351 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
6352 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6353 if (!SWIG_IsOK(res1)) {
6354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetY" "', expected argument " "1"" of type '" "wxRect *""'");
6355 }
6356 arg1 = reinterpret_cast< wxRect * >(argp1);
6357 ecode2 = SWIG_AsVal_int(obj1, &val2);
6358 if (!SWIG_IsOK(ecode2)) {
6359 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetY" "', expected argument " "2"" of type '" "int""'");
6360 }
6361 arg2 = static_cast< int >(val2);
6362 {
6363 PyThreadState* __tstate = wxPyBeginAllowThreads();
6364 (arg1)->SetY(arg2);
6365 wxPyEndAllowThreads(__tstate);
6366 if (PyErr_Occurred()) SWIG_fail;
6367 }
6368 resultobj = SWIG_Py_Void();
6369 return resultobj;
6370 fail:
6371 return NULL;
6372 }
6373
6374
6375 SWIGINTERN PyObject *_wrap_Rect_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6376 PyObject *resultobj = 0;
6377 wxRect *arg1 = (wxRect *) 0 ;
6378 int result;
6379 void *argp1 = 0 ;
6380 int res1 = 0 ;
6381 PyObject *swig_obj[1] ;
6382
6383 if (!args) SWIG_fail;
6384 swig_obj[0] = args;
6385 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6386 if (!SWIG_IsOK(res1)) {
6387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetWidth" "', expected argument " "1"" of type '" "wxRect const *""'");
6388 }
6389 arg1 = reinterpret_cast< wxRect * >(argp1);
6390 {
6391 PyThreadState* __tstate = wxPyBeginAllowThreads();
6392 result = (int)((wxRect const *)arg1)->GetWidth();
6393 wxPyEndAllowThreads(__tstate);
6394 if (PyErr_Occurred()) SWIG_fail;
6395 }
6396 resultobj = SWIG_From_int(static_cast< int >(result));
6397 return resultobj;
6398 fail:
6399 return NULL;
6400 }
6401
6402
6403 SWIGINTERN PyObject *_wrap_Rect_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6404 PyObject *resultobj = 0;
6405 wxRect *arg1 = (wxRect *) 0 ;
6406 int arg2 ;
6407 void *argp1 = 0 ;
6408 int res1 = 0 ;
6409 int val2 ;
6410 int ecode2 = 0 ;
6411 PyObject * obj0 = 0 ;
6412 PyObject * obj1 = 0 ;
6413 char * kwnames[] = {
6414 (char *) "self",(char *) "w", NULL
6415 };
6416
6417 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
6418 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6419 if (!SWIG_IsOK(res1)) {
6420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetWidth" "', expected argument " "1"" of type '" "wxRect *""'");
6421 }
6422 arg1 = reinterpret_cast< wxRect * >(argp1);
6423 ecode2 = SWIG_AsVal_int(obj1, &val2);
6424 if (!SWIG_IsOK(ecode2)) {
6425 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetWidth" "', expected argument " "2"" of type '" "int""'");
6426 }
6427 arg2 = static_cast< int >(val2);
6428 {
6429 PyThreadState* __tstate = wxPyBeginAllowThreads();
6430 (arg1)->SetWidth(arg2);
6431 wxPyEndAllowThreads(__tstate);
6432 if (PyErr_Occurred()) SWIG_fail;
6433 }
6434 resultobj = SWIG_Py_Void();
6435 return resultobj;
6436 fail:
6437 return NULL;
6438 }
6439
6440
6441 SWIGINTERN PyObject *_wrap_Rect_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6442 PyObject *resultobj = 0;
6443 wxRect *arg1 = (wxRect *) 0 ;
6444 int result;
6445 void *argp1 = 0 ;
6446 int res1 = 0 ;
6447 PyObject *swig_obj[1] ;
6448
6449 if (!args) SWIG_fail;
6450 swig_obj[0] = args;
6451 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6452 if (!SWIG_IsOK(res1)) {
6453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetHeight" "', expected argument " "1"" of type '" "wxRect const *""'");
6454 }
6455 arg1 = reinterpret_cast< wxRect * >(argp1);
6456 {
6457 PyThreadState* __tstate = wxPyBeginAllowThreads();
6458 result = (int)((wxRect const *)arg1)->GetHeight();
6459 wxPyEndAllowThreads(__tstate);
6460 if (PyErr_Occurred()) SWIG_fail;
6461 }
6462 resultobj = SWIG_From_int(static_cast< int >(result));
6463 return resultobj;
6464 fail:
6465 return NULL;
6466 }
6467
6468
6469 SWIGINTERN PyObject *_wrap_Rect_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6470 PyObject *resultobj = 0;
6471 wxRect *arg1 = (wxRect *) 0 ;
6472 int arg2 ;
6473 void *argp1 = 0 ;
6474 int res1 = 0 ;
6475 int val2 ;
6476 int ecode2 = 0 ;
6477 PyObject * obj0 = 0 ;
6478 PyObject * obj1 = 0 ;
6479 char * kwnames[] = {
6480 (char *) "self",(char *) "h", NULL
6481 };
6482
6483 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
6484 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6485 if (!SWIG_IsOK(res1)) {
6486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetHeight" "', expected argument " "1"" of type '" "wxRect *""'");
6487 }
6488 arg1 = reinterpret_cast< wxRect * >(argp1);
6489 ecode2 = SWIG_AsVal_int(obj1, &val2);
6490 if (!SWIG_IsOK(ecode2)) {
6491 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetHeight" "', expected argument " "2"" of type '" "int""'");
6492 }
6493 arg2 = static_cast< int >(val2);
6494 {
6495 PyThreadState* __tstate = wxPyBeginAllowThreads();
6496 (arg1)->SetHeight(arg2);
6497 wxPyEndAllowThreads(__tstate);
6498 if (PyErr_Occurred()) SWIG_fail;
6499 }
6500 resultobj = SWIG_Py_Void();
6501 return resultobj;
6502 fail:
6503 return NULL;
6504 }
6505
6506
6507 SWIGINTERN PyObject *_wrap_Rect_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6508 PyObject *resultobj = 0;
6509 wxRect *arg1 = (wxRect *) 0 ;
6510 wxPoint result;
6511 void *argp1 = 0 ;
6512 int res1 = 0 ;
6513 PyObject *swig_obj[1] ;
6514
6515 if (!args) SWIG_fail;
6516 swig_obj[0] = args;
6517 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6518 if (!SWIG_IsOK(res1)) {
6519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetPosition" "', expected argument " "1"" of type '" "wxRect const *""'");
6520 }
6521 arg1 = reinterpret_cast< wxRect * >(argp1);
6522 {
6523 PyThreadState* __tstate = wxPyBeginAllowThreads();
6524 result = ((wxRect const *)arg1)->GetPosition();
6525 wxPyEndAllowThreads(__tstate);
6526 if (PyErr_Occurred()) SWIG_fail;
6527 }
6528 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6529 return resultobj;
6530 fail:
6531 return NULL;
6532 }
6533
6534
6535 SWIGINTERN PyObject *_wrap_Rect_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6536 PyObject *resultobj = 0;
6537 wxRect *arg1 = (wxRect *) 0 ;
6538 wxPoint *arg2 = 0 ;
6539 void *argp1 = 0 ;
6540 int res1 = 0 ;
6541 wxPoint temp2 ;
6542 PyObject * obj0 = 0 ;
6543 PyObject * obj1 = 0 ;
6544 char * kwnames[] = {
6545 (char *) "self",(char *) "p", NULL
6546 };
6547
6548 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
6549 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6550 if (!SWIG_IsOK(res1)) {
6551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetPosition" "', expected argument " "1"" of type '" "wxRect *""'");
6552 }
6553 arg1 = reinterpret_cast< wxRect * >(argp1);
6554 {
6555 arg2 = &temp2;
6556 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6557 }
6558 {
6559 PyThreadState* __tstate = wxPyBeginAllowThreads();
6560 (arg1)->SetPosition((wxPoint const &)*arg2);
6561 wxPyEndAllowThreads(__tstate);
6562 if (PyErr_Occurred()) SWIG_fail;
6563 }
6564 resultobj = SWIG_Py_Void();
6565 return resultobj;
6566 fail:
6567 return NULL;
6568 }
6569
6570
6571 SWIGINTERN PyObject *_wrap_Rect_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6572 PyObject *resultobj = 0;
6573 wxRect *arg1 = (wxRect *) 0 ;
6574 wxSize result;
6575 void *argp1 = 0 ;
6576 int res1 = 0 ;
6577 PyObject *swig_obj[1] ;
6578
6579 if (!args) SWIG_fail;
6580 swig_obj[0] = args;
6581 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6582 if (!SWIG_IsOK(res1)) {
6583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetSize" "', expected argument " "1"" of type '" "wxRect const *""'");
6584 }
6585 arg1 = reinterpret_cast< wxRect * >(argp1);
6586 {
6587 PyThreadState* __tstate = wxPyBeginAllowThreads();
6588 result = ((wxRect const *)arg1)->GetSize();
6589 wxPyEndAllowThreads(__tstate);
6590 if (PyErr_Occurred()) SWIG_fail;
6591 }
6592 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6593 return resultobj;
6594 fail:
6595 return NULL;
6596 }
6597
6598
6599 SWIGINTERN PyObject *_wrap_Rect_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6600 PyObject *resultobj = 0;
6601 wxRect *arg1 = (wxRect *) 0 ;
6602 wxSize *arg2 = 0 ;
6603 void *argp1 = 0 ;
6604 int res1 = 0 ;
6605 wxSize temp2 ;
6606 PyObject * obj0 = 0 ;
6607 PyObject * obj1 = 0 ;
6608 char * kwnames[] = {
6609 (char *) "self",(char *) "s", NULL
6610 };
6611
6612 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
6613 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6614 if (!SWIG_IsOK(res1)) {
6615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetSize" "', expected argument " "1"" of type '" "wxRect *""'");
6616 }
6617 arg1 = reinterpret_cast< wxRect * >(argp1);
6618 {
6619 arg2 = &temp2;
6620 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6621 }
6622 {
6623 PyThreadState* __tstate = wxPyBeginAllowThreads();
6624 (arg1)->SetSize((wxSize const &)*arg2);
6625 wxPyEndAllowThreads(__tstate);
6626 if (PyErr_Occurred()) SWIG_fail;
6627 }
6628 resultobj = SWIG_Py_Void();
6629 return resultobj;
6630 fail:
6631 return NULL;
6632 }
6633
6634
6635 SWIGINTERN PyObject *_wrap_Rect_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6636 PyObject *resultobj = 0;
6637 wxRect *arg1 = (wxRect *) 0 ;
6638 bool result;
6639 void *argp1 = 0 ;
6640 int res1 = 0 ;
6641 PyObject *swig_obj[1] ;
6642
6643 if (!args) SWIG_fail;
6644 swig_obj[0] = args;
6645 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6646 if (!SWIG_IsOK(res1)) {
6647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_IsEmpty" "', expected argument " "1"" of type '" "wxRect const *""'");
6648 }
6649 arg1 = reinterpret_cast< wxRect * >(argp1);
6650 {
6651 PyThreadState* __tstate = wxPyBeginAllowThreads();
6652 result = (bool)((wxRect const *)arg1)->IsEmpty();
6653 wxPyEndAllowThreads(__tstate);
6654 if (PyErr_Occurred()) SWIG_fail;
6655 }
6656 {
6657 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6658 }
6659 return resultobj;
6660 fail:
6661 return NULL;
6662 }
6663
6664
6665 SWIGINTERN PyObject *_wrap_Rect_GetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6666 PyObject *resultobj = 0;
6667 wxRect *arg1 = (wxRect *) 0 ;
6668 wxPoint result;
6669 void *argp1 = 0 ;
6670 int res1 = 0 ;
6671 PyObject *swig_obj[1] ;
6672
6673 if (!args) SWIG_fail;
6674 swig_obj[0] = args;
6675 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6676 if (!SWIG_IsOK(res1)) {
6677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6678 }
6679 arg1 = reinterpret_cast< wxRect * >(argp1);
6680 {
6681 PyThreadState* __tstate = wxPyBeginAllowThreads();
6682 result = ((wxRect const *)arg1)->GetTopLeft();
6683 wxPyEndAllowThreads(__tstate);
6684 if (PyErr_Occurred()) SWIG_fail;
6685 }
6686 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6687 return resultobj;
6688 fail:
6689 return NULL;
6690 }
6691
6692
6693 SWIGINTERN PyObject *_wrap_Rect_SetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6694 PyObject *resultobj = 0;
6695 wxRect *arg1 = (wxRect *) 0 ;
6696 wxPoint *arg2 = 0 ;
6697 void *argp1 = 0 ;
6698 int res1 = 0 ;
6699 wxPoint temp2 ;
6700 PyObject * obj0 = 0 ;
6701 PyObject * obj1 = 0 ;
6702 char * kwnames[] = {
6703 (char *) "self",(char *) "p", NULL
6704 };
6705
6706 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6707 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6708 if (!SWIG_IsOK(res1)) {
6709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6710 }
6711 arg1 = reinterpret_cast< wxRect * >(argp1);
6712 {
6713 arg2 = &temp2;
6714 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6715 }
6716 {
6717 PyThreadState* __tstate = wxPyBeginAllowThreads();
6718 (arg1)->SetTopLeft((wxPoint const &)*arg2);
6719 wxPyEndAllowThreads(__tstate);
6720 if (PyErr_Occurred()) SWIG_fail;
6721 }
6722 resultobj = SWIG_Py_Void();
6723 return resultobj;
6724 fail:
6725 return NULL;
6726 }
6727
6728
6729 SWIGINTERN PyObject *_wrap_Rect_GetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6730 PyObject *resultobj = 0;
6731 wxRect *arg1 = (wxRect *) 0 ;
6732 wxPoint result;
6733 void *argp1 = 0 ;
6734 int res1 = 0 ;
6735 PyObject *swig_obj[1] ;
6736
6737 if (!args) SWIG_fail;
6738 swig_obj[0] = args;
6739 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6740 if (!SWIG_IsOK(res1)) {
6741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6742 }
6743 arg1 = reinterpret_cast< wxRect * >(argp1);
6744 {
6745 PyThreadState* __tstate = wxPyBeginAllowThreads();
6746 result = ((wxRect const *)arg1)->GetBottomRight();
6747 wxPyEndAllowThreads(__tstate);
6748 if (PyErr_Occurred()) SWIG_fail;
6749 }
6750 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6751 return resultobj;
6752 fail:
6753 return NULL;
6754 }
6755
6756
6757 SWIGINTERN PyObject *_wrap_Rect_SetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6758 PyObject *resultobj = 0;
6759 wxRect *arg1 = (wxRect *) 0 ;
6760 wxPoint *arg2 = 0 ;
6761 void *argp1 = 0 ;
6762 int res1 = 0 ;
6763 wxPoint temp2 ;
6764 PyObject * obj0 = 0 ;
6765 PyObject * obj1 = 0 ;
6766 char * kwnames[] = {
6767 (char *) "self",(char *) "p", NULL
6768 };
6769
6770 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) SWIG_fail;
6771 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6772 if (!SWIG_IsOK(res1)) {
6773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomRight" "', expected argument " "1"" of type '" "wxRect *""'");
6774 }
6775 arg1 = reinterpret_cast< wxRect * >(argp1);
6776 {
6777 arg2 = &temp2;
6778 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6779 }
6780 {
6781 PyThreadState* __tstate = wxPyBeginAllowThreads();
6782 (arg1)->SetBottomRight((wxPoint const &)*arg2);
6783 wxPyEndAllowThreads(__tstate);
6784 if (PyErr_Occurred()) SWIG_fail;
6785 }
6786 resultobj = SWIG_Py_Void();
6787 return resultobj;
6788 fail:
6789 return NULL;
6790 }
6791
6792
6793 SWIGINTERN PyObject *_wrap_Rect_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6794 PyObject *resultobj = 0;
6795 wxRect *arg1 = (wxRect *) 0 ;
6796 int result;
6797 void *argp1 = 0 ;
6798 int res1 = 0 ;
6799 PyObject *swig_obj[1] ;
6800
6801 if (!args) SWIG_fail;
6802 swig_obj[0] = args;
6803 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6804 if (!SWIG_IsOK(res1)) {
6805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6806 }
6807 arg1 = reinterpret_cast< wxRect * >(argp1);
6808 {
6809 PyThreadState* __tstate = wxPyBeginAllowThreads();
6810 result = (int)((wxRect const *)arg1)->GetLeft();
6811 wxPyEndAllowThreads(__tstate);
6812 if (PyErr_Occurred()) SWIG_fail;
6813 }
6814 resultobj = SWIG_From_int(static_cast< int >(result));
6815 return resultobj;
6816 fail:
6817 return NULL;
6818 }
6819
6820
6821 SWIGINTERN PyObject *_wrap_Rect_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6822 PyObject *resultobj = 0;
6823 wxRect *arg1 = (wxRect *) 0 ;
6824 int result;
6825 void *argp1 = 0 ;
6826 int res1 = 0 ;
6827 PyObject *swig_obj[1] ;
6828
6829 if (!args) SWIG_fail;
6830 swig_obj[0] = args;
6831 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6832 if (!SWIG_IsOK(res1)) {
6833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTop" "', expected argument " "1"" of type '" "wxRect const *""'");
6834 }
6835 arg1 = reinterpret_cast< wxRect * >(argp1);
6836 {
6837 PyThreadState* __tstate = wxPyBeginAllowThreads();
6838 result = (int)((wxRect const *)arg1)->GetTop();
6839 wxPyEndAllowThreads(__tstate);
6840 if (PyErr_Occurred()) SWIG_fail;
6841 }
6842 resultobj = SWIG_From_int(static_cast< int >(result));
6843 return resultobj;
6844 fail:
6845 return NULL;
6846 }
6847
6848
6849 SWIGINTERN PyObject *_wrap_Rect_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6850 PyObject *resultobj = 0;
6851 wxRect *arg1 = (wxRect *) 0 ;
6852 int result;
6853 void *argp1 = 0 ;
6854 int res1 = 0 ;
6855 PyObject *swig_obj[1] ;
6856
6857 if (!args) SWIG_fail;
6858 swig_obj[0] = args;
6859 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6860 if (!SWIG_IsOK(res1)) {
6861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottom" "', expected argument " "1"" of type '" "wxRect const *""'");
6862 }
6863 arg1 = reinterpret_cast< wxRect * >(argp1);
6864 {
6865 PyThreadState* __tstate = wxPyBeginAllowThreads();
6866 result = (int)((wxRect const *)arg1)->GetBottom();
6867 wxPyEndAllowThreads(__tstate);
6868 if (PyErr_Occurred()) SWIG_fail;
6869 }
6870 resultobj = SWIG_From_int(static_cast< int >(result));
6871 return resultobj;
6872 fail:
6873 return NULL;
6874 }
6875
6876
6877 SWIGINTERN PyObject *_wrap_Rect_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6878 PyObject *resultobj = 0;
6879 wxRect *arg1 = (wxRect *) 0 ;
6880 int result;
6881 void *argp1 = 0 ;
6882 int res1 = 0 ;
6883 PyObject *swig_obj[1] ;
6884
6885 if (!args) SWIG_fail;
6886 swig_obj[0] = args;
6887 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6888 if (!SWIG_IsOK(res1)) {
6889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6890 }
6891 arg1 = reinterpret_cast< wxRect * >(argp1);
6892 {
6893 PyThreadState* __tstate = wxPyBeginAllowThreads();
6894 result = (int)((wxRect const *)arg1)->GetRight();
6895 wxPyEndAllowThreads(__tstate);
6896 if (PyErr_Occurred()) SWIG_fail;
6897 }
6898 resultobj = SWIG_From_int(static_cast< int >(result));
6899 return resultobj;
6900 fail:
6901 return NULL;
6902 }
6903
6904
6905 SWIGINTERN PyObject *_wrap_Rect_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6906 PyObject *resultobj = 0;
6907 wxRect *arg1 = (wxRect *) 0 ;
6908 int arg2 ;
6909 void *argp1 = 0 ;
6910 int res1 = 0 ;
6911 int val2 ;
6912 int ecode2 = 0 ;
6913 PyObject * obj0 = 0 ;
6914 PyObject * obj1 = 0 ;
6915 char * kwnames[] = {
6916 (char *) "self",(char *) "left", NULL
6917 };
6918
6919 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6920 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6921 if (!SWIG_IsOK(res1)) {
6922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6923 }
6924 arg1 = reinterpret_cast< wxRect * >(argp1);
6925 ecode2 = SWIG_AsVal_int(obj1, &val2);
6926 if (!SWIG_IsOK(ecode2)) {
6927 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetLeft" "', expected argument " "2"" of type '" "int""'");
6928 }
6929 arg2 = static_cast< int >(val2);
6930 {
6931 PyThreadState* __tstate = wxPyBeginAllowThreads();
6932 (arg1)->SetLeft(arg2);
6933 wxPyEndAllowThreads(__tstate);
6934 if (PyErr_Occurred()) SWIG_fail;
6935 }
6936 resultobj = SWIG_Py_Void();
6937 return resultobj;
6938 fail:
6939 return NULL;
6940 }
6941
6942
6943 SWIGINTERN PyObject *_wrap_Rect_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6944 PyObject *resultobj = 0;
6945 wxRect *arg1 = (wxRect *) 0 ;
6946 int arg2 ;
6947 void *argp1 = 0 ;
6948 int res1 = 0 ;
6949 int val2 ;
6950 int ecode2 = 0 ;
6951 PyObject * obj0 = 0 ;
6952 PyObject * obj1 = 0 ;
6953 char * kwnames[] = {
6954 (char *) "self",(char *) "right", NULL
6955 };
6956
6957 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
6958 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6959 if (!SWIG_IsOK(res1)) {
6960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetRight" "', expected argument " "1"" of type '" "wxRect *""'");
6961 }
6962 arg1 = reinterpret_cast< wxRect * >(argp1);
6963 ecode2 = SWIG_AsVal_int(obj1, &val2);
6964 if (!SWIG_IsOK(ecode2)) {
6965 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetRight" "', expected argument " "2"" of type '" "int""'");
6966 }
6967 arg2 = static_cast< int >(val2);
6968 {
6969 PyThreadState* __tstate = wxPyBeginAllowThreads();
6970 (arg1)->SetRight(arg2);
6971 wxPyEndAllowThreads(__tstate);
6972 if (PyErr_Occurred()) SWIG_fail;
6973 }
6974 resultobj = SWIG_Py_Void();
6975 return resultobj;
6976 fail:
6977 return NULL;
6978 }
6979
6980
6981 SWIGINTERN PyObject *_wrap_Rect_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6982 PyObject *resultobj = 0;
6983 wxRect *arg1 = (wxRect *) 0 ;
6984 int arg2 ;
6985 void *argp1 = 0 ;
6986 int res1 = 0 ;
6987 int val2 ;
6988 int ecode2 = 0 ;
6989 PyObject * obj0 = 0 ;
6990 PyObject * obj1 = 0 ;
6991 char * kwnames[] = {
6992 (char *) "self",(char *) "top", NULL
6993 };
6994
6995 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
6996 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6997 if (!SWIG_IsOK(res1)) {
6998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTop" "', expected argument " "1"" of type '" "wxRect *""'");
6999 }
7000 arg1 = reinterpret_cast< wxRect * >(argp1);
7001 ecode2 = SWIG_AsVal_int(obj1, &val2);
7002 if (!SWIG_IsOK(ecode2)) {
7003 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetTop" "', expected argument " "2"" of type '" "int""'");
7004 }
7005 arg2 = static_cast< int >(val2);
7006 {
7007 PyThreadState* __tstate = wxPyBeginAllowThreads();
7008 (arg1)->SetTop(arg2);
7009 wxPyEndAllowThreads(__tstate);
7010 if (PyErr_Occurred()) SWIG_fail;
7011 }
7012 resultobj = SWIG_Py_Void();
7013 return resultobj;
7014 fail:
7015 return NULL;
7016 }
7017
7018
7019 SWIGINTERN PyObject *_wrap_Rect_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7020 PyObject *resultobj = 0;
7021 wxRect *arg1 = (wxRect *) 0 ;
7022 int arg2 ;
7023 void *argp1 = 0 ;
7024 int res1 = 0 ;
7025 int val2 ;
7026 int ecode2 = 0 ;
7027 PyObject * obj0 = 0 ;
7028 PyObject * obj1 = 0 ;
7029 char * kwnames[] = {
7030 (char *) "self",(char *) "bottom", NULL
7031 };
7032
7033 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) 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_SetBottom" "', 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_SetBottom" "', expected argument " "2"" of type '" "int""'");
7042 }
7043 arg2 = static_cast< int >(val2);
7044 {
7045 PyThreadState* __tstate = wxPyBeginAllowThreads();
7046 (arg1)->SetBottom(arg2);
7047 wxPyEndAllowThreads(__tstate);
7048 if (PyErr_Occurred()) SWIG_fail;
7049 }
7050 resultobj = SWIG_Py_Void();
7051 return resultobj;
7052 fail:
7053 return NULL;
7054 }
7055
7056
7057 SWIGINTERN PyObject *_wrap_Rect_Inflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7058 PyObject *resultobj = 0;
7059 wxRect *arg1 = (wxRect *) 0 ;
7060 int arg2 ;
7061 int arg3 ;
7062 wxRect *result = 0 ;
7063 void *argp1 = 0 ;
7064 int res1 = 0 ;
7065 int val2 ;
7066 int ecode2 = 0 ;
7067 int val3 ;
7068 int ecode3 = 0 ;
7069 PyObject * obj0 = 0 ;
7070 PyObject * obj1 = 0 ;
7071 PyObject * obj2 = 0 ;
7072 char * kwnames[] = {
7073 (char *) "self",(char *) "dx",(char *) "dy", NULL
7074 };
7075
7076 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7077 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7078 if (!SWIG_IsOK(res1)) {
7079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inflate" "', expected argument " "1"" of type '" "wxRect *""'");
7080 }
7081 arg1 = reinterpret_cast< wxRect * >(argp1);
7082 ecode2 = SWIG_AsVal_int(obj1, &val2);
7083 if (!SWIG_IsOK(ecode2)) {
7084 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Inflate" "', expected argument " "2"" of type '" "int""'");
7085 }
7086 arg2 = static_cast< int >(val2);
7087 ecode3 = SWIG_AsVal_int(obj2, &val3);
7088 if (!SWIG_IsOK(ecode3)) {
7089 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Inflate" "', expected argument " "3"" of type '" "int""'");
7090 }
7091 arg3 = static_cast< int >(val3);
7092 {
7093 PyThreadState* __tstate = wxPyBeginAllowThreads();
7094 {
7095 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
7096 result = (wxRect *) &_result_ref;
7097 }
7098 wxPyEndAllowThreads(__tstate);
7099 if (PyErr_Occurred()) SWIG_fail;
7100 }
7101 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7102 return resultobj;
7103 fail:
7104 return NULL;
7105 }
7106
7107
7108 SWIGINTERN PyObject *_wrap_Rect_Deflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7109 PyObject *resultobj = 0;
7110 wxRect *arg1 = (wxRect *) 0 ;
7111 int arg2 ;
7112 int arg3 ;
7113 wxRect *result = 0 ;
7114 void *argp1 = 0 ;
7115 int res1 = 0 ;
7116 int val2 ;
7117 int ecode2 = 0 ;
7118 int val3 ;
7119 int ecode3 = 0 ;
7120 PyObject * obj0 = 0 ;
7121 PyObject * obj1 = 0 ;
7122 PyObject * obj2 = 0 ;
7123 char * kwnames[] = {
7124 (char *) "self",(char *) "dx",(char *) "dy", NULL
7125 };
7126
7127 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7128 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7129 if (!SWIG_IsOK(res1)) {
7130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Deflate" "', expected argument " "1"" of type '" "wxRect *""'");
7131 }
7132 arg1 = reinterpret_cast< wxRect * >(argp1);
7133 ecode2 = SWIG_AsVal_int(obj1, &val2);
7134 if (!SWIG_IsOK(ecode2)) {
7135 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Deflate" "', expected argument " "2"" of type '" "int""'");
7136 }
7137 arg2 = static_cast< int >(val2);
7138 ecode3 = SWIG_AsVal_int(obj2, &val3);
7139 if (!SWIG_IsOK(ecode3)) {
7140 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Deflate" "', expected argument " "3"" of type '" "int""'");
7141 }
7142 arg3 = static_cast< int >(val3);
7143 {
7144 PyThreadState* __tstate = wxPyBeginAllowThreads();
7145 {
7146 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
7147 result = (wxRect *) &_result_ref;
7148 }
7149 wxPyEndAllowThreads(__tstate);
7150 if (PyErr_Occurred()) SWIG_fail;
7151 }
7152 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7153 return resultobj;
7154 fail:
7155 return NULL;
7156 }
7157
7158
7159 SWIGINTERN PyObject *_wrap_Rect_OffsetXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7160 PyObject *resultobj = 0;
7161 wxRect *arg1 = (wxRect *) 0 ;
7162 int arg2 ;
7163 int arg3 ;
7164 void *argp1 = 0 ;
7165 int res1 = 0 ;
7166 int val2 ;
7167 int ecode2 = 0 ;
7168 int val3 ;
7169 int ecode3 = 0 ;
7170 PyObject * obj0 = 0 ;
7171 PyObject * obj1 = 0 ;
7172 PyObject * obj2 = 0 ;
7173 char * kwnames[] = {
7174 (char *) "self",(char *) "dx",(char *) "dy", NULL
7175 };
7176
7177 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7178 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7179 if (!SWIG_IsOK(res1)) {
7180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_OffsetXY" "', expected argument " "1"" of type '" "wxRect *""'");
7181 }
7182 arg1 = reinterpret_cast< wxRect * >(argp1);
7183 ecode2 = SWIG_AsVal_int(obj1, &val2);
7184 if (!SWIG_IsOK(ecode2)) {
7185 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_OffsetXY" "', expected argument " "2"" of type '" "int""'");
7186 }
7187 arg2 = static_cast< int >(val2);
7188 ecode3 = SWIG_AsVal_int(obj2, &val3);
7189 if (!SWIG_IsOK(ecode3)) {
7190 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_OffsetXY" "', expected argument " "3"" of type '" "int""'");
7191 }
7192 arg3 = static_cast< int >(val3);
7193 {
7194 PyThreadState* __tstate = wxPyBeginAllowThreads();
7195 (arg1)->Offset(arg2,arg3);
7196 wxPyEndAllowThreads(__tstate);
7197 if (PyErr_Occurred()) SWIG_fail;
7198 }
7199 resultobj = SWIG_Py_Void();
7200 return resultobj;
7201 fail:
7202 return NULL;
7203 }
7204
7205
7206 SWIGINTERN PyObject *_wrap_Rect_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7207 PyObject *resultobj = 0;
7208 wxRect *arg1 = (wxRect *) 0 ;
7209 wxPoint *arg2 = 0 ;
7210 void *argp1 = 0 ;
7211 int res1 = 0 ;
7212 wxPoint temp2 ;
7213 PyObject * obj0 = 0 ;
7214 PyObject * obj1 = 0 ;
7215 char * kwnames[] = {
7216 (char *) "self",(char *) "pt", NULL
7217 };
7218
7219 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
7220 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7221 if (!SWIG_IsOK(res1)) {
7222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Offset" "', expected argument " "1"" of type '" "wxRect *""'");
7223 }
7224 arg1 = reinterpret_cast< wxRect * >(argp1);
7225 {
7226 arg2 = &temp2;
7227 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7228 }
7229 {
7230 PyThreadState* __tstate = wxPyBeginAllowThreads();
7231 (arg1)->Offset((wxPoint const &)*arg2);
7232 wxPyEndAllowThreads(__tstate);
7233 if (PyErr_Occurred()) SWIG_fail;
7234 }
7235 resultobj = SWIG_Py_Void();
7236 return resultobj;
7237 fail:
7238 return NULL;
7239 }
7240
7241
7242 SWIGINTERN PyObject *_wrap_Rect_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7243 PyObject *resultobj = 0;
7244 wxRect *arg1 = (wxRect *) 0 ;
7245 wxRect *arg2 = 0 ;
7246 wxRect result;
7247 void *argp1 = 0 ;
7248 int res1 = 0 ;
7249 wxRect temp2 ;
7250 PyObject * obj0 = 0 ;
7251 PyObject * obj1 = 0 ;
7252 char * kwnames[] = {
7253 (char *) "self",(char *) "rect", NULL
7254 };
7255
7256 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
7257 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7258 if (!SWIG_IsOK(res1)) {
7259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersect" "', expected argument " "1"" of type '" "wxRect *""'");
7260 }
7261 arg1 = reinterpret_cast< wxRect * >(argp1);
7262 {
7263 arg2 = &temp2;
7264 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7265 }
7266 {
7267 PyThreadState* __tstate = wxPyBeginAllowThreads();
7268 result = (arg1)->Intersect((wxRect const &)*arg2);
7269 wxPyEndAllowThreads(__tstate);
7270 if (PyErr_Occurred()) SWIG_fail;
7271 }
7272 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7273 return resultobj;
7274 fail:
7275 return NULL;
7276 }
7277
7278
7279 SWIGINTERN PyObject *_wrap_Rect_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7280 PyObject *resultobj = 0;
7281 wxRect *arg1 = (wxRect *) 0 ;
7282 wxRect *arg2 = 0 ;
7283 wxRect result;
7284 void *argp1 = 0 ;
7285 int res1 = 0 ;
7286 wxRect temp2 ;
7287 PyObject * obj0 = 0 ;
7288 PyObject * obj1 = 0 ;
7289 char * kwnames[] = {
7290 (char *) "self",(char *) "rect", NULL
7291 };
7292
7293 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) SWIG_fail;
7294 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7295 if (!SWIG_IsOK(res1)) {
7296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Union" "', expected argument " "1"" of type '" "wxRect *""'");
7297 }
7298 arg1 = reinterpret_cast< wxRect * >(argp1);
7299 {
7300 arg2 = &temp2;
7301 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7302 }
7303 {
7304 PyThreadState* __tstate = wxPyBeginAllowThreads();
7305 result = (arg1)->Union((wxRect const &)*arg2);
7306 wxPyEndAllowThreads(__tstate);
7307 if (PyErr_Occurred()) SWIG_fail;
7308 }
7309 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7310 return resultobj;
7311 fail:
7312 return NULL;
7313 }
7314
7315
7316 SWIGINTERN PyObject *_wrap_Rect___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7317 PyObject *resultobj = 0;
7318 wxRect *arg1 = (wxRect *) 0 ;
7319 wxRect *arg2 = 0 ;
7320 wxRect result;
7321 void *argp1 = 0 ;
7322 int res1 = 0 ;
7323 wxRect temp2 ;
7324 PyObject * obj0 = 0 ;
7325 PyObject * obj1 = 0 ;
7326 char * kwnames[] = {
7327 (char *) "self",(char *) "rect", NULL
7328 };
7329
7330 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) SWIG_fail;
7331 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7332 if (!SWIG_IsOK(res1)) {
7333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___add__" "', expected argument " "1"" of type '" "wxRect const *""'");
7334 }
7335 arg1 = reinterpret_cast< wxRect * >(argp1);
7336 {
7337 arg2 = &temp2;
7338 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7339 }
7340 {
7341 PyThreadState* __tstate = wxPyBeginAllowThreads();
7342 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
7343 wxPyEndAllowThreads(__tstate);
7344 if (PyErr_Occurred()) SWIG_fail;
7345 }
7346 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7347 return resultobj;
7348 fail:
7349 return NULL;
7350 }
7351
7352
7353 SWIGINTERN PyObject *_wrap_Rect___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7354 PyObject *resultobj = 0;
7355 wxRect *arg1 = (wxRect *) 0 ;
7356 wxRect *arg2 = 0 ;
7357 wxRect *result = 0 ;
7358 void *argp1 = 0 ;
7359 int res1 = 0 ;
7360 wxRect temp2 ;
7361 PyObject * obj0 = 0 ;
7362 PyObject * obj1 = 0 ;
7363 char * kwnames[] = {
7364 (char *) "self",(char *) "rect", NULL
7365 };
7366
7367 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
7368 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
7369 if (!SWIG_IsOK(res1)) {
7370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___iadd__" "', expected argument " "1"" of type '" "wxRect *""'");
7371 }
7372 arg1 = reinterpret_cast< wxRect * >(argp1);
7373 {
7374 arg2 = &temp2;
7375 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7376 }
7377 {
7378 PyThreadState* __tstate = wxPyBeginAllowThreads();
7379 {
7380 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
7381 result = (wxRect *) &_result_ref;
7382 }
7383 wxPyEndAllowThreads(__tstate);
7384 if (PyErr_Occurred()) SWIG_fail;
7385 }
7386 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7387 return resultobj;
7388 fail:
7389 return NULL;
7390 }
7391
7392
7393 SWIGINTERN PyObject *_wrap_Rect___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7394 PyObject *resultobj = 0;
7395 wxRect *arg1 = (wxRect *) 0 ;
7396 PyObject *arg2 = (PyObject *) 0 ;
7397 bool result;
7398 void *argp1 = 0 ;
7399 int res1 = 0 ;
7400 PyObject * obj0 = 0 ;
7401 PyObject * obj1 = 0 ;
7402 char * kwnames[] = {
7403 (char *) "self",(char *) "other", NULL
7404 };
7405
7406 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
7407 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7408 if (!SWIG_IsOK(res1)) {
7409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___eq__" "', expected argument " "1"" of type '" "wxRect *""'");
7410 }
7411 arg1 = reinterpret_cast< wxRect * >(argp1);
7412 arg2 = obj1;
7413 {
7414 result = (bool)wxRect___eq__(arg1,arg2);
7415 if (PyErr_Occurred()) SWIG_fail;
7416 }
7417 {
7418 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7419 }
7420 return resultobj;
7421 fail:
7422 return NULL;
7423 }
7424
7425
7426 SWIGINTERN PyObject *_wrap_Rect___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7427 PyObject *resultobj = 0;
7428 wxRect *arg1 = (wxRect *) 0 ;
7429 PyObject *arg2 = (PyObject *) 0 ;
7430 bool result;
7431 void *argp1 = 0 ;
7432 int res1 = 0 ;
7433 PyObject * obj0 = 0 ;
7434 PyObject * obj1 = 0 ;
7435 char * kwnames[] = {
7436 (char *) "self",(char *) "other", NULL
7437 };
7438
7439 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
7440 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7441 if (!SWIG_IsOK(res1)) {
7442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___ne__" "', expected argument " "1"" of type '" "wxRect *""'");
7443 }
7444 arg1 = reinterpret_cast< wxRect * >(argp1);
7445 arg2 = obj1;
7446 {
7447 result = (bool)wxRect___ne__(arg1,arg2);
7448 if (PyErr_Occurred()) SWIG_fail;
7449 }
7450 {
7451 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7452 }
7453 return resultobj;
7454 fail:
7455 return NULL;
7456 }
7457
7458
7459 SWIGINTERN PyObject *_wrap_Rect_InsideXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7460 PyObject *resultobj = 0;
7461 wxRect *arg1 = (wxRect *) 0 ;
7462 int arg2 ;
7463 int arg3 ;
7464 bool result;
7465 void *argp1 = 0 ;
7466 int res1 = 0 ;
7467 int val2 ;
7468 int ecode2 = 0 ;
7469 int val3 ;
7470 int ecode3 = 0 ;
7471 PyObject * obj0 = 0 ;
7472 PyObject * obj1 = 0 ;
7473 PyObject * obj2 = 0 ;
7474 char * kwnames[] = {
7475 (char *) "self",(char *) "x",(char *) "y", NULL
7476 };
7477
7478 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_InsideXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7479 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7480 if (!SWIG_IsOK(res1)) {
7481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_InsideXY" "', expected argument " "1"" of type '" "wxRect const *""'");
7482 }
7483 arg1 = reinterpret_cast< wxRect * >(argp1);
7484 ecode2 = SWIG_AsVal_int(obj1, &val2);
7485 if (!SWIG_IsOK(ecode2)) {
7486 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_InsideXY" "', expected argument " "2"" of type '" "int""'");
7487 }
7488 arg2 = static_cast< int >(val2);
7489 ecode3 = SWIG_AsVal_int(obj2, &val3);
7490 if (!SWIG_IsOK(ecode3)) {
7491 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_InsideXY" "', expected argument " "3"" of type '" "int""'");
7492 }
7493 arg3 = static_cast< int >(val3);
7494 {
7495 PyThreadState* __tstate = wxPyBeginAllowThreads();
7496 result = (bool)((wxRect const *)arg1)->Inside(arg2,arg3);
7497 wxPyEndAllowThreads(__tstate);
7498 if (PyErr_Occurred()) SWIG_fail;
7499 }
7500 {
7501 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7502 }
7503 return resultobj;
7504 fail:
7505 return NULL;
7506 }
7507
7508
7509 SWIGINTERN PyObject *_wrap_Rect_Inside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7510 PyObject *resultobj = 0;
7511 wxRect *arg1 = (wxRect *) 0 ;
7512 wxPoint *arg2 = 0 ;
7513 bool result;
7514 void *argp1 = 0 ;
7515 int res1 = 0 ;
7516 wxPoint temp2 ;
7517 PyObject * obj0 = 0 ;
7518 PyObject * obj1 = 0 ;
7519 char * kwnames[] = {
7520 (char *) "self",(char *) "pt", NULL
7521 };
7522
7523 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Inside",kwnames,&obj0,&obj1)) SWIG_fail;
7524 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7525 if (!SWIG_IsOK(res1)) {
7526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inside" "', expected argument " "1"" of type '" "wxRect const *""'");
7527 }
7528 arg1 = reinterpret_cast< wxRect * >(argp1);
7529 {
7530 arg2 = &temp2;
7531 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7532 }
7533 {
7534 PyThreadState* __tstate = wxPyBeginAllowThreads();
7535 result = (bool)((wxRect const *)arg1)->Inside((wxPoint const &)*arg2);
7536 wxPyEndAllowThreads(__tstate);
7537 if (PyErr_Occurred()) SWIG_fail;
7538 }
7539 {
7540 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7541 }
7542 return resultobj;
7543 fail:
7544 return NULL;
7545 }
7546
7547
7548 SWIGINTERN PyObject *_wrap_Rect_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7549 PyObject *resultobj = 0;
7550 wxRect *arg1 = (wxRect *) 0 ;
7551 wxRect *arg2 = 0 ;
7552 bool result;
7553 void *argp1 = 0 ;
7554 int res1 = 0 ;
7555 wxRect temp2 ;
7556 PyObject * obj0 = 0 ;
7557 PyObject * obj1 = 0 ;
7558 char * kwnames[] = {
7559 (char *) "self",(char *) "rect", NULL
7560 };
7561
7562 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) 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_Intersects" "', expected argument " "1"" of type '" "wxRect const *""'");
7566 }
7567 arg1 = reinterpret_cast< wxRect * >(argp1);
7568 {
7569 arg2 = &temp2;
7570 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7571 }
7572 {
7573 PyThreadState* __tstate = wxPyBeginAllowThreads();
7574 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
7575 wxPyEndAllowThreads(__tstate);
7576 if (PyErr_Occurred()) SWIG_fail;
7577 }
7578 {
7579 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7580 }
7581 return resultobj;
7582 fail:
7583 return NULL;
7584 }
7585
7586
7587 SWIGINTERN PyObject *_wrap_Rect_CenterIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7588 PyObject *resultobj = 0;
7589 wxRect *arg1 = (wxRect *) 0 ;
7590 wxRect *arg2 = 0 ;
7591 int arg3 = (int) wxBOTH ;
7592 wxRect result;
7593 void *argp1 = 0 ;
7594 int res1 = 0 ;
7595 wxRect temp2 ;
7596 int val3 ;
7597 int ecode3 = 0 ;
7598 PyObject * obj0 = 0 ;
7599 PyObject * obj1 = 0 ;
7600 PyObject * obj2 = 0 ;
7601 char * kwnames[] = {
7602 (char *) "self",(char *) "r",(char *) "dir", NULL
7603 };
7604
7605 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Rect_CenterIn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7606 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7607 if (!SWIG_IsOK(res1)) {
7608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_CenterIn" "', expected argument " "1"" of type '" "wxRect *""'");
7609 }
7610 arg1 = reinterpret_cast< wxRect * >(argp1);
7611 {
7612 arg2 = &temp2;
7613 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7614 }
7615 if (obj2) {
7616 ecode3 = SWIG_AsVal_int(obj2, &val3);
7617 if (!SWIG_IsOK(ecode3)) {
7618 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_CenterIn" "', expected argument " "3"" of type '" "int""'");
7619 }
7620 arg3 = static_cast< int >(val3);
7621 }
7622 {
7623 PyThreadState* __tstate = wxPyBeginAllowThreads();
7624 result = (arg1)->CenterIn((wxRect const &)*arg2,arg3);
7625 wxPyEndAllowThreads(__tstate);
7626 if (PyErr_Occurred()) SWIG_fail;
7627 }
7628 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7629 return resultobj;
7630 fail:
7631 return NULL;
7632 }
7633
7634
7635 SWIGINTERN PyObject *_wrap_Rect_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7636 PyObject *resultobj = 0;
7637 wxRect *arg1 = (wxRect *) 0 ;
7638 int arg2 ;
7639 void *argp1 = 0 ;
7640 int res1 = 0 ;
7641 int val2 ;
7642 int ecode2 = 0 ;
7643 PyObject *swig_obj[2] ;
7644
7645 if (!SWIG_Python_UnpackTuple(args,"Rect_x_set",2,2,swig_obj)) SWIG_fail;
7646 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7647 if (!SWIG_IsOK(res1)) {
7648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_set" "', expected argument " "1"" of type '" "wxRect *""'");
7649 }
7650 arg1 = reinterpret_cast< wxRect * >(argp1);
7651 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7652 if (!SWIG_IsOK(ecode2)) {
7653 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_x_set" "', expected argument " "2"" of type '" "int""'");
7654 }
7655 arg2 = static_cast< int >(val2);
7656 if (arg1) (arg1)->x = arg2;
7657
7658 resultobj = SWIG_Py_Void();
7659 return resultobj;
7660 fail:
7661 return NULL;
7662 }
7663
7664
7665 SWIGINTERN PyObject *_wrap_Rect_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7666 PyObject *resultobj = 0;
7667 wxRect *arg1 = (wxRect *) 0 ;
7668 int result;
7669 void *argp1 = 0 ;
7670 int res1 = 0 ;
7671 PyObject *swig_obj[1] ;
7672
7673 if (!args) SWIG_fail;
7674 swig_obj[0] = args;
7675 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7676 if (!SWIG_IsOK(res1)) {
7677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_get" "', expected argument " "1"" of type '" "wxRect *""'");
7678 }
7679 arg1 = reinterpret_cast< wxRect * >(argp1);
7680 result = (int) ((arg1)->x);
7681 resultobj = SWIG_From_int(static_cast< int >(result));
7682 return resultobj;
7683 fail:
7684 return NULL;
7685 }
7686
7687
7688 SWIGINTERN PyObject *_wrap_Rect_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7689 PyObject *resultobj = 0;
7690 wxRect *arg1 = (wxRect *) 0 ;
7691 int arg2 ;
7692 void *argp1 = 0 ;
7693 int res1 = 0 ;
7694 int val2 ;
7695 int ecode2 = 0 ;
7696 PyObject *swig_obj[2] ;
7697
7698 if (!SWIG_Python_UnpackTuple(args,"Rect_y_set",2,2,swig_obj)) SWIG_fail;
7699 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7700 if (!SWIG_IsOK(res1)) {
7701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_set" "', expected argument " "1"" of type '" "wxRect *""'");
7702 }
7703 arg1 = reinterpret_cast< wxRect * >(argp1);
7704 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7705 if (!SWIG_IsOK(ecode2)) {
7706 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_y_set" "', expected argument " "2"" of type '" "int""'");
7707 }
7708 arg2 = static_cast< int >(val2);
7709 if (arg1) (arg1)->y = arg2;
7710
7711 resultobj = SWIG_Py_Void();
7712 return resultobj;
7713 fail:
7714 return NULL;
7715 }
7716
7717
7718 SWIGINTERN PyObject *_wrap_Rect_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7719 PyObject *resultobj = 0;
7720 wxRect *arg1 = (wxRect *) 0 ;
7721 int result;
7722 void *argp1 = 0 ;
7723 int res1 = 0 ;
7724 PyObject *swig_obj[1] ;
7725
7726 if (!args) SWIG_fail;
7727 swig_obj[0] = args;
7728 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7729 if (!SWIG_IsOK(res1)) {
7730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_get" "', expected argument " "1"" of type '" "wxRect *""'");
7731 }
7732 arg1 = reinterpret_cast< wxRect * >(argp1);
7733 result = (int) ((arg1)->y);
7734 resultobj = SWIG_From_int(static_cast< int >(result));
7735 return resultobj;
7736 fail:
7737 return NULL;
7738 }
7739
7740
7741 SWIGINTERN PyObject *_wrap_Rect_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7742 PyObject *resultobj = 0;
7743 wxRect *arg1 = (wxRect *) 0 ;
7744 int arg2 ;
7745 void *argp1 = 0 ;
7746 int res1 = 0 ;
7747 int val2 ;
7748 int ecode2 = 0 ;
7749 PyObject *swig_obj[2] ;
7750
7751 if (!SWIG_Python_UnpackTuple(args,"Rect_width_set",2,2,swig_obj)) SWIG_fail;
7752 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7753 if (!SWIG_IsOK(res1)) {
7754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_set" "', expected argument " "1"" of type '" "wxRect *""'");
7755 }
7756 arg1 = reinterpret_cast< wxRect * >(argp1);
7757 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7758 if (!SWIG_IsOK(ecode2)) {
7759 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_width_set" "', expected argument " "2"" of type '" "int""'");
7760 }
7761 arg2 = static_cast< int >(val2);
7762 if (arg1) (arg1)->width = arg2;
7763
7764 resultobj = SWIG_Py_Void();
7765 return resultobj;
7766 fail:
7767 return NULL;
7768 }
7769
7770
7771 SWIGINTERN PyObject *_wrap_Rect_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7772 PyObject *resultobj = 0;
7773 wxRect *arg1 = (wxRect *) 0 ;
7774 int result;
7775 void *argp1 = 0 ;
7776 int res1 = 0 ;
7777 PyObject *swig_obj[1] ;
7778
7779 if (!args) SWIG_fail;
7780 swig_obj[0] = args;
7781 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7782 if (!SWIG_IsOK(res1)) {
7783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_get" "', expected argument " "1"" of type '" "wxRect *""'");
7784 }
7785 arg1 = reinterpret_cast< wxRect * >(argp1);
7786 result = (int) ((arg1)->width);
7787 resultobj = SWIG_From_int(static_cast< int >(result));
7788 return resultobj;
7789 fail:
7790 return NULL;
7791 }
7792
7793
7794 SWIGINTERN PyObject *_wrap_Rect_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7795 PyObject *resultobj = 0;
7796 wxRect *arg1 = (wxRect *) 0 ;
7797 int arg2 ;
7798 void *argp1 = 0 ;
7799 int res1 = 0 ;
7800 int val2 ;
7801 int ecode2 = 0 ;
7802 PyObject *swig_obj[2] ;
7803
7804 if (!SWIG_Python_UnpackTuple(args,"Rect_height_set",2,2,swig_obj)) SWIG_fail;
7805 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7806 if (!SWIG_IsOK(res1)) {
7807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_set" "', expected argument " "1"" of type '" "wxRect *""'");
7808 }
7809 arg1 = reinterpret_cast< wxRect * >(argp1);
7810 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7811 if (!SWIG_IsOK(ecode2)) {
7812 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_height_set" "', expected argument " "2"" of type '" "int""'");
7813 }
7814 arg2 = static_cast< int >(val2);
7815 if (arg1) (arg1)->height = arg2;
7816
7817 resultobj = SWIG_Py_Void();
7818 return resultobj;
7819 fail:
7820 return NULL;
7821 }
7822
7823
7824 SWIGINTERN PyObject *_wrap_Rect_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7825 PyObject *resultobj = 0;
7826 wxRect *arg1 = (wxRect *) 0 ;
7827 int result;
7828 void *argp1 = 0 ;
7829 int res1 = 0 ;
7830 PyObject *swig_obj[1] ;
7831
7832 if (!args) SWIG_fail;
7833 swig_obj[0] = args;
7834 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7835 if (!SWIG_IsOK(res1)) {
7836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_get" "', expected argument " "1"" of type '" "wxRect *""'");
7837 }
7838 arg1 = reinterpret_cast< wxRect * >(argp1);
7839 result = (int) ((arg1)->height);
7840 resultobj = SWIG_From_int(static_cast< int >(result));
7841 return resultobj;
7842 fail:
7843 return NULL;
7844 }
7845
7846
7847 SWIGINTERN PyObject *_wrap_Rect_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7848 PyObject *resultobj = 0;
7849 wxRect *arg1 = (wxRect *) 0 ;
7850 int arg2 = (int) 0 ;
7851 int arg3 = (int) 0 ;
7852 int arg4 = (int) 0 ;
7853 int arg5 = (int) 0 ;
7854 void *argp1 = 0 ;
7855 int res1 = 0 ;
7856 int val2 ;
7857 int ecode2 = 0 ;
7858 int val3 ;
7859 int ecode3 = 0 ;
7860 int val4 ;
7861 int ecode4 = 0 ;
7862 int val5 ;
7863 int ecode5 = 0 ;
7864 PyObject * obj0 = 0 ;
7865 PyObject * obj1 = 0 ;
7866 PyObject * obj2 = 0 ;
7867 PyObject * obj3 = 0 ;
7868 PyObject * obj4 = 0 ;
7869 char * kwnames[] = {
7870 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
7871 };
7872
7873 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
7874 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7875 if (!SWIG_IsOK(res1)) {
7876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Set" "', expected argument " "1"" of type '" "wxRect *""'");
7877 }
7878 arg1 = reinterpret_cast< wxRect * >(argp1);
7879 if (obj1) {
7880 ecode2 = SWIG_AsVal_int(obj1, &val2);
7881 if (!SWIG_IsOK(ecode2)) {
7882 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Set" "', expected argument " "2"" of type '" "int""'");
7883 }
7884 arg2 = static_cast< int >(val2);
7885 }
7886 if (obj2) {
7887 ecode3 = SWIG_AsVal_int(obj2, &val3);
7888 if (!SWIG_IsOK(ecode3)) {
7889 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Set" "', expected argument " "3"" of type '" "int""'");
7890 }
7891 arg3 = static_cast< int >(val3);
7892 }
7893 if (obj3) {
7894 ecode4 = SWIG_AsVal_int(obj3, &val4);
7895 if (!SWIG_IsOK(ecode4)) {
7896 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Rect_Set" "', expected argument " "4"" of type '" "int""'");
7897 }
7898 arg4 = static_cast< int >(val4);
7899 }
7900 if (obj4) {
7901 ecode5 = SWIG_AsVal_int(obj4, &val5);
7902 if (!SWIG_IsOK(ecode5)) {
7903 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Rect_Set" "', expected argument " "5"" of type '" "int""'");
7904 }
7905 arg5 = static_cast< int >(val5);
7906 }
7907 {
7908 PyThreadState* __tstate = wxPyBeginAllowThreads();
7909 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
7910 wxPyEndAllowThreads(__tstate);
7911 if (PyErr_Occurred()) SWIG_fail;
7912 }
7913 resultobj = SWIG_Py_Void();
7914 return resultobj;
7915 fail:
7916 return NULL;
7917 }
7918
7919
7920 SWIGINTERN PyObject *_wrap_Rect_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7921 PyObject *resultobj = 0;
7922 wxRect *arg1 = (wxRect *) 0 ;
7923 PyObject *result = 0 ;
7924 void *argp1 = 0 ;
7925 int res1 = 0 ;
7926 PyObject *swig_obj[1] ;
7927
7928 if (!args) SWIG_fail;
7929 swig_obj[0] = args;
7930 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7931 if (!SWIG_IsOK(res1)) {
7932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Get" "', expected argument " "1"" of type '" "wxRect *""'");
7933 }
7934 arg1 = reinterpret_cast< wxRect * >(argp1);
7935 {
7936 PyThreadState* __tstate = wxPyBeginAllowThreads();
7937 result = (PyObject *)wxRect_Get(arg1);
7938 wxPyEndAllowThreads(__tstate);
7939 if (PyErr_Occurred()) SWIG_fail;
7940 }
7941 resultobj = result;
7942 return resultobj;
7943 fail:
7944 return NULL;
7945 }
7946
7947
7948 SWIGINTERN PyObject *Rect_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7949 PyObject *obj;
7950 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7951 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect, SWIG_NewClientData(obj));
7952 return SWIG_Py_Void();
7953 }
7954
7955 SWIGINTERN PyObject *Rect_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7956 return SWIG_Python_InitShadowInstance(args);
7957 }
7958
7959 SWIGINTERN PyObject *_wrap_IntersectRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7960 PyObject *resultobj = 0;
7961 wxRect *arg1 = (wxRect *) 0 ;
7962 wxRect *arg2 = (wxRect *) 0 ;
7963 PyObject *result = 0 ;
7964 void *argp1 = 0 ;
7965 int res1 = 0 ;
7966 void *argp2 = 0 ;
7967 int res2 = 0 ;
7968 PyObject * obj0 = 0 ;
7969 PyObject * obj1 = 0 ;
7970 char * kwnames[] = {
7971 (char *) "r1",(char *) "r2", NULL
7972 };
7973
7974 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) SWIG_fail;
7975 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7976 if (!SWIG_IsOK(res1)) {
7977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntersectRect" "', expected argument " "1"" of type '" "wxRect *""'");
7978 }
7979 arg1 = reinterpret_cast< wxRect * >(argp1);
7980 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
7981 if (!SWIG_IsOK(res2)) {
7982 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntersectRect" "', expected argument " "2"" of type '" "wxRect *""'");
7983 }
7984 arg2 = reinterpret_cast< wxRect * >(argp2);
7985 {
7986 if (!wxPyCheckForApp()) SWIG_fail;
7987 PyThreadState* __tstate = wxPyBeginAllowThreads();
7988 result = (PyObject *)wxIntersectRect(arg1,arg2);
7989 wxPyEndAllowThreads(__tstate);
7990 if (PyErr_Occurred()) SWIG_fail;
7991 }
7992 resultobj = result;
7993 return resultobj;
7994 fail:
7995 return NULL;
7996 }
7997
7998
7999 SWIGINTERN PyObject *_wrap_new_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8000 PyObject *resultobj = 0;
8001 double arg1 = (double) 0.0 ;
8002 double arg2 = (double) 0.0 ;
8003 wxPoint2D *result = 0 ;
8004 double val1 ;
8005 int ecode1 = 0 ;
8006 double val2 ;
8007 int ecode2 = 0 ;
8008 PyObject * obj0 = 0 ;
8009 PyObject * obj1 = 0 ;
8010 char * kwnames[] = {
8011 (char *) "x",(char *) "y", NULL
8012 };
8013
8014 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) SWIG_fail;
8015 if (obj0) {
8016 ecode1 = SWIG_AsVal_double(obj0, &val1);
8017 if (!SWIG_IsOK(ecode1)) {
8018 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point2D" "', expected argument " "1"" of type '" "double""'");
8019 }
8020 arg1 = static_cast< double >(val1);
8021 }
8022 if (obj1) {
8023 ecode2 = SWIG_AsVal_double(obj1, &val2);
8024 if (!SWIG_IsOK(ecode2)) {
8025 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point2D" "', expected argument " "2"" of type '" "double""'");
8026 }
8027 arg2 = static_cast< double >(val2);
8028 }
8029 {
8030 PyThreadState* __tstate = wxPyBeginAllowThreads();
8031 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
8032 wxPyEndAllowThreads(__tstate);
8033 if (PyErr_Occurred()) SWIG_fail;
8034 }
8035 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_NEW | 0 );
8036 return resultobj;
8037 fail:
8038 return NULL;
8039 }
8040
8041
8042 SWIGINTERN PyObject *_wrap_new_Point2DCopy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8043 PyObject *resultobj = 0;
8044 wxPoint2D *arg1 = 0 ;
8045 wxPoint2D *result = 0 ;
8046 wxPoint2D temp1 ;
8047 PyObject * obj0 = 0 ;
8048 char * kwnames[] = {
8049 (char *) "pt", NULL
8050 };
8051
8052 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) SWIG_fail;
8053 {
8054 arg1 = &temp1;
8055 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
8056 }
8057 {
8058 PyThreadState* __tstate = wxPyBeginAllowThreads();
8059 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
8060 wxPyEndAllowThreads(__tstate);
8061 if (PyErr_Occurred()) SWIG_fail;
8062 }
8063 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8064 return resultobj;
8065 fail:
8066 return NULL;
8067 }
8068
8069
8070 SWIGINTERN PyObject *_wrap_new_Point2DFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8071 PyObject *resultobj = 0;
8072 wxPoint *arg1 = 0 ;
8073 wxPoint2D *result = 0 ;
8074 wxPoint temp1 ;
8075 PyObject * obj0 = 0 ;
8076 char * kwnames[] = {
8077 (char *) "pt", NULL
8078 };
8079
8080 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) SWIG_fail;
8081 {
8082 arg1 = &temp1;
8083 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
8084 }
8085 {
8086 PyThreadState* __tstate = wxPyBeginAllowThreads();
8087 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
8088 wxPyEndAllowThreads(__tstate);
8089 if (PyErr_Occurred()) SWIG_fail;
8090 }
8091 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8092 return resultobj;
8093 fail:
8094 return NULL;
8095 }
8096
8097
8098 SWIGINTERN PyObject *_wrap_Point2D_GetFloor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8099 PyObject *resultobj = 0;
8100 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8101 int *arg2 = (int *) 0 ;
8102 int *arg3 = (int *) 0 ;
8103 void *argp1 = 0 ;
8104 int res1 = 0 ;
8105 int temp2 ;
8106 int res2 = SWIG_TMPOBJ ;
8107 int temp3 ;
8108 int res3 = SWIG_TMPOBJ ;
8109 PyObject *swig_obj[1] ;
8110
8111 arg2 = &temp2;
8112 arg3 = &temp3;
8113 if (!args) SWIG_fail;
8114 swig_obj[0] = args;
8115 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8116 if (!SWIG_IsOK(res1)) {
8117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetFloor" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8118 }
8119 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8120 {
8121 PyThreadState* __tstate = wxPyBeginAllowThreads();
8122 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
8123 wxPyEndAllowThreads(__tstate);
8124 if (PyErr_Occurred()) SWIG_fail;
8125 }
8126 resultobj = SWIG_Py_Void();
8127 if (SWIG_IsTmpObj(res2)) {
8128 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8129 } else {
8130 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8131 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8132 }
8133 if (SWIG_IsTmpObj(res3)) {
8134 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8135 } else {
8136 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8137 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8138 }
8139 return resultobj;
8140 fail:
8141 return NULL;
8142 }
8143
8144
8145 SWIGINTERN PyObject *_wrap_Point2D_GetRounded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8146 PyObject *resultobj = 0;
8147 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8148 int *arg2 = (int *) 0 ;
8149 int *arg3 = (int *) 0 ;
8150 void *argp1 = 0 ;
8151 int res1 = 0 ;
8152 int temp2 ;
8153 int res2 = SWIG_TMPOBJ ;
8154 int temp3 ;
8155 int res3 = SWIG_TMPOBJ ;
8156 PyObject *swig_obj[1] ;
8157
8158 arg2 = &temp2;
8159 arg3 = &temp3;
8160 if (!args) SWIG_fail;
8161 swig_obj[0] = args;
8162 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8163 if (!SWIG_IsOK(res1)) {
8164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetRounded" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8165 }
8166 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8167 {
8168 PyThreadState* __tstate = wxPyBeginAllowThreads();
8169 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
8170 wxPyEndAllowThreads(__tstate);
8171 if (PyErr_Occurred()) SWIG_fail;
8172 }
8173 resultobj = SWIG_Py_Void();
8174 if (SWIG_IsTmpObj(res2)) {
8175 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8176 } else {
8177 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8178 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8179 }
8180 if (SWIG_IsTmpObj(res3)) {
8181 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8182 } else {
8183 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8184 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8185 }
8186 return resultobj;
8187 fail:
8188 return NULL;
8189 }
8190
8191
8192 SWIGINTERN PyObject *_wrap_Point2D_GetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8193 PyObject *resultobj = 0;
8194 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8195 double result;
8196 void *argp1 = 0 ;
8197 int res1 = 0 ;
8198 PyObject *swig_obj[1] ;
8199
8200 if (!args) SWIG_fail;
8201 swig_obj[0] = args;
8202 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8203 if (!SWIG_IsOK(res1)) {
8204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8205 }
8206 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8207 {
8208 PyThreadState* __tstate = wxPyBeginAllowThreads();
8209 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
8210 wxPyEndAllowThreads(__tstate);
8211 if (PyErr_Occurred()) SWIG_fail;
8212 }
8213 resultobj = SWIG_From_double(static_cast< double >(result));
8214 return resultobj;
8215 fail:
8216 return NULL;
8217 }
8218
8219
8220 SWIGINTERN PyObject *_wrap_Point2D_GetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8221 PyObject *resultobj = 0;
8222 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8223 double result;
8224 void *argp1 = 0 ;
8225 int res1 = 0 ;
8226 PyObject *swig_obj[1] ;
8227
8228 if (!args) SWIG_fail;
8229 swig_obj[0] = args;
8230 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8231 if (!SWIG_IsOK(res1)) {
8232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8233 }
8234 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8235 {
8236 PyThreadState* __tstate = wxPyBeginAllowThreads();
8237 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
8238 wxPyEndAllowThreads(__tstate);
8239 if (PyErr_Occurred()) SWIG_fail;
8240 }
8241 resultobj = SWIG_From_double(static_cast< double >(result));
8242 return resultobj;
8243 fail:
8244 return NULL;
8245 }
8246
8247
8248 SWIGINTERN PyObject *_wrap_Point2D_SetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8249 PyObject *resultobj = 0;
8250 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8251 double arg2 ;
8252 void *argp1 = 0 ;
8253 int res1 = 0 ;
8254 double val2 ;
8255 int ecode2 = 0 ;
8256 PyObject * obj0 = 0 ;
8257 PyObject * obj1 = 0 ;
8258 char * kwnames[] = {
8259 (char *) "self",(char *) "length", NULL
8260 };
8261
8262 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) SWIG_fail;
8263 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8264 if (!SWIG_IsOK(res1)) {
8265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8266 }
8267 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8268 ecode2 = SWIG_AsVal_double(obj1, &val2);
8269 if (!SWIG_IsOK(ecode2)) {
8270 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorLength" "', expected argument " "2"" of type '" "double""'");
8271 }
8272 arg2 = static_cast< double >(val2);
8273 {
8274 PyThreadState* __tstate = wxPyBeginAllowThreads();
8275 (arg1)->SetVectorLength(arg2);
8276 wxPyEndAllowThreads(__tstate);
8277 if (PyErr_Occurred()) SWIG_fail;
8278 }
8279 resultobj = SWIG_Py_Void();
8280 return resultobj;
8281 fail:
8282 return NULL;
8283 }
8284
8285
8286 SWIGINTERN PyObject *_wrap_Point2D_SetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8287 PyObject *resultobj = 0;
8288 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8289 double arg2 ;
8290 void *argp1 = 0 ;
8291 int res1 = 0 ;
8292 double val2 ;
8293 int ecode2 = 0 ;
8294 PyObject * obj0 = 0 ;
8295 PyObject * obj1 = 0 ;
8296 char * kwnames[] = {
8297 (char *) "self",(char *) "degrees", NULL
8298 };
8299
8300 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) SWIG_fail;
8301 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8302 if (!SWIG_IsOK(res1)) {
8303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8304 }
8305 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8306 ecode2 = SWIG_AsVal_double(obj1, &val2);
8307 if (!SWIG_IsOK(ecode2)) {
8308 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorAngle" "', expected argument " "2"" of type '" "double""'");
8309 }
8310 arg2 = static_cast< double >(val2);
8311 {
8312 PyThreadState* __tstate = wxPyBeginAllowThreads();
8313 (arg1)->SetVectorAngle(arg2);
8314 wxPyEndAllowThreads(__tstate);
8315 if (PyErr_Occurred()) SWIG_fail;
8316 }
8317 resultobj = SWIG_Py_Void();
8318 return resultobj;
8319 fail:
8320 return NULL;
8321 }
8322
8323
8324 SWIGINTERN PyObject *_wrap_Point2D_GetDistance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8325 PyObject *resultobj = 0;
8326 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8327 wxPoint2D *arg2 = 0 ;
8328 double result;
8329 void *argp1 = 0 ;
8330 int res1 = 0 ;
8331 wxPoint2D temp2 ;
8332 PyObject * obj0 = 0 ;
8333 PyObject * obj1 = 0 ;
8334 char * kwnames[] = {
8335 (char *) "self",(char *) "pt", NULL
8336 };
8337
8338 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) SWIG_fail;
8339 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8340 if (!SWIG_IsOK(res1)) {
8341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistance" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8342 }
8343 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8344 {
8345 arg2 = &temp2;
8346 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8347 }
8348 {
8349 PyThreadState* __tstate = wxPyBeginAllowThreads();
8350 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
8351 wxPyEndAllowThreads(__tstate);
8352 if (PyErr_Occurred()) SWIG_fail;
8353 }
8354 resultobj = SWIG_From_double(static_cast< double >(result));
8355 return resultobj;
8356 fail:
8357 return NULL;
8358 }
8359
8360
8361 SWIGINTERN PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8362 PyObject *resultobj = 0;
8363 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8364 wxPoint2D *arg2 = 0 ;
8365 double result;
8366 void *argp1 = 0 ;
8367 int res1 = 0 ;
8368 wxPoint2D temp2 ;
8369 PyObject * obj0 = 0 ;
8370 PyObject * obj1 = 0 ;
8371 char * kwnames[] = {
8372 (char *) "self",(char *) "pt", NULL
8373 };
8374
8375 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) SWIG_fail;
8376 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8377 if (!SWIG_IsOK(res1)) {
8378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistanceSquare" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8379 }
8380 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8381 {
8382 arg2 = &temp2;
8383 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8384 }
8385 {
8386 PyThreadState* __tstate = wxPyBeginAllowThreads();
8387 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
8388 wxPyEndAllowThreads(__tstate);
8389 if (PyErr_Occurred()) SWIG_fail;
8390 }
8391 resultobj = SWIG_From_double(static_cast< double >(result));
8392 return resultobj;
8393 fail:
8394 return NULL;
8395 }
8396
8397
8398 SWIGINTERN PyObject *_wrap_Point2D_GetDotProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8399 PyObject *resultobj = 0;
8400 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8401 wxPoint2D *arg2 = 0 ;
8402 double result;
8403 void *argp1 = 0 ;
8404 int res1 = 0 ;
8405 wxPoint2D temp2 ;
8406 PyObject * obj0 = 0 ;
8407 PyObject * obj1 = 0 ;
8408 char * kwnames[] = {
8409 (char *) "self",(char *) "vec", NULL
8410 };
8411
8412 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8413 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8414 if (!SWIG_IsOK(res1)) {
8415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDotProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8416 }
8417 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8418 {
8419 arg2 = &temp2;
8420 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8421 }
8422 {
8423 PyThreadState* __tstate = wxPyBeginAllowThreads();
8424 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
8425 wxPyEndAllowThreads(__tstate);
8426 if (PyErr_Occurred()) SWIG_fail;
8427 }
8428 resultobj = SWIG_From_double(static_cast< double >(result));
8429 return resultobj;
8430 fail:
8431 return NULL;
8432 }
8433
8434
8435 SWIGINTERN PyObject *_wrap_Point2D_GetCrossProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8436 PyObject *resultobj = 0;
8437 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8438 wxPoint2D *arg2 = 0 ;
8439 double result;
8440 void *argp1 = 0 ;
8441 int res1 = 0 ;
8442 wxPoint2D temp2 ;
8443 PyObject * obj0 = 0 ;
8444 PyObject * obj1 = 0 ;
8445 char * kwnames[] = {
8446 (char *) "self",(char *) "vec", NULL
8447 };
8448
8449 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8450 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8451 if (!SWIG_IsOK(res1)) {
8452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetCrossProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8453 }
8454 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8455 {
8456 arg2 = &temp2;
8457 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8458 }
8459 {
8460 PyThreadState* __tstate = wxPyBeginAllowThreads();
8461 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
8462 wxPyEndAllowThreads(__tstate);
8463 if (PyErr_Occurred()) SWIG_fail;
8464 }
8465 resultobj = SWIG_From_double(static_cast< double >(result));
8466 return resultobj;
8467 fail:
8468 return NULL;
8469 }
8470
8471
8472 SWIGINTERN PyObject *_wrap_Point2D___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8473 PyObject *resultobj = 0;
8474 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8475 wxPoint2D result;
8476 void *argp1 = 0 ;
8477 int res1 = 0 ;
8478 PyObject *swig_obj[1] ;
8479
8480 if (!args) SWIG_fail;
8481 swig_obj[0] = args;
8482 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8483 if (!SWIG_IsOK(res1)) {
8484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___neg__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8485 }
8486 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8487 {
8488 PyThreadState* __tstate = wxPyBeginAllowThreads();
8489 result = (arg1)->operator -();
8490 wxPyEndAllowThreads(__tstate);
8491 if (PyErr_Occurred()) SWIG_fail;
8492 }
8493 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8494 return resultobj;
8495 fail:
8496 return NULL;
8497 }
8498
8499
8500 SWIGINTERN PyObject *_wrap_Point2D___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8501 PyObject *resultobj = 0;
8502 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8503 wxPoint2D *arg2 = 0 ;
8504 wxPoint2D *result = 0 ;
8505 void *argp1 = 0 ;
8506 int res1 = 0 ;
8507 wxPoint2D temp2 ;
8508 PyObject * obj0 = 0 ;
8509 PyObject * obj1 = 0 ;
8510 char * kwnames[] = {
8511 (char *) "self",(char *) "pt", NULL
8512 };
8513
8514 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
8515 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8516 if (!SWIG_IsOK(res1)) {
8517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___iadd__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8518 }
8519 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8520 {
8521 arg2 = &temp2;
8522 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8523 }
8524 {
8525 PyThreadState* __tstate = wxPyBeginAllowThreads();
8526 {
8527 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
8528 result = (wxPoint2D *) &_result_ref;
8529 }
8530 wxPyEndAllowThreads(__tstate);
8531 if (PyErr_Occurred()) SWIG_fail;
8532 }
8533 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8534 return resultobj;
8535 fail:
8536 return NULL;
8537 }
8538
8539
8540 SWIGINTERN PyObject *_wrap_Point2D___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8541 PyObject *resultobj = 0;
8542 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8543 wxPoint2D *arg2 = 0 ;
8544 wxPoint2D *result = 0 ;
8545 void *argp1 = 0 ;
8546 int res1 = 0 ;
8547 wxPoint2D temp2 ;
8548 PyObject * obj0 = 0 ;
8549 PyObject * obj1 = 0 ;
8550 char * kwnames[] = {
8551 (char *) "self",(char *) "pt", NULL
8552 };
8553
8554 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
8555 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8556 if (!SWIG_IsOK(res1)) {
8557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___isub__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8558 }
8559 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8560 {
8561 arg2 = &temp2;
8562 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8563 }
8564 {
8565 PyThreadState* __tstate = wxPyBeginAllowThreads();
8566 {
8567 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
8568 result = (wxPoint2D *) &_result_ref;
8569 }
8570 wxPyEndAllowThreads(__tstate);
8571 if (PyErr_Occurred()) SWIG_fail;
8572 }
8573 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8574 return resultobj;
8575 fail:
8576 return NULL;
8577 }
8578
8579
8580 SWIGINTERN PyObject *_wrap_Point2D___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8581 PyObject *resultobj = 0;
8582 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8583 wxPoint2D *arg2 = 0 ;
8584 wxPoint2D *result = 0 ;
8585 void *argp1 = 0 ;
8586 int res1 = 0 ;
8587 wxPoint2D temp2 ;
8588 PyObject * obj0 = 0 ;
8589 PyObject * obj1 = 0 ;
8590 char * kwnames[] = {
8591 (char *) "self",(char *) "pt", NULL
8592 };
8593
8594 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
8595 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8596 if (!SWIG_IsOK(res1)) {
8597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___imul__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8598 }
8599 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8600 {
8601 arg2 = &temp2;
8602 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8603 }
8604 {
8605 PyThreadState* __tstate = wxPyBeginAllowThreads();
8606 {
8607 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
8608 result = (wxPoint2D *) &_result_ref;
8609 }
8610 wxPyEndAllowThreads(__tstate);
8611 if (PyErr_Occurred()) SWIG_fail;
8612 }
8613 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8614 return resultobj;
8615 fail:
8616 return NULL;
8617 }
8618
8619
8620 SWIGINTERN PyObject *_wrap_Point2D___idiv__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8621 PyObject *resultobj = 0;
8622 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8623 wxPoint2D *arg2 = 0 ;
8624 wxPoint2D *result = 0 ;
8625 void *argp1 = 0 ;
8626 int res1 = 0 ;
8627 wxPoint2D temp2 ;
8628 PyObject * obj0 = 0 ;
8629 PyObject * obj1 = 0 ;
8630 char * kwnames[] = {
8631 (char *) "self",(char *) "pt", NULL
8632 };
8633
8634 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) SWIG_fail;
8635 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8636 if (!SWIG_IsOK(res1)) {
8637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___idiv__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8638 }
8639 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8640 {
8641 arg2 = &temp2;
8642 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8643 }
8644 {
8645 PyThreadState* __tstate = wxPyBeginAllowThreads();
8646 {
8647 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
8648 result = (wxPoint2D *) &_result_ref;
8649 }
8650 wxPyEndAllowThreads(__tstate);
8651 if (PyErr_Occurred()) SWIG_fail;
8652 }
8653 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8654 return resultobj;
8655 fail:
8656 return NULL;
8657 }
8658
8659
8660 SWIGINTERN PyObject *_wrap_Point2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8661 PyObject *resultobj = 0;
8662 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8663 PyObject *arg2 = (PyObject *) 0 ;
8664 bool result;
8665 void *argp1 = 0 ;
8666 int res1 = 0 ;
8667 PyObject * obj0 = 0 ;
8668 PyObject * obj1 = 0 ;
8669 char * kwnames[] = {
8670 (char *) "self",(char *) "other", NULL
8671 };
8672
8673 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
8674 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8675 if (!SWIG_IsOK(res1)) {
8676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___eq__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8677 }
8678 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8679 arg2 = obj1;
8680 {
8681 result = (bool)wxPoint2D___eq__(arg1,arg2);
8682 if (PyErr_Occurred()) SWIG_fail;
8683 }
8684 {
8685 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8686 }
8687 return resultobj;
8688 fail:
8689 return NULL;
8690 }
8691
8692
8693 SWIGINTERN PyObject *_wrap_Point2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8694 PyObject *resultobj = 0;
8695 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8696 PyObject *arg2 = (PyObject *) 0 ;
8697 bool result;
8698 void *argp1 = 0 ;
8699 int res1 = 0 ;
8700 PyObject * obj0 = 0 ;
8701 PyObject * obj1 = 0 ;
8702 char * kwnames[] = {
8703 (char *) "self",(char *) "other", NULL
8704 };
8705
8706 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
8707 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8708 if (!SWIG_IsOK(res1)) {
8709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___ne__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8710 }
8711 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8712 arg2 = obj1;
8713 {
8714 result = (bool)wxPoint2D___ne__(arg1,arg2);
8715 if (PyErr_Occurred()) SWIG_fail;
8716 }
8717 {
8718 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8719 }
8720 return resultobj;
8721 fail:
8722 return NULL;
8723 }
8724
8725
8726 SWIGINTERN PyObject *_wrap_Point2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8727 PyObject *resultobj = 0;
8728 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8729 double arg2 ;
8730 void *argp1 = 0 ;
8731 int res1 = 0 ;
8732 double val2 ;
8733 int ecode2 = 0 ;
8734 PyObject *swig_obj[2] ;
8735
8736 if (!SWIG_Python_UnpackTuple(args,"Point2D_x_set",2,2,swig_obj)) SWIG_fail;
8737 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8738 if (!SWIG_IsOK(res1)) {
8739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8740 }
8741 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8742 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8743 if (!SWIG_IsOK(ecode2)) {
8744 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_x_set" "', expected argument " "2"" of type '" "double""'");
8745 }
8746 arg2 = static_cast< double >(val2);
8747 if (arg1) (arg1)->m_x = arg2;
8748
8749 resultobj = SWIG_Py_Void();
8750 return resultobj;
8751 fail:
8752 return NULL;
8753 }
8754
8755
8756 SWIGINTERN PyObject *_wrap_Point2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8757 PyObject *resultobj = 0;
8758 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8759 double result;
8760 void *argp1 = 0 ;
8761 int res1 = 0 ;
8762 PyObject *swig_obj[1] ;
8763
8764 if (!args) SWIG_fail;
8765 swig_obj[0] = args;
8766 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8767 if (!SWIG_IsOK(res1)) {
8768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8769 }
8770 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8771 result = (double) ((arg1)->m_x);
8772 resultobj = SWIG_From_double(static_cast< double >(result));
8773 return resultobj;
8774 fail:
8775 return NULL;
8776 }
8777
8778
8779 SWIGINTERN PyObject *_wrap_Point2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8780 PyObject *resultobj = 0;
8781 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8782 double arg2 ;
8783 void *argp1 = 0 ;
8784 int res1 = 0 ;
8785 double val2 ;
8786 int ecode2 = 0 ;
8787 PyObject *swig_obj[2] ;
8788
8789 if (!SWIG_Python_UnpackTuple(args,"Point2D_y_set",2,2,swig_obj)) SWIG_fail;
8790 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8791 if (!SWIG_IsOK(res1)) {
8792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8793 }
8794 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8795 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8796 if (!SWIG_IsOK(ecode2)) {
8797 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_y_set" "', expected argument " "2"" of type '" "double""'");
8798 }
8799 arg2 = static_cast< double >(val2);
8800 if (arg1) (arg1)->m_y = arg2;
8801
8802 resultobj = SWIG_Py_Void();
8803 return resultobj;
8804 fail:
8805 return NULL;
8806 }
8807
8808
8809 SWIGINTERN PyObject *_wrap_Point2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8810 PyObject *resultobj = 0;
8811 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8812 double result;
8813 void *argp1 = 0 ;
8814 int res1 = 0 ;
8815 PyObject *swig_obj[1] ;
8816
8817 if (!args) SWIG_fail;
8818 swig_obj[0] = args;
8819 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8820 if (!SWIG_IsOK(res1)) {
8821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8822 }
8823 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8824 result = (double) ((arg1)->m_y);
8825 resultobj = SWIG_From_double(static_cast< double >(result));
8826 return resultobj;
8827 fail:
8828 return NULL;
8829 }
8830
8831
8832 SWIGINTERN PyObject *_wrap_Point2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8833 PyObject *resultobj = 0;
8834 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8835 double arg2 = (double) 0 ;
8836 double arg3 = (double) 0 ;
8837 void *argp1 = 0 ;
8838 int res1 = 0 ;
8839 double val2 ;
8840 int ecode2 = 0 ;
8841 double val3 ;
8842 int ecode3 = 0 ;
8843 PyObject * obj0 = 0 ;
8844 PyObject * obj1 = 0 ;
8845 PyObject * obj2 = 0 ;
8846 char * kwnames[] = {
8847 (char *) "self",(char *) "x",(char *) "y", NULL
8848 };
8849
8850 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8851 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8852 if (!SWIG_IsOK(res1)) {
8853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8854 }
8855 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8856 if (obj1) {
8857 ecode2 = SWIG_AsVal_double(obj1, &val2);
8858 if (!SWIG_IsOK(ecode2)) {
8859 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_Set" "', expected argument " "2"" of type '" "double""'");
8860 }
8861 arg2 = static_cast< double >(val2);
8862 }
8863 if (obj2) {
8864 ecode3 = SWIG_AsVal_double(obj2, &val3);
8865 if (!SWIG_IsOK(ecode3)) {
8866 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point2D_Set" "', expected argument " "3"" of type '" "double""'");
8867 }
8868 arg3 = static_cast< double >(val3);
8869 }
8870 {
8871 PyThreadState* __tstate = wxPyBeginAllowThreads();
8872 wxPoint2D_Set(arg1,arg2,arg3);
8873 wxPyEndAllowThreads(__tstate);
8874 if (PyErr_Occurred()) SWIG_fail;
8875 }
8876 resultobj = SWIG_Py_Void();
8877 return resultobj;
8878 fail:
8879 return NULL;
8880 }
8881
8882
8883 SWIGINTERN PyObject *_wrap_Point2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8884 PyObject *resultobj = 0;
8885 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8886 PyObject *result = 0 ;
8887 void *argp1 = 0 ;
8888 int res1 = 0 ;
8889 PyObject *swig_obj[1] ;
8890
8891 if (!args) SWIG_fail;
8892 swig_obj[0] = args;
8893 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8894 if (!SWIG_IsOK(res1)) {
8895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8896 }
8897 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8898 {
8899 PyThreadState* __tstate = wxPyBeginAllowThreads();
8900 result = (PyObject *)wxPoint2D_Get(arg1);
8901 wxPyEndAllowThreads(__tstate);
8902 if (PyErr_Occurred()) SWIG_fail;
8903 }
8904 resultobj = result;
8905 return resultobj;
8906 fail:
8907 return NULL;
8908 }
8909
8910
8911 SWIGINTERN PyObject *Point2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8912 PyObject *obj;
8913 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8914 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint2D, SWIG_NewClientData(obj));
8915 return SWIG_Py_Void();
8916 }
8917
8918 SWIGINTERN PyObject *Point2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8919 return SWIG_Python_InitShadowInstance(args);
8920 }
8921
8922 SWIGINTERN int DefaultPosition_set(PyObject *) {
8923 SWIG_Error(SWIG_AttributeError,"Variable DefaultPosition is read-only.");
8924 return 1;
8925 }
8926
8927
8928 SWIGINTERN PyObject *DefaultPosition_get(void) {
8929 PyObject *pyobj = 0;
8930
8931 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0 );
8932 return pyobj;
8933 }
8934
8935
8936 SWIGINTERN int DefaultSize_set(PyObject *) {
8937 SWIG_Error(SWIG_AttributeError,"Variable DefaultSize is read-only.");
8938 return 1;
8939 }
8940
8941
8942 SWIGINTERN PyObject *DefaultSize_get(void) {
8943 PyObject *pyobj = 0;
8944
8945 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSize), SWIGTYPE_p_wxSize, 0 );
8946 return pyobj;
8947 }
8948
8949
8950 SWIGINTERN PyObject *_wrap_new_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8951 PyObject *resultobj = 0;
8952 PyObject *arg1 = (PyObject *) 0 ;
8953 wxPyInputStream *result = 0 ;
8954 PyObject * obj0 = 0 ;
8955 char * kwnames[] = {
8956 (char *) "p", NULL
8957 };
8958
8959 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) SWIG_fail;
8960 arg1 = obj0;
8961 {
8962 PyThreadState* __tstate = wxPyBeginAllowThreads();
8963 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
8964 wxPyEndAllowThreads(__tstate);
8965 if (PyErr_Occurred()) SWIG_fail;
8966 }
8967 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_NEW | 0 );
8968 return resultobj;
8969 fail:
8970 return NULL;
8971 }
8972
8973
8974 SWIGINTERN PyObject *_wrap_delete_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8975 PyObject *resultobj = 0;
8976 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8977 void *argp1 = 0 ;
8978 int res1 = 0 ;
8979 PyObject *swig_obj[1] ;
8980
8981 if (!args) SWIG_fail;
8982 swig_obj[0] = args;
8983 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_DISOWN | 0 );
8984 if (!SWIG_IsOK(res1)) {
8985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InputStream" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
8986 }
8987 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
8988 {
8989 PyThreadState* __tstate = wxPyBeginAllowThreads();
8990 delete arg1;
8991
8992 wxPyEndAllowThreads(__tstate);
8993 if (PyErr_Occurred()) SWIG_fail;
8994 }
8995 resultobj = SWIG_Py_Void();
8996 return resultobj;
8997 fail:
8998 return NULL;
8999 }
9000
9001
9002 SWIGINTERN PyObject *_wrap_InputStream_close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9003 PyObject *resultobj = 0;
9004 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9005 void *argp1 = 0 ;
9006 int res1 = 0 ;
9007 PyObject *swig_obj[1] ;
9008
9009 if (!args) SWIG_fail;
9010 swig_obj[0] = args;
9011 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9012 if (!SWIG_IsOK(res1)) {
9013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_close" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9014 }
9015 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9016 {
9017 PyThreadState* __tstate = wxPyBeginAllowThreads();
9018 (arg1)->close();
9019 wxPyEndAllowThreads(__tstate);
9020 if (PyErr_Occurred()) SWIG_fail;
9021 }
9022 resultobj = SWIG_Py_Void();
9023 return resultobj;
9024 fail:
9025 return NULL;
9026 }
9027
9028
9029 SWIGINTERN PyObject *_wrap_InputStream_flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9030 PyObject *resultobj = 0;
9031 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9032 void *argp1 = 0 ;
9033 int res1 = 0 ;
9034 PyObject *swig_obj[1] ;
9035
9036 if (!args) SWIG_fail;
9037 swig_obj[0] = args;
9038 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9039 if (!SWIG_IsOK(res1)) {
9040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_flush" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9041 }
9042 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9043 {
9044 PyThreadState* __tstate = wxPyBeginAllowThreads();
9045 (arg1)->flush();
9046 wxPyEndAllowThreads(__tstate);
9047 if (PyErr_Occurred()) SWIG_fail;
9048 }
9049 resultobj = SWIG_Py_Void();
9050 return resultobj;
9051 fail:
9052 return NULL;
9053 }
9054
9055
9056 SWIGINTERN PyObject *_wrap_InputStream_eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9057 PyObject *resultobj = 0;
9058 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9059 bool result;
9060 void *argp1 = 0 ;
9061 int res1 = 0 ;
9062 PyObject *swig_obj[1] ;
9063
9064 if (!args) SWIG_fail;
9065 swig_obj[0] = args;
9066 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9067 if (!SWIG_IsOK(res1)) {
9068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9069 }
9070 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9071 {
9072 PyThreadState* __tstate = wxPyBeginAllowThreads();
9073 result = (bool)(arg1)->eof();
9074 wxPyEndAllowThreads(__tstate);
9075 if (PyErr_Occurred()) SWIG_fail;
9076 }
9077 {
9078 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9079 }
9080 return resultobj;
9081 fail:
9082 return NULL;
9083 }
9084
9085
9086 SWIGINTERN PyObject *_wrap_InputStream_read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9087 PyObject *resultobj = 0;
9088 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9089 int arg2 = (int) -1 ;
9090 PyObject *result = 0 ;
9091 void *argp1 = 0 ;
9092 int res1 = 0 ;
9093 int val2 ;
9094 int ecode2 = 0 ;
9095 PyObject * obj0 = 0 ;
9096 PyObject * obj1 = 0 ;
9097 char * kwnames[] = {
9098 (char *) "self",(char *) "size", NULL
9099 };
9100
9101 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) SWIG_fail;
9102 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9103 if (!SWIG_IsOK(res1)) {
9104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_read" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9105 }
9106 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9107 if (obj1) {
9108 ecode2 = SWIG_AsVal_int(obj1, &val2);
9109 if (!SWIG_IsOK(ecode2)) {
9110 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_read" "', expected argument " "2"" of type '" "int""'");
9111 }
9112 arg2 = static_cast< int >(val2);
9113 }
9114 {
9115 PyThreadState* __tstate = wxPyBeginAllowThreads();
9116 result = (PyObject *)(arg1)->read(arg2);
9117 wxPyEndAllowThreads(__tstate);
9118 if (PyErr_Occurred()) SWIG_fail;
9119 }
9120 resultobj = result;
9121 return resultobj;
9122 fail:
9123 return NULL;
9124 }
9125
9126
9127 SWIGINTERN PyObject *_wrap_InputStream_readline(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9128 PyObject *resultobj = 0;
9129 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9130 int arg2 = (int) -1 ;
9131 PyObject *result = 0 ;
9132 void *argp1 = 0 ;
9133 int res1 = 0 ;
9134 int val2 ;
9135 int ecode2 = 0 ;
9136 PyObject * obj0 = 0 ;
9137 PyObject * obj1 = 0 ;
9138 char * kwnames[] = {
9139 (char *) "self",(char *) "size", NULL
9140 };
9141
9142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) SWIG_fail;
9143 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9144 if (!SWIG_IsOK(res1)) {
9145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readline" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9146 }
9147 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9148 if (obj1) {
9149 ecode2 = SWIG_AsVal_int(obj1, &val2);
9150 if (!SWIG_IsOK(ecode2)) {
9151 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readline" "', expected argument " "2"" of type '" "int""'");
9152 }
9153 arg2 = static_cast< int >(val2);
9154 }
9155 {
9156 PyThreadState* __tstate = wxPyBeginAllowThreads();
9157 result = (PyObject *)(arg1)->readline(arg2);
9158 wxPyEndAllowThreads(__tstate);
9159 if (PyErr_Occurred()) SWIG_fail;
9160 }
9161 resultobj = result;
9162 return resultobj;
9163 fail:
9164 return NULL;
9165 }
9166
9167
9168 SWIGINTERN PyObject *_wrap_InputStream_readlines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9169 PyObject *resultobj = 0;
9170 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9171 int arg2 = (int) -1 ;
9172 PyObject *result = 0 ;
9173 void *argp1 = 0 ;
9174 int res1 = 0 ;
9175 int val2 ;
9176 int ecode2 = 0 ;
9177 PyObject * obj0 = 0 ;
9178 PyObject * obj1 = 0 ;
9179 char * kwnames[] = {
9180 (char *) "self",(char *) "sizehint", NULL
9181 };
9182
9183 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) SWIG_fail;
9184 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9185 if (!SWIG_IsOK(res1)) {
9186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readlines" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9187 }
9188 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9189 if (obj1) {
9190 ecode2 = SWIG_AsVal_int(obj1, &val2);
9191 if (!SWIG_IsOK(ecode2)) {
9192 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readlines" "', expected argument " "2"" of type '" "int""'");
9193 }
9194 arg2 = static_cast< int >(val2);
9195 }
9196 {
9197 PyThreadState* __tstate = wxPyBeginAllowThreads();
9198 result = (PyObject *)(arg1)->readlines(arg2);
9199 wxPyEndAllowThreads(__tstate);
9200 if (PyErr_Occurred()) SWIG_fail;
9201 }
9202 resultobj = result;
9203 return resultobj;
9204 fail:
9205 return NULL;
9206 }
9207
9208
9209 SWIGINTERN PyObject *_wrap_InputStream_seek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9210 PyObject *resultobj = 0;
9211 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9212 int arg2 ;
9213 int arg3 = (int) 0 ;
9214 void *argp1 = 0 ;
9215 int res1 = 0 ;
9216 int val2 ;
9217 int ecode2 = 0 ;
9218 int val3 ;
9219 int ecode3 = 0 ;
9220 PyObject * obj0 = 0 ;
9221 PyObject * obj1 = 0 ;
9222 PyObject * obj2 = 0 ;
9223 char * kwnames[] = {
9224 (char *) "self",(char *) "offset",(char *) "whence", NULL
9225 };
9226
9227 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9228 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9229 if (!SWIG_IsOK(res1)) {
9230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_seek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9231 }
9232 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9233 ecode2 = SWIG_AsVal_int(obj1, &val2);
9234 if (!SWIG_IsOK(ecode2)) {
9235 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_seek" "', expected argument " "2"" of type '" "int""'");
9236 }
9237 arg2 = static_cast< int >(val2);
9238 if (obj2) {
9239 ecode3 = SWIG_AsVal_int(obj2, &val3);
9240 if (!SWIG_IsOK(ecode3)) {
9241 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_seek" "', expected argument " "3"" of type '" "int""'");
9242 }
9243 arg3 = static_cast< int >(val3);
9244 }
9245 {
9246 PyThreadState* __tstate = wxPyBeginAllowThreads();
9247 (arg1)->seek(arg2,arg3);
9248 wxPyEndAllowThreads(__tstate);
9249 if (PyErr_Occurred()) SWIG_fail;
9250 }
9251 resultobj = SWIG_Py_Void();
9252 return resultobj;
9253 fail:
9254 return NULL;
9255 }
9256
9257
9258 SWIGINTERN PyObject *_wrap_InputStream_tell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9259 PyObject *resultobj = 0;
9260 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9261 int result;
9262 void *argp1 = 0 ;
9263 int res1 = 0 ;
9264 PyObject *swig_obj[1] ;
9265
9266 if (!args) SWIG_fail;
9267 swig_obj[0] = args;
9268 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9269 if (!SWIG_IsOK(res1)) {
9270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_tell" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9271 }
9272 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9273 {
9274 PyThreadState* __tstate = wxPyBeginAllowThreads();
9275 result = (int)(arg1)->tell();
9276 wxPyEndAllowThreads(__tstate);
9277 if (PyErr_Occurred()) SWIG_fail;
9278 }
9279 resultobj = SWIG_From_int(static_cast< int >(result));
9280 return resultobj;
9281 fail:
9282 return NULL;
9283 }
9284
9285
9286 SWIGINTERN PyObject *_wrap_InputStream_Peek(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9287 PyObject *resultobj = 0;
9288 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9289 char result;
9290 void *argp1 = 0 ;
9291 int res1 = 0 ;
9292 PyObject *swig_obj[1] ;
9293
9294 if (!args) SWIG_fail;
9295 swig_obj[0] = args;
9296 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9297 if (!SWIG_IsOK(res1)) {
9298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Peek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9299 }
9300 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9301 {
9302 PyThreadState* __tstate = wxPyBeginAllowThreads();
9303 result = (char)(arg1)->Peek();
9304 wxPyEndAllowThreads(__tstate);
9305 if (PyErr_Occurred()) SWIG_fail;
9306 }
9307 resultobj = SWIG_From_char(static_cast< char >(result));
9308 return resultobj;
9309 fail:
9310 return NULL;
9311 }
9312
9313
9314 SWIGINTERN PyObject *_wrap_InputStream_GetC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9315 PyObject *resultobj = 0;
9316 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9317 char result;
9318 void *argp1 = 0 ;
9319 int res1 = 0 ;
9320 PyObject *swig_obj[1] ;
9321
9322 if (!args) SWIG_fail;
9323 swig_obj[0] = args;
9324 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9325 if (!SWIG_IsOK(res1)) {
9326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_GetC" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9327 }
9328 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9329 {
9330 PyThreadState* __tstate = wxPyBeginAllowThreads();
9331 result = (char)(arg1)->GetC();
9332 wxPyEndAllowThreads(__tstate);
9333 if (PyErr_Occurred()) SWIG_fail;
9334 }
9335 resultobj = SWIG_From_char(static_cast< char >(result));
9336 return resultobj;
9337 fail:
9338 return NULL;
9339 }
9340
9341
9342 SWIGINTERN PyObject *_wrap_InputStream_LastRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9343 PyObject *resultobj = 0;
9344 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9345 size_t result;
9346 void *argp1 = 0 ;
9347 int res1 = 0 ;
9348 PyObject *swig_obj[1] ;
9349
9350 if (!args) SWIG_fail;
9351 swig_obj[0] = args;
9352 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9353 if (!SWIG_IsOK(res1)) {
9354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_LastRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9355 }
9356 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9357 {
9358 PyThreadState* __tstate = wxPyBeginAllowThreads();
9359 result = (size_t)(arg1)->LastRead();
9360 wxPyEndAllowThreads(__tstate);
9361 if (PyErr_Occurred()) SWIG_fail;
9362 }
9363 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9364 return resultobj;
9365 fail:
9366 return NULL;
9367 }
9368
9369
9370 SWIGINTERN PyObject *_wrap_InputStream_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9371 PyObject *resultobj = 0;
9372 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9373 bool result;
9374 void *argp1 = 0 ;
9375 int res1 = 0 ;
9376 PyObject *swig_obj[1] ;
9377
9378 if (!args) SWIG_fail;
9379 swig_obj[0] = args;
9380 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9381 if (!SWIG_IsOK(res1)) {
9382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_CanRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9383 }
9384 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9385 {
9386 PyThreadState* __tstate = wxPyBeginAllowThreads();
9387 result = (bool)(arg1)->CanRead();
9388 wxPyEndAllowThreads(__tstate);
9389 if (PyErr_Occurred()) SWIG_fail;
9390 }
9391 {
9392 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9393 }
9394 return resultobj;
9395 fail:
9396 return NULL;
9397 }
9398
9399
9400 SWIGINTERN PyObject *_wrap_InputStream_Eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9401 PyObject *resultobj = 0;
9402 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9403 bool result;
9404 void *argp1 = 0 ;
9405 int res1 = 0 ;
9406 PyObject *swig_obj[1] ;
9407
9408 if (!args) SWIG_fail;
9409 swig_obj[0] = args;
9410 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9411 if (!SWIG_IsOK(res1)) {
9412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9413 }
9414 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9415 {
9416 PyThreadState* __tstate = wxPyBeginAllowThreads();
9417 result = (bool)(arg1)->Eof();
9418 wxPyEndAllowThreads(__tstate);
9419 if (PyErr_Occurred()) SWIG_fail;
9420 }
9421 {
9422 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9423 }
9424 return resultobj;
9425 fail:
9426 return NULL;
9427 }
9428
9429
9430 SWIGINTERN PyObject *_wrap_InputStream_Ungetch(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9431 PyObject *resultobj = 0;
9432 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9433 char arg2 ;
9434 bool result;
9435 void *argp1 = 0 ;
9436 int res1 = 0 ;
9437 char val2 ;
9438 int ecode2 = 0 ;
9439 PyObject * obj0 = 0 ;
9440 PyObject * obj1 = 0 ;
9441 char * kwnames[] = {
9442 (char *) "self",(char *) "c", NULL
9443 };
9444
9445 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) SWIG_fail;
9446 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9447 if (!SWIG_IsOK(res1)) {
9448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Ungetch" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9449 }
9450 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9451 ecode2 = SWIG_AsVal_char(obj1, &val2);
9452 if (!SWIG_IsOK(ecode2)) {
9453 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_Ungetch" "', expected argument " "2"" of type '" "char""'");
9454 }
9455 arg2 = static_cast< char >(val2);
9456 {
9457 PyThreadState* __tstate = wxPyBeginAllowThreads();
9458 result = (bool)(arg1)->Ungetch(arg2);
9459 wxPyEndAllowThreads(__tstate);
9460 if (PyErr_Occurred()) SWIG_fail;
9461 }
9462 {
9463 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9464 }
9465 return resultobj;
9466 fail:
9467 return NULL;
9468 }
9469
9470
9471 SWIGINTERN PyObject *_wrap_InputStream_SeekI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9472 PyObject *resultobj = 0;
9473 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9474 long arg2 ;
9475 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
9476 long result;
9477 void *argp1 = 0 ;
9478 int res1 = 0 ;
9479 long val2 ;
9480 int ecode2 = 0 ;
9481 int val3 ;
9482 int ecode3 = 0 ;
9483 PyObject * obj0 = 0 ;
9484 PyObject * obj1 = 0 ;
9485 PyObject * obj2 = 0 ;
9486 char * kwnames[] = {
9487 (char *) "self",(char *) "pos",(char *) "mode", NULL
9488 };
9489
9490 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9491 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9492 if (!SWIG_IsOK(res1)) {
9493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_SeekI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9494 }
9495 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9496 ecode2 = SWIG_AsVal_long(obj1, &val2);
9497 if (!SWIG_IsOK(ecode2)) {
9498 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_SeekI" "', expected argument " "2"" of type '" "long""'");
9499 }
9500 arg2 = static_cast< long >(val2);
9501 if (obj2) {
9502 ecode3 = SWIG_AsVal_int(obj2, &val3);
9503 if (!SWIG_IsOK(ecode3)) {
9504 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_SeekI" "', expected argument " "3"" of type '" "wxSeekMode""'");
9505 }
9506 arg3 = static_cast< wxSeekMode >(val3);
9507 }
9508 {
9509 PyThreadState* __tstate = wxPyBeginAllowThreads();
9510 result = (long)(arg1)->SeekI(arg2,arg3);
9511 wxPyEndAllowThreads(__tstate);
9512 if (PyErr_Occurred()) SWIG_fail;
9513 }
9514 resultobj = SWIG_From_long(static_cast< long >(result));
9515 return resultobj;
9516 fail:
9517 return NULL;
9518 }
9519
9520
9521 SWIGINTERN PyObject *_wrap_InputStream_TellI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9522 PyObject *resultobj = 0;
9523 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9524 long result;
9525 void *argp1 = 0 ;
9526 int res1 = 0 ;
9527 PyObject *swig_obj[1] ;
9528
9529 if (!args) SWIG_fail;
9530 swig_obj[0] = args;
9531 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9532 if (!SWIG_IsOK(res1)) {
9533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_TellI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9534 }
9535 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9536 {
9537 PyThreadState* __tstate = wxPyBeginAllowThreads();
9538 result = (long)(arg1)->TellI();
9539 wxPyEndAllowThreads(__tstate);
9540 if (PyErr_Occurred()) SWIG_fail;
9541 }
9542 resultobj = SWIG_From_long(static_cast< long >(result));
9543 return resultobj;
9544 fail:
9545 return NULL;
9546 }
9547
9548
9549 SWIGINTERN PyObject *InputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9550 PyObject *obj;
9551 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9552 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyInputStream, SWIG_NewClientData(obj));
9553 return SWIG_Py_Void();
9554 }
9555
9556 SWIGINTERN PyObject *InputStream_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9557 return SWIG_Python_InitShadowInstance(args);
9558 }
9559
9560 SWIGINTERN PyObject *_wrap_OutputStream_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9561 PyObject *resultobj = 0;
9562 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9563 PyObject *arg2 = (PyObject *) 0 ;
9564 void *argp1 = 0 ;
9565 int res1 = 0 ;
9566 PyObject * obj0 = 0 ;
9567 PyObject * obj1 = 0 ;
9568 char * kwnames[] = {
9569 (char *) "self",(char *) "obj", NULL
9570 };
9571
9572 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) SWIG_fail;
9573 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9574 if (!SWIG_IsOK(res1)) {
9575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_write" "', expected argument " "1"" of type '" "wxOutputStream *""'");
9576 }
9577 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9578 arg2 = obj1;
9579 {
9580 PyThreadState* __tstate = wxPyBeginAllowThreads();
9581 wxOutputStream_write(arg1,arg2);
9582 wxPyEndAllowThreads(__tstate);
9583 if (PyErr_Occurred()) SWIG_fail;
9584 }
9585 resultobj = SWIG_Py_Void();
9586 return resultobj;
9587 fail:
9588 return NULL;
9589 }
9590
9591
9592 SWIGINTERN PyObject *_wrap_OutputStream_LastWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9593 PyObject *resultobj = 0;
9594 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9595 size_t result;
9596 void *argp1 = 0 ;
9597 int res1 = 0 ;
9598 PyObject *swig_obj[1] ;
9599
9600 if (!args) SWIG_fail;
9601 swig_obj[0] = args;
9602 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9603 if (!SWIG_IsOK(res1)) {
9604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_LastWrite" "', expected argument " "1"" of type '" "wxOutputStream const *""'");
9605 }
9606 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9607 {
9608 PyThreadState* __tstate = wxPyBeginAllowThreads();
9609 result = (size_t)((wxOutputStream const *)arg1)->LastWrite();
9610 wxPyEndAllowThreads(__tstate);
9611 if (PyErr_Occurred()) SWIG_fail;
9612 }
9613 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9614 return resultobj;
9615 fail:
9616 return NULL;
9617 }
9618
9619
9620 SWIGINTERN PyObject *OutputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9621 PyObject *obj;
9622 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9623 SWIG_TypeNewClientData(SWIGTYPE_p_wxOutputStream, SWIG_NewClientData(obj));
9624 return SWIG_Py_Void();
9625 }
9626
9627 SWIGINTERN PyObject *_wrap_new_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9628 PyObject *resultobj = 0;
9629 wxInputStream *arg1 = (wxInputStream *) 0 ;
9630 wxString *arg2 = 0 ;
9631 wxString *arg3 = 0 ;
9632 wxString *arg4 = 0 ;
9633 wxDateTime arg5 ;
9634 wxFSFile *result = 0 ;
9635 wxPyInputStream *temp1 ;
9636 bool temp2 = false ;
9637 bool temp3 = false ;
9638 bool temp4 = false ;
9639 void *argp5 ;
9640 int res5 = 0 ;
9641 PyObject * obj0 = 0 ;
9642 PyObject * obj1 = 0 ;
9643 PyObject * obj2 = 0 ;
9644 PyObject * obj3 = 0 ;
9645 PyObject * obj4 = 0 ;
9646 char * kwnames[] = {
9647 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
9648 };
9649
9650 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9651 {
9652 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
9653 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
9654 } else {
9655 PyErr_Clear(); // clear the failure of the wxPyConvert above
9656 arg1 = wxPyCBInputStream_create(obj0, true);
9657 if (arg1 == NULL) {
9658 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
9659 SWIG_fail;
9660 }
9661 }
9662 }
9663 {
9664 arg2 = wxString_in_helper(obj1);
9665 if (arg2 == NULL) SWIG_fail;
9666 temp2 = true;
9667 }
9668 {
9669 arg3 = wxString_in_helper(obj2);
9670 if (arg3 == NULL) SWIG_fail;
9671 temp3 = true;
9672 }
9673 {
9674 arg4 = wxString_in_helper(obj3);
9675 if (arg4 == NULL) SWIG_fail;
9676 temp4 = true;
9677 }
9678 {
9679 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDateTime, 0 | 0);
9680 if (!SWIG_IsOK(res5)) {
9681 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9682 }
9683 if (!argp5) {
9684 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9685 } else {
9686 wxDateTime * temp = reinterpret_cast< wxDateTime * >(argp5);
9687 arg5 = *temp;
9688 if (SWIG_IsNewObj(res5)) delete temp;
9689 }
9690 }
9691 {
9692 PyThreadState* __tstate = wxPyBeginAllowThreads();
9693 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
9694 wxPyEndAllowThreads(__tstate);
9695 if (PyErr_Occurred()) SWIG_fail;
9696 }
9697 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFSFile, SWIG_POINTER_NEW | 0 );
9698 {
9699 if (temp2)
9700 delete arg2;
9701 }
9702 {
9703 if (temp3)
9704 delete arg3;
9705 }
9706 {
9707 if (temp4)
9708 delete arg4;
9709 }
9710 return resultobj;
9711 fail:
9712 {
9713 if (temp2)
9714 delete arg2;
9715 }
9716 {
9717 if (temp3)
9718 delete arg3;
9719 }
9720 {
9721 if (temp4)
9722 delete arg4;
9723 }
9724 return NULL;
9725 }
9726
9727
9728 SWIGINTERN PyObject *_wrap_delete_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9729 PyObject *resultobj = 0;
9730 wxFSFile *arg1 = (wxFSFile *) 0 ;
9731 void *argp1 = 0 ;
9732 int res1 = 0 ;
9733 PyObject *swig_obj[1] ;
9734
9735 if (!args) SWIG_fail;
9736 swig_obj[0] = args;
9737 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, SWIG_POINTER_DISOWN | 0 );
9738 if (!SWIG_IsOK(res1)) {
9739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FSFile" "', expected argument " "1"" of type '" "wxFSFile *""'");
9740 }
9741 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9742 {
9743 PyThreadState* __tstate = wxPyBeginAllowThreads();
9744 delete arg1;
9745
9746 wxPyEndAllowThreads(__tstate);
9747 if (PyErr_Occurred()) SWIG_fail;
9748 }
9749 resultobj = SWIG_Py_Void();
9750 return resultobj;
9751 fail:
9752 return NULL;
9753 }
9754
9755
9756 SWIGINTERN PyObject *_wrap_FSFile_GetStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9757 PyObject *resultobj = 0;
9758 wxFSFile *arg1 = (wxFSFile *) 0 ;
9759 wxInputStream *result = 0 ;
9760 void *argp1 = 0 ;
9761 int res1 = 0 ;
9762 PyObject *swig_obj[1] ;
9763
9764 if (!args) SWIG_fail;
9765 swig_obj[0] = args;
9766 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9767 if (!SWIG_IsOK(res1)) {
9768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
9769 }
9770 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9771 {
9772 PyThreadState* __tstate = wxPyBeginAllowThreads();
9773 result = (wxInputStream *)(arg1)->GetStream();
9774 wxPyEndAllowThreads(__tstate);
9775 if (PyErr_Occurred()) SWIG_fail;
9776 }
9777 {
9778 wxPyInputStream * _ptr = NULL;
9779
9780 if (result) {
9781 _ptr = new wxPyInputStream(result);
9782 }
9783 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
9784 }
9785 return resultobj;
9786 fail:
9787 return NULL;
9788 }
9789
9790
9791 SWIGINTERN PyObject *_wrap_FSFile_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9792 PyObject *resultobj = 0;
9793 wxFSFile *arg1 = (wxFSFile *) 0 ;
9794 wxString *result = 0 ;
9795 void *argp1 = 0 ;
9796 int res1 = 0 ;
9797 PyObject *swig_obj[1] ;
9798
9799 if (!args) SWIG_fail;
9800 swig_obj[0] = args;
9801 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9802 if (!SWIG_IsOK(res1)) {
9803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetMimeType" "', expected argument " "1"" of type '" "wxFSFile *""'");
9804 }
9805 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9806 {
9807 PyThreadState* __tstate = wxPyBeginAllowThreads();
9808 {
9809 wxString const &_result_ref = (arg1)->GetMimeType();
9810 result = (wxString *) &_result_ref;
9811 }
9812 wxPyEndAllowThreads(__tstate);
9813 if (PyErr_Occurred()) SWIG_fail;
9814 }
9815 {
9816 #if wxUSE_UNICODE
9817 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9818 #else
9819 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9820 #endif
9821 }
9822 return resultobj;
9823 fail:
9824 return NULL;
9825 }
9826
9827
9828 SWIGINTERN PyObject *_wrap_FSFile_GetLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9829 PyObject *resultobj = 0;
9830 wxFSFile *arg1 = (wxFSFile *) 0 ;
9831 wxString *result = 0 ;
9832 void *argp1 = 0 ;
9833 int res1 = 0 ;
9834 PyObject *swig_obj[1] ;
9835
9836 if (!args) SWIG_fail;
9837 swig_obj[0] = args;
9838 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9839 if (!SWIG_IsOK(res1)) {
9840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetLocation" "', expected argument " "1"" of type '" "wxFSFile *""'");
9841 }
9842 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9843 {
9844 PyThreadState* __tstate = wxPyBeginAllowThreads();
9845 {
9846 wxString const &_result_ref = (arg1)->GetLocation();
9847 result = (wxString *) &_result_ref;
9848 }
9849 wxPyEndAllowThreads(__tstate);
9850 if (PyErr_Occurred()) SWIG_fail;
9851 }
9852 {
9853 #if wxUSE_UNICODE
9854 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9855 #else
9856 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9857 #endif
9858 }
9859 return resultobj;
9860 fail:
9861 return NULL;
9862 }
9863
9864
9865 SWIGINTERN PyObject *_wrap_FSFile_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9866 PyObject *resultobj = 0;
9867 wxFSFile *arg1 = (wxFSFile *) 0 ;
9868 wxString *result = 0 ;
9869 void *argp1 = 0 ;
9870 int res1 = 0 ;
9871 PyObject *swig_obj[1] ;
9872
9873 if (!args) SWIG_fail;
9874 swig_obj[0] = args;
9875 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9876 if (!SWIG_IsOK(res1)) {
9877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetAnchor" "', expected argument " "1"" of type '" "wxFSFile *""'");
9878 }
9879 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9880 {
9881 PyThreadState* __tstate = wxPyBeginAllowThreads();
9882 {
9883 wxString const &_result_ref = (arg1)->GetAnchor();
9884 result = (wxString *) &_result_ref;
9885 }
9886 wxPyEndAllowThreads(__tstate);
9887 if (PyErr_Occurred()) SWIG_fail;
9888 }
9889 {
9890 #if wxUSE_UNICODE
9891 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9892 #else
9893 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9894 #endif
9895 }
9896 return resultobj;
9897 fail:
9898 return NULL;
9899 }
9900
9901
9902 SWIGINTERN PyObject *_wrap_FSFile_GetModificationTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9903 PyObject *resultobj = 0;
9904 wxFSFile *arg1 = (wxFSFile *) 0 ;
9905 wxDateTime result;
9906 void *argp1 = 0 ;
9907 int res1 = 0 ;
9908 PyObject *swig_obj[1] ;
9909
9910 if (!args) SWIG_fail;
9911 swig_obj[0] = args;
9912 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9913 if (!SWIG_IsOK(res1)) {
9914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetModificationTime" "', expected argument " "1"" of type '" "wxFSFile *""'");
9915 }
9916 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9917 {
9918 PyThreadState* __tstate = wxPyBeginAllowThreads();
9919 result = (arg1)->GetModificationTime();
9920 wxPyEndAllowThreads(__tstate);
9921 if (PyErr_Occurred()) SWIG_fail;
9922 }
9923 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
9924 return resultobj;
9925 fail:
9926 return NULL;
9927 }
9928
9929
9930 SWIGINTERN PyObject *FSFile_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9931 PyObject *obj;
9932 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9933 SWIG_TypeNewClientData(SWIGTYPE_p_wxFSFile, SWIG_NewClientData(obj));
9934 return SWIG_Py_Void();
9935 }
9936
9937 SWIGINTERN PyObject *FSFile_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9938 return SWIG_Python_InitShadowInstance(args);
9939 }
9940
9941 SWIGINTERN PyObject *_wrap_delete_CPPFileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9942 PyObject *resultobj = 0;
9943 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
9944 void *argp1 = 0 ;
9945 int res1 = 0 ;
9946 PyObject *swig_obj[1] ;
9947
9948 if (!args) SWIG_fail;
9949 swig_obj[0] = args;
9950 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
9951 if (!SWIG_IsOK(res1)) {
9952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CPPFileSystemHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
9953 }
9954 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
9955 {
9956 PyThreadState* __tstate = wxPyBeginAllowThreads();
9957 delete arg1;
9958
9959 wxPyEndAllowThreads(__tstate);
9960 if (PyErr_Occurred()) SWIG_fail;
9961 }
9962 resultobj = SWIG_Py_Void();
9963 return resultobj;
9964 fail:
9965 return NULL;
9966 }
9967
9968
9969 SWIGINTERN PyObject *CPPFileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9970 PyObject *obj;
9971 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9972 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystemHandler, SWIG_NewClientData(obj));
9973 return SWIG_Py_Void();
9974 }
9975
9976 SWIGINTERN PyObject *_wrap_new_FileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9977 PyObject *resultobj = 0;
9978 wxPyFileSystemHandler *result = 0 ;
9979
9980 if (!SWIG_Python_UnpackTuple(args,"new_FileSystemHandler",0,0,0)) SWIG_fail;
9981 {
9982 PyThreadState* __tstate = wxPyBeginAllowThreads();
9983 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
9984 wxPyEndAllowThreads(__tstate);
9985 if (PyErr_Occurred()) SWIG_fail;
9986 }
9987 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_NEW | 0 );
9988 return resultobj;
9989 fail:
9990 return NULL;
9991 }
9992
9993
9994 SWIGINTERN PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9995 PyObject *resultobj = 0;
9996 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
9997 PyObject *arg2 = (PyObject *) 0 ;
9998 PyObject *arg3 = (PyObject *) 0 ;
9999 void *argp1 = 0 ;
10000 int res1 = 0 ;
10001 PyObject * obj0 = 0 ;
10002 PyObject * obj1 = 0 ;
10003 PyObject * obj2 = 0 ;
10004 char * kwnames[] = {
10005 (char *) "self",(char *) "self",(char *) "_class", NULL
10006 };
10007
10008 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10009 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10010 if (!SWIG_IsOK(res1)) {
10011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10012 }
10013 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10014 arg2 = obj1;
10015 arg3 = obj2;
10016 {
10017 PyThreadState* __tstate = wxPyBeginAllowThreads();
10018 (arg1)->_setCallbackInfo(arg2,arg3);
10019 wxPyEndAllowThreads(__tstate);
10020 if (PyErr_Occurred()) SWIG_fail;
10021 }
10022 resultobj = SWIG_Py_Void();
10023 return resultobj;
10024 fail:
10025 return NULL;
10026 }
10027
10028
10029 SWIGINTERN PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10030 PyObject *resultobj = 0;
10031 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10032 wxString *arg2 = 0 ;
10033 bool result;
10034 void *argp1 = 0 ;
10035 int res1 = 0 ;
10036 bool temp2 = false ;
10037 PyObject * obj0 = 0 ;
10038 PyObject * obj1 = 0 ;
10039 char * kwnames[] = {
10040 (char *) "self",(char *) "location", NULL
10041 };
10042
10043 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
10044 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10045 if (!SWIG_IsOK(res1)) {
10046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_CanOpen" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10047 }
10048 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10049 {
10050 arg2 = wxString_in_helper(obj1);
10051 if (arg2 == NULL) SWIG_fail;
10052 temp2 = true;
10053 }
10054 {
10055 PyThreadState* __tstate = wxPyBeginAllowThreads();
10056 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
10057 wxPyEndAllowThreads(__tstate);
10058 if (PyErr_Occurred()) SWIG_fail;
10059 }
10060 {
10061 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10062 }
10063 {
10064 if (temp2)
10065 delete arg2;
10066 }
10067 return resultobj;
10068 fail:
10069 {
10070 if (temp2)
10071 delete arg2;
10072 }
10073 return NULL;
10074 }
10075
10076
10077 SWIGINTERN PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10078 PyObject *resultobj = 0;
10079 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10080 wxFileSystem *arg2 = 0 ;
10081 wxString *arg3 = 0 ;
10082 wxFSFile *result = 0 ;
10083 void *argp1 = 0 ;
10084 int res1 = 0 ;
10085 void *argp2 = 0 ;
10086 int res2 = 0 ;
10087 bool temp3 = false ;
10088 PyObject * obj0 = 0 ;
10089 PyObject * obj1 = 0 ;
10090 PyObject * obj2 = 0 ;
10091 char * kwnames[] = {
10092 (char *) "self",(char *) "fs",(char *) "location", NULL
10093 };
10094
10095 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10096 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10097 if (!SWIG_IsOK(res1)) {
10098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10099 }
10100 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10101 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
10102 if (!SWIG_IsOK(res2)) {
10103 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10104 }
10105 if (!argp2) {
10106 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10107 }
10108 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
10109 {
10110 arg3 = wxString_in_helper(obj2);
10111 if (arg3 == NULL) SWIG_fail;
10112 temp3 = true;
10113 }
10114 {
10115 PyThreadState* __tstate = wxPyBeginAllowThreads();
10116 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
10117 wxPyEndAllowThreads(__tstate);
10118 if (PyErr_Occurred()) SWIG_fail;
10119 }
10120 {
10121 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
10122 }
10123 {
10124 if (temp3)
10125 delete arg3;
10126 }
10127 return resultobj;
10128 fail:
10129 {
10130 if (temp3)
10131 delete arg3;
10132 }
10133 return NULL;
10134 }
10135
10136
10137 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10138 PyObject *resultobj = 0;
10139 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10140 wxString *arg2 = 0 ;
10141 int arg3 = (int) 0 ;
10142 wxString result;
10143 void *argp1 = 0 ;
10144 int res1 = 0 ;
10145 bool temp2 = false ;
10146 int val3 ;
10147 int ecode3 = 0 ;
10148 PyObject * obj0 = 0 ;
10149 PyObject * obj1 = 0 ;
10150 PyObject * obj2 = 0 ;
10151 char * kwnames[] = {
10152 (char *) "self",(char *) "spec",(char *) "flags", NULL
10153 };
10154
10155 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10156 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10157 if (!SWIG_IsOK(res1)) {
10158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10159 }
10160 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10161 {
10162 arg2 = wxString_in_helper(obj1);
10163 if (arg2 == NULL) SWIG_fail;
10164 temp2 = true;
10165 }
10166 if (obj2) {
10167 ecode3 = SWIG_AsVal_int(obj2, &val3);
10168 if (!SWIG_IsOK(ecode3)) {
10169 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
10170 }
10171 arg3 = static_cast< int >(val3);
10172 }
10173 {
10174 PyThreadState* __tstate = wxPyBeginAllowThreads();
10175 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10176 wxPyEndAllowThreads(__tstate);
10177 if (PyErr_Occurred()) SWIG_fail;
10178 }
10179 {
10180 #if wxUSE_UNICODE
10181 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10182 #else
10183 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10184 #endif
10185 }
10186 {
10187 if (temp2)
10188 delete arg2;
10189 }
10190 return resultobj;
10191 fail:
10192 {
10193 if (temp2)
10194 delete arg2;
10195 }
10196 return NULL;
10197 }
10198
10199
10200 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10201 PyObject *resultobj = 0;
10202 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10203 wxString result;
10204 void *argp1 = 0 ;
10205 int res1 = 0 ;
10206 PyObject *swig_obj[1] ;
10207
10208 if (!args) SWIG_fail;
10209 swig_obj[0] = args;
10210 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10211 if (!SWIG_IsOK(res1)) {
10212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindNext" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10213 }
10214 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10215 {
10216 PyThreadState* __tstate = wxPyBeginAllowThreads();
10217 result = (arg1)->FindNext();
10218 wxPyEndAllowThreads(__tstate);
10219 if (PyErr_Occurred()) SWIG_fail;
10220 }
10221 {
10222 #if wxUSE_UNICODE
10223 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10224 #else
10225 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10226 #endif
10227 }
10228 return resultobj;
10229 fail:
10230 return NULL;
10231 }
10232
10233
10234 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10235 PyObject *resultobj = 0;
10236 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10237 wxString *arg2 = 0 ;
10238 wxString result;
10239 void *argp1 = 0 ;
10240 int res1 = 0 ;
10241 bool temp2 = false ;
10242 PyObject * obj0 = 0 ;
10243 PyObject * obj1 = 0 ;
10244 char * kwnames[] = {
10245 (char *) "self",(char *) "location", NULL
10246 };
10247
10248 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) SWIG_fail;
10249 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10250 if (!SWIG_IsOK(res1)) {
10251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetProtocol" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10252 }
10253 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10254 {
10255 arg2 = wxString_in_helper(obj1);
10256 if (arg2 == NULL) SWIG_fail;
10257 temp2 = true;
10258 }
10259 {
10260 PyThreadState* __tstate = wxPyBeginAllowThreads();
10261 result = (arg1)->GetProtocol((wxString const &)*arg2);
10262 wxPyEndAllowThreads(__tstate);
10263 if (PyErr_Occurred()) SWIG_fail;
10264 }
10265 {
10266 #if wxUSE_UNICODE
10267 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10268 #else
10269 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10270 #endif
10271 }
10272 {
10273 if (temp2)
10274 delete arg2;
10275 }
10276 return resultobj;
10277 fail:
10278 {
10279 if (temp2)
10280 delete arg2;
10281 }
10282 return NULL;
10283 }
10284
10285
10286 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10287 PyObject *resultobj = 0;
10288 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10289 wxString *arg2 = 0 ;
10290 wxString result;
10291 void *argp1 = 0 ;
10292 int res1 = 0 ;
10293 bool temp2 = false ;
10294 PyObject * obj0 = 0 ;
10295 PyObject * obj1 = 0 ;
10296 char * kwnames[] = {
10297 (char *) "self",(char *) "location", NULL
10298 };
10299
10300 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10301 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10302 if (!SWIG_IsOK(res1)) {
10303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetLeftLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10304 }
10305 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10306 {
10307 arg2 = wxString_in_helper(obj1);
10308 if (arg2 == NULL) SWIG_fail;
10309 temp2 = true;
10310 }
10311 {
10312 PyThreadState* __tstate = wxPyBeginAllowThreads();
10313 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
10314 wxPyEndAllowThreads(__tstate);
10315 if (PyErr_Occurred()) SWIG_fail;
10316 }
10317 {
10318 #if wxUSE_UNICODE
10319 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10320 #else
10321 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10322 #endif
10323 }
10324 {
10325 if (temp2)
10326 delete arg2;
10327 }
10328 return resultobj;
10329 fail:
10330 {
10331 if (temp2)
10332 delete arg2;
10333 }
10334 return NULL;
10335 }
10336
10337
10338 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10339 PyObject *resultobj = 0;
10340 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10341 wxString *arg2 = 0 ;
10342 wxString result;
10343 void *argp1 = 0 ;
10344 int res1 = 0 ;
10345 bool temp2 = false ;
10346 PyObject * obj0 = 0 ;
10347 PyObject * obj1 = 0 ;
10348 char * kwnames[] = {
10349 (char *) "self",(char *) "location", NULL
10350 };
10351
10352 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) SWIG_fail;
10353 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10354 if (!SWIG_IsOK(res1)) {
10355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetAnchor" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10356 }
10357 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10358 {
10359 arg2 = wxString_in_helper(obj1);
10360 if (arg2 == NULL) SWIG_fail;
10361 temp2 = true;
10362 }
10363 {
10364 PyThreadState* __tstate = wxPyBeginAllowThreads();
10365 result = (arg1)->GetAnchor((wxString const &)*arg2);
10366 wxPyEndAllowThreads(__tstate);
10367 if (PyErr_Occurred()) SWIG_fail;
10368 }
10369 {
10370 #if wxUSE_UNICODE
10371 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10372 #else
10373 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10374 #endif
10375 }
10376 {
10377 if (temp2)
10378 delete arg2;
10379 }
10380 return resultobj;
10381 fail:
10382 {
10383 if (temp2)
10384 delete arg2;
10385 }
10386 return NULL;
10387 }
10388
10389
10390 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10391 PyObject *resultobj = 0;
10392 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10393 wxString *arg2 = 0 ;
10394 wxString result;
10395 void *argp1 = 0 ;
10396 int res1 = 0 ;
10397 bool temp2 = false ;
10398 PyObject * obj0 = 0 ;
10399 PyObject * obj1 = 0 ;
10400 char * kwnames[] = {
10401 (char *) "self",(char *) "location", NULL
10402 };
10403
10404 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10405 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10406 if (!SWIG_IsOK(res1)) {
10407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetRightLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10408 }
10409 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10410 {
10411 arg2 = wxString_in_helper(obj1);
10412 if (arg2 == NULL) SWIG_fail;
10413 temp2 = true;
10414 }
10415 {
10416 PyThreadState* __tstate = wxPyBeginAllowThreads();
10417 result = (arg1)->GetRightLocation((wxString const &)*arg2);
10418 wxPyEndAllowThreads(__tstate);
10419 if (PyErr_Occurred()) SWIG_fail;
10420 }
10421 {
10422 #if wxUSE_UNICODE
10423 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10424 #else
10425 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10426 #endif
10427 }
10428 {
10429 if (temp2)
10430 delete arg2;
10431 }
10432 return resultobj;
10433 fail:
10434 {
10435 if (temp2)
10436 delete arg2;
10437 }
10438 return NULL;
10439 }
10440
10441
10442 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10443 PyObject *resultobj = 0;
10444 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10445 wxString *arg2 = 0 ;
10446 wxString result;
10447 void *argp1 = 0 ;
10448 int res1 = 0 ;
10449 bool temp2 = false ;
10450 PyObject * obj0 = 0 ;
10451 PyObject * obj1 = 0 ;
10452 char * kwnames[] = {
10453 (char *) "self",(char *) "location", NULL
10454 };
10455
10456 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) SWIG_fail;
10457 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10458 if (!SWIG_IsOK(res1)) {
10459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetMimeTypeFromExt" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10460 }
10461 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10462 {
10463 arg2 = wxString_in_helper(obj1);
10464 if (arg2 == NULL) SWIG_fail;
10465 temp2 = true;
10466 }
10467 {
10468 PyThreadState* __tstate = wxPyBeginAllowThreads();
10469 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
10470 wxPyEndAllowThreads(__tstate);
10471 if (PyErr_Occurred()) SWIG_fail;
10472 }
10473 {
10474 #if wxUSE_UNICODE
10475 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10476 #else
10477 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10478 #endif
10479 }
10480 {
10481 if (temp2)
10482 delete arg2;
10483 }
10484 return resultobj;
10485 fail:
10486 {
10487 if (temp2)
10488 delete arg2;
10489 }
10490 return NULL;
10491 }
10492
10493
10494 SWIGINTERN PyObject *FileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10495 PyObject *obj;
10496 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10497 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileSystemHandler, SWIG_NewClientData(obj));
10498 return SWIG_Py_Void();
10499 }
10500
10501 SWIGINTERN PyObject *FileSystemHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10502 return SWIG_Python_InitShadowInstance(args);
10503 }
10504
10505 SWIGINTERN PyObject *_wrap_new_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10506 PyObject *resultobj = 0;
10507 wxFileSystem *result = 0 ;
10508
10509 if (!SWIG_Python_UnpackTuple(args,"new_FileSystem",0,0,0)) SWIG_fail;
10510 {
10511 PyThreadState* __tstate = wxPyBeginAllowThreads();
10512 result = (wxFileSystem *)new wxFileSystem();
10513 wxPyEndAllowThreads(__tstate);
10514 if (PyErr_Occurred()) SWIG_fail;
10515 }
10516 {
10517 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
10518 }
10519 return resultobj;
10520 fail:
10521 return NULL;
10522 }
10523
10524
10525 SWIGINTERN PyObject *_wrap_delete_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10526 PyObject *resultobj = 0;
10527 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10528 void *argp1 = 0 ;
10529 int res1 = 0 ;
10530 PyObject *swig_obj[1] ;
10531
10532 if (!args) SWIG_fail;
10533 swig_obj[0] = args;
10534 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, SWIG_POINTER_DISOWN | 0 );
10535 if (!SWIG_IsOK(res1)) {
10536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileSystem" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10537 }
10538 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10539 {
10540 PyThreadState* __tstate = wxPyBeginAllowThreads();
10541 delete arg1;
10542
10543 wxPyEndAllowThreads(__tstate);
10544 if (PyErr_Occurred()) SWIG_fail;
10545 }
10546 resultobj = SWIG_Py_Void();
10547 return resultobj;
10548 fail:
10549 return NULL;
10550 }
10551
10552
10553 SWIGINTERN PyObject *_wrap_FileSystem_ChangePathTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10554 PyObject *resultobj = 0;
10555 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10556 wxString *arg2 = 0 ;
10557 bool arg3 = (bool) false ;
10558 void *argp1 = 0 ;
10559 int res1 = 0 ;
10560 bool temp2 = false ;
10561 bool val3 ;
10562 int ecode3 = 0 ;
10563 PyObject * obj0 = 0 ;
10564 PyObject * obj1 = 0 ;
10565 PyObject * obj2 = 0 ;
10566 char * kwnames[] = {
10567 (char *) "self",(char *) "location",(char *) "is_dir", NULL
10568 };
10569
10570 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10571 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10572 if (!SWIG_IsOK(res1)) {
10573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_ChangePathTo" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10574 }
10575 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10576 {
10577 arg2 = wxString_in_helper(obj1);
10578 if (arg2 == NULL) SWIG_fail;
10579 temp2 = true;
10580 }
10581 if (obj2) {
10582 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10583 if (!SWIG_IsOK(ecode3)) {
10584 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_ChangePathTo" "', expected argument " "3"" of type '" "bool""'");
10585 }
10586 arg3 = static_cast< bool >(val3);
10587 }
10588 {
10589 PyThreadState* __tstate = wxPyBeginAllowThreads();
10590 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
10591 wxPyEndAllowThreads(__tstate);
10592 if (PyErr_Occurred()) SWIG_fail;
10593 }
10594 resultobj = SWIG_Py_Void();
10595 {
10596 if (temp2)
10597 delete arg2;
10598 }
10599 return resultobj;
10600 fail:
10601 {
10602 if (temp2)
10603 delete arg2;
10604 }
10605 return NULL;
10606 }
10607
10608
10609 SWIGINTERN PyObject *_wrap_FileSystem_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10610 PyObject *resultobj = 0;
10611 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10612 wxString result;
10613 void *argp1 = 0 ;
10614 int res1 = 0 ;
10615 PyObject *swig_obj[1] ;
10616
10617 if (!args) SWIG_fail;
10618 swig_obj[0] = args;
10619 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10620 if (!SWIG_IsOK(res1)) {
10621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_GetPath" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10622 }
10623 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10624 {
10625 PyThreadState* __tstate = wxPyBeginAllowThreads();
10626 result = (arg1)->GetPath();
10627 wxPyEndAllowThreads(__tstate);
10628 if (PyErr_Occurred()) SWIG_fail;
10629 }
10630 {
10631 #if wxUSE_UNICODE
10632 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10633 #else
10634 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10635 #endif
10636 }
10637 return resultobj;
10638 fail:
10639 return NULL;
10640 }
10641
10642
10643 SWIGINTERN PyObject *_wrap_FileSystem_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10644 PyObject *resultobj = 0;
10645 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10646 wxString *arg2 = 0 ;
10647 wxFSFile *result = 0 ;
10648 void *argp1 = 0 ;
10649 int res1 = 0 ;
10650 bool temp2 = false ;
10651 PyObject * obj0 = 0 ;
10652 PyObject * obj1 = 0 ;
10653 char * kwnames[] = {
10654 (char *) "self",(char *) "location", NULL
10655 };
10656
10657 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) SWIG_fail;
10658 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10659 if (!SWIG_IsOK(res1)) {
10660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_OpenFile" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10661 }
10662 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10663 {
10664 arg2 = wxString_in_helper(obj1);
10665 if (arg2 == NULL) SWIG_fail;
10666 temp2 = true;
10667 }
10668 {
10669 PyThreadState* __tstate = wxPyBeginAllowThreads();
10670 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
10671 wxPyEndAllowThreads(__tstate);
10672 if (PyErr_Occurred()) SWIG_fail;
10673 }
10674 {
10675 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
10676 }
10677 {
10678 if (temp2)
10679 delete arg2;
10680 }
10681 return resultobj;
10682 fail:
10683 {
10684 if (temp2)
10685 delete arg2;
10686 }
10687 return NULL;
10688 }
10689
10690
10691 SWIGINTERN PyObject *_wrap_FileSystem_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10692 PyObject *resultobj = 0;
10693 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10694 wxString *arg2 = 0 ;
10695 int arg3 = (int) 0 ;
10696 wxString result;
10697 void *argp1 = 0 ;
10698 int res1 = 0 ;
10699 bool temp2 = false ;
10700 int val3 ;
10701 int ecode3 = 0 ;
10702 PyObject * obj0 = 0 ;
10703 PyObject * obj1 = 0 ;
10704 PyObject * obj2 = 0 ;
10705 char * kwnames[] = {
10706 (char *) "self",(char *) "spec",(char *) "flags", NULL
10707 };
10708
10709 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10710 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10711 if (!SWIG_IsOK(res1)) {
10712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindFirst" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10713 }
10714 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10715 {
10716 arg2 = wxString_in_helper(obj1);
10717 if (arg2 == NULL) SWIG_fail;
10718 temp2 = true;
10719 }
10720 if (obj2) {
10721 ecode3 = SWIG_AsVal_int(obj2, &val3);
10722 if (!SWIG_IsOK(ecode3)) {
10723 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_FindFirst" "', expected argument " "3"" of type '" "int""'");
10724 }
10725 arg3 = static_cast< int >(val3);
10726 }
10727 {
10728 PyThreadState* __tstate = wxPyBeginAllowThreads();
10729 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10730 wxPyEndAllowThreads(__tstate);
10731 if (PyErr_Occurred()) SWIG_fail;
10732 }
10733 {
10734 #if wxUSE_UNICODE
10735 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10736 #else
10737 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10738 #endif
10739 }
10740 {
10741 if (temp2)
10742 delete arg2;
10743 }
10744 return resultobj;
10745 fail:
10746 {
10747 if (temp2)
10748 delete arg2;
10749 }
10750 return NULL;
10751 }
10752
10753
10754 SWIGINTERN PyObject *_wrap_FileSystem_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10755 PyObject *resultobj = 0;
10756 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10757 wxString result;
10758 void *argp1 = 0 ;
10759 int res1 = 0 ;
10760 PyObject *swig_obj[1] ;
10761
10762 if (!args) SWIG_fail;
10763 swig_obj[0] = args;
10764 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10765 if (!SWIG_IsOK(res1)) {
10766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindNext" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10767 }
10768 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10769 {
10770 PyThreadState* __tstate = wxPyBeginAllowThreads();
10771 result = (arg1)->FindNext();
10772 wxPyEndAllowThreads(__tstate);
10773 if (PyErr_Occurred()) SWIG_fail;
10774 }
10775 {
10776 #if wxUSE_UNICODE
10777 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10778 #else
10779 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10780 #endif
10781 }
10782 return resultobj;
10783 fail:
10784 return NULL;
10785 }
10786
10787
10788 SWIGINTERN PyObject *_wrap_FileSystem_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10789 PyObject *resultobj = 0;
10790 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
10791 int res1 = 0 ;
10792 PyObject * obj0 = 0 ;
10793 char * kwnames[] = {
10794 (char *) "handler", NULL
10795 };
10796
10797 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) SWIG_fail;
10798 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
10799 if (!SWIG_IsOK(res1)) {
10800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_AddHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
10801 }
10802 {
10803 PyThreadState* __tstate = wxPyBeginAllowThreads();
10804 wxFileSystem::AddHandler(arg1);
10805 wxPyEndAllowThreads(__tstate);
10806 if (PyErr_Occurred()) SWIG_fail;
10807 }
10808 resultobj = SWIG_Py_Void();
10809 return resultobj;
10810 fail:
10811 return NULL;
10812 }
10813
10814
10815 SWIGINTERN PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10816 PyObject *resultobj = 0;
10817
10818 if (!SWIG_Python_UnpackTuple(args,"FileSystem_CleanUpHandlers",0,0,0)) SWIG_fail;
10819 {
10820 PyThreadState* __tstate = wxPyBeginAllowThreads();
10821 wxFileSystem::CleanUpHandlers();
10822 wxPyEndAllowThreads(__tstate);
10823 if (PyErr_Occurred()) SWIG_fail;
10824 }
10825 resultobj = SWIG_Py_Void();
10826 return resultobj;
10827 fail:
10828 return NULL;
10829 }
10830
10831
10832 SWIGINTERN PyObject *_wrap_FileSystem_FileNameToURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10833 PyObject *resultobj = 0;
10834 wxString *arg1 = 0 ;
10835 wxString result;
10836 bool temp1 = false ;
10837 PyObject * obj0 = 0 ;
10838 char * kwnames[] = {
10839 (char *) "filename", NULL
10840 };
10841
10842 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) SWIG_fail;
10843 {
10844 arg1 = wxString_in_helper(obj0);
10845 if (arg1 == NULL) SWIG_fail;
10846 temp1 = true;
10847 }
10848 {
10849 PyThreadState* __tstate = wxPyBeginAllowThreads();
10850 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
10851 wxPyEndAllowThreads(__tstate);
10852 if (PyErr_Occurred()) SWIG_fail;
10853 }
10854 {
10855 #if wxUSE_UNICODE
10856 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10857 #else
10858 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10859 #endif
10860 }
10861 {
10862 if (temp1)
10863 delete arg1;
10864 }
10865 return resultobj;
10866 fail:
10867 {
10868 if (temp1)
10869 delete arg1;
10870 }
10871 return NULL;
10872 }
10873
10874
10875 SWIGINTERN PyObject *_wrap_FileSystem_URLToFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10876 PyObject *resultobj = 0;
10877 wxString *arg1 = 0 ;
10878 wxString result;
10879 bool temp1 = false ;
10880 PyObject * obj0 = 0 ;
10881 char * kwnames[] = {
10882 (char *) "url", NULL
10883 };
10884
10885 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) SWIG_fail;
10886 {
10887 arg1 = wxString_in_helper(obj0);
10888 if (arg1 == NULL) SWIG_fail;
10889 temp1 = true;
10890 }
10891 {
10892 PyThreadState* __tstate = wxPyBeginAllowThreads();
10893 result = wxFileSystem_URLToFileName((wxString const &)*arg1);
10894 wxPyEndAllowThreads(__tstate);
10895 if (PyErr_Occurred()) SWIG_fail;
10896 }
10897 {
10898 #if wxUSE_UNICODE
10899 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10900 #else
10901 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10902 #endif
10903 }
10904 {
10905 if (temp1)
10906 delete arg1;
10907 }
10908 return resultobj;
10909 fail:
10910 {
10911 if (temp1)
10912 delete arg1;
10913 }
10914 return NULL;
10915 }
10916
10917
10918 SWIGINTERN PyObject *FileSystem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10919 PyObject *obj;
10920 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10921 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystem, SWIG_NewClientData(obj));
10922 return SWIG_Py_Void();
10923 }
10924
10925 SWIGINTERN PyObject *FileSystem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10926 return SWIG_Python_InitShadowInstance(args);
10927 }
10928
10929 SWIGINTERN PyObject *_wrap_new_InternetFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10930 PyObject *resultobj = 0;
10931 wxInternetFSHandler *result = 0 ;
10932
10933 if (!SWIG_Python_UnpackTuple(args,"new_InternetFSHandler",0,0,0)) SWIG_fail;
10934 {
10935 PyThreadState* __tstate = wxPyBeginAllowThreads();
10936 result = (wxInternetFSHandler *)new wxInternetFSHandler();
10937 wxPyEndAllowThreads(__tstate);
10938 if (PyErr_Occurred()) SWIG_fail;
10939 }
10940 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_NEW | 0 );
10941 return resultobj;
10942 fail:
10943 return NULL;
10944 }
10945
10946
10947 SWIGINTERN PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10948 PyObject *resultobj = 0;
10949 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
10950 wxString *arg2 = 0 ;
10951 bool result;
10952 void *argp1 = 0 ;
10953 int res1 = 0 ;
10954 bool temp2 = false ;
10955 PyObject * obj0 = 0 ;
10956 PyObject * obj1 = 0 ;
10957 char * kwnames[] = {
10958 (char *) "self",(char *) "location", NULL
10959 };
10960
10961 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
10962 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
10963 if (!SWIG_IsOK(res1)) {
10964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
10965 }
10966 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
10967 {
10968 arg2 = wxString_in_helper(obj1);
10969 if (arg2 == NULL) SWIG_fail;
10970 temp2 = true;
10971 }
10972 {
10973 PyThreadState* __tstate = wxPyBeginAllowThreads();
10974 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
10975 wxPyEndAllowThreads(__tstate);
10976 if (PyErr_Occurred()) SWIG_fail;
10977 }
10978 {
10979 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10980 }
10981 {
10982 if (temp2)
10983 delete arg2;
10984 }
10985 return resultobj;
10986 fail:
10987 {
10988 if (temp2)
10989 delete arg2;
10990 }
10991 return NULL;
10992 }
10993
10994
10995 SWIGINTERN PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10996 PyObject *resultobj = 0;
10997 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
10998 wxFileSystem *arg2 = 0 ;
10999 wxString *arg3 = 0 ;
11000 wxFSFile *result = 0 ;
11001 void *argp1 = 0 ;
11002 int res1 = 0 ;
11003 void *argp2 = 0 ;
11004 int res2 = 0 ;
11005 bool temp3 = false ;
11006 PyObject * obj0 = 0 ;
11007 PyObject * obj1 = 0 ;
11008 PyObject * obj2 = 0 ;
11009 char * kwnames[] = {
11010 (char *) "self",(char *) "fs",(char *) "location", NULL
11011 };
11012
11013 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11014 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
11015 if (!SWIG_IsOK(res1)) {
11016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
11017 }
11018 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
11019 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11020 if (!SWIG_IsOK(res2)) {
11021 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11022 }
11023 if (!argp2) {
11024 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11025 }
11026 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11027 {
11028 arg3 = wxString_in_helper(obj2);
11029 if (arg3 == NULL) SWIG_fail;
11030 temp3 = true;
11031 }
11032 {
11033 PyThreadState* __tstate = wxPyBeginAllowThreads();
11034 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11035 wxPyEndAllowThreads(__tstate);
11036 if (PyErr_Occurred()) SWIG_fail;
11037 }
11038 {
11039 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11040 }
11041 {
11042 if (temp3)
11043 delete arg3;
11044 }
11045 return resultobj;
11046 fail:
11047 {
11048 if (temp3)
11049 delete arg3;
11050 }
11051 return NULL;
11052 }
11053
11054
11055 SWIGINTERN PyObject *InternetFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11056 PyObject *obj;
11057 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11058 SWIG_TypeNewClientData(SWIGTYPE_p_wxInternetFSHandler, SWIG_NewClientData(obj));
11059 return SWIG_Py_Void();
11060 }
11061
11062 SWIGINTERN PyObject *InternetFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11063 return SWIG_Python_InitShadowInstance(args);
11064 }
11065
11066 SWIGINTERN PyObject *_wrap_new_ZipFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11067 PyObject *resultobj = 0;
11068 wxZipFSHandler *result = 0 ;
11069
11070 if (!SWIG_Python_UnpackTuple(args,"new_ZipFSHandler",0,0,0)) SWIG_fail;
11071 {
11072 PyThreadState* __tstate = wxPyBeginAllowThreads();
11073 result = (wxZipFSHandler *)new wxZipFSHandler();
11074 wxPyEndAllowThreads(__tstate);
11075 if (PyErr_Occurred()) SWIG_fail;
11076 }
11077 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_NEW | 0 );
11078 return resultobj;
11079 fail:
11080 return NULL;
11081 }
11082
11083
11084 SWIGINTERN PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11085 PyObject *resultobj = 0;
11086 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11087 wxString *arg2 = 0 ;
11088 bool result;
11089 void *argp1 = 0 ;
11090 int res1 = 0 ;
11091 bool temp2 = false ;
11092 PyObject * obj0 = 0 ;
11093 PyObject * obj1 = 0 ;
11094 char * kwnames[] = {
11095 (char *) "self",(char *) "location", NULL
11096 };
11097
11098 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11099 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11100 if (!SWIG_IsOK(res1)) {
11101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11102 }
11103 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11104 {
11105 arg2 = wxString_in_helper(obj1);
11106 if (arg2 == NULL) SWIG_fail;
11107 temp2 = true;
11108 }
11109 {
11110 PyThreadState* __tstate = wxPyBeginAllowThreads();
11111 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11112 wxPyEndAllowThreads(__tstate);
11113 if (PyErr_Occurred()) SWIG_fail;
11114 }
11115 {
11116 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11117 }
11118 {
11119 if (temp2)
11120 delete arg2;
11121 }
11122 return resultobj;
11123 fail:
11124 {
11125 if (temp2)
11126 delete arg2;
11127 }
11128 return NULL;
11129 }
11130
11131
11132 SWIGINTERN PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11133 PyObject *resultobj = 0;
11134 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11135 wxFileSystem *arg2 = 0 ;
11136 wxString *arg3 = 0 ;
11137 wxFSFile *result = 0 ;
11138 void *argp1 = 0 ;
11139 int res1 = 0 ;
11140 void *argp2 = 0 ;
11141 int res2 = 0 ;
11142 bool temp3 = false ;
11143 PyObject * obj0 = 0 ;
11144 PyObject * obj1 = 0 ;
11145 PyObject * obj2 = 0 ;
11146 char * kwnames[] = {
11147 (char *) "self",(char *) "fs",(char *) "location", NULL
11148 };
11149
11150 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11151 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11152 if (!SWIG_IsOK(res1)) {
11153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11154 }
11155 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11156 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11157 if (!SWIG_IsOK(res2)) {
11158 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11159 }
11160 if (!argp2) {
11161 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11162 }
11163 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11164 {
11165 arg3 = wxString_in_helper(obj2);
11166 if (arg3 == NULL) SWIG_fail;
11167 temp3 = true;
11168 }
11169 {
11170 PyThreadState* __tstate = wxPyBeginAllowThreads();
11171 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11172 wxPyEndAllowThreads(__tstate);
11173 if (PyErr_Occurred()) SWIG_fail;
11174 }
11175 {
11176 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11177 }
11178 {
11179 if (temp3)
11180 delete arg3;
11181 }
11182 return resultobj;
11183 fail:
11184 {
11185 if (temp3)
11186 delete arg3;
11187 }
11188 return NULL;
11189 }
11190
11191
11192 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11193 PyObject *resultobj = 0;
11194 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11195 wxString *arg2 = 0 ;
11196 int arg3 = (int) 0 ;
11197 wxString result;
11198 void *argp1 = 0 ;
11199 int res1 = 0 ;
11200 bool temp2 = false ;
11201 int val3 ;
11202 int ecode3 = 0 ;
11203 PyObject * obj0 = 0 ;
11204 PyObject * obj1 = 0 ;
11205 PyObject * obj2 = 0 ;
11206 char * kwnames[] = {
11207 (char *) "self",(char *) "spec",(char *) "flags", NULL
11208 };
11209
11210 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11211 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11212 if (!SWIG_IsOK(res1)) {
11213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11214 }
11215 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11216 {
11217 arg2 = wxString_in_helper(obj1);
11218 if (arg2 == NULL) SWIG_fail;
11219 temp2 = true;
11220 }
11221 if (obj2) {
11222 ecode3 = SWIG_AsVal_int(obj2, &val3);
11223 if (!SWIG_IsOK(ecode3)) {
11224 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11225 }
11226 arg3 = static_cast< int >(val3);
11227 }
11228 {
11229 PyThreadState* __tstate = wxPyBeginAllowThreads();
11230 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11231 wxPyEndAllowThreads(__tstate);
11232 if (PyErr_Occurred()) SWIG_fail;
11233 }
11234 {
11235 #if wxUSE_UNICODE
11236 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11237 #else
11238 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11239 #endif
11240 }
11241 {
11242 if (temp2)
11243 delete arg2;
11244 }
11245 return resultobj;
11246 fail:
11247 {
11248 if (temp2)
11249 delete arg2;
11250 }
11251 return NULL;
11252 }
11253
11254
11255 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11256 PyObject *resultobj = 0;
11257 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11258 wxString result;
11259 void *argp1 = 0 ;
11260 int res1 = 0 ;
11261 PyObject *swig_obj[1] ;
11262
11263 if (!args) SWIG_fail;
11264 swig_obj[0] = args;
11265 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11266 if (!SWIG_IsOK(res1)) {
11267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindNext" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11268 }
11269 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11270 {
11271 PyThreadState* __tstate = wxPyBeginAllowThreads();
11272 result = (arg1)->FindNext();
11273 wxPyEndAllowThreads(__tstate);
11274 if (PyErr_Occurred()) SWIG_fail;
11275 }
11276 {
11277 #if wxUSE_UNICODE
11278 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11279 #else
11280 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11281 #endif
11282 }
11283 return resultobj;
11284 fail:
11285 return NULL;
11286 }
11287
11288
11289 SWIGINTERN PyObject *ZipFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11290 PyObject *obj;
11291 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11292 SWIG_TypeNewClientData(SWIGTYPE_p_wxZipFSHandler, SWIG_NewClientData(obj));
11293 return SWIG_Py_Void();
11294 }
11295
11296 SWIGINTERN PyObject *ZipFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11297 return SWIG_Python_InitShadowInstance(args);
11298 }
11299
11300 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11301 PyObject *resultobj = 0;
11302 wxString *arg1 = 0 ;
11303 wxImage *arg2 = 0 ;
11304 long arg3 ;
11305 bool temp1 = false ;
11306 void *argp2 = 0 ;
11307 int res2 = 0 ;
11308 long val3 ;
11309 int ecode3 = 0 ;
11310 PyObject * obj0 = 0 ;
11311 PyObject * obj1 = 0 ;
11312 PyObject * obj2 = 0 ;
11313 char * kwnames[] = {
11314 (char *) "filename",(char *) "image",(char *) "type", NULL
11315 };
11316
11317 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11318 {
11319 arg1 = wxString_in_helper(obj0);
11320 if (arg1 == NULL) SWIG_fail;
11321 temp1 = true;
11322 }
11323 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
11324 if (!SWIG_IsOK(res2)) {
11325 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11326 }
11327 if (!argp2) {
11328 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11329 }
11330 arg2 = reinterpret_cast< wxImage * >(argp2);
11331 ecode3 = SWIG_AsVal_long(obj2, &val3);
11332 if (!SWIG_IsOK(ecode3)) {
11333 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "3"" of type '" "long""'");
11334 }
11335 arg3 = static_cast< long >(val3);
11336 {
11337 PyThreadState* __tstate = wxPyBeginAllowThreads();
11338 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
11339 wxPyEndAllowThreads(__tstate);
11340 if (PyErr_Occurred()) SWIG_fail;
11341 }
11342 resultobj = SWIG_Py_Void();
11343 {
11344 if (temp1)
11345 delete arg1;
11346 }
11347 return resultobj;
11348 fail:
11349 {
11350 if (temp1)
11351 delete arg1;
11352 }
11353 return NULL;
11354 }
11355
11356
11357 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11358 PyObject *resultobj = 0;
11359 wxString *arg1 = 0 ;
11360 wxBitmap *arg2 = 0 ;
11361 long arg3 ;
11362 bool temp1 = false ;
11363 void *argp2 = 0 ;
11364 int res2 = 0 ;
11365 long val3 ;
11366 int ecode3 = 0 ;
11367 PyObject * obj0 = 0 ;
11368 PyObject * obj1 = 0 ;
11369 PyObject * obj2 = 0 ;
11370 char * kwnames[] = {
11371 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
11372 };
11373
11374 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11375 {
11376 arg1 = wxString_in_helper(obj0);
11377 if (arg1 == NULL) SWIG_fail;
11378 temp1 = true;
11379 }
11380 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
11381 if (!SWIG_IsOK(res2)) {
11382 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11383 }
11384 if (!argp2) {
11385 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11386 }
11387 arg2 = reinterpret_cast< wxBitmap * >(argp2);
11388 ecode3 = SWIG_AsVal_long(obj2, &val3);
11389 if (!SWIG_IsOK(ecode3)) {
11390 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "3"" of type '" "long""'");
11391 }
11392 arg3 = static_cast< long >(val3);
11393 {
11394 PyThreadState* __tstate = wxPyBeginAllowThreads();
11395 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
11396 wxPyEndAllowThreads(__tstate);
11397 if (PyErr_Occurred()) SWIG_fail;
11398 }
11399 resultobj = SWIG_Py_Void();
11400 {
11401 if (temp1)
11402 delete arg1;
11403 }
11404 return resultobj;
11405 fail:
11406 {
11407 if (temp1)
11408 delete arg1;
11409 }
11410 return NULL;
11411 }
11412
11413
11414 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11415 PyObject *resultobj = 0;
11416 wxString *arg1 = 0 ;
11417 PyObject *arg2 = (PyObject *) 0 ;
11418 bool temp1 = false ;
11419 PyObject * obj0 = 0 ;
11420 PyObject * obj1 = 0 ;
11421 char * kwnames[] = {
11422 (char *) "filename",(char *) "data", NULL
11423 };
11424
11425 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) SWIG_fail;
11426 {
11427 arg1 = wxString_in_helper(obj0);
11428 if (arg1 == NULL) SWIG_fail;
11429 temp1 = true;
11430 }
11431 arg2 = obj1;
11432 {
11433 PyThreadState* __tstate = wxPyBeginAllowThreads();
11434 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
11435 wxPyEndAllowThreads(__tstate);
11436 if (PyErr_Occurred()) SWIG_fail;
11437 }
11438 resultobj = SWIG_Py_Void();
11439 {
11440 if (temp1)
11441 delete arg1;
11442 }
11443 return resultobj;
11444 fail:
11445 {
11446 if (temp1)
11447 delete arg1;
11448 }
11449 return NULL;
11450 }
11451
11452
11453 SWIGINTERN PyObject *_wrap_new_MemoryFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11454 PyObject *resultobj = 0;
11455 wxMemoryFSHandler *result = 0 ;
11456
11457 if (!SWIG_Python_UnpackTuple(args,"new_MemoryFSHandler",0,0,0)) SWIG_fail;
11458 {
11459 PyThreadState* __tstate = wxPyBeginAllowThreads();
11460 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
11461 wxPyEndAllowThreads(__tstate);
11462 if (PyErr_Occurred()) SWIG_fail;
11463 }
11464 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_NEW | 0 );
11465 return resultobj;
11466 fail:
11467 return NULL;
11468 }
11469
11470
11471 SWIGINTERN PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11472 PyObject *resultobj = 0;
11473 wxString *arg1 = 0 ;
11474 bool temp1 = false ;
11475 PyObject * obj0 = 0 ;
11476 char * kwnames[] = {
11477 (char *) "filename", NULL
11478 };
11479
11480 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) SWIG_fail;
11481 {
11482 arg1 = wxString_in_helper(obj0);
11483 if (arg1 == NULL) SWIG_fail;
11484 temp1 = true;
11485 }
11486 {
11487 PyThreadState* __tstate = wxPyBeginAllowThreads();
11488 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
11489 wxPyEndAllowThreads(__tstate);
11490 if (PyErr_Occurred()) SWIG_fail;
11491 }
11492 resultobj = SWIG_Py_Void();
11493 {
11494 if (temp1)
11495 delete arg1;
11496 }
11497 return resultobj;
11498 fail:
11499 {
11500 if (temp1)
11501 delete arg1;
11502 }
11503 return NULL;
11504 }
11505
11506
11507 SWIGINTERN PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11508 PyObject *resultobj = 0;
11509 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11510 wxString *arg2 = 0 ;
11511 bool result;
11512 void *argp1 = 0 ;
11513 int res1 = 0 ;
11514 bool temp2 = false ;
11515 PyObject * obj0 = 0 ;
11516 PyObject * obj1 = 0 ;
11517 char * kwnames[] = {
11518 (char *) "self",(char *) "location", NULL
11519 };
11520
11521 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11522 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11523 if (!SWIG_IsOK(res1)) {
11524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11525 }
11526 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11527 {
11528 arg2 = wxString_in_helper(obj1);
11529 if (arg2 == NULL) SWIG_fail;
11530 temp2 = true;
11531 }
11532 {
11533 PyThreadState* __tstate = wxPyBeginAllowThreads();
11534 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11535 wxPyEndAllowThreads(__tstate);
11536 if (PyErr_Occurred()) SWIG_fail;
11537 }
11538 {
11539 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11540 }
11541 {
11542 if (temp2)
11543 delete arg2;
11544 }
11545 return resultobj;
11546 fail:
11547 {
11548 if (temp2)
11549 delete arg2;
11550 }
11551 return NULL;
11552 }
11553
11554
11555 SWIGINTERN PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11556 PyObject *resultobj = 0;
11557 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11558 wxFileSystem *arg2 = 0 ;
11559 wxString *arg3 = 0 ;
11560 wxFSFile *result = 0 ;
11561 void *argp1 = 0 ;
11562 int res1 = 0 ;
11563 void *argp2 = 0 ;
11564 int res2 = 0 ;
11565 bool temp3 = false ;
11566 PyObject * obj0 = 0 ;
11567 PyObject * obj1 = 0 ;
11568 PyObject * obj2 = 0 ;
11569 char * kwnames[] = {
11570 (char *) "self",(char *) "fs",(char *) "location", NULL
11571 };
11572
11573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11574 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11575 if (!SWIG_IsOK(res1)) {
11576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11577 }
11578 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11579 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11580 if (!SWIG_IsOK(res2)) {
11581 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11582 }
11583 if (!argp2) {
11584 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11585 }
11586 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11587 {
11588 arg3 = wxString_in_helper(obj2);
11589 if (arg3 == NULL) SWIG_fail;
11590 temp3 = true;
11591 }
11592 {
11593 PyThreadState* __tstate = wxPyBeginAllowThreads();
11594 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11595 wxPyEndAllowThreads(__tstate);
11596 if (PyErr_Occurred()) SWIG_fail;
11597 }
11598 {
11599 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11600 }
11601 {
11602 if (temp3)
11603 delete arg3;
11604 }
11605 return resultobj;
11606 fail:
11607 {
11608 if (temp3)
11609 delete arg3;
11610 }
11611 return NULL;
11612 }
11613
11614
11615 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11616 PyObject *resultobj = 0;
11617 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11618 wxString *arg2 = 0 ;
11619 int arg3 = (int) 0 ;
11620 wxString result;
11621 void *argp1 = 0 ;
11622 int res1 = 0 ;
11623 bool temp2 = false ;
11624 int val3 ;
11625 int ecode3 = 0 ;
11626 PyObject * obj0 = 0 ;
11627 PyObject * obj1 = 0 ;
11628 PyObject * obj2 = 0 ;
11629 char * kwnames[] = {
11630 (char *) "self",(char *) "spec",(char *) "flags", NULL
11631 };
11632
11633 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11634 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11635 if (!SWIG_IsOK(res1)) {
11636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11637 }
11638 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11639 {
11640 arg2 = wxString_in_helper(obj1);
11641 if (arg2 == NULL) SWIG_fail;
11642 temp2 = true;
11643 }
11644 if (obj2) {
11645 ecode3 = SWIG_AsVal_int(obj2, &val3);
11646 if (!SWIG_IsOK(ecode3)) {
11647 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11648 }
11649 arg3 = static_cast< int >(val3);
11650 }
11651 {
11652 PyThreadState* __tstate = wxPyBeginAllowThreads();
11653 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11654 wxPyEndAllowThreads(__tstate);
11655 if (PyErr_Occurred()) SWIG_fail;
11656 }
11657 {
11658 #if wxUSE_UNICODE
11659 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11660 #else
11661 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11662 #endif
11663 }
11664 {
11665 if (temp2)
11666 delete arg2;
11667 }
11668 return resultobj;
11669 fail:
11670 {
11671 if (temp2)
11672 delete arg2;
11673 }
11674 return NULL;
11675 }
11676
11677
11678 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11679 PyObject *resultobj = 0;
11680 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11681 wxString result;
11682 void *argp1 = 0 ;
11683 int res1 = 0 ;
11684 PyObject *swig_obj[1] ;
11685
11686 if (!args) SWIG_fail;
11687 swig_obj[0] = args;
11688 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11689 if (!SWIG_IsOK(res1)) {
11690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindNext" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11691 }
11692 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11693 {
11694 PyThreadState* __tstate = wxPyBeginAllowThreads();
11695 result = (arg1)->FindNext();
11696 wxPyEndAllowThreads(__tstate);
11697 if (PyErr_Occurred()) SWIG_fail;
11698 }
11699 {
11700 #if wxUSE_UNICODE
11701 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11702 #else
11703 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11704 #endif
11705 }
11706 return resultobj;
11707 fail:
11708 return NULL;
11709 }
11710
11711
11712 SWIGINTERN PyObject *MemoryFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11713 PyObject *obj;
11714 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11715 SWIG_TypeNewClientData(SWIGTYPE_p_wxMemoryFSHandler, SWIG_NewClientData(obj));
11716 return SWIG_Py_Void();
11717 }
11718
11719 SWIGINTERN PyObject *MemoryFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11720 return SWIG_Python_InitShadowInstance(args);
11721 }
11722
11723 SWIGINTERN PyObject *_wrap_ImageHandler_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11724 PyObject *resultobj = 0;
11725 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11726 wxString result;
11727 void *argp1 = 0 ;
11728 int res1 = 0 ;
11729 PyObject *swig_obj[1] ;
11730
11731 if (!args) SWIG_fail;
11732 swig_obj[0] = args;
11733 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11734 if (!SWIG_IsOK(res1)) {
11735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11736 }
11737 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11738 {
11739 PyThreadState* __tstate = wxPyBeginAllowThreads();
11740 result = (arg1)->GetName();
11741 wxPyEndAllowThreads(__tstate);
11742 if (PyErr_Occurred()) SWIG_fail;
11743 }
11744 {
11745 #if wxUSE_UNICODE
11746 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11747 #else
11748 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11749 #endif
11750 }
11751 return resultobj;
11752 fail:
11753 return NULL;
11754 }
11755
11756
11757 SWIGINTERN PyObject *_wrap_ImageHandler_GetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11758 PyObject *resultobj = 0;
11759 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11760 wxString result;
11761 void *argp1 = 0 ;
11762 int res1 = 0 ;
11763 PyObject *swig_obj[1] ;
11764
11765 if (!args) SWIG_fail;
11766 swig_obj[0] = args;
11767 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11768 if (!SWIG_IsOK(res1)) {
11769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11770 }
11771 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11772 {
11773 PyThreadState* __tstate = wxPyBeginAllowThreads();
11774 result = (arg1)->GetExtension();
11775 wxPyEndAllowThreads(__tstate);
11776 if (PyErr_Occurred()) SWIG_fail;
11777 }
11778 {
11779 #if wxUSE_UNICODE
11780 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11781 #else
11782 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11783 #endif
11784 }
11785 return resultobj;
11786 fail:
11787 return NULL;
11788 }
11789
11790
11791 SWIGINTERN PyObject *_wrap_ImageHandler_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11792 PyObject *resultobj = 0;
11793 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11794 long result;
11795 void *argp1 = 0 ;
11796 int res1 = 0 ;
11797 PyObject *swig_obj[1] ;
11798
11799 if (!args) SWIG_fail;
11800 swig_obj[0] = args;
11801 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11802 if (!SWIG_IsOK(res1)) {
11803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11804 }
11805 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11806 {
11807 PyThreadState* __tstate = wxPyBeginAllowThreads();
11808 result = (long)(arg1)->GetType();
11809 wxPyEndAllowThreads(__tstate);
11810 if (PyErr_Occurred()) SWIG_fail;
11811 }
11812 resultobj = SWIG_From_long(static_cast< long >(result));
11813 return resultobj;
11814 fail:
11815 return NULL;
11816 }
11817
11818
11819 SWIGINTERN PyObject *_wrap_ImageHandler_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11820 PyObject *resultobj = 0;
11821 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11822 wxString result;
11823 void *argp1 = 0 ;
11824 int res1 = 0 ;
11825 PyObject *swig_obj[1] ;
11826
11827 if (!args) SWIG_fail;
11828 swig_obj[0] = args;
11829 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11830 if (!SWIG_IsOK(res1)) {
11831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11832 }
11833 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11834 {
11835 PyThreadState* __tstate = wxPyBeginAllowThreads();
11836 result = (arg1)->GetMimeType();
11837 wxPyEndAllowThreads(__tstate);
11838 if (PyErr_Occurred()) SWIG_fail;
11839 }
11840 {
11841 #if wxUSE_UNICODE
11842 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11843 #else
11844 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11845 #endif
11846 }
11847 return resultobj;
11848 fail:
11849 return NULL;
11850 }
11851
11852
11853 SWIGINTERN PyObject *_wrap_ImageHandler_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11854 PyObject *resultobj = 0;
11855 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11856 wxString *arg2 = 0 ;
11857 bool result;
11858 void *argp1 = 0 ;
11859 int res1 = 0 ;
11860 bool temp2 = false ;
11861 PyObject * obj0 = 0 ;
11862 PyObject * obj1 = 0 ;
11863 char * kwnames[] = {
11864 (char *) "self",(char *) "name", NULL
11865 };
11866
11867 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) SWIG_fail;
11868 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11869 if (!SWIG_IsOK(res1)) {
11870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanRead" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11871 }
11872 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11873 {
11874 arg2 = wxString_in_helper(obj1);
11875 if (arg2 == NULL) SWIG_fail;
11876 temp2 = true;
11877 }
11878 {
11879 PyThreadState* __tstate = wxPyBeginAllowThreads();
11880 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
11881 wxPyEndAllowThreads(__tstate);
11882 if (PyErr_Occurred()) SWIG_fail;
11883 }
11884 {
11885 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11886 }
11887 {
11888 if (temp2)
11889 delete arg2;
11890 }
11891 return resultobj;
11892 fail:
11893 {
11894 if (temp2)
11895 delete arg2;
11896 }
11897 return NULL;
11898 }
11899
11900
11901 SWIGINTERN PyObject *_wrap_ImageHandler_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11902 PyObject *resultobj = 0;
11903 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11904 wxInputStream *arg2 = 0 ;
11905 bool result;
11906 void *argp1 = 0 ;
11907 int res1 = 0 ;
11908 wxPyInputStream *temp2 ;
11909 bool created2 ;
11910 PyObject * obj0 = 0 ;
11911 PyObject * obj1 = 0 ;
11912 char * kwnames[] = {
11913 (char *) "self",(char *) "stream", NULL
11914 };
11915
11916 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanReadStream",kwnames,&obj0,&obj1)) SWIG_fail;
11917 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11918 if (!SWIG_IsOK(res1)) {
11919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanReadStream" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11920 }
11921 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11922 {
11923 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
11924 arg2 = temp2->m_wxis;
11925 created2 = false;
11926 } else {
11927 PyErr_Clear(); // clear the failure of the wxPyConvert above
11928 arg2 = wxPyCBInputStream_create(obj1, false);
11929 if (arg2 == NULL) {
11930 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
11931 SWIG_fail;
11932 }
11933 created2 = true;
11934 }
11935 }
11936 {
11937 PyThreadState* __tstate = wxPyBeginAllowThreads();
11938 result = (bool)(arg1)->CanRead(*arg2);
11939 wxPyEndAllowThreads(__tstate);
11940 if (PyErr_Occurred()) SWIG_fail;
11941 }
11942 {
11943 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11944 }
11945 {
11946 if (created2) delete arg2;
11947 }
11948 return resultobj;
11949 fail:
11950 {
11951 if (created2) delete arg2;
11952 }
11953 return NULL;
11954 }
11955
11956
11957 SWIGINTERN PyObject *_wrap_ImageHandler_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11958 PyObject *resultobj = 0;
11959 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11960 wxString *arg2 = 0 ;
11961 void *argp1 = 0 ;
11962 int res1 = 0 ;
11963 bool temp2 = false ;
11964 PyObject * obj0 = 0 ;
11965 PyObject * obj1 = 0 ;
11966 char * kwnames[] = {
11967 (char *) "self",(char *) "name", NULL
11968 };
11969
11970 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
11971 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11972 if (!SWIG_IsOK(res1)) {
11973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11974 }
11975 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11976 {
11977 arg2 = wxString_in_helper(obj1);
11978 if (arg2 == NULL) SWIG_fail;
11979 temp2 = true;
11980 }
11981 {
11982 PyThreadState* __tstate = wxPyBeginAllowThreads();
11983 (arg1)->SetName((wxString const &)*arg2);
11984 wxPyEndAllowThreads(__tstate);
11985 if (PyErr_Occurred()) SWIG_fail;
11986 }
11987 resultobj = SWIG_Py_Void();
11988 {
11989 if (temp2)
11990 delete arg2;
11991 }
11992 return resultobj;
11993 fail:
11994 {
11995 if (temp2)
11996 delete arg2;
11997 }
11998 return NULL;
11999 }
12000
12001
12002 SWIGINTERN PyObject *_wrap_ImageHandler_SetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12003 PyObject *resultobj = 0;
12004 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12005 wxString *arg2 = 0 ;
12006 void *argp1 = 0 ;
12007 int res1 = 0 ;
12008 bool temp2 = false ;
12009 PyObject * obj0 = 0 ;
12010 PyObject * obj1 = 0 ;
12011 char * kwnames[] = {
12012 (char *) "self",(char *) "extension", NULL
12013 };
12014
12015 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) SWIG_fail;
12016 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12017 if (!SWIG_IsOK(res1)) {
12018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12019 }
12020 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12021 {
12022 arg2 = wxString_in_helper(obj1);
12023 if (arg2 == NULL) SWIG_fail;
12024 temp2 = true;
12025 }
12026 {
12027 PyThreadState* __tstate = wxPyBeginAllowThreads();
12028 (arg1)->SetExtension((wxString const &)*arg2);
12029 wxPyEndAllowThreads(__tstate);
12030 if (PyErr_Occurred()) SWIG_fail;
12031 }
12032 resultobj = SWIG_Py_Void();
12033 {
12034 if (temp2)
12035 delete arg2;
12036 }
12037 return resultobj;
12038 fail:
12039 {
12040 if (temp2)
12041 delete arg2;
12042 }
12043 return NULL;
12044 }
12045
12046
12047 SWIGINTERN PyObject *_wrap_ImageHandler_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12048 PyObject *resultobj = 0;
12049 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12050 long arg2 ;
12051 void *argp1 = 0 ;
12052 int res1 = 0 ;
12053 long val2 ;
12054 int ecode2 = 0 ;
12055 PyObject * obj0 = 0 ;
12056 PyObject * obj1 = 0 ;
12057 char * kwnames[] = {
12058 (char *) "self",(char *) "type", NULL
12059 };
12060
12061 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
12062 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12063 if (!SWIG_IsOK(res1)) {
12064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12065 }
12066 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12067 ecode2 = SWIG_AsVal_long(obj1, &val2);
12068 if (!SWIG_IsOK(ecode2)) {
12069 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHandler_SetType" "', expected argument " "2"" of type '" "long""'");
12070 }
12071 arg2 = static_cast< long >(val2);
12072 {
12073 PyThreadState* __tstate = wxPyBeginAllowThreads();
12074 (arg1)->SetType(arg2);
12075 wxPyEndAllowThreads(__tstate);
12076 if (PyErr_Occurred()) SWIG_fail;
12077 }
12078 resultobj = SWIG_Py_Void();
12079 return resultobj;
12080 fail:
12081 return NULL;
12082 }
12083
12084
12085 SWIGINTERN PyObject *_wrap_ImageHandler_SetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12086 PyObject *resultobj = 0;
12087 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12088 wxString *arg2 = 0 ;
12089 void *argp1 = 0 ;
12090 int res1 = 0 ;
12091 bool temp2 = false ;
12092 PyObject * obj0 = 0 ;
12093 PyObject * obj1 = 0 ;
12094 char * kwnames[] = {
12095 (char *) "self",(char *) "mimetype", NULL
12096 };
12097
12098 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
12099 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12100 if (!SWIG_IsOK(res1)) {
12101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12102 }
12103 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12104 {
12105 arg2 = wxString_in_helper(obj1);
12106 if (arg2 == NULL) SWIG_fail;
12107 temp2 = true;
12108 }
12109 {
12110 PyThreadState* __tstate = wxPyBeginAllowThreads();
12111 (arg1)->SetMimeType((wxString const &)*arg2);
12112 wxPyEndAllowThreads(__tstate);
12113 if (PyErr_Occurred()) SWIG_fail;
12114 }
12115 resultobj = SWIG_Py_Void();
12116 {
12117 if (temp2)
12118 delete arg2;
12119 }
12120 return resultobj;
12121 fail:
12122 {
12123 if (temp2)
12124 delete arg2;
12125 }
12126 return NULL;
12127 }
12128
12129
12130 SWIGINTERN PyObject *ImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12131 PyObject *obj;
12132 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12133 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHandler, SWIG_NewClientData(obj));
12134 return SWIG_Py_Void();
12135 }
12136
12137 SWIGINTERN PyObject *_wrap_new_PyImageHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12138 PyObject *resultobj = 0;
12139 wxPyImageHandler *result = 0 ;
12140
12141 if (!SWIG_Python_UnpackTuple(args,"new_PyImageHandler",0,0,0)) SWIG_fail;
12142 {
12143 PyThreadState* __tstate = wxPyBeginAllowThreads();
12144 result = (wxPyImageHandler *)new wxPyImageHandler();
12145 wxPyEndAllowThreads(__tstate);
12146 if (PyErr_Occurred()) SWIG_fail;
12147 }
12148 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyImageHandler, SWIG_POINTER_NEW | 0 );
12149 return resultobj;
12150 fail:
12151 return NULL;
12152 }
12153
12154
12155 SWIGINTERN PyObject *_wrap_PyImageHandler__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12156 PyObject *resultobj = 0;
12157 wxPyImageHandler *arg1 = (wxPyImageHandler *) 0 ;
12158 PyObject *arg2 = (PyObject *) 0 ;
12159 void *argp1 = 0 ;
12160 int res1 = 0 ;
12161 PyObject * obj0 = 0 ;
12162 PyObject * obj1 = 0 ;
12163 char * kwnames[] = {
12164 (char *) "self",(char *) "self", NULL
12165 };
12166
12167 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyImageHandler__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
12168 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyImageHandler, 0 | 0 );
12169 if (!SWIG_IsOK(res1)) {
12170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyImageHandler__SetSelf" "', expected argument " "1"" of type '" "wxPyImageHandler *""'");
12171 }
12172 arg1 = reinterpret_cast< wxPyImageHandler * >(argp1);
12173 arg2 = obj1;
12174 {
12175 PyThreadState* __tstate = wxPyBeginAllowThreads();
12176 (arg1)->_SetSelf(arg2);
12177 wxPyEndAllowThreads(__tstate);
12178 if (PyErr_Occurred()) SWIG_fail;
12179 }
12180 resultobj = SWIG_Py_Void();
12181 return resultobj;
12182 fail:
12183 return NULL;
12184 }
12185
12186
12187 SWIGINTERN PyObject *PyImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12188 PyObject *obj;
12189 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12190 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyImageHandler, SWIG_NewClientData(obj));
12191 return SWIG_Py_Void();
12192 }
12193
12194 SWIGINTERN PyObject *PyImageHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12195 return SWIG_Python_InitShadowInstance(args);
12196 }
12197
12198 SWIGINTERN PyObject *_wrap_new_ImageHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12199 PyObject *resultobj = 0;
12200 wxImageHistogram *result = 0 ;
12201
12202 if (!SWIG_Python_UnpackTuple(args,"new_ImageHistogram",0,0,0)) SWIG_fail;
12203 {
12204 PyThreadState* __tstate = wxPyBeginAllowThreads();
12205 result = (wxImageHistogram *)new wxImageHistogram();
12206 wxPyEndAllowThreads(__tstate);
12207 if (PyErr_Occurred()) SWIG_fail;
12208 }
12209 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_NEW | 0 );
12210 return resultobj;
12211 fail:
12212 return NULL;
12213 }
12214
12215
12216 SWIGINTERN PyObject *_wrap_ImageHistogram_MakeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12217 PyObject *resultobj = 0;
12218 byte arg1 ;
12219 byte arg2 ;
12220 byte arg3 ;
12221 unsigned long result;
12222 unsigned char val1 ;
12223 int ecode1 = 0 ;
12224 unsigned char val2 ;
12225 int ecode2 = 0 ;
12226 unsigned char val3 ;
12227 int ecode3 = 0 ;
12228 PyObject * obj0 = 0 ;
12229 PyObject * obj1 = 0 ;
12230 PyObject * obj2 = 0 ;
12231 char * kwnames[] = {
12232 (char *) "r",(char *) "g",(char *) "b", NULL
12233 };
12234
12235 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12236 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12237 if (!SWIG_IsOK(ecode1)) {
12238 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ImageHistogram_MakeKey" "', expected argument " "1"" of type '" "byte""'");
12239 }
12240 arg1 = static_cast< byte >(val1);
12241 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12242 if (!SWIG_IsOK(ecode2)) {
12243 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_MakeKey" "', expected argument " "2"" of type '" "byte""'");
12244 }
12245 arg2 = static_cast< byte >(val2);
12246 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12247 if (!SWIG_IsOK(ecode3)) {
12248 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_MakeKey" "', expected argument " "3"" of type '" "byte""'");
12249 }
12250 arg3 = static_cast< byte >(val3);
12251 {
12252 PyThreadState* __tstate = wxPyBeginAllowThreads();
12253 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
12254 wxPyEndAllowThreads(__tstate);
12255 if (PyErr_Occurred()) SWIG_fail;
12256 }
12257 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12258 return resultobj;
12259 fail:
12260 return NULL;
12261 }
12262
12263
12264 SWIGINTERN PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12265 PyObject *resultobj = 0;
12266 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12267 byte *arg2 = (byte *) 0 ;
12268 byte *arg3 = (byte *) 0 ;
12269 byte *arg4 = (byte *) 0 ;
12270 byte arg5 = (byte) 1 ;
12271 byte arg6 = (byte) 0 ;
12272 byte arg7 = (byte) 0 ;
12273 bool result;
12274 void *argp1 = 0 ;
12275 int res1 = 0 ;
12276 byte temp2 ;
12277 int res2 = SWIG_TMPOBJ ;
12278 byte temp3 ;
12279 int res3 = SWIG_TMPOBJ ;
12280 byte temp4 ;
12281 int res4 = SWIG_TMPOBJ ;
12282 unsigned char val5 ;
12283 int ecode5 = 0 ;
12284 unsigned char val6 ;
12285 int ecode6 = 0 ;
12286 unsigned char val7 ;
12287 int ecode7 = 0 ;
12288 PyObject * obj0 = 0 ;
12289 PyObject * obj1 = 0 ;
12290 PyObject * obj2 = 0 ;
12291 PyObject * obj3 = 0 ;
12292 char * kwnames[] = {
12293 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
12294 };
12295
12296 arg2 = &temp2;
12297 arg3 = &temp3;
12298 arg4 = &temp4;
12299 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12300 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12301 if (!SWIG_IsOK(res1)) {
12302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImageHistogram const *""'");
12303 }
12304 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12305 if (obj1) {
12306 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
12307 if (!SWIG_IsOK(ecode5)) {
12308 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
12309 }
12310 arg5 = static_cast< byte >(val5);
12311 }
12312 if (obj2) {
12313 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
12314 if (!SWIG_IsOK(ecode6)) {
12315 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
12316 }
12317 arg6 = static_cast< byte >(val6);
12318 }
12319 if (obj3) {
12320 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
12321 if (!SWIG_IsOK(ecode7)) {
12322 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
12323 }
12324 arg7 = static_cast< byte >(val7);
12325 }
12326 {
12327 PyThreadState* __tstate = wxPyBeginAllowThreads();
12328 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
12329 wxPyEndAllowThreads(__tstate);
12330 if (PyErr_Occurred()) SWIG_fail;
12331 }
12332 {
12333 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12334 }
12335 if (SWIG_IsTmpObj(res2)) {
12336 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
12337 } else {
12338 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12339 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
12340 }
12341 if (SWIG_IsTmpObj(res3)) {
12342 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
12343 } else {
12344 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12345 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
12346 }
12347 if (SWIG_IsTmpObj(res4)) {
12348 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
12349 } else {
12350 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12351 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
12352 }
12353 return resultobj;
12354 fail:
12355 return NULL;
12356 }
12357
12358
12359 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12360 PyObject *resultobj = 0;
12361 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12362 unsigned long arg2 ;
12363 unsigned long result;
12364 void *argp1 = 0 ;
12365 int res1 = 0 ;
12366 unsigned long val2 ;
12367 int ecode2 = 0 ;
12368 PyObject * obj0 = 0 ;
12369 PyObject * obj1 = 0 ;
12370 char * kwnames[] = {
12371 (char *) "self",(char *) "key", NULL
12372 };
12373
12374 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) SWIG_fail;
12375 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12376 if (!SWIG_IsOK(res1)) {
12377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCount" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12378 }
12379 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12380 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
12381 if (!SWIG_IsOK(ecode2)) {
12382 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCount" "', expected argument " "2"" of type '" "unsigned long""'");
12383 }
12384 arg2 = static_cast< unsigned long >(val2);
12385 {
12386 PyThreadState* __tstate = wxPyBeginAllowThreads();
12387 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
12388 wxPyEndAllowThreads(__tstate);
12389 if (PyErr_Occurred()) SWIG_fail;
12390 }
12391 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12392 return resultobj;
12393 fail:
12394 return NULL;
12395 }
12396
12397
12398 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12399 PyObject *resultobj = 0;
12400 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12401 byte arg2 ;
12402 byte arg3 ;
12403 byte arg4 ;
12404 unsigned long result;
12405 void *argp1 = 0 ;
12406 int res1 = 0 ;
12407 unsigned char val2 ;
12408 int ecode2 = 0 ;
12409 unsigned char val3 ;
12410 int ecode3 = 0 ;
12411 unsigned char val4 ;
12412 int ecode4 = 0 ;
12413 PyObject * obj0 = 0 ;
12414 PyObject * obj1 = 0 ;
12415 PyObject * obj2 = 0 ;
12416 PyObject * obj3 = 0 ;
12417 char * kwnames[] = {
12418 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12419 };
12420
12421 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12422 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12423 if (!SWIG_IsOK(res1)) {
12424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12425 }
12426 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12427 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12428 if (!SWIG_IsOK(ecode2)) {
12429 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "2"" of type '" "byte""'");
12430 }
12431 arg2 = static_cast< byte >(val2);
12432 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12433 if (!SWIG_IsOK(ecode3)) {
12434 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "3"" of type '" "byte""'");
12435 }
12436 arg3 = static_cast< byte >(val3);
12437 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
12438 if (!SWIG_IsOK(ecode4)) {
12439 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "4"" of type '" "byte""'");
12440 }
12441 arg4 = static_cast< byte >(val4);
12442 {
12443 PyThreadState* __tstate = wxPyBeginAllowThreads();
12444 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
12445 wxPyEndAllowThreads(__tstate);
12446 if (PyErr_Occurred()) SWIG_fail;
12447 }
12448 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12449 return resultobj;
12450 fail:
12451 return NULL;
12452 }
12453
12454
12455 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12456 PyObject *resultobj = 0;
12457 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12458 wxColour *arg2 = 0 ;
12459 unsigned long result;
12460 void *argp1 = 0 ;
12461 int res1 = 0 ;
12462 wxColour temp2 ;
12463 PyObject * obj0 = 0 ;
12464 PyObject * obj1 = 0 ;
12465 char * kwnames[] = {
12466 (char *) "self",(char *) "colour", NULL
12467 };
12468
12469 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) SWIG_fail;
12470 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12471 if (!SWIG_IsOK(res1)) {
12472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountColour" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12473 }
12474 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12475 {
12476 arg2 = &temp2;
12477 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
12478 }
12479 {
12480 PyThreadState* __tstate = wxPyBeginAllowThreads();
12481 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
12482 wxPyEndAllowThreads(__tstate);
12483 if (PyErr_Occurred()) SWIG_fail;
12484 }
12485 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12486 return resultobj;
12487 fail:
12488 return NULL;
12489 }
12490
12491
12492 SWIGINTERN PyObject *ImageHistogram_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12493 PyObject *obj;
12494 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12495 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHistogram, SWIG_NewClientData(obj));
12496 return SWIG_Py_Void();
12497 }
12498
12499 SWIGINTERN PyObject *ImageHistogram_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12500 return SWIG_Python_InitShadowInstance(args);
12501 }
12502
12503 SWIGINTERN PyObject *_wrap_new_Image_RGBValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12504 PyObject *resultobj = 0;
12505 byte arg1 = (byte) 0 ;
12506 byte arg2 = (byte) 0 ;
12507 byte arg3 = (byte) 0 ;
12508 wxImage_RGBValue *result = 0 ;
12509 unsigned char val1 ;
12510 int ecode1 = 0 ;
12511 unsigned char val2 ;
12512 int ecode2 = 0 ;
12513 unsigned char val3 ;
12514 int ecode3 = 0 ;
12515 PyObject * obj0 = 0 ;
12516 PyObject * obj1 = 0 ;
12517 PyObject * obj2 = 0 ;
12518 char * kwnames[] = {
12519 (char *) "r",(char *) "g",(char *) "b", NULL
12520 };
12521
12522 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_RGBValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12523 if (obj0) {
12524 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12525 if (!SWIG_IsOK(ecode1)) {
12526 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_RGBValue" "', expected argument " "1"" of type '" "byte""'");
12527 }
12528 arg1 = static_cast< byte >(val1);
12529 }
12530 if (obj1) {
12531 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12532 if (!SWIG_IsOK(ecode2)) {
12533 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_RGBValue" "', expected argument " "2"" of type '" "byte""'");
12534 }
12535 arg2 = static_cast< byte >(val2);
12536 }
12537 if (obj2) {
12538 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12539 if (!SWIG_IsOK(ecode3)) {
12540 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_RGBValue" "', expected argument " "3"" of type '" "byte""'");
12541 }
12542 arg3 = static_cast< byte >(val3);
12543 }
12544 {
12545 PyThreadState* __tstate = wxPyBeginAllowThreads();
12546 result = (wxImage_RGBValue *)new wxImage_RGBValue(arg1,arg2,arg3);
12547 wxPyEndAllowThreads(__tstate);
12548 if (PyErr_Occurred()) SWIG_fail;
12549 }
12550 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_NEW | 0 );
12551 return resultobj;
12552 fail:
12553 return NULL;
12554 }
12555
12556
12557 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12558 PyObject *resultobj = 0;
12559 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12560 byte arg2 ;
12561 void *argp1 = 0 ;
12562 int res1 = 0 ;
12563 unsigned char val2 ;
12564 int ecode2 = 0 ;
12565 PyObject *swig_obj[2] ;
12566
12567 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_red_set",2,2,swig_obj)) SWIG_fail;
12568 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12569 if (!SWIG_IsOK(res1)) {
12570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12571 }
12572 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12573 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12574 if (!SWIG_IsOK(ecode2)) {
12575 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_red_set" "', expected argument " "2"" of type '" "byte""'");
12576 }
12577 arg2 = static_cast< byte >(val2);
12578 if (arg1) (arg1)->red = arg2;
12579
12580 resultobj = SWIG_Py_Void();
12581 return resultobj;
12582 fail:
12583 return NULL;
12584 }
12585
12586
12587 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12588 PyObject *resultobj = 0;
12589 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12590 byte result;
12591 void *argp1 = 0 ;
12592 int res1 = 0 ;
12593 PyObject *swig_obj[1] ;
12594
12595 if (!args) SWIG_fail;
12596 swig_obj[0] = args;
12597 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12598 if (!SWIG_IsOK(res1)) {
12599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12600 }
12601 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12602 result = (byte) ((arg1)->red);
12603 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12604 return resultobj;
12605 fail:
12606 return NULL;
12607 }
12608
12609
12610 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12611 PyObject *resultobj = 0;
12612 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12613 byte arg2 ;
12614 void *argp1 = 0 ;
12615 int res1 = 0 ;
12616 unsigned char val2 ;
12617 int ecode2 = 0 ;
12618 PyObject *swig_obj[2] ;
12619
12620 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_green_set",2,2,swig_obj)) SWIG_fail;
12621 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12622 if (!SWIG_IsOK(res1)) {
12623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12624 }
12625 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12626 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12627 if (!SWIG_IsOK(ecode2)) {
12628 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_green_set" "', expected argument " "2"" of type '" "byte""'");
12629 }
12630 arg2 = static_cast< byte >(val2);
12631 if (arg1) (arg1)->green = arg2;
12632
12633 resultobj = SWIG_Py_Void();
12634 return resultobj;
12635 fail:
12636 return NULL;
12637 }
12638
12639
12640 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12641 PyObject *resultobj = 0;
12642 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12643 byte result;
12644 void *argp1 = 0 ;
12645 int res1 = 0 ;
12646 PyObject *swig_obj[1] ;
12647
12648 if (!args) SWIG_fail;
12649 swig_obj[0] = args;
12650 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12651 if (!SWIG_IsOK(res1)) {
12652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12653 }
12654 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12655 result = (byte) ((arg1)->green);
12656 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12657 return resultobj;
12658 fail:
12659 return NULL;
12660 }
12661
12662
12663 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12664 PyObject *resultobj = 0;
12665 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12666 byte arg2 ;
12667 void *argp1 = 0 ;
12668 int res1 = 0 ;
12669 unsigned char val2 ;
12670 int ecode2 = 0 ;
12671 PyObject *swig_obj[2] ;
12672
12673 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_blue_set",2,2,swig_obj)) SWIG_fail;
12674 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12675 if (!SWIG_IsOK(res1)) {
12676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12677 }
12678 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12679 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12680 if (!SWIG_IsOK(ecode2)) {
12681 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_blue_set" "', expected argument " "2"" of type '" "byte""'");
12682 }
12683 arg2 = static_cast< byte >(val2);
12684 if (arg1) (arg1)->blue = arg2;
12685
12686 resultobj = SWIG_Py_Void();
12687 return resultobj;
12688 fail:
12689 return NULL;
12690 }
12691
12692
12693 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12694 PyObject *resultobj = 0;
12695 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12696 byte result;
12697 void *argp1 = 0 ;
12698 int res1 = 0 ;
12699 PyObject *swig_obj[1] ;
12700
12701 if (!args) SWIG_fail;
12702 swig_obj[0] = args;
12703 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12704 if (!SWIG_IsOK(res1)) {
12705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12706 }
12707 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12708 result = (byte) ((arg1)->blue);
12709 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12710 return resultobj;
12711 fail:
12712 return NULL;
12713 }
12714
12715
12716 SWIGINTERN PyObject *Image_RGBValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12717 PyObject *obj;
12718 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12719 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_RGBValue, SWIG_NewClientData(obj));
12720 return SWIG_Py_Void();
12721 }
12722
12723 SWIGINTERN PyObject *Image_RGBValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12724 return SWIG_Python_InitShadowInstance(args);
12725 }
12726
12727 SWIGINTERN PyObject *_wrap_new_Image_HSVValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12728 PyObject *resultobj = 0;
12729 double arg1 = (double) 0.0 ;
12730 double arg2 = (double) 0.0 ;
12731 double arg3 = (double) 0.0 ;
12732 wxImage_HSVValue *result = 0 ;
12733 double val1 ;
12734 int ecode1 = 0 ;
12735 double val2 ;
12736 int ecode2 = 0 ;
12737 double val3 ;
12738 int ecode3 = 0 ;
12739 PyObject * obj0 = 0 ;
12740 PyObject * obj1 = 0 ;
12741 PyObject * obj2 = 0 ;
12742 char * kwnames[] = {
12743 (char *) "h",(char *) "s",(char *) "v", NULL
12744 };
12745
12746 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_HSVValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12747 if (obj0) {
12748 ecode1 = SWIG_AsVal_double(obj0, &val1);
12749 if (!SWIG_IsOK(ecode1)) {
12750 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_HSVValue" "', expected argument " "1"" of type '" "double""'");
12751 }
12752 arg1 = static_cast< double >(val1);
12753 }
12754 if (obj1) {
12755 ecode2 = SWIG_AsVal_double(obj1, &val2);
12756 if (!SWIG_IsOK(ecode2)) {
12757 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_HSVValue" "', expected argument " "2"" of type '" "double""'");
12758 }
12759 arg2 = static_cast< double >(val2);
12760 }
12761 if (obj2) {
12762 ecode3 = SWIG_AsVal_double(obj2, &val3);
12763 if (!SWIG_IsOK(ecode3)) {
12764 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_HSVValue" "', expected argument " "3"" of type '" "double""'");
12765 }
12766 arg3 = static_cast< double >(val3);
12767 }
12768 {
12769 PyThreadState* __tstate = wxPyBeginAllowThreads();
12770 result = (wxImage_HSVValue *)new wxImage_HSVValue(arg1,arg2,arg3);
12771 wxPyEndAllowThreads(__tstate);
12772 if (PyErr_Occurred()) SWIG_fail;
12773 }
12774 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_NEW | 0 );
12775 return resultobj;
12776 fail:
12777 return NULL;
12778 }
12779
12780
12781 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12782 PyObject *resultobj = 0;
12783 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12784 double arg2 ;
12785 void *argp1 = 0 ;
12786 int res1 = 0 ;
12787 double val2 ;
12788 int ecode2 = 0 ;
12789 PyObject *swig_obj[2] ;
12790
12791 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_hue_set",2,2,swig_obj)) SWIG_fail;
12792 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12793 if (!SWIG_IsOK(res1)) {
12794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12795 }
12796 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12797 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12798 if (!SWIG_IsOK(ecode2)) {
12799 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_hue_set" "', expected argument " "2"" of type '" "double""'");
12800 }
12801 arg2 = static_cast< double >(val2);
12802 if (arg1) (arg1)->hue = arg2;
12803
12804 resultobj = SWIG_Py_Void();
12805 return resultobj;
12806 fail:
12807 return NULL;
12808 }
12809
12810
12811 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12812 PyObject *resultobj = 0;
12813 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12814 double result;
12815 void *argp1 = 0 ;
12816 int res1 = 0 ;
12817 PyObject *swig_obj[1] ;
12818
12819 if (!args) SWIG_fail;
12820 swig_obj[0] = args;
12821 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12822 if (!SWIG_IsOK(res1)) {
12823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12824 }
12825 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12826 result = (double) ((arg1)->hue);
12827 resultobj = SWIG_From_double(static_cast< double >(result));
12828 return resultobj;
12829 fail:
12830 return NULL;
12831 }
12832
12833
12834 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12835 PyObject *resultobj = 0;
12836 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12837 double arg2 ;
12838 void *argp1 = 0 ;
12839 int res1 = 0 ;
12840 double val2 ;
12841 int ecode2 = 0 ;
12842 PyObject *swig_obj[2] ;
12843
12844 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_saturation_set",2,2,swig_obj)) SWIG_fail;
12845 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12846 if (!SWIG_IsOK(res1)) {
12847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12848 }
12849 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12850 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12851 if (!SWIG_IsOK(ecode2)) {
12852 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "2"" of type '" "double""'");
12853 }
12854 arg2 = static_cast< double >(val2);
12855 if (arg1) (arg1)->saturation = arg2;
12856
12857 resultobj = SWIG_Py_Void();
12858 return resultobj;
12859 fail:
12860 return NULL;
12861 }
12862
12863
12864 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12865 PyObject *resultobj = 0;
12866 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12867 double result;
12868 void *argp1 = 0 ;
12869 int res1 = 0 ;
12870 PyObject *swig_obj[1] ;
12871
12872 if (!args) SWIG_fail;
12873 swig_obj[0] = args;
12874 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12875 if (!SWIG_IsOK(res1)) {
12876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12877 }
12878 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12879 result = (double) ((arg1)->saturation);
12880 resultobj = SWIG_From_double(static_cast< double >(result));
12881 return resultobj;
12882 fail:
12883 return NULL;
12884 }
12885
12886
12887 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12888 PyObject *resultobj = 0;
12889 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12890 double arg2 ;
12891 void *argp1 = 0 ;
12892 int res1 = 0 ;
12893 double val2 ;
12894 int ecode2 = 0 ;
12895 PyObject *swig_obj[2] ;
12896
12897 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_value_set",2,2,swig_obj)) SWIG_fail;
12898 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12899 if (!SWIG_IsOK(res1)) {
12900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12901 }
12902 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12903 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12904 if (!SWIG_IsOK(ecode2)) {
12905 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_value_set" "', expected argument " "2"" of type '" "double""'");
12906 }
12907 arg2 = static_cast< double >(val2);
12908 if (arg1) (arg1)->value = arg2;
12909
12910 resultobj = SWIG_Py_Void();
12911 return resultobj;
12912 fail:
12913 return NULL;
12914 }
12915
12916
12917 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12918 PyObject *resultobj = 0;
12919 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12920 double result;
12921 void *argp1 = 0 ;
12922 int res1 = 0 ;
12923 PyObject *swig_obj[1] ;
12924
12925 if (!args) SWIG_fail;
12926 swig_obj[0] = args;
12927 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12928 if (!SWIG_IsOK(res1)) {
12929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12930 }
12931 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12932 result = (double) ((arg1)->value);
12933 resultobj = SWIG_From_double(static_cast< double >(result));
12934 return resultobj;
12935 fail:
12936 return NULL;
12937 }
12938
12939
12940 SWIGINTERN PyObject *Image_HSVValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12941 PyObject *obj;
12942 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12943 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_HSVValue, SWIG_NewClientData(obj));
12944 return SWIG_Py_Void();
12945 }
12946
12947 SWIGINTERN PyObject *Image_HSVValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12948 return SWIG_Python_InitShadowInstance(args);
12949 }
12950
12951 SWIGINTERN PyObject *_wrap_new_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12952 PyObject *resultobj = 0;
12953 wxString *arg1 = 0 ;
12954 long arg2 = (long) wxBITMAP_TYPE_ANY ;
12955 int arg3 = (int) -1 ;
12956 wxImage *result = 0 ;
12957 bool temp1 = false ;
12958 long val2 ;
12959 int ecode2 = 0 ;
12960 int val3 ;
12961 int ecode3 = 0 ;
12962 PyObject * obj0 = 0 ;
12963 PyObject * obj1 = 0 ;
12964 PyObject * obj2 = 0 ;
12965 char * kwnames[] = {
12966 (char *) "name",(char *) "type",(char *) "index", NULL
12967 };
12968
12969 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12970 {
12971 arg1 = wxString_in_helper(obj0);
12972 if (arg1 == NULL) SWIG_fail;
12973 temp1 = true;
12974 }
12975 if (obj1) {
12976 ecode2 = SWIG_AsVal_long(obj1, &val2);
12977 if (!SWIG_IsOK(ecode2)) {
12978 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image" "', expected argument " "2"" of type '" "long""'");
12979 }
12980 arg2 = static_cast< long >(val2);
12981 }
12982 if (obj2) {
12983 ecode3 = SWIG_AsVal_int(obj2, &val3);
12984 if (!SWIG_IsOK(ecode3)) {
12985 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image" "', expected argument " "3"" of type '" "int""'");
12986 }
12987 arg3 = static_cast< int >(val3);
12988 }
12989 {
12990 PyThreadState* __tstate = wxPyBeginAllowThreads();
12991 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
12992 wxPyEndAllowThreads(__tstate);
12993 if (PyErr_Occurred()) SWIG_fail;
12994 }
12995 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_NEW | 0 );
12996 {
12997 if (temp1)
12998 delete arg1;
12999 }
13000 return resultobj;
13001 fail:
13002 {
13003 if (temp1)
13004 delete arg1;
13005 }
13006 return NULL;
13007 }
13008
13009
13010 SWIGINTERN PyObject *_wrap_delete_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13011 PyObject *resultobj = 0;
13012 wxImage *arg1 = (wxImage *) 0 ;
13013 void *argp1 = 0 ;
13014 int res1 = 0 ;
13015 PyObject *swig_obj[1] ;
13016
13017 if (!args) SWIG_fail;
13018 swig_obj[0] = args;
13019 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, SWIG_POINTER_DISOWN | 0 );
13020 if (!SWIG_IsOK(res1)) {
13021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Image" "', expected argument " "1"" of type '" "wxImage *""'");
13022 }
13023 arg1 = reinterpret_cast< wxImage * >(argp1);
13024 {
13025 PyThreadState* __tstate = wxPyBeginAllowThreads();
13026 delete arg1;
13027
13028 wxPyEndAllowThreads(__tstate);
13029 if (PyErr_Occurred()) SWIG_fail;
13030 }
13031 resultobj = SWIG_Py_Void();
13032 return resultobj;
13033 fail:
13034 return NULL;
13035 }
13036
13037
13038 SWIGINTERN PyObject *_wrap_new_ImageFromMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13039 PyObject *resultobj = 0;
13040 wxString *arg1 = 0 ;
13041 wxString *arg2 = 0 ;
13042 int arg3 = (int) -1 ;
13043 wxImage *result = 0 ;
13044 bool temp1 = false ;
13045 bool temp2 = false ;
13046 int val3 ;
13047 int ecode3 = 0 ;
13048 PyObject * obj0 = 0 ;
13049 PyObject * obj1 = 0 ;
13050 PyObject * obj2 = 0 ;
13051 char * kwnames[] = {
13052 (char *) "name",(char *) "mimetype",(char *) "index", NULL
13053 };
13054
13055 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13056 {
13057 arg1 = wxString_in_helper(obj0);
13058 if (arg1 == NULL) SWIG_fail;
13059 temp1 = true;
13060 }
13061 {
13062 arg2 = wxString_in_helper(obj1);
13063 if (arg2 == NULL) SWIG_fail;
13064 temp2 = true;
13065 }
13066 if (obj2) {
13067 ecode3 = SWIG_AsVal_int(obj2, &val3);
13068 if (!SWIG_IsOK(ecode3)) {
13069 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromMime" "', expected argument " "3"" of type '" "int""'");
13070 }
13071 arg3 = static_cast< int >(val3);
13072 }
13073 {
13074 PyThreadState* __tstate = wxPyBeginAllowThreads();
13075 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
13076 wxPyEndAllowThreads(__tstate);
13077 if (PyErr_Occurred()) SWIG_fail;
13078 }
13079 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13080 {
13081 if (temp1)
13082 delete arg1;
13083 }
13084 {
13085 if (temp2)
13086 delete arg2;
13087 }
13088 return resultobj;
13089 fail:
13090 {
13091 if (temp1)
13092 delete arg1;
13093 }
13094 {
13095 if (temp2)
13096 delete arg2;
13097 }
13098 return NULL;
13099 }
13100
13101
13102 SWIGINTERN PyObject *_wrap_new_ImageFromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13103 PyObject *resultobj = 0;
13104 wxInputStream *arg1 = 0 ;
13105 long arg2 = (long) wxBITMAP_TYPE_ANY ;
13106 int arg3 = (int) -1 ;
13107 wxImage *result = 0 ;
13108 wxPyInputStream *temp1 ;
13109 bool created1 ;
13110 long val2 ;
13111 int ecode2 = 0 ;
13112 int val3 ;
13113 int ecode3 = 0 ;
13114 PyObject * obj0 = 0 ;
13115 PyObject * obj1 = 0 ;
13116 PyObject * obj2 = 0 ;
13117 char * kwnames[] = {
13118 (char *) "stream",(char *) "type",(char *) "index", NULL
13119 };
13120
13121 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13122 {
13123 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13124 arg1 = temp1->m_wxis;
13125 created1 = false;
13126 } else {
13127 PyErr_Clear(); // clear the failure of the wxPyConvert above
13128 arg1 = wxPyCBInputStream_create(obj0, false);
13129 if (arg1 == NULL) {
13130 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13131 SWIG_fail;
13132 }
13133 created1 = true;
13134 }
13135 }
13136 if (obj1) {
13137 ecode2 = SWIG_AsVal_long(obj1, &val2);
13138 if (!SWIG_IsOK(ecode2)) {
13139 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromStream" "', expected argument " "2"" of type '" "long""'");
13140 }
13141 arg2 = static_cast< long >(val2);
13142 }
13143 if (obj2) {
13144 ecode3 = SWIG_AsVal_int(obj2, &val3);
13145 if (!SWIG_IsOK(ecode3)) {
13146 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStream" "', expected argument " "3"" of type '" "int""'");
13147 }
13148 arg3 = static_cast< int >(val3);
13149 }
13150 {
13151 PyThreadState* __tstate = wxPyBeginAllowThreads();
13152 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
13153 wxPyEndAllowThreads(__tstate);
13154 if (PyErr_Occurred()) SWIG_fail;
13155 }
13156 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13157 {
13158 if (created1) delete arg1;
13159 }
13160 return resultobj;
13161 fail:
13162 {
13163 if (created1) delete arg1;
13164 }
13165 return NULL;
13166 }
13167
13168
13169 SWIGINTERN PyObject *_wrap_new_ImageFromStreamMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13170 PyObject *resultobj = 0;
13171 wxInputStream *arg1 = 0 ;
13172 wxString *arg2 = 0 ;
13173 int arg3 = (int) -1 ;
13174 wxImage *result = 0 ;
13175 wxPyInputStream *temp1 ;
13176 bool created1 ;
13177 bool temp2 = false ;
13178 int val3 ;
13179 int ecode3 = 0 ;
13180 PyObject * obj0 = 0 ;
13181 PyObject * obj1 = 0 ;
13182 PyObject * obj2 = 0 ;
13183 char * kwnames[] = {
13184 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
13185 };
13186
13187 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13188 {
13189 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13190 arg1 = temp1->m_wxis;
13191 created1 = false;
13192 } else {
13193 PyErr_Clear(); // clear the failure of the wxPyConvert above
13194 arg1 = wxPyCBInputStream_create(obj0, false);
13195 if (arg1 == NULL) {
13196 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13197 SWIG_fail;
13198 }
13199 created1 = true;
13200 }
13201 }
13202 {
13203 arg2 = wxString_in_helper(obj1);
13204 if (arg2 == NULL) SWIG_fail;
13205 temp2 = true;
13206 }
13207 if (obj2) {
13208 ecode3 = SWIG_AsVal_int(obj2, &val3);
13209 if (!SWIG_IsOK(ecode3)) {
13210 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStreamMime" "', expected argument " "3"" of type '" "int""'");
13211 }
13212 arg3 = static_cast< int >(val3);
13213 }
13214 {
13215 PyThreadState* __tstate = wxPyBeginAllowThreads();
13216 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
13217 wxPyEndAllowThreads(__tstate);
13218 if (PyErr_Occurred()) SWIG_fail;
13219 }
13220 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13221 {
13222 if (created1) delete arg1;
13223 }
13224 {
13225 if (temp2)
13226 delete arg2;
13227 }
13228 return resultobj;
13229 fail:
13230 {
13231 if (created1) delete arg1;
13232 }
13233 {
13234 if (temp2)
13235 delete arg2;
13236 }
13237 return NULL;
13238 }
13239
13240
13241 SWIGINTERN PyObject *_wrap_new_EmptyImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13242 PyObject *resultobj = 0;
13243 int arg1 = (int) 0 ;
13244 int arg2 = (int) 0 ;
13245 bool arg3 = (bool) true ;
13246 wxImage *result = 0 ;
13247 int val1 ;
13248 int ecode1 = 0 ;
13249 int val2 ;
13250 int ecode2 = 0 ;
13251 bool val3 ;
13252 int ecode3 = 0 ;
13253 PyObject * obj0 = 0 ;
13254 PyObject * obj1 = 0 ;
13255 PyObject * obj2 = 0 ;
13256 char * kwnames[] = {
13257 (char *) "width",(char *) "height",(char *) "clear", NULL
13258 };
13259
13260 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13261 if (obj0) {
13262 ecode1 = SWIG_AsVal_int(obj0, &val1);
13263 if (!SWIG_IsOK(ecode1)) {
13264 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EmptyImage" "', expected argument " "1"" of type '" "int""'");
13265 }
13266 arg1 = static_cast< int >(val1);
13267 }
13268 if (obj1) {
13269 ecode2 = SWIG_AsVal_int(obj1, &val2);
13270 if (!SWIG_IsOK(ecode2)) {
13271 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EmptyImage" "', expected argument " "2"" of type '" "int""'");
13272 }
13273 arg2 = static_cast< int >(val2);
13274 }
13275 if (obj2) {
13276 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13277 if (!SWIG_IsOK(ecode3)) {
13278 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EmptyImage" "', expected argument " "3"" of type '" "bool""'");
13279 }
13280 arg3 = static_cast< bool >(val3);
13281 }
13282 {
13283 PyThreadState* __tstate = wxPyBeginAllowThreads();
13284 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
13285 wxPyEndAllowThreads(__tstate);
13286 if (PyErr_Occurred()) SWIG_fail;
13287 }
13288 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13289 return resultobj;
13290 fail:
13291 return NULL;
13292 }
13293
13294
13295 SWIGINTERN PyObject *_wrap_new_ImageFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13296 PyObject *resultobj = 0;
13297 wxBitmap *arg1 = 0 ;
13298 wxImage *result = 0 ;
13299 void *argp1 = 0 ;
13300 int res1 = 0 ;
13301 PyObject * obj0 = 0 ;
13302 char * kwnames[] = {
13303 (char *) "bitmap", NULL
13304 };
13305
13306 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) SWIG_fail;
13307 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
13308 if (!SWIG_IsOK(res1)) {
13309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13310 }
13311 if (!argp1) {
13312 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13313 }
13314 arg1 = reinterpret_cast< wxBitmap * >(argp1);
13315 {
13316 if (!wxPyCheckForApp()) SWIG_fail;
13317 PyThreadState* __tstate = wxPyBeginAllowThreads();
13318 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
13319 wxPyEndAllowThreads(__tstate);
13320 if (PyErr_Occurred()) SWIG_fail;
13321 }
13322 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13323 return resultobj;
13324 fail:
13325 return NULL;
13326 }
13327
13328
13329 SWIGINTERN PyObject *_wrap_new_ImageFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13330 PyObject *resultobj = 0;
13331 int arg1 ;
13332 int arg2 ;
13333 buffer arg3 ;
13334 int arg4 ;
13335 wxImage *result = 0 ;
13336 int val1 ;
13337 int ecode1 = 0 ;
13338 int val2 ;
13339 int ecode2 = 0 ;
13340 PyObject * obj0 = 0 ;
13341 PyObject * obj1 = 0 ;
13342 PyObject * obj2 = 0 ;
13343 char * kwnames[] = {
13344 (char *) "width",(char *) "height",(char *) "data", NULL
13345 };
13346
13347 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13348 ecode1 = SWIG_AsVal_int(obj0, &val1);
13349 if (!SWIG_IsOK(ecode1)) {
13350 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromData" "', expected argument " "1"" of type '" "int""'");
13351 }
13352 arg1 = static_cast< int >(val1);
13353 ecode2 = SWIG_AsVal_int(obj1, &val2);
13354 if (!SWIG_IsOK(ecode2)) {
13355 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromData" "', expected argument " "2"" of type '" "int""'");
13356 }
13357 arg2 = static_cast< int >(val2);
13358 {
13359 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
13360 }
13361 {
13362 PyThreadState* __tstate = wxPyBeginAllowThreads();
13363 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
13364 wxPyEndAllowThreads(__tstate);
13365 if (PyErr_Occurred()) SWIG_fail;
13366 }
13367 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13368 return resultobj;
13369 fail:
13370 return NULL;
13371 }
13372
13373
13374 SWIGINTERN PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13375 PyObject *resultobj = 0;
13376 int arg1 ;
13377 int arg2 ;
13378 buffer arg3 ;
13379 int arg4 ;
13380 buffer arg5 ;
13381 int arg6 ;
13382 wxImage *result = 0 ;
13383 int val1 ;
13384 int ecode1 = 0 ;
13385 int val2 ;
13386 int ecode2 = 0 ;
13387 PyObject * obj0 = 0 ;
13388 PyObject * obj1 = 0 ;
13389 PyObject * obj2 = 0 ;
13390 PyObject * obj3 = 0 ;
13391 char * kwnames[] = {
13392 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
13393 };
13394
13395 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13396 ecode1 = SWIG_AsVal_int(obj0, &val1);
13397 if (!SWIG_IsOK(ecode1)) {
13398 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "1"" of type '" "int""'");
13399 }
13400 arg1 = static_cast< int >(val1);
13401 ecode2 = SWIG_AsVal_int(obj1, &val2);
13402 if (!SWIG_IsOK(ecode2)) {
13403 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "2"" of type '" "int""'");
13404 }
13405 arg2 = static_cast< int >(val2);
13406 {
13407 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
13408 }
13409 {
13410 if (!PyArg_Parse(obj3, "t#", &arg5, &arg6)) SWIG_fail;
13411 }
13412 {
13413 PyThreadState* __tstate = wxPyBeginAllowThreads();
13414 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
13415 wxPyEndAllowThreads(__tstate);
13416 if (PyErr_Occurred()) SWIG_fail;
13417 }
13418 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13419 return resultobj;
13420 fail:
13421 return NULL;
13422 }
13423
13424
13425 SWIGINTERN PyObject *_wrap_Image_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13426 PyObject *resultobj = 0;
13427 wxImage *arg1 = (wxImage *) 0 ;
13428 int arg2 ;
13429 int arg3 ;
13430 bool arg4 = (bool) true ;
13431 void *argp1 = 0 ;
13432 int res1 = 0 ;
13433 int val2 ;
13434 int ecode2 = 0 ;
13435 int val3 ;
13436 int ecode3 = 0 ;
13437 bool val4 ;
13438 int ecode4 = 0 ;
13439 PyObject * obj0 = 0 ;
13440 PyObject * obj1 = 0 ;
13441 PyObject * obj2 = 0 ;
13442 PyObject * obj3 = 0 ;
13443 char * kwnames[] = {
13444 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
13445 };
13446
13447 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13448 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13449 if (!SWIG_IsOK(res1)) {
13450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Create" "', expected argument " "1"" of type '" "wxImage *""'");
13451 }
13452 arg1 = reinterpret_cast< wxImage * >(argp1);
13453 ecode2 = SWIG_AsVal_int(obj1, &val2);
13454 if (!SWIG_IsOK(ecode2)) {
13455 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Create" "', expected argument " "2"" of type '" "int""'");
13456 }
13457 arg2 = static_cast< int >(val2);
13458 ecode3 = SWIG_AsVal_int(obj2, &val3);
13459 if (!SWIG_IsOK(ecode3)) {
13460 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Create" "', expected argument " "3"" of type '" "int""'");
13461 }
13462 arg3 = static_cast< int >(val3);
13463 if (obj3) {
13464 ecode4 = SWIG_AsVal_bool(obj3, &val4);
13465 if (!SWIG_IsOK(ecode4)) {
13466 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Create" "', expected argument " "4"" of type '" "bool""'");
13467 }
13468 arg4 = static_cast< bool >(val4);
13469 }
13470 {
13471 PyThreadState* __tstate = wxPyBeginAllowThreads();
13472 (arg1)->Create(arg2,arg3,arg4);
13473 wxPyEndAllowThreads(__tstate);
13474 if (PyErr_Occurred()) SWIG_fail;
13475 }
13476 resultobj = SWIG_Py_Void();
13477 return resultobj;
13478 fail:
13479 return NULL;
13480 }
13481
13482
13483 SWIGINTERN PyObject *_wrap_Image_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13484 PyObject *resultobj = 0;
13485 wxImage *arg1 = (wxImage *) 0 ;
13486 void *argp1 = 0 ;
13487 int res1 = 0 ;
13488 PyObject *swig_obj[1] ;
13489
13490 if (!args) SWIG_fail;
13491 swig_obj[0] = args;
13492 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13493 if (!SWIG_IsOK(res1)) {
13494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Destroy" "', expected argument " "1"" of type '" "wxImage *""'");
13495 }
13496 arg1 = reinterpret_cast< wxImage * >(argp1);
13497 {
13498 PyThreadState* __tstate = wxPyBeginAllowThreads();
13499 (arg1)->Destroy();
13500 wxPyEndAllowThreads(__tstate);
13501 if (PyErr_Occurred()) SWIG_fail;
13502 }
13503 resultobj = SWIG_Py_Void();
13504 return resultobj;
13505 fail:
13506 return NULL;
13507 }
13508
13509
13510 SWIGINTERN PyObject *_wrap_Image_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13511 PyObject *resultobj = 0;
13512 wxImage *arg1 = (wxImage *) 0 ;
13513 int arg2 ;
13514 int arg3 ;
13515 SwigValueWrapper<wxImage > result;
13516 void *argp1 = 0 ;
13517 int res1 = 0 ;
13518 int val2 ;
13519 int ecode2 = 0 ;
13520 int val3 ;
13521 int ecode3 = 0 ;
13522 PyObject * obj0 = 0 ;
13523 PyObject * obj1 = 0 ;
13524 PyObject * obj2 = 0 ;
13525 char * kwnames[] = {
13526 (char *) "self",(char *) "width",(char *) "height", NULL
13527 };
13528
13529 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13530 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13531 if (!SWIG_IsOK(res1)) {
13532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Scale" "', expected argument " "1"" of type '" "wxImage *""'");
13533 }
13534 arg1 = reinterpret_cast< wxImage * >(argp1);
13535 ecode2 = SWIG_AsVal_int(obj1, &val2);
13536 if (!SWIG_IsOK(ecode2)) {
13537 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Scale" "', expected argument " "2"" of type '" "int""'");
13538 }
13539 arg2 = static_cast< int >(val2);
13540 ecode3 = SWIG_AsVal_int(obj2, &val3);
13541 if (!SWIG_IsOK(ecode3)) {
13542 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Scale" "', expected argument " "3"" of type '" "int""'");
13543 }
13544 arg3 = static_cast< int >(val3);
13545 {
13546 PyThreadState* __tstate = wxPyBeginAllowThreads();
13547 result = (arg1)->Scale(arg2,arg3);
13548 wxPyEndAllowThreads(__tstate);
13549 if (PyErr_Occurred()) SWIG_fail;
13550 }
13551 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13552 return resultobj;
13553 fail:
13554 return NULL;
13555 }
13556
13557
13558 SWIGINTERN PyObject *_wrap_Image_ShrinkBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13559 PyObject *resultobj = 0;
13560 wxImage *arg1 = (wxImage *) 0 ;
13561 int arg2 ;
13562 int arg3 ;
13563 SwigValueWrapper<wxImage > result;
13564 void *argp1 = 0 ;
13565 int res1 = 0 ;
13566 int val2 ;
13567 int ecode2 = 0 ;
13568 int val3 ;
13569 int ecode3 = 0 ;
13570 PyObject * obj0 = 0 ;
13571 PyObject * obj1 = 0 ;
13572 PyObject * obj2 = 0 ;
13573 char * kwnames[] = {
13574 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
13575 };
13576
13577 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13578 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13579 if (!SWIG_IsOK(res1)) {
13580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ShrinkBy" "', expected argument " "1"" of type '" "wxImage const *""'");
13581 }
13582 arg1 = reinterpret_cast< wxImage * >(argp1);
13583 ecode2 = SWIG_AsVal_int(obj1, &val2);
13584 if (!SWIG_IsOK(ecode2)) {
13585 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ShrinkBy" "', expected argument " "2"" of type '" "int""'");
13586 }
13587 arg2 = static_cast< int >(val2);
13588 ecode3 = SWIG_AsVal_int(obj2, &val3);
13589 if (!SWIG_IsOK(ecode3)) {
13590 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ShrinkBy" "', expected argument " "3"" of type '" "int""'");
13591 }
13592 arg3 = static_cast< int >(val3);
13593 {
13594 PyThreadState* __tstate = wxPyBeginAllowThreads();
13595 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
13596 wxPyEndAllowThreads(__tstate);
13597 if (PyErr_Occurred()) SWIG_fail;
13598 }
13599 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13600 return resultobj;
13601 fail:
13602 return NULL;
13603 }
13604
13605
13606 SWIGINTERN PyObject *_wrap_Image_Rescale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13607 PyObject *resultobj = 0;
13608 wxImage *arg1 = (wxImage *) 0 ;
13609 int arg2 ;
13610 int arg3 ;
13611 wxImage *result = 0 ;
13612 void *argp1 = 0 ;
13613 int res1 = 0 ;
13614 int val2 ;
13615 int ecode2 = 0 ;
13616 int val3 ;
13617 int ecode3 = 0 ;
13618 PyObject * obj0 = 0 ;
13619 PyObject * obj1 = 0 ;
13620 PyObject * obj2 = 0 ;
13621 char * kwnames[] = {
13622 (char *) "self",(char *) "width",(char *) "height", NULL
13623 };
13624
13625 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Rescale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13626 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13627 if (!SWIG_IsOK(res1)) {
13628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rescale" "', expected argument " "1"" of type '" "wxImage *""'");
13629 }
13630 arg1 = reinterpret_cast< wxImage * >(argp1);
13631 ecode2 = SWIG_AsVal_int(obj1, &val2);
13632 if (!SWIG_IsOK(ecode2)) {
13633 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rescale" "', expected argument " "2"" of type '" "int""'");
13634 }
13635 arg2 = static_cast< int >(val2);
13636 ecode3 = SWIG_AsVal_int(obj2, &val3);
13637 if (!SWIG_IsOK(ecode3)) {
13638 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Rescale" "', expected argument " "3"" of type '" "int""'");
13639 }
13640 arg3 = static_cast< int >(val3);
13641 {
13642 PyThreadState* __tstate = wxPyBeginAllowThreads();
13643 {
13644 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3);
13645 result = (wxImage *) &_result_ref;
13646 }
13647 wxPyEndAllowThreads(__tstate);
13648 if (PyErr_Occurred()) SWIG_fail;
13649 }
13650 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13651 return resultobj;
13652 fail:
13653 return NULL;
13654 }
13655
13656
13657 SWIGINTERN PyObject *_wrap_Image_Resize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13658 PyObject *resultobj = 0;
13659 wxImage *arg1 = (wxImage *) 0 ;
13660 wxSize *arg2 = 0 ;
13661 wxPoint *arg3 = 0 ;
13662 int arg4 = (int) -1 ;
13663 int arg5 = (int) -1 ;
13664 int arg6 = (int) -1 ;
13665 wxImage *result = 0 ;
13666 void *argp1 = 0 ;
13667 int res1 = 0 ;
13668 wxSize temp2 ;
13669 wxPoint temp3 ;
13670 int val4 ;
13671 int ecode4 = 0 ;
13672 int val5 ;
13673 int ecode5 = 0 ;
13674 int val6 ;
13675 int ecode6 = 0 ;
13676 PyObject * obj0 = 0 ;
13677 PyObject * obj1 = 0 ;
13678 PyObject * obj2 = 0 ;
13679 PyObject * obj3 = 0 ;
13680 PyObject * obj4 = 0 ;
13681 PyObject * obj5 = 0 ;
13682 char * kwnames[] = {
13683 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
13684 };
13685
13686 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13687 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13688 if (!SWIG_IsOK(res1)) {
13689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Resize" "', expected argument " "1"" of type '" "wxImage *""'");
13690 }
13691 arg1 = reinterpret_cast< wxImage * >(argp1);
13692 {
13693 arg2 = &temp2;
13694 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
13695 }
13696 {
13697 arg3 = &temp3;
13698 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13699 }
13700 if (obj3) {
13701 ecode4 = SWIG_AsVal_int(obj3, &val4);
13702 if (!SWIG_IsOK(ecode4)) {
13703 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Resize" "', expected argument " "4"" of type '" "int""'");
13704 }
13705 arg4 = static_cast< int >(val4);
13706 }
13707 if (obj4) {
13708 ecode5 = SWIG_AsVal_int(obj4, &val5);
13709 if (!SWIG_IsOK(ecode5)) {
13710 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Resize" "', expected argument " "5"" of type '" "int""'");
13711 }
13712 arg5 = static_cast< int >(val5);
13713 }
13714 if (obj5) {
13715 ecode6 = SWIG_AsVal_int(obj5, &val6);
13716 if (!SWIG_IsOK(ecode6)) {
13717 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Resize" "', expected argument " "6"" of type '" "int""'");
13718 }
13719 arg6 = static_cast< int >(val6);
13720 }
13721 {
13722 PyThreadState* __tstate = wxPyBeginAllowThreads();
13723 {
13724 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
13725 result = (wxImage *) &_result_ref;
13726 }
13727 wxPyEndAllowThreads(__tstate);
13728 if (PyErr_Occurred()) SWIG_fail;
13729 }
13730 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13731 return resultobj;
13732 fail:
13733 return NULL;
13734 }
13735
13736
13737 SWIGINTERN PyObject *_wrap_Image_SetRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13738 PyObject *resultobj = 0;
13739 wxImage *arg1 = (wxImage *) 0 ;
13740 int arg2 ;
13741 int arg3 ;
13742 byte arg4 ;
13743 byte arg5 ;
13744 byte arg6 ;
13745 void *argp1 = 0 ;
13746 int res1 = 0 ;
13747 int val2 ;
13748 int ecode2 = 0 ;
13749 int val3 ;
13750 int ecode3 = 0 ;
13751 unsigned char val4 ;
13752 int ecode4 = 0 ;
13753 unsigned char val5 ;
13754 int ecode5 = 0 ;
13755 unsigned char val6 ;
13756 int ecode6 = 0 ;
13757 PyObject * obj0 = 0 ;
13758 PyObject * obj1 = 0 ;
13759 PyObject * obj2 = 0 ;
13760 PyObject * obj3 = 0 ;
13761 PyObject * obj4 = 0 ;
13762 PyObject * obj5 = 0 ;
13763 char * kwnames[] = {
13764 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
13765 };
13766
13767 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13768 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13769 if (!SWIG_IsOK(res1)) {
13770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGB" "', expected argument " "1"" of type '" "wxImage *""'");
13771 }
13772 arg1 = reinterpret_cast< wxImage * >(argp1);
13773 ecode2 = SWIG_AsVal_int(obj1, &val2);
13774 if (!SWIG_IsOK(ecode2)) {
13775 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetRGB" "', expected argument " "2"" of type '" "int""'");
13776 }
13777 arg2 = static_cast< int >(val2);
13778 ecode3 = SWIG_AsVal_int(obj2, &val3);
13779 if (!SWIG_IsOK(ecode3)) {
13780 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGB" "', expected argument " "3"" of type '" "int""'");
13781 }
13782 arg3 = static_cast< int >(val3);
13783 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13784 if (!SWIG_IsOK(ecode4)) {
13785 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGB" "', expected argument " "4"" of type '" "byte""'");
13786 }
13787 arg4 = static_cast< byte >(val4);
13788 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
13789 if (!SWIG_IsOK(ecode5)) {
13790 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGB" "', expected argument " "5"" of type '" "byte""'");
13791 }
13792 arg5 = static_cast< byte >(val5);
13793 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
13794 if (!SWIG_IsOK(ecode6)) {
13795 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_SetRGB" "', expected argument " "6"" of type '" "byte""'");
13796 }
13797 arg6 = static_cast< byte >(val6);
13798 {
13799 PyThreadState* __tstate = wxPyBeginAllowThreads();
13800 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
13801 wxPyEndAllowThreads(__tstate);
13802 if (PyErr_Occurred()) SWIG_fail;
13803 }
13804 resultobj = SWIG_Py_Void();
13805 return resultobj;
13806 fail:
13807 return NULL;
13808 }
13809
13810
13811 SWIGINTERN PyObject *_wrap_Image_SetRGBRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13812 PyObject *resultobj = 0;
13813 wxImage *arg1 = (wxImage *) 0 ;
13814 wxRect *arg2 = 0 ;
13815 byte arg3 ;
13816 byte arg4 ;
13817 byte arg5 ;
13818 void *argp1 = 0 ;
13819 int res1 = 0 ;
13820 wxRect temp2 ;
13821 unsigned char val3 ;
13822 int ecode3 = 0 ;
13823 unsigned char val4 ;
13824 int ecode4 = 0 ;
13825 unsigned char val5 ;
13826 int ecode5 = 0 ;
13827 PyObject * obj0 = 0 ;
13828 PyObject * obj1 = 0 ;
13829 PyObject * obj2 = 0 ;
13830 PyObject * obj3 = 0 ;
13831 PyObject * obj4 = 0 ;
13832 char * kwnames[] = {
13833 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
13834 };
13835
13836 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
13837 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13838 if (!SWIG_IsOK(res1)) {
13839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGBRect" "', expected argument " "1"" of type '" "wxImage *""'");
13840 }
13841 arg1 = reinterpret_cast< wxImage * >(argp1);
13842 {
13843 arg2 = &temp2;
13844 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13845 }
13846 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
13847 if (!SWIG_IsOK(ecode3)) {
13848 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGBRect" "', expected argument " "3"" of type '" "byte""'");
13849 }
13850 arg3 = static_cast< byte >(val3);
13851 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13852 if (!SWIG_IsOK(ecode4)) {
13853 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGBRect" "', expected argument " "4"" of type '" "byte""'");
13854 }
13855 arg4 = static_cast< byte >(val4);
13856 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
13857 if (!SWIG_IsOK(ecode5)) {
13858 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGBRect" "', expected argument " "5"" of type '" "byte""'");
13859 }
13860 arg5 = static_cast< byte >(val5);
13861 {
13862 PyThreadState* __tstate = wxPyBeginAllowThreads();
13863 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
13864 wxPyEndAllowThreads(__tstate);
13865 if (PyErr_Occurred()) SWIG_fail;
13866 }
13867 resultobj = SWIG_Py_Void();
13868 return resultobj;
13869 fail:
13870 return NULL;
13871 }
13872
13873
13874 SWIGINTERN PyObject *_wrap_Image_GetRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13875 PyObject *resultobj = 0;
13876 wxImage *arg1 = (wxImage *) 0 ;
13877 int arg2 ;
13878 int arg3 ;
13879 byte result;
13880 void *argp1 = 0 ;
13881 int res1 = 0 ;
13882 int val2 ;
13883 int ecode2 = 0 ;
13884 int val3 ;
13885 int ecode3 = 0 ;
13886 PyObject * obj0 = 0 ;
13887 PyObject * obj1 = 0 ;
13888 PyObject * obj2 = 0 ;
13889 char * kwnames[] = {
13890 (char *) "self",(char *) "x",(char *) "y", NULL
13891 };
13892
13893 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13894 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13895 if (!SWIG_IsOK(res1)) {
13896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetRed" "', expected argument " "1"" of type '" "wxImage *""'");
13897 }
13898 arg1 = reinterpret_cast< wxImage * >(argp1);
13899 ecode2 = SWIG_AsVal_int(obj1, &val2);
13900 if (!SWIG_IsOK(ecode2)) {
13901 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetRed" "', expected argument " "2"" of type '" "int""'");
13902 }
13903 arg2 = static_cast< int >(val2);
13904 ecode3 = SWIG_AsVal_int(obj2, &val3);
13905 if (!SWIG_IsOK(ecode3)) {
13906 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetRed" "', expected argument " "3"" of type '" "int""'");
13907 }
13908 arg3 = static_cast< int >(val3);
13909 {
13910 PyThreadState* __tstate = wxPyBeginAllowThreads();
13911 result = (byte)(arg1)->GetRed(arg2,arg3);
13912 wxPyEndAllowThreads(__tstate);
13913 if (PyErr_Occurred()) SWIG_fail;
13914 }
13915 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13916 return resultobj;
13917 fail:
13918 return NULL;
13919 }
13920
13921
13922 SWIGINTERN PyObject *_wrap_Image_GetGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13923 PyObject *resultobj = 0;
13924 wxImage *arg1 = (wxImage *) 0 ;
13925 int arg2 ;
13926 int arg3 ;
13927 byte result;
13928 void *argp1 = 0 ;
13929 int res1 = 0 ;
13930 int val2 ;
13931 int ecode2 = 0 ;
13932 int val3 ;
13933 int ecode3 = 0 ;
13934 PyObject * obj0 = 0 ;
13935 PyObject * obj1 = 0 ;
13936 PyObject * obj2 = 0 ;
13937 char * kwnames[] = {
13938 (char *) "self",(char *) "x",(char *) "y", NULL
13939 };
13940
13941 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13942 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13943 if (!SWIG_IsOK(res1)) {
13944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetGreen" "', expected argument " "1"" of type '" "wxImage *""'");
13945 }
13946 arg1 = reinterpret_cast< wxImage * >(argp1);
13947 ecode2 = SWIG_AsVal_int(obj1, &val2);
13948 if (!SWIG_IsOK(ecode2)) {
13949 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetGreen" "', expected argument " "2"" of type '" "int""'");
13950 }
13951 arg2 = static_cast< int >(val2);
13952 ecode3 = SWIG_AsVal_int(obj2, &val3);
13953 if (!SWIG_IsOK(ecode3)) {
13954 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetGreen" "', expected argument " "3"" of type '" "int""'");
13955 }
13956 arg3 = static_cast< int >(val3);
13957 {
13958 PyThreadState* __tstate = wxPyBeginAllowThreads();
13959 result = (byte)(arg1)->GetGreen(arg2,arg3);
13960 wxPyEndAllowThreads(__tstate);
13961 if (PyErr_Occurred()) SWIG_fail;
13962 }
13963 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13964 return resultobj;
13965 fail:
13966 return NULL;
13967 }
13968
13969
13970 SWIGINTERN PyObject *_wrap_Image_GetBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13971 PyObject *resultobj = 0;
13972 wxImage *arg1 = (wxImage *) 0 ;
13973 int arg2 ;
13974 int arg3 ;
13975 byte result;
13976 void *argp1 = 0 ;
13977 int res1 = 0 ;
13978 int val2 ;
13979 int ecode2 = 0 ;
13980 int val3 ;
13981 int ecode3 = 0 ;
13982 PyObject * obj0 = 0 ;
13983 PyObject * obj1 = 0 ;
13984 PyObject * obj2 = 0 ;
13985 char * kwnames[] = {
13986 (char *) "self",(char *) "x",(char *) "y", NULL
13987 };
13988
13989 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13990 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13991 if (!SWIG_IsOK(res1)) {
13992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetBlue" "', expected argument " "1"" of type '" "wxImage *""'");
13993 }
13994 arg1 = reinterpret_cast< wxImage * >(argp1);
13995 ecode2 = SWIG_AsVal_int(obj1, &val2);
13996 if (!SWIG_IsOK(ecode2)) {
13997 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetBlue" "', expected argument " "2"" of type '" "int""'");
13998 }
13999 arg2 = static_cast< int >(val2);
14000 ecode3 = SWIG_AsVal_int(obj2, &val3);
14001 if (!SWIG_IsOK(ecode3)) {
14002 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetBlue" "', expected argument " "3"" of type '" "int""'");
14003 }
14004 arg3 = static_cast< int >(val3);
14005 {
14006 PyThreadState* __tstate = wxPyBeginAllowThreads();
14007 result = (byte)(arg1)->GetBlue(arg2,arg3);
14008 wxPyEndAllowThreads(__tstate);
14009 if (PyErr_Occurred()) SWIG_fail;
14010 }
14011 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14012 return resultobj;
14013 fail:
14014 return NULL;
14015 }
14016
14017
14018 SWIGINTERN PyObject *_wrap_Image_SetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14019 PyObject *resultobj = 0;
14020 wxImage *arg1 = (wxImage *) 0 ;
14021 int arg2 ;
14022 int arg3 ;
14023 byte arg4 ;
14024 void *argp1 = 0 ;
14025 int res1 = 0 ;
14026 int val2 ;
14027 int ecode2 = 0 ;
14028 int val3 ;
14029 int ecode3 = 0 ;
14030 unsigned char val4 ;
14031 int ecode4 = 0 ;
14032 PyObject * obj0 = 0 ;
14033 PyObject * obj1 = 0 ;
14034 PyObject * obj2 = 0 ;
14035 PyObject * obj3 = 0 ;
14036 char * kwnames[] = {
14037 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
14038 };
14039
14040 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14041 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14042 if (!SWIG_IsOK(res1)) {
14043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14044 }
14045 arg1 = reinterpret_cast< wxImage * >(argp1);
14046 ecode2 = SWIG_AsVal_int(obj1, &val2);
14047 if (!SWIG_IsOK(ecode2)) {
14048 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetAlpha" "', expected argument " "2"" of type '" "int""'");
14049 }
14050 arg2 = static_cast< int >(val2);
14051 ecode3 = SWIG_AsVal_int(obj2, &val3);
14052 if (!SWIG_IsOK(ecode3)) {
14053 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetAlpha" "', expected argument " "3"" of type '" "int""'");
14054 }
14055 arg3 = static_cast< int >(val3);
14056 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14057 if (!SWIG_IsOK(ecode4)) {
14058 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetAlpha" "', expected argument " "4"" of type '" "byte""'");
14059 }
14060 arg4 = static_cast< byte >(val4);
14061 {
14062 PyThreadState* __tstate = wxPyBeginAllowThreads();
14063 (arg1)->SetAlpha(arg2,arg3,arg4);
14064 wxPyEndAllowThreads(__tstate);
14065 if (PyErr_Occurred()) SWIG_fail;
14066 }
14067 resultobj = SWIG_Py_Void();
14068 return resultobj;
14069 fail:
14070 return NULL;
14071 }
14072
14073
14074 SWIGINTERN PyObject *_wrap_Image_GetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14075 PyObject *resultobj = 0;
14076 wxImage *arg1 = (wxImage *) 0 ;
14077 int arg2 ;
14078 int arg3 ;
14079 byte result;
14080 void *argp1 = 0 ;
14081 int res1 = 0 ;
14082 int val2 ;
14083 int ecode2 = 0 ;
14084 int val3 ;
14085 int ecode3 = 0 ;
14086 PyObject * obj0 = 0 ;
14087 PyObject * obj1 = 0 ;
14088 PyObject * obj2 = 0 ;
14089 char * kwnames[] = {
14090 (char *) "self",(char *) "x",(char *) "y", NULL
14091 };
14092
14093 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14094 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14095 if (!SWIG_IsOK(res1)) {
14096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14097 }
14098 arg1 = reinterpret_cast< wxImage * >(argp1);
14099 ecode2 = SWIG_AsVal_int(obj1, &val2);
14100 if (!SWIG_IsOK(ecode2)) {
14101 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetAlpha" "', expected argument " "2"" of type '" "int""'");
14102 }
14103 arg2 = static_cast< int >(val2);
14104 ecode3 = SWIG_AsVal_int(obj2, &val3);
14105 if (!SWIG_IsOK(ecode3)) {
14106 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetAlpha" "', expected argument " "3"" of type '" "int""'");
14107 }
14108 arg3 = static_cast< int >(val3);
14109 {
14110 PyThreadState* __tstate = wxPyBeginAllowThreads();
14111 result = (byte)(arg1)->GetAlpha(arg2,arg3);
14112 wxPyEndAllowThreads(__tstate);
14113 if (PyErr_Occurred()) SWIG_fail;
14114 }
14115 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14116 return resultobj;
14117 fail:
14118 return NULL;
14119 }
14120
14121
14122 SWIGINTERN PyObject *_wrap_Image_HasAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14123 PyObject *resultobj = 0;
14124 wxImage *arg1 = (wxImage *) 0 ;
14125 bool result;
14126 void *argp1 = 0 ;
14127 int res1 = 0 ;
14128 PyObject *swig_obj[1] ;
14129
14130 if (!args) SWIG_fail;
14131 swig_obj[0] = args;
14132 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14133 if (!SWIG_IsOK(res1)) {
14134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14135 }
14136 arg1 = reinterpret_cast< wxImage * >(argp1);
14137 {
14138 PyThreadState* __tstate = wxPyBeginAllowThreads();
14139 result = (bool)(arg1)->HasAlpha();
14140 wxPyEndAllowThreads(__tstate);
14141 if (PyErr_Occurred()) SWIG_fail;
14142 }
14143 {
14144 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14145 }
14146 return resultobj;
14147 fail:
14148 return NULL;
14149 }
14150
14151
14152 SWIGINTERN PyObject *_wrap_Image_InitAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14153 PyObject *resultobj = 0;
14154 wxImage *arg1 = (wxImage *) 0 ;
14155 void *argp1 = 0 ;
14156 int res1 = 0 ;
14157 PyObject *swig_obj[1] ;
14158
14159 if (!args) SWIG_fail;
14160 swig_obj[0] = args;
14161 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14162 if (!SWIG_IsOK(res1)) {
14163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InitAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14164 }
14165 arg1 = reinterpret_cast< wxImage * >(argp1);
14166 {
14167 PyThreadState* __tstate = wxPyBeginAllowThreads();
14168 (arg1)->InitAlpha();
14169 wxPyEndAllowThreads(__tstate);
14170 if (PyErr_Occurred()) SWIG_fail;
14171 }
14172 resultobj = SWIG_Py_Void();
14173 return resultobj;
14174 fail:
14175 return NULL;
14176 }
14177
14178
14179 SWIGINTERN PyObject *_wrap_Image_IsTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14180 PyObject *resultobj = 0;
14181 wxImage *arg1 = (wxImage *) 0 ;
14182 int arg2 ;
14183 int arg3 ;
14184 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14185 bool result;
14186 void *argp1 = 0 ;
14187 int res1 = 0 ;
14188 int val2 ;
14189 int ecode2 = 0 ;
14190 int val3 ;
14191 int ecode3 = 0 ;
14192 unsigned char val4 ;
14193 int ecode4 = 0 ;
14194 PyObject * obj0 = 0 ;
14195 PyObject * obj1 = 0 ;
14196 PyObject * obj2 = 0 ;
14197 PyObject * obj3 = 0 ;
14198 char * kwnames[] = {
14199 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
14200 };
14201
14202 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14203 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14204 if (!SWIG_IsOK(res1)) {
14205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsTransparent" "', expected argument " "1"" of type '" "wxImage const *""'");
14206 }
14207 arg1 = reinterpret_cast< wxImage * >(argp1);
14208 ecode2 = SWIG_AsVal_int(obj1, &val2);
14209 if (!SWIG_IsOK(ecode2)) {
14210 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_IsTransparent" "', expected argument " "2"" of type '" "int""'");
14211 }
14212 arg2 = static_cast< int >(val2);
14213 ecode3 = SWIG_AsVal_int(obj2, &val3);
14214 if (!SWIG_IsOK(ecode3)) {
14215 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_IsTransparent" "', expected argument " "3"" of type '" "int""'");
14216 }
14217 arg3 = static_cast< int >(val3);
14218 if (obj3) {
14219 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14220 if (!SWIG_IsOK(ecode4)) {
14221 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_IsTransparent" "', expected argument " "4"" of type '" "byte""'");
14222 }
14223 arg4 = static_cast< byte >(val4);
14224 }
14225 {
14226 PyThreadState* __tstate = wxPyBeginAllowThreads();
14227 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
14228 wxPyEndAllowThreads(__tstate);
14229 if (PyErr_Occurred()) SWIG_fail;
14230 }
14231 {
14232 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14233 }
14234 return resultobj;
14235 fail:
14236 return NULL;
14237 }
14238
14239
14240 SWIGINTERN PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14241 PyObject *resultobj = 0;
14242 wxImage *arg1 = (wxImage *) 0 ;
14243 byte *arg2 = (byte *) 0 ;
14244 byte *arg3 = (byte *) 0 ;
14245 byte *arg4 = (byte *) 0 ;
14246 byte arg5 = (byte) 0 ;
14247 byte arg6 = (byte) 0 ;
14248 byte arg7 = (byte) 0 ;
14249 bool result;
14250 void *argp1 = 0 ;
14251 int res1 = 0 ;
14252 byte temp2 ;
14253 int res2 = SWIG_TMPOBJ ;
14254 byte temp3 ;
14255 int res3 = SWIG_TMPOBJ ;
14256 byte temp4 ;
14257 int res4 = SWIG_TMPOBJ ;
14258 unsigned char val5 ;
14259 int ecode5 = 0 ;
14260 unsigned char val6 ;
14261 int ecode6 = 0 ;
14262 unsigned char val7 ;
14263 int ecode7 = 0 ;
14264 PyObject * obj0 = 0 ;
14265 PyObject * obj1 = 0 ;
14266 PyObject * obj2 = 0 ;
14267 PyObject * obj3 = 0 ;
14268 char * kwnames[] = {
14269 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
14270 };
14271
14272 arg2 = &temp2;
14273 arg3 = &temp3;
14274 arg4 = &temp4;
14275 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14276 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14277 if (!SWIG_IsOK(res1)) {
14278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImage const *""'");
14279 }
14280 arg1 = reinterpret_cast< wxImage * >(argp1);
14281 if (obj1) {
14282 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
14283 if (!SWIG_IsOK(ecode5)) {
14284 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
14285 }
14286 arg5 = static_cast< byte >(val5);
14287 }
14288 if (obj2) {
14289 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
14290 if (!SWIG_IsOK(ecode6)) {
14291 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
14292 }
14293 arg6 = static_cast< byte >(val6);
14294 }
14295 if (obj3) {
14296 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
14297 if (!SWIG_IsOK(ecode7)) {
14298 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
14299 }
14300 arg7 = static_cast< byte >(val7);
14301 }
14302 {
14303 PyThreadState* __tstate = wxPyBeginAllowThreads();
14304 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
14305 wxPyEndAllowThreads(__tstate);
14306 if (PyErr_Occurred()) SWIG_fail;
14307 }
14308 {
14309 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14310 }
14311 if (SWIG_IsTmpObj(res2)) {
14312 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
14313 } else {
14314 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14315 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
14316 }
14317 if (SWIG_IsTmpObj(res3)) {
14318 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
14319 } else {
14320 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14321 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
14322 }
14323 if (SWIG_IsTmpObj(res4)) {
14324 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
14325 } else {
14326 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14327 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
14328 }
14329 return resultobj;
14330 fail:
14331 return NULL;
14332 }
14333
14334
14335 SWIGINTERN PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14336 PyObject *resultobj = 0;
14337 wxImage *arg1 = (wxImage *) 0 ;
14338 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14339 bool result;
14340 void *argp1 = 0 ;
14341 int res1 = 0 ;
14342 unsigned char val2 ;
14343 int ecode2 = 0 ;
14344 PyObject * obj0 = 0 ;
14345 PyObject * obj1 = 0 ;
14346 char * kwnames[] = {
14347 (char *) "self",(char *) "threshold", NULL
14348 };
14349
14350 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) SWIG_fail;
14351 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14352 if (!SWIG_IsOK(res1)) {
14353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "1"" of type '" "wxImage *""'");
14354 }
14355 arg1 = reinterpret_cast< wxImage * >(argp1);
14356 if (obj1) {
14357 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14358 if (!SWIG_IsOK(ecode2)) {
14359 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "2"" of type '" "byte""'");
14360 }
14361 arg2 = static_cast< byte >(val2);
14362 }
14363 {
14364 PyThreadState* __tstate = wxPyBeginAllowThreads();
14365 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
14366 wxPyEndAllowThreads(__tstate);
14367 if (PyErr_Occurred()) SWIG_fail;
14368 }
14369 {
14370 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14371 }
14372 return resultobj;
14373 fail:
14374 return NULL;
14375 }
14376
14377
14378 SWIGINTERN PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14379 PyObject *resultobj = 0;
14380 wxImage *arg1 = (wxImage *) 0 ;
14381 byte arg2 ;
14382 byte arg3 ;
14383 byte arg4 ;
14384 bool result;
14385 void *argp1 = 0 ;
14386 int res1 = 0 ;
14387 unsigned char val2 ;
14388 int ecode2 = 0 ;
14389 unsigned char val3 ;
14390 int ecode3 = 0 ;
14391 unsigned char val4 ;
14392 int ecode4 = 0 ;
14393 PyObject * obj0 = 0 ;
14394 PyObject * obj1 = 0 ;
14395 PyObject * obj2 = 0 ;
14396 PyObject * obj3 = 0 ;
14397 char * kwnames[] = {
14398 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
14399 };
14400
14401 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14402 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14403 if (!SWIG_IsOK(res1)) {
14404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14405 }
14406 arg1 = reinterpret_cast< wxImage * >(argp1);
14407 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14408 if (!SWIG_IsOK(ecode2)) {
14409 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "2"" of type '" "byte""'");
14410 }
14411 arg2 = static_cast< byte >(val2);
14412 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14413 if (!SWIG_IsOK(ecode3)) {
14414 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "3"" of type '" "byte""'");
14415 }
14416 arg3 = static_cast< byte >(val3);
14417 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14418 if (!SWIG_IsOK(ecode4)) {
14419 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "4"" of type '" "byte""'");
14420 }
14421 arg4 = static_cast< byte >(val4);
14422 {
14423 PyThreadState* __tstate = wxPyBeginAllowThreads();
14424 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
14425 wxPyEndAllowThreads(__tstate);
14426 if (PyErr_Occurred()) SWIG_fail;
14427 }
14428 {
14429 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14430 }
14431 return resultobj;
14432 fail:
14433 return NULL;
14434 }
14435
14436
14437 SWIGINTERN PyObject *_wrap_Image_SetMaskFromImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14438 PyObject *resultobj = 0;
14439 wxImage *arg1 = (wxImage *) 0 ;
14440 wxImage *arg2 = 0 ;
14441 byte arg3 ;
14442 byte arg4 ;
14443 byte arg5 ;
14444 bool result;
14445 void *argp1 = 0 ;
14446 int res1 = 0 ;
14447 void *argp2 = 0 ;
14448 int res2 = 0 ;
14449 unsigned char val3 ;
14450 int ecode3 = 0 ;
14451 unsigned char val4 ;
14452 int ecode4 = 0 ;
14453 unsigned char val5 ;
14454 int ecode5 = 0 ;
14455 PyObject * obj0 = 0 ;
14456 PyObject * obj1 = 0 ;
14457 PyObject * obj2 = 0 ;
14458 PyObject * obj3 = 0 ;
14459 PyObject * obj4 = 0 ;
14460 char * kwnames[] = {
14461 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
14462 };
14463
14464 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
14465 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14466 if (!SWIG_IsOK(res1)) {
14467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskFromImage" "', expected argument " "1"" of type '" "wxImage *""'");
14468 }
14469 arg1 = reinterpret_cast< wxImage * >(argp1);
14470 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
14471 if (!SWIG_IsOK(res2)) {
14472 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14473 }
14474 if (!argp2) {
14475 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14476 }
14477 arg2 = reinterpret_cast< wxImage * >(argp2);
14478 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14479 if (!SWIG_IsOK(ecode3)) {
14480 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskFromImage" "', expected argument " "3"" of type '" "byte""'");
14481 }
14482 arg3 = static_cast< byte >(val3);
14483 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14484 if (!SWIG_IsOK(ecode4)) {
14485 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskFromImage" "', expected argument " "4"" of type '" "byte""'");
14486 }
14487 arg4 = static_cast< byte >(val4);
14488 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
14489 if (!SWIG_IsOK(ecode5)) {
14490 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetMaskFromImage" "', expected argument " "5"" of type '" "byte""'");
14491 }
14492 arg5 = static_cast< byte >(val5);
14493 {
14494 PyThreadState* __tstate = wxPyBeginAllowThreads();
14495 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
14496 wxPyEndAllowThreads(__tstate);
14497 if (PyErr_Occurred()) SWIG_fail;
14498 }
14499 {
14500 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14501 }
14502 return resultobj;
14503 fail:
14504 return NULL;
14505 }
14506
14507
14508 SWIGINTERN PyObject *_wrap_Image_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14509 PyObject *resultobj = 0;
14510 wxString *arg1 = 0 ;
14511 bool result;
14512 bool temp1 = false ;
14513 PyObject * obj0 = 0 ;
14514 char * kwnames[] = {
14515 (char *) "filename", NULL
14516 };
14517
14518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) SWIG_fail;
14519 {
14520 arg1 = wxString_in_helper(obj0);
14521 if (arg1 == NULL) SWIG_fail;
14522 temp1 = true;
14523 }
14524 {
14525 PyThreadState* __tstate = wxPyBeginAllowThreads();
14526 result = (bool)wxImage::CanRead((wxString const &)*arg1);
14527 wxPyEndAllowThreads(__tstate);
14528 if (PyErr_Occurred()) SWIG_fail;
14529 }
14530 {
14531 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14532 }
14533 {
14534 if (temp1)
14535 delete arg1;
14536 }
14537 return resultobj;
14538 fail:
14539 {
14540 if (temp1)
14541 delete arg1;
14542 }
14543 return NULL;
14544 }
14545
14546
14547 SWIGINTERN PyObject *_wrap_Image_GetImageCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14548 PyObject *resultobj = 0;
14549 wxString *arg1 = 0 ;
14550 long arg2 = (long) wxBITMAP_TYPE_ANY ;
14551 int result;
14552 bool temp1 = false ;
14553 long val2 ;
14554 int ecode2 = 0 ;
14555 PyObject * obj0 = 0 ;
14556 PyObject * obj1 = 0 ;
14557 char * kwnames[] = {
14558 (char *) "filename",(char *) "type", NULL
14559 };
14560
14561 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) SWIG_fail;
14562 {
14563 arg1 = wxString_in_helper(obj0);
14564 if (arg1 == NULL) SWIG_fail;
14565 temp1 = true;
14566 }
14567 if (obj1) {
14568 ecode2 = SWIG_AsVal_long(obj1, &val2);
14569 if (!SWIG_IsOK(ecode2)) {
14570 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetImageCount" "', expected argument " "2"" of type '" "long""'");
14571 }
14572 arg2 = static_cast< long >(val2);
14573 }
14574 {
14575 PyThreadState* __tstate = wxPyBeginAllowThreads();
14576 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
14577 wxPyEndAllowThreads(__tstate);
14578 if (PyErr_Occurred()) SWIG_fail;
14579 }
14580 resultobj = SWIG_From_int(static_cast< int >(result));
14581 {
14582 if (temp1)
14583 delete arg1;
14584 }
14585 return resultobj;
14586 fail:
14587 {
14588 if (temp1)
14589 delete arg1;
14590 }
14591 return NULL;
14592 }
14593
14594
14595 SWIGINTERN PyObject *_wrap_Image_LoadFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14596 PyObject *resultobj = 0;
14597 wxImage *arg1 = (wxImage *) 0 ;
14598 wxString *arg2 = 0 ;
14599 long arg3 = (long) wxBITMAP_TYPE_ANY ;
14600 int arg4 = (int) -1 ;
14601 bool result;
14602 void *argp1 = 0 ;
14603 int res1 = 0 ;
14604 bool temp2 = false ;
14605 long val3 ;
14606 int ecode3 = 0 ;
14607 int val4 ;
14608 int ecode4 = 0 ;
14609 PyObject * obj0 = 0 ;
14610 PyObject * obj1 = 0 ;
14611 PyObject * obj2 = 0 ;
14612 PyObject * obj3 = 0 ;
14613 char * kwnames[] = {
14614 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
14615 };
14616
14617 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14618 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14619 if (!SWIG_IsOK(res1)) {
14620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadFile" "', expected argument " "1"" of type '" "wxImage *""'");
14621 }
14622 arg1 = reinterpret_cast< wxImage * >(argp1);
14623 {
14624 arg2 = wxString_in_helper(obj1);
14625 if (arg2 == NULL) SWIG_fail;
14626 temp2 = true;
14627 }
14628 if (obj2) {
14629 ecode3 = SWIG_AsVal_long(obj2, &val3);
14630 if (!SWIG_IsOK(ecode3)) {
14631 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadFile" "', expected argument " "3"" of type '" "long""'");
14632 }
14633 arg3 = static_cast< long >(val3);
14634 }
14635 if (obj3) {
14636 ecode4 = SWIG_AsVal_int(obj3, &val4);
14637 if (!SWIG_IsOK(ecode4)) {
14638 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadFile" "', expected argument " "4"" of type '" "int""'");
14639 }
14640 arg4 = static_cast< int >(val4);
14641 }
14642 {
14643 PyThreadState* __tstate = wxPyBeginAllowThreads();
14644 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
14645 wxPyEndAllowThreads(__tstate);
14646 if (PyErr_Occurred()) SWIG_fail;
14647 }
14648 {
14649 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14650 }
14651 {
14652 if (temp2)
14653 delete arg2;
14654 }
14655 return resultobj;
14656 fail:
14657 {
14658 if (temp2)
14659 delete arg2;
14660 }
14661 return NULL;
14662 }
14663
14664
14665 SWIGINTERN PyObject *_wrap_Image_LoadMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14666 PyObject *resultobj = 0;
14667 wxImage *arg1 = (wxImage *) 0 ;
14668 wxString *arg2 = 0 ;
14669 wxString *arg3 = 0 ;
14670 int arg4 = (int) -1 ;
14671 bool result;
14672 void *argp1 = 0 ;
14673 int res1 = 0 ;
14674 bool temp2 = false ;
14675 bool temp3 = false ;
14676 int val4 ;
14677 int ecode4 = 0 ;
14678 PyObject * obj0 = 0 ;
14679 PyObject * obj1 = 0 ;
14680 PyObject * obj2 = 0 ;
14681 PyObject * obj3 = 0 ;
14682 char * kwnames[] = {
14683 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
14684 };
14685
14686 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14687 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14688 if (!SWIG_IsOK(res1)) {
14689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14690 }
14691 arg1 = reinterpret_cast< wxImage * >(argp1);
14692 {
14693 arg2 = wxString_in_helper(obj1);
14694 if (arg2 == NULL) SWIG_fail;
14695 temp2 = true;
14696 }
14697 {
14698 arg3 = wxString_in_helper(obj2);
14699 if (arg3 == NULL) SWIG_fail;
14700 temp3 = true;
14701 }
14702 if (obj3) {
14703 ecode4 = SWIG_AsVal_int(obj3, &val4);
14704 if (!SWIG_IsOK(ecode4)) {
14705 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeFile" "', expected argument " "4"" of type '" "int""'");
14706 }
14707 arg4 = static_cast< int >(val4);
14708 }
14709 {
14710 PyThreadState* __tstate = wxPyBeginAllowThreads();
14711 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
14712 wxPyEndAllowThreads(__tstate);
14713 if (PyErr_Occurred()) SWIG_fail;
14714 }
14715 {
14716 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14717 }
14718 {
14719 if (temp2)
14720 delete arg2;
14721 }
14722 {
14723 if (temp3)
14724 delete arg3;
14725 }
14726 return resultobj;
14727 fail:
14728 {
14729 if (temp2)
14730 delete arg2;
14731 }
14732 {
14733 if (temp3)
14734 delete arg3;
14735 }
14736 return NULL;
14737 }
14738
14739
14740 SWIGINTERN PyObject *_wrap_Image_SaveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14741 PyObject *resultobj = 0;
14742 wxImage *arg1 = (wxImage *) 0 ;
14743 wxString *arg2 = 0 ;
14744 int arg3 ;
14745 bool result;
14746 void *argp1 = 0 ;
14747 int res1 = 0 ;
14748 bool temp2 = false ;
14749 int val3 ;
14750 int ecode3 = 0 ;
14751 PyObject * obj0 = 0 ;
14752 PyObject * obj1 = 0 ;
14753 PyObject * obj2 = 0 ;
14754 char * kwnames[] = {
14755 (char *) "self",(char *) "name",(char *) "type", NULL
14756 };
14757
14758 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14759 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14760 if (!SWIG_IsOK(res1)) {
14761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveFile" "', expected argument " "1"" of type '" "wxImage *""'");
14762 }
14763 arg1 = reinterpret_cast< wxImage * >(argp1);
14764 {
14765 arg2 = wxString_in_helper(obj1);
14766 if (arg2 == NULL) SWIG_fail;
14767 temp2 = true;
14768 }
14769 ecode3 = SWIG_AsVal_int(obj2, &val3);
14770 if (!SWIG_IsOK(ecode3)) {
14771 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SaveFile" "', expected argument " "3"" of type '" "int""'");
14772 }
14773 arg3 = static_cast< int >(val3);
14774 {
14775 PyThreadState* __tstate = wxPyBeginAllowThreads();
14776 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
14777 wxPyEndAllowThreads(__tstate);
14778 if (PyErr_Occurred()) SWIG_fail;
14779 }
14780 {
14781 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14782 }
14783 {
14784 if (temp2)
14785 delete arg2;
14786 }
14787 return resultobj;
14788 fail:
14789 {
14790 if (temp2)
14791 delete arg2;
14792 }
14793 return NULL;
14794 }
14795
14796
14797 SWIGINTERN PyObject *_wrap_Image_SaveMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14798 PyObject *resultobj = 0;
14799 wxImage *arg1 = (wxImage *) 0 ;
14800 wxString *arg2 = 0 ;
14801 wxString *arg3 = 0 ;
14802 bool result;
14803 void *argp1 = 0 ;
14804 int res1 = 0 ;
14805 bool temp2 = false ;
14806 bool temp3 = false ;
14807 PyObject * obj0 = 0 ;
14808 PyObject * obj1 = 0 ;
14809 PyObject * obj2 = 0 ;
14810 char * kwnames[] = {
14811 (char *) "self",(char *) "name",(char *) "mimetype", NULL
14812 };
14813
14814 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14815 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14816 if (!SWIG_IsOK(res1)) {
14817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14818 }
14819 arg1 = reinterpret_cast< wxImage * >(argp1);
14820 {
14821 arg2 = wxString_in_helper(obj1);
14822 if (arg2 == NULL) SWIG_fail;
14823 temp2 = true;
14824 }
14825 {
14826 arg3 = wxString_in_helper(obj2);
14827 if (arg3 == NULL) SWIG_fail;
14828 temp3 = true;
14829 }
14830 {
14831 PyThreadState* __tstate = wxPyBeginAllowThreads();
14832 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
14833 wxPyEndAllowThreads(__tstate);
14834 if (PyErr_Occurred()) SWIG_fail;
14835 }
14836 {
14837 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14838 }
14839 {
14840 if (temp2)
14841 delete arg2;
14842 }
14843 {
14844 if (temp3)
14845 delete arg3;
14846 }
14847 return resultobj;
14848 fail:
14849 {
14850 if (temp2)
14851 delete arg2;
14852 }
14853 {
14854 if (temp3)
14855 delete arg3;
14856 }
14857 return NULL;
14858 }
14859
14860
14861 SWIGINTERN PyObject *_wrap_Image_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14862 PyObject *resultobj = 0;
14863 wxInputStream *arg1 = 0 ;
14864 bool result;
14865 wxPyInputStream *temp1 ;
14866 bool created1 ;
14867 PyObject * obj0 = 0 ;
14868 char * kwnames[] = {
14869 (char *) "stream", NULL
14870 };
14871
14872 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) SWIG_fail;
14873 {
14874 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
14875 arg1 = temp1->m_wxis;
14876 created1 = false;
14877 } else {
14878 PyErr_Clear(); // clear the failure of the wxPyConvert above
14879 arg1 = wxPyCBInputStream_create(obj0, false);
14880 if (arg1 == NULL) {
14881 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14882 SWIG_fail;
14883 }
14884 created1 = true;
14885 }
14886 }
14887 {
14888 PyThreadState* __tstate = wxPyBeginAllowThreads();
14889 result = (bool)wxImage::CanRead(*arg1);
14890 wxPyEndAllowThreads(__tstate);
14891 if (PyErr_Occurred()) SWIG_fail;
14892 }
14893 {
14894 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14895 }
14896 {
14897 if (created1) delete arg1;
14898 }
14899 return resultobj;
14900 fail:
14901 {
14902 if (created1) delete arg1;
14903 }
14904 return NULL;
14905 }
14906
14907
14908 SWIGINTERN PyObject *_wrap_Image_LoadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14909 PyObject *resultobj = 0;
14910 wxImage *arg1 = (wxImage *) 0 ;
14911 wxInputStream *arg2 = 0 ;
14912 long arg3 = (long) wxBITMAP_TYPE_ANY ;
14913 int arg4 = (int) -1 ;
14914 bool result;
14915 void *argp1 = 0 ;
14916 int res1 = 0 ;
14917 wxPyInputStream *temp2 ;
14918 bool created2 ;
14919 long val3 ;
14920 int ecode3 = 0 ;
14921 int val4 ;
14922 int ecode4 = 0 ;
14923 PyObject * obj0 = 0 ;
14924 PyObject * obj1 = 0 ;
14925 PyObject * obj2 = 0 ;
14926 PyObject * obj3 = 0 ;
14927 char * kwnames[] = {
14928 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
14929 };
14930
14931 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14932 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14933 if (!SWIG_IsOK(res1)) {
14934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadStream" "', expected argument " "1"" of type '" "wxImage *""'");
14935 }
14936 arg1 = reinterpret_cast< wxImage * >(argp1);
14937 {
14938 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
14939 arg2 = temp2->m_wxis;
14940 created2 = false;
14941 } else {
14942 PyErr_Clear(); // clear the failure of the wxPyConvert above
14943 arg2 = wxPyCBInputStream_create(obj1, false);
14944 if (arg2 == NULL) {
14945 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14946 SWIG_fail;
14947 }
14948 created2 = true;
14949 }
14950 }
14951 if (obj2) {
14952 ecode3 = SWIG_AsVal_long(obj2, &val3);
14953 if (!SWIG_IsOK(ecode3)) {
14954 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadStream" "', expected argument " "3"" of type '" "long""'");
14955 }
14956 arg3 = static_cast< long >(val3);
14957 }
14958 if (obj3) {
14959 ecode4 = SWIG_AsVal_int(obj3, &val4);
14960 if (!SWIG_IsOK(ecode4)) {
14961 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadStream" "', expected argument " "4"" of type '" "int""'");
14962 }
14963 arg4 = static_cast< int >(val4);
14964 }
14965 {
14966 PyThreadState* __tstate = wxPyBeginAllowThreads();
14967 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
14968 wxPyEndAllowThreads(__tstate);
14969 if (PyErr_Occurred()) SWIG_fail;
14970 }
14971 {
14972 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14973 }
14974 {
14975 if (created2) delete arg2;
14976 }
14977 return resultobj;
14978 fail:
14979 {
14980 if (created2) delete arg2;
14981 }
14982 return NULL;
14983 }
14984
14985
14986 SWIGINTERN PyObject *_wrap_Image_LoadMimeStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14987 PyObject *resultobj = 0;
14988 wxImage *arg1 = (wxImage *) 0 ;
14989 wxInputStream *arg2 = 0 ;
14990 wxString *arg3 = 0 ;
14991 int arg4 = (int) -1 ;
14992 bool result;
14993 void *argp1 = 0 ;
14994 int res1 = 0 ;
14995 wxPyInputStream *temp2 ;
14996 bool created2 ;
14997 bool temp3 = false ;
14998 int val4 ;
14999 int ecode4 = 0 ;
15000 PyObject * obj0 = 0 ;
15001 PyObject * obj1 = 0 ;
15002 PyObject * obj2 = 0 ;
15003 PyObject * obj3 = 0 ;
15004 char * kwnames[] = {
15005 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
15006 };
15007
15008 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15009 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15010 if (!SWIG_IsOK(res1)) {
15011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeStream" "', expected argument " "1"" of type '" "wxImage *""'");
15012 }
15013 arg1 = reinterpret_cast< wxImage * >(argp1);
15014 {
15015 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
15016 arg2 = temp2->m_wxis;
15017 created2 = false;
15018 } else {
15019 PyErr_Clear(); // clear the failure of the wxPyConvert above
15020 arg2 = wxPyCBInputStream_create(obj1, false);
15021 if (arg2 == NULL) {
15022 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15023 SWIG_fail;
15024 }
15025 created2 = true;
15026 }
15027 }
15028 {
15029 arg3 = wxString_in_helper(obj2);
15030 if (arg3 == NULL) SWIG_fail;
15031 temp3 = true;
15032 }
15033 if (obj3) {
15034 ecode4 = SWIG_AsVal_int(obj3, &val4);
15035 if (!SWIG_IsOK(ecode4)) {
15036 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeStream" "', expected argument " "4"" of type '" "int""'");
15037 }
15038 arg4 = static_cast< int >(val4);
15039 }
15040 {
15041 PyThreadState* __tstate = wxPyBeginAllowThreads();
15042 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
15043 wxPyEndAllowThreads(__tstate);
15044 if (PyErr_Occurred()) SWIG_fail;
15045 }
15046 {
15047 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15048 }
15049 {
15050 if (created2) delete arg2;
15051 }
15052 {
15053 if (temp3)
15054 delete arg3;
15055 }
15056 return resultobj;
15057 fail:
15058 {
15059 if (created2) delete arg2;
15060 }
15061 {
15062 if (temp3)
15063 delete arg3;
15064 }
15065 return NULL;
15066 }
15067
15068
15069 SWIGINTERN PyObject *_wrap_Image_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15070 PyObject *resultobj = 0;
15071 wxImage *arg1 = (wxImage *) 0 ;
15072 bool result;
15073 void *argp1 = 0 ;
15074 int res1 = 0 ;
15075 PyObject *swig_obj[1] ;
15076
15077 if (!args) SWIG_fail;
15078 swig_obj[0] = args;
15079 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15080 if (!SWIG_IsOK(res1)) {
15081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Ok" "', expected argument " "1"" of type '" "wxImage *""'");
15082 }
15083 arg1 = reinterpret_cast< wxImage * >(argp1);
15084 {
15085 PyThreadState* __tstate = wxPyBeginAllowThreads();
15086 result = (bool)(arg1)->Ok();
15087 wxPyEndAllowThreads(__tstate);
15088 if (PyErr_Occurred()) SWIG_fail;
15089 }
15090 {
15091 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15092 }
15093 return resultobj;
15094 fail:
15095 return NULL;
15096 }
15097
15098
15099 SWIGINTERN PyObject *_wrap_Image_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15100 PyObject *resultobj = 0;
15101 wxImage *arg1 = (wxImage *) 0 ;
15102 int result;
15103 void *argp1 = 0 ;
15104 int res1 = 0 ;
15105 PyObject *swig_obj[1] ;
15106
15107 if (!args) SWIG_fail;
15108 swig_obj[0] = args;
15109 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15110 if (!SWIG_IsOK(res1)) {
15111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetWidth" "', expected argument " "1"" of type '" "wxImage *""'");
15112 }
15113 arg1 = reinterpret_cast< wxImage * >(argp1);
15114 {
15115 PyThreadState* __tstate = wxPyBeginAllowThreads();
15116 result = (int)(arg1)->GetWidth();
15117 wxPyEndAllowThreads(__tstate);
15118 if (PyErr_Occurred()) SWIG_fail;
15119 }
15120 resultobj = SWIG_From_int(static_cast< int >(result));
15121 return resultobj;
15122 fail:
15123 return NULL;
15124 }
15125
15126
15127 SWIGINTERN PyObject *_wrap_Image_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15128 PyObject *resultobj = 0;
15129 wxImage *arg1 = (wxImage *) 0 ;
15130 int result;
15131 void *argp1 = 0 ;
15132 int res1 = 0 ;
15133 PyObject *swig_obj[1] ;
15134
15135 if (!args) SWIG_fail;
15136 swig_obj[0] = args;
15137 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15138 if (!SWIG_IsOK(res1)) {
15139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetHeight" "', expected argument " "1"" of type '" "wxImage *""'");
15140 }
15141 arg1 = reinterpret_cast< wxImage * >(argp1);
15142 {
15143 PyThreadState* __tstate = wxPyBeginAllowThreads();
15144 result = (int)(arg1)->GetHeight();
15145 wxPyEndAllowThreads(__tstate);
15146 if (PyErr_Occurred()) SWIG_fail;
15147 }
15148 resultobj = SWIG_From_int(static_cast< int >(result));
15149 return resultobj;
15150 fail:
15151 return NULL;
15152 }
15153
15154
15155 SWIGINTERN PyObject *_wrap_Image_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15156 PyObject *resultobj = 0;
15157 wxImage *arg1 = (wxImage *) 0 ;
15158 wxSize result;
15159 void *argp1 = 0 ;
15160 int res1 = 0 ;
15161 PyObject *swig_obj[1] ;
15162
15163 if (!args) SWIG_fail;
15164 swig_obj[0] = args;
15165 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15166 if (!SWIG_IsOK(res1)) {
15167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSize" "', expected argument " "1"" of type '" "wxImage *""'");
15168 }
15169 arg1 = reinterpret_cast< wxImage * >(argp1);
15170 {
15171 PyThreadState* __tstate = wxPyBeginAllowThreads();
15172 result = wxImage_GetSize(arg1);
15173 wxPyEndAllowThreads(__tstate);
15174 if (PyErr_Occurred()) SWIG_fail;
15175 }
15176 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
15177 return resultobj;
15178 fail:
15179 return NULL;
15180 }
15181
15182
15183 SWIGINTERN PyObject *_wrap_Image_GetSubImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15184 PyObject *resultobj = 0;
15185 wxImage *arg1 = (wxImage *) 0 ;
15186 wxRect *arg2 = 0 ;
15187 SwigValueWrapper<wxImage > result;
15188 void *argp1 = 0 ;
15189 int res1 = 0 ;
15190 wxRect temp2 ;
15191 PyObject * obj0 = 0 ;
15192 PyObject * obj1 = 0 ;
15193 char * kwnames[] = {
15194 (char *) "self",(char *) "rect", NULL
15195 };
15196
15197 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) SWIG_fail;
15198 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15199 if (!SWIG_IsOK(res1)) {
15200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSubImage" "', expected argument " "1"" of type '" "wxImage *""'");
15201 }
15202 arg1 = reinterpret_cast< wxImage * >(argp1);
15203 {
15204 arg2 = &temp2;
15205 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
15206 }
15207 {
15208 PyThreadState* __tstate = wxPyBeginAllowThreads();
15209 result = (arg1)->GetSubImage((wxRect const &)*arg2);
15210 wxPyEndAllowThreads(__tstate);
15211 if (PyErr_Occurred()) SWIG_fail;
15212 }
15213 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15214 return resultobj;
15215 fail:
15216 return NULL;
15217 }
15218
15219
15220 SWIGINTERN PyObject *_wrap_Image_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15221 PyObject *resultobj = 0;
15222 wxImage *arg1 = (wxImage *) 0 ;
15223 wxSize *arg2 = 0 ;
15224 wxPoint *arg3 = 0 ;
15225 int arg4 = (int) -1 ;
15226 int arg5 = (int) -1 ;
15227 int arg6 = (int) -1 ;
15228 SwigValueWrapper<wxImage > result;
15229 void *argp1 = 0 ;
15230 int res1 = 0 ;
15231 wxSize temp2 ;
15232 wxPoint temp3 ;
15233 int val4 ;
15234 int ecode4 = 0 ;
15235 int val5 ;
15236 int ecode5 = 0 ;
15237 int val6 ;
15238 int ecode6 = 0 ;
15239 PyObject * obj0 = 0 ;
15240 PyObject * obj1 = 0 ;
15241 PyObject * obj2 = 0 ;
15242 PyObject * obj3 = 0 ;
15243 PyObject * obj4 = 0 ;
15244 PyObject * obj5 = 0 ;
15245 char * kwnames[] = {
15246 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
15247 };
15248
15249 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
15250 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15251 if (!SWIG_IsOK(res1)) {
15252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Size" "', expected argument " "1"" of type '" "wxImage const *""'");
15253 }
15254 arg1 = reinterpret_cast< wxImage * >(argp1);
15255 {
15256 arg2 = &temp2;
15257 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
15258 }
15259 {
15260 arg3 = &temp3;
15261 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
15262 }
15263 if (obj3) {
15264 ecode4 = SWIG_AsVal_int(obj3, &val4);
15265 if (!SWIG_IsOK(ecode4)) {
15266 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Size" "', expected argument " "4"" of type '" "int""'");
15267 }
15268 arg4 = static_cast< int >(val4);
15269 }
15270 if (obj4) {
15271 ecode5 = SWIG_AsVal_int(obj4, &val5);
15272 if (!SWIG_IsOK(ecode5)) {
15273 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Size" "', expected argument " "5"" of type '" "int""'");
15274 }
15275 arg5 = static_cast< int >(val5);
15276 }
15277 if (obj5) {
15278 ecode6 = SWIG_AsVal_int(obj5, &val6);
15279 if (!SWIG_IsOK(ecode6)) {
15280 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Size" "', expected argument " "6"" of type '" "int""'");
15281 }
15282 arg6 = static_cast< int >(val6);
15283 }
15284 {
15285 PyThreadState* __tstate = wxPyBeginAllowThreads();
15286 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
15287 wxPyEndAllowThreads(__tstate);
15288 if (PyErr_Occurred()) SWIG_fail;
15289 }
15290 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15291 return resultobj;
15292 fail:
15293 return NULL;
15294 }
15295
15296
15297 SWIGINTERN PyObject *_wrap_Image_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15298 PyObject *resultobj = 0;
15299 wxImage *arg1 = (wxImage *) 0 ;
15300 SwigValueWrapper<wxImage > result;
15301 void *argp1 = 0 ;
15302 int res1 = 0 ;
15303 PyObject *swig_obj[1] ;
15304
15305 if (!args) SWIG_fail;
15306 swig_obj[0] = args;
15307 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15308 if (!SWIG_IsOK(res1)) {
15309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Copy" "', expected argument " "1"" of type '" "wxImage *""'");
15310 }
15311 arg1 = reinterpret_cast< wxImage * >(argp1);
15312 {
15313 PyThreadState* __tstate = wxPyBeginAllowThreads();
15314 result = (arg1)->Copy();
15315 wxPyEndAllowThreads(__tstate);
15316 if (PyErr_Occurred()) SWIG_fail;
15317 }
15318 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15319 return resultobj;
15320 fail:
15321 return NULL;
15322 }
15323
15324
15325 SWIGINTERN PyObject *_wrap_Image_Paste(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15326 PyObject *resultobj = 0;
15327 wxImage *arg1 = (wxImage *) 0 ;
15328 wxImage *arg2 = 0 ;
15329 int arg3 ;
15330 int arg4 ;
15331 void *argp1 = 0 ;
15332 int res1 = 0 ;
15333 void *argp2 = 0 ;
15334 int res2 = 0 ;
15335 int val3 ;
15336 int ecode3 = 0 ;
15337 int val4 ;
15338 int ecode4 = 0 ;
15339 PyObject * obj0 = 0 ;
15340 PyObject * obj1 = 0 ;
15341 PyObject * obj2 = 0 ;
15342 PyObject * obj3 = 0 ;
15343 char * kwnames[] = {
15344 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
15345 };
15346
15347 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15348 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15349 if (!SWIG_IsOK(res1)) {
15350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Paste" "', expected argument " "1"" of type '" "wxImage *""'");
15351 }
15352 arg1 = reinterpret_cast< wxImage * >(argp1);
15353 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
15354 if (!SWIG_IsOK(res2)) {
15355 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15356 }
15357 if (!argp2) {
15358 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15359 }
15360 arg2 = reinterpret_cast< wxImage * >(argp2);
15361 ecode3 = SWIG_AsVal_int(obj2, &val3);
15362 if (!SWIG_IsOK(ecode3)) {
15363 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Paste" "', expected argument " "3"" of type '" "int""'");
15364 }
15365 arg3 = static_cast< int >(val3);
15366 ecode4 = SWIG_AsVal_int(obj3, &val4);
15367 if (!SWIG_IsOK(ecode4)) {
15368 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Paste" "', expected argument " "4"" of type '" "int""'");
15369 }
15370 arg4 = static_cast< int >(val4);
15371 {
15372 PyThreadState* __tstate = wxPyBeginAllowThreads();
15373 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
15374 wxPyEndAllowThreads(__tstate);
15375 if (PyErr_Occurred()) SWIG_fail;
15376 }
15377 resultobj = SWIG_Py_Void();
15378 return resultobj;
15379 fail:
15380 return NULL;
15381 }
15382
15383
15384 SWIGINTERN PyObject *_wrap_Image_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15385 PyObject *resultobj = 0;
15386 wxImage *arg1 = (wxImage *) 0 ;
15387 PyObject *result = 0 ;
15388 void *argp1 = 0 ;
15389 int res1 = 0 ;
15390 PyObject *swig_obj[1] ;
15391
15392 if (!args) SWIG_fail;
15393 swig_obj[0] = args;
15394 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15395 if (!SWIG_IsOK(res1)) {
15396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetData" "', expected argument " "1"" of type '" "wxImage *""'");
15397 }
15398 arg1 = reinterpret_cast< wxImage * >(argp1);
15399 {
15400 PyThreadState* __tstate = wxPyBeginAllowThreads();
15401 result = (PyObject *)wxImage_GetData(arg1);
15402 wxPyEndAllowThreads(__tstate);
15403 if (PyErr_Occurred()) SWIG_fail;
15404 }
15405 resultobj = result;
15406 return resultobj;
15407 fail:
15408 return NULL;
15409 }
15410
15411
15412 SWIGINTERN PyObject *_wrap_Image_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15413 PyObject *resultobj = 0;
15414 wxImage *arg1 = (wxImage *) 0 ;
15415 buffer arg2 ;
15416 int arg3 ;
15417 void *argp1 = 0 ;
15418 int res1 = 0 ;
15419 PyObject * obj0 = 0 ;
15420 PyObject * obj1 = 0 ;
15421 char * kwnames[] = {
15422 (char *) "self",(char *) "data", NULL
15423 };
15424
15425 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
15426 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15427 if (!SWIG_IsOK(res1)) {
15428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetData" "', expected argument " "1"" of type '" "wxImage *""'");
15429 }
15430 arg1 = reinterpret_cast< wxImage * >(argp1);
15431 {
15432 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15433 }
15434 {
15435 PyThreadState* __tstate = wxPyBeginAllowThreads();
15436 wxImage_SetData(arg1,arg2,arg3);
15437 wxPyEndAllowThreads(__tstate);
15438 if (PyErr_Occurred()) SWIG_fail;
15439 }
15440 resultobj = SWIG_Py_Void();
15441 return resultobj;
15442 fail:
15443 return NULL;
15444 }
15445
15446
15447 SWIGINTERN PyObject *_wrap_Image_GetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15448 PyObject *resultobj = 0;
15449 wxImage *arg1 = (wxImage *) 0 ;
15450 PyObject *result = 0 ;
15451 void *argp1 = 0 ;
15452 int res1 = 0 ;
15453 PyObject *swig_obj[1] ;
15454
15455 if (!args) SWIG_fail;
15456 swig_obj[0] = args;
15457 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15458 if (!SWIG_IsOK(res1)) {
15459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15460 }
15461 arg1 = reinterpret_cast< wxImage * >(argp1);
15462 {
15463 PyThreadState* __tstate = wxPyBeginAllowThreads();
15464 result = (PyObject *)wxImage_GetDataBuffer(arg1);
15465 wxPyEndAllowThreads(__tstate);
15466 if (PyErr_Occurred()) SWIG_fail;
15467 }
15468 resultobj = result;
15469 return resultobj;
15470 fail:
15471 return NULL;
15472 }
15473
15474
15475 SWIGINTERN PyObject *_wrap_Image_SetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15476 PyObject *resultobj = 0;
15477 wxImage *arg1 = (wxImage *) 0 ;
15478 buffer arg2 ;
15479 int arg3 ;
15480 void *argp1 = 0 ;
15481 int res1 = 0 ;
15482 PyObject * obj0 = 0 ;
15483 PyObject * obj1 = 0 ;
15484 char * kwnames[] = {
15485 (char *) "self",(char *) "data", NULL
15486 };
15487
15488 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
15489 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15490 if (!SWIG_IsOK(res1)) {
15491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15492 }
15493 arg1 = reinterpret_cast< wxImage * >(argp1);
15494 {
15495 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15496 }
15497 {
15498 PyThreadState* __tstate = wxPyBeginAllowThreads();
15499 wxImage_SetDataBuffer(arg1,arg2,arg3);
15500 wxPyEndAllowThreads(__tstate);
15501 if (PyErr_Occurred()) SWIG_fail;
15502 }
15503 resultobj = SWIG_Py_Void();
15504 return resultobj;
15505 fail:
15506 return NULL;
15507 }
15508
15509
15510 SWIGINTERN PyObject *_wrap_Image_GetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15511 PyObject *resultobj = 0;
15512 wxImage *arg1 = (wxImage *) 0 ;
15513 PyObject *result = 0 ;
15514 void *argp1 = 0 ;
15515 int res1 = 0 ;
15516 PyObject *swig_obj[1] ;
15517
15518 if (!args) SWIG_fail;
15519 swig_obj[0] = args;
15520 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15521 if (!SWIG_IsOK(res1)) {
15522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15523 }
15524 arg1 = reinterpret_cast< wxImage * >(argp1);
15525 {
15526 PyThreadState* __tstate = wxPyBeginAllowThreads();
15527 result = (PyObject *)wxImage_GetAlphaData(arg1);
15528 wxPyEndAllowThreads(__tstate);
15529 if (PyErr_Occurred()) SWIG_fail;
15530 }
15531 resultobj = result;
15532 return resultobj;
15533 fail:
15534 return NULL;
15535 }
15536
15537
15538 SWIGINTERN PyObject *_wrap_Image_SetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15539 PyObject *resultobj = 0;
15540 wxImage *arg1 = (wxImage *) 0 ;
15541 buffer arg2 ;
15542 int arg3 ;
15543 void *argp1 = 0 ;
15544 int res1 = 0 ;
15545 PyObject * obj0 = 0 ;
15546 PyObject * obj1 = 0 ;
15547 char * kwnames[] = {
15548 (char *) "self",(char *) "alpha", NULL
15549 };
15550
15551 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) SWIG_fail;
15552 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15553 if (!SWIG_IsOK(res1)) {
15554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15555 }
15556 arg1 = reinterpret_cast< wxImage * >(argp1);
15557 {
15558 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15559 }
15560 {
15561 PyThreadState* __tstate = wxPyBeginAllowThreads();
15562 wxImage_SetAlphaData(arg1,arg2,arg3);
15563 wxPyEndAllowThreads(__tstate);
15564 if (PyErr_Occurred()) SWIG_fail;
15565 }
15566 resultobj = SWIG_Py_Void();
15567 return resultobj;
15568 fail:
15569 return NULL;
15570 }
15571
15572
15573 SWIGINTERN PyObject *_wrap_Image_GetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15574 PyObject *resultobj = 0;
15575 wxImage *arg1 = (wxImage *) 0 ;
15576 PyObject *result = 0 ;
15577 void *argp1 = 0 ;
15578 int res1 = 0 ;
15579 PyObject *swig_obj[1] ;
15580
15581 if (!args) SWIG_fail;
15582 swig_obj[0] = args;
15583 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15584 if (!SWIG_IsOK(res1)) {
15585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15586 }
15587 arg1 = reinterpret_cast< wxImage * >(argp1);
15588 {
15589 PyThreadState* __tstate = wxPyBeginAllowThreads();
15590 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
15591 wxPyEndAllowThreads(__tstate);
15592 if (PyErr_Occurred()) SWIG_fail;
15593 }
15594 resultobj = result;
15595 return resultobj;
15596 fail:
15597 return NULL;
15598 }
15599
15600
15601 SWIGINTERN PyObject *_wrap_Image_SetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15602 PyObject *resultobj = 0;
15603 wxImage *arg1 = (wxImage *) 0 ;
15604 buffer arg2 ;
15605 int arg3 ;
15606 void *argp1 = 0 ;
15607 int res1 = 0 ;
15608 PyObject * obj0 = 0 ;
15609 PyObject * obj1 = 0 ;
15610 char * kwnames[] = {
15611 (char *) "self",(char *) "alpha", NULL
15612 };
15613
15614 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
15615 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15616 if (!SWIG_IsOK(res1)) {
15617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15618 }
15619 arg1 = reinterpret_cast< wxImage * >(argp1);
15620 {
15621 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15622 }
15623 {
15624 PyThreadState* __tstate = wxPyBeginAllowThreads();
15625 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
15626 wxPyEndAllowThreads(__tstate);
15627 if (PyErr_Occurred()) SWIG_fail;
15628 }
15629 resultobj = SWIG_Py_Void();
15630 return resultobj;
15631 fail:
15632 return NULL;
15633 }
15634
15635
15636 SWIGINTERN PyObject *_wrap_Image_SetMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15637 PyObject *resultobj = 0;
15638 wxImage *arg1 = (wxImage *) 0 ;
15639 byte arg2 ;
15640 byte arg3 ;
15641 byte arg4 ;
15642 void *argp1 = 0 ;
15643 int res1 = 0 ;
15644 unsigned char val2 ;
15645 int ecode2 = 0 ;
15646 unsigned char val3 ;
15647 int ecode3 = 0 ;
15648 unsigned char val4 ;
15649 int ecode4 = 0 ;
15650 PyObject * obj0 = 0 ;
15651 PyObject * obj1 = 0 ;
15652 PyObject * obj2 = 0 ;
15653 PyObject * obj3 = 0 ;
15654 char * kwnames[] = {
15655 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
15656 };
15657
15658 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15659 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15660 if (!SWIG_IsOK(res1)) {
15661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskColour" "', expected argument " "1"" of type '" "wxImage *""'");
15662 }
15663 arg1 = reinterpret_cast< wxImage * >(argp1);
15664 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15665 if (!SWIG_IsOK(ecode2)) {
15666 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMaskColour" "', expected argument " "2"" of type '" "byte""'");
15667 }
15668 arg2 = static_cast< byte >(val2);
15669 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15670 if (!SWIG_IsOK(ecode3)) {
15671 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskColour" "', expected argument " "3"" of type '" "byte""'");
15672 }
15673 arg3 = static_cast< byte >(val3);
15674 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
15675 if (!SWIG_IsOK(ecode4)) {
15676 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskColour" "', expected argument " "4"" of type '" "byte""'");
15677 }
15678 arg4 = static_cast< byte >(val4);
15679 {
15680 PyThreadState* __tstate = wxPyBeginAllowThreads();
15681 (arg1)->SetMaskColour(arg2,arg3,arg4);
15682 wxPyEndAllowThreads(__tstate);
15683 if (PyErr_Occurred()) SWIG_fail;
15684 }
15685 resultobj = SWIG_Py_Void();
15686 return resultobj;
15687 fail:
15688 return NULL;
15689 }
15690
15691
15692 SWIGINTERN PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15693 PyObject *resultobj = 0;
15694 wxImage *arg1 = (wxImage *) 0 ;
15695 byte *arg2 = (byte *) 0 ;
15696 byte *arg3 = (byte *) 0 ;
15697 byte *arg4 = (byte *) 0 ;
15698 void *argp1 = 0 ;
15699 int res1 = 0 ;
15700 byte temp2 ;
15701 int res2 = SWIG_TMPOBJ ;
15702 byte temp3 ;
15703 int res3 = SWIG_TMPOBJ ;
15704 byte temp4 ;
15705 int res4 = SWIG_TMPOBJ ;
15706 PyObject *swig_obj[1] ;
15707
15708 arg2 = &temp2;
15709 arg3 = &temp3;
15710 arg4 = &temp4;
15711 if (!args) SWIG_fail;
15712 swig_obj[0] = args;
15713 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15714 if (!SWIG_IsOK(res1)) {
15715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOrFindMaskColour" "', expected argument " "1"" of type '" "wxImage const *""'");
15716 }
15717 arg1 = reinterpret_cast< wxImage * >(argp1);
15718 {
15719 PyThreadState* __tstate = wxPyBeginAllowThreads();
15720 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
15721 wxPyEndAllowThreads(__tstate);
15722 if (PyErr_Occurred()) SWIG_fail;
15723 }
15724 resultobj = SWIG_Py_Void();
15725 if (SWIG_IsTmpObj(res2)) {
15726 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
15727 } else {
15728 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15729 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
15730 }
15731 if (SWIG_IsTmpObj(res3)) {
15732 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
15733 } else {
15734 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15735 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
15736 }
15737 if (SWIG_IsTmpObj(res4)) {
15738 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
15739 } else {
15740 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15741 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
15742 }
15743 return resultobj;
15744 fail:
15745 return NULL;
15746 }
15747
15748
15749 SWIGINTERN PyObject *_wrap_Image_GetMaskRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15750 PyObject *resultobj = 0;
15751 wxImage *arg1 = (wxImage *) 0 ;
15752 byte result;
15753 void *argp1 = 0 ;
15754 int res1 = 0 ;
15755 PyObject *swig_obj[1] ;
15756
15757 if (!args) SWIG_fail;
15758 swig_obj[0] = args;
15759 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15760 if (!SWIG_IsOK(res1)) {
15761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskRed" "', expected argument " "1"" of type '" "wxImage *""'");
15762 }
15763 arg1 = reinterpret_cast< wxImage * >(argp1);
15764 {
15765 PyThreadState* __tstate = wxPyBeginAllowThreads();
15766 result = (byte)(arg1)->GetMaskRed();
15767 wxPyEndAllowThreads(__tstate);
15768 if (PyErr_Occurred()) SWIG_fail;
15769 }
15770 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15771 return resultobj;
15772 fail:
15773 return NULL;
15774 }
15775
15776
15777 SWIGINTERN PyObject *_wrap_Image_GetMaskGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15778 PyObject *resultobj = 0;
15779 wxImage *arg1 = (wxImage *) 0 ;
15780 byte result;
15781 void *argp1 = 0 ;
15782 int res1 = 0 ;
15783 PyObject *swig_obj[1] ;
15784
15785 if (!args) SWIG_fail;
15786 swig_obj[0] = args;
15787 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15788 if (!SWIG_IsOK(res1)) {
15789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskGreen" "', expected argument " "1"" of type '" "wxImage *""'");
15790 }
15791 arg1 = reinterpret_cast< wxImage * >(argp1);
15792 {
15793 PyThreadState* __tstate = wxPyBeginAllowThreads();
15794 result = (byte)(arg1)->GetMaskGreen();
15795 wxPyEndAllowThreads(__tstate);
15796 if (PyErr_Occurred()) SWIG_fail;
15797 }
15798 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15799 return resultobj;
15800 fail:
15801 return NULL;
15802 }
15803
15804
15805 SWIGINTERN PyObject *_wrap_Image_GetMaskBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15806 PyObject *resultobj = 0;
15807 wxImage *arg1 = (wxImage *) 0 ;
15808 byte result;
15809 void *argp1 = 0 ;
15810 int res1 = 0 ;
15811 PyObject *swig_obj[1] ;
15812
15813 if (!args) SWIG_fail;
15814 swig_obj[0] = args;
15815 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15816 if (!SWIG_IsOK(res1)) {
15817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskBlue" "', expected argument " "1"" of type '" "wxImage *""'");
15818 }
15819 arg1 = reinterpret_cast< wxImage * >(argp1);
15820 {
15821 PyThreadState* __tstate = wxPyBeginAllowThreads();
15822 result = (byte)(arg1)->GetMaskBlue();
15823 wxPyEndAllowThreads(__tstate);
15824 if (PyErr_Occurred()) SWIG_fail;
15825 }
15826 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15827 return resultobj;
15828 fail:
15829 return NULL;
15830 }
15831
15832
15833 SWIGINTERN PyObject *_wrap_Image_SetMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15834 PyObject *resultobj = 0;
15835 wxImage *arg1 = (wxImage *) 0 ;
15836 bool arg2 = (bool) true ;
15837 void *argp1 = 0 ;
15838 int res1 = 0 ;
15839 bool val2 ;
15840 int ecode2 = 0 ;
15841 PyObject * obj0 = 0 ;
15842 PyObject * obj1 = 0 ;
15843 char * kwnames[] = {
15844 (char *) "self",(char *) "mask", NULL
15845 };
15846
15847 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) SWIG_fail;
15848 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15849 if (!SWIG_IsOK(res1)) {
15850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMask" "', expected argument " "1"" of type '" "wxImage *""'");
15851 }
15852 arg1 = reinterpret_cast< wxImage * >(argp1);
15853 if (obj1) {
15854 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15855 if (!SWIG_IsOK(ecode2)) {
15856 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMask" "', expected argument " "2"" of type '" "bool""'");
15857 }
15858 arg2 = static_cast< bool >(val2);
15859 }
15860 {
15861 PyThreadState* __tstate = wxPyBeginAllowThreads();
15862 (arg1)->SetMask(arg2);
15863 wxPyEndAllowThreads(__tstate);
15864 if (PyErr_Occurred()) SWIG_fail;
15865 }
15866 resultobj = SWIG_Py_Void();
15867 return resultobj;
15868 fail:
15869 return NULL;
15870 }
15871
15872
15873 SWIGINTERN PyObject *_wrap_Image_HasMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15874 PyObject *resultobj = 0;
15875 wxImage *arg1 = (wxImage *) 0 ;
15876 bool result;
15877 void *argp1 = 0 ;
15878 int res1 = 0 ;
15879 PyObject *swig_obj[1] ;
15880
15881 if (!args) SWIG_fail;
15882 swig_obj[0] = args;
15883 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15884 if (!SWIG_IsOK(res1)) {
15885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasMask" "', expected argument " "1"" of type '" "wxImage *""'");
15886 }
15887 arg1 = reinterpret_cast< wxImage * >(argp1);
15888 {
15889 PyThreadState* __tstate = wxPyBeginAllowThreads();
15890 result = (bool)(arg1)->HasMask();
15891 wxPyEndAllowThreads(__tstate);
15892 if (PyErr_Occurred()) SWIG_fail;
15893 }
15894 {
15895 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15896 }
15897 return resultobj;
15898 fail:
15899 return NULL;
15900 }
15901
15902
15903 SWIGINTERN PyObject *_wrap_Image_Rotate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15904 PyObject *resultobj = 0;
15905 wxImage *arg1 = (wxImage *) 0 ;
15906 double arg2 ;
15907 wxPoint *arg3 = 0 ;
15908 bool arg4 = (bool) true ;
15909 wxPoint *arg5 = (wxPoint *) NULL ;
15910 SwigValueWrapper<wxImage > result;
15911 void *argp1 = 0 ;
15912 int res1 = 0 ;
15913 double val2 ;
15914 int ecode2 = 0 ;
15915 wxPoint temp3 ;
15916 bool val4 ;
15917 int ecode4 = 0 ;
15918 void *argp5 = 0 ;
15919 int res5 = 0 ;
15920 PyObject * obj0 = 0 ;
15921 PyObject * obj1 = 0 ;
15922 PyObject * obj2 = 0 ;
15923 PyObject * obj3 = 0 ;
15924 PyObject * obj4 = 0 ;
15925 char * kwnames[] = {
15926 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
15927 };
15928
15929 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
15930 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15931 if (!SWIG_IsOK(res1)) {
15932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate" "', expected argument " "1"" of type '" "wxImage const *""'");
15933 }
15934 arg1 = reinterpret_cast< wxImage * >(argp1);
15935 ecode2 = SWIG_AsVal_double(obj1, &val2);
15936 if (!SWIG_IsOK(ecode2)) {
15937 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate" "', expected argument " "2"" of type '" "double""'");
15938 }
15939 arg2 = static_cast< double >(val2);
15940 {
15941 arg3 = &temp3;
15942 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
15943 }
15944 if (obj3) {
15945 ecode4 = SWIG_AsVal_bool(obj3, &val4);
15946 if (!SWIG_IsOK(ecode4)) {
15947 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rotate" "', expected argument " "4"" of type '" "bool""'");
15948 }
15949 arg4 = static_cast< bool >(val4);
15950 }
15951 if (obj4) {
15952 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxPoint, 0 | 0 );
15953 if (!SWIG_IsOK(res5)) {
15954 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Image_Rotate" "', expected argument " "5"" of type '" "wxPoint *""'");
15955 }
15956 arg5 = reinterpret_cast< wxPoint * >(argp5);
15957 }
15958 {
15959 PyThreadState* __tstate = wxPyBeginAllowThreads();
15960 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
15961 wxPyEndAllowThreads(__tstate);
15962 if (PyErr_Occurred()) SWIG_fail;
15963 }
15964 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15965 return resultobj;
15966 fail:
15967 return NULL;
15968 }
15969
15970
15971 SWIGINTERN PyObject *_wrap_Image_Rotate90(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15972 PyObject *resultobj = 0;
15973 wxImage *arg1 = (wxImage *) 0 ;
15974 bool arg2 = (bool) true ;
15975 SwigValueWrapper<wxImage > result;
15976 void *argp1 = 0 ;
15977 int res1 = 0 ;
15978 bool val2 ;
15979 int ecode2 = 0 ;
15980 PyObject * obj0 = 0 ;
15981 PyObject * obj1 = 0 ;
15982 char * kwnames[] = {
15983 (char *) "self",(char *) "clockwise", NULL
15984 };
15985
15986 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) SWIG_fail;
15987 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15988 if (!SWIG_IsOK(res1)) {
15989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate90" "', expected argument " "1"" of type '" "wxImage *""'");
15990 }
15991 arg1 = reinterpret_cast< wxImage * >(argp1);
15992 if (obj1) {
15993 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15994 if (!SWIG_IsOK(ecode2)) {
15995 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate90" "', expected argument " "2"" of type '" "bool""'");
15996 }
15997 arg2 = static_cast< bool >(val2);
15998 }
15999 {
16000 PyThreadState* __tstate = wxPyBeginAllowThreads();
16001 result = (arg1)->Rotate90(arg2);
16002 wxPyEndAllowThreads(__tstate);
16003 if (PyErr_Occurred()) SWIG_fail;
16004 }
16005 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16006 return resultobj;
16007 fail:
16008 return NULL;
16009 }
16010
16011
16012 SWIGINTERN PyObject *_wrap_Image_Mirror(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16013 PyObject *resultobj = 0;
16014 wxImage *arg1 = (wxImage *) 0 ;
16015 bool arg2 = (bool) true ;
16016 SwigValueWrapper<wxImage > result;
16017 void *argp1 = 0 ;
16018 int res1 = 0 ;
16019 bool val2 ;
16020 int ecode2 = 0 ;
16021 PyObject * obj0 = 0 ;
16022 PyObject * obj1 = 0 ;
16023 char * kwnames[] = {
16024 (char *) "self",(char *) "horizontally", NULL
16025 };
16026
16027 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) SWIG_fail;
16028 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16029 if (!SWIG_IsOK(res1)) {
16030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Mirror" "', expected argument " "1"" of type '" "wxImage *""'");
16031 }
16032 arg1 = reinterpret_cast< wxImage * >(argp1);
16033 if (obj1) {
16034 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16035 if (!SWIG_IsOK(ecode2)) {
16036 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Mirror" "', expected argument " "2"" of type '" "bool""'");
16037 }
16038 arg2 = static_cast< bool >(val2);
16039 }
16040 {
16041 PyThreadState* __tstate = wxPyBeginAllowThreads();
16042 result = (arg1)->Mirror(arg2);
16043 wxPyEndAllowThreads(__tstate);
16044 if (PyErr_Occurred()) SWIG_fail;
16045 }
16046 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16047 return resultobj;
16048 fail:
16049 return NULL;
16050 }
16051
16052
16053 SWIGINTERN PyObject *_wrap_Image_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16054 PyObject *resultobj = 0;
16055 wxImage *arg1 = (wxImage *) 0 ;
16056 byte arg2 ;
16057 byte arg3 ;
16058 byte arg4 ;
16059 byte arg5 ;
16060 byte arg6 ;
16061 byte arg7 ;
16062 void *argp1 = 0 ;
16063 int res1 = 0 ;
16064 unsigned char val2 ;
16065 int ecode2 = 0 ;
16066 unsigned char val3 ;
16067 int ecode3 = 0 ;
16068 unsigned char val4 ;
16069 int ecode4 = 0 ;
16070 unsigned char val5 ;
16071 int ecode5 = 0 ;
16072 unsigned char val6 ;
16073 int ecode6 = 0 ;
16074 unsigned char val7 ;
16075 int ecode7 = 0 ;
16076 PyObject * obj0 = 0 ;
16077 PyObject * obj1 = 0 ;
16078 PyObject * obj2 = 0 ;
16079 PyObject * obj3 = 0 ;
16080 PyObject * obj4 = 0 ;
16081 PyObject * obj5 = 0 ;
16082 PyObject * obj6 = 0 ;
16083 char * kwnames[] = {
16084 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
16085 };
16086
16087 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
16088 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16089 if (!SWIG_IsOK(res1)) {
16090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Replace" "', expected argument " "1"" of type '" "wxImage *""'");
16091 }
16092 arg1 = reinterpret_cast< wxImage * >(argp1);
16093 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16094 if (!SWIG_IsOK(ecode2)) {
16095 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Replace" "', expected argument " "2"" of type '" "byte""'");
16096 }
16097 arg2 = static_cast< byte >(val2);
16098 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16099 if (!SWIG_IsOK(ecode3)) {
16100 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Replace" "', expected argument " "3"" of type '" "byte""'");
16101 }
16102 arg3 = static_cast< byte >(val3);
16103 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16104 if (!SWIG_IsOK(ecode4)) {
16105 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Replace" "', expected argument " "4"" of type '" "byte""'");
16106 }
16107 arg4 = static_cast< byte >(val4);
16108 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
16109 if (!SWIG_IsOK(ecode5)) {
16110 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Replace" "', expected argument " "5"" of type '" "byte""'");
16111 }
16112 arg5 = static_cast< byte >(val5);
16113 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
16114 if (!SWIG_IsOK(ecode6)) {
16115 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Replace" "', expected argument " "6"" of type '" "byte""'");
16116 }
16117 arg6 = static_cast< byte >(val6);
16118 ecode7 = SWIG_AsVal_unsigned_SS_char(obj6, &val7);
16119 if (!SWIG_IsOK(ecode7)) {
16120 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_Replace" "', expected argument " "7"" of type '" "byte""'");
16121 }
16122 arg7 = static_cast< byte >(val7);
16123 {
16124 PyThreadState* __tstate = wxPyBeginAllowThreads();
16125 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
16126 wxPyEndAllowThreads(__tstate);
16127 if (PyErr_Occurred()) SWIG_fail;
16128 }
16129 resultobj = SWIG_Py_Void();
16130 return resultobj;
16131 fail:
16132 return NULL;
16133 }
16134
16135
16136 SWIGINTERN PyObject *_wrap_Image_ConvertToGreyscale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16137 PyObject *resultobj = 0;
16138 wxImage *arg1 = (wxImage *) 0 ;
16139 double arg2 = (double) 0.299 ;
16140 double arg3 = (double) 0.587 ;
16141 double arg4 = (double) 0.114 ;
16142 SwigValueWrapper<wxImage > result;
16143 void *argp1 = 0 ;
16144 int res1 = 0 ;
16145 double val2 ;
16146 int ecode2 = 0 ;
16147 double val3 ;
16148 int ecode3 = 0 ;
16149 double val4 ;
16150 int ecode4 = 0 ;
16151 PyObject * obj0 = 0 ;
16152 PyObject * obj1 = 0 ;
16153 PyObject * obj2 = 0 ;
16154 PyObject * obj3 = 0 ;
16155 char * kwnames[] = {
16156 (char *) "self",(char *) "lr",(char *) "lg",(char *) "lb", NULL
16157 };
16158
16159 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_ConvertToGreyscale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16160 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16161 if (!SWIG_IsOK(res1)) {
16162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToGreyscale" "', expected argument " "1"" of type '" "wxImage const *""'");
16163 }
16164 arg1 = reinterpret_cast< wxImage * >(argp1);
16165 if (obj1) {
16166 ecode2 = SWIG_AsVal_double(obj1, &val2);
16167 if (!SWIG_IsOK(ecode2)) {
16168 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToGreyscale" "', expected argument " "2"" of type '" "double""'");
16169 }
16170 arg2 = static_cast< double >(val2);
16171 }
16172 if (obj2) {
16173 ecode3 = SWIG_AsVal_double(obj2, &val3);
16174 if (!SWIG_IsOK(ecode3)) {
16175 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToGreyscale" "', expected argument " "3"" of type '" "double""'");
16176 }
16177 arg3 = static_cast< double >(val3);
16178 }
16179 if (obj3) {
16180 ecode4 = SWIG_AsVal_double(obj3, &val4);
16181 if (!SWIG_IsOK(ecode4)) {
16182 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToGreyscale" "', expected argument " "4"" of type '" "double""'");
16183 }
16184 arg4 = static_cast< double >(val4);
16185 }
16186 {
16187 PyThreadState* __tstate = wxPyBeginAllowThreads();
16188 result = ((wxImage const *)arg1)->ConvertToGreyscale(arg2,arg3,arg4);
16189 wxPyEndAllowThreads(__tstate);
16190 if (PyErr_Occurred()) SWIG_fail;
16191 }
16192 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16193 return resultobj;
16194 fail:
16195 return NULL;
16196 }
16197
16198
16199 SWIGINTERN PyObject *_wrap_Image_ConvertToMono(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16200 PyObject *resultobj = 0;
16201 wxImage *arg1 = (wxImage *) 0 ;
16202 byte arg2 ;
16203 byte arg3 ;
16204 byte arg4 ;
16205 SwigValueWrapper<wxImage > result;
16206 void *argp1 = 0 ;
16207 int res1 = 0 ;
16208 unsigned char val2 ;
16209 int ecode2 = 0 ;
16210 unsigned char val3 ;
16211 int ecode3 = 0 ;
16212 unsigned char val4 ;
16213 int ecode4 = 0 ;
16214 PyObject * obj0 = 0 ;
16215 PyObject * obj1 = 0 ;
16216 PyObject * obj2 = 0 ;
16217 PyObject * obj3 = 0 ;
16218 char * kwnames[] = {
16219 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
16220 };
16221
16222 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16223 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16224 if (!SWIG_IsOK(res1)) {
16225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMono" "', expected argument " "1"" of type '" "wxImage const *""'");
16226 }
16227 arg1 = reinterpret_cast< wxImage * >(argp1);
16228 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16229 if (!SWIG_IsOK(ecode2)) {
16230 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMono" "', expected argument " "2"" of type '" "byte""'");
16231 }
16232 arg2 = static_cast< byte >(val2);
16233 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16234 if (!SWIG_IsOK(ecode3)) {
16235 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMono" "', expected argument " "3"" of type '" "byte""'");
16236 }
16237 arg3 = static_cast< byte >(val3);
16238 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16239 if (!SWIG_IsOK(ecode4)) {
16240 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMono" "', expected argument " "4"" of type '" "byte""'");
16241 }
16242 arg4 = static_cast< byte >(val4);
16243 {
16244 PyThreadState* __tstate = wxPyBeginAllowThreads();
16245 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
16246 wxPyEndAllowThreads(__tstate);
16247 if (PyErr_Occurred()) SWIG_fail;
16248 }
16249 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16250 return resultobj;
16251 fail:
16252 return NULL;
16253 }
16254
16255
16256 SWIGINTERN PyObject *_wrap_Image_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16257 PyObject *resultobj = 0;
16258 wxImage *arg1 = (wxImage *) 0 ;
16259 wxString *arg2 = 0 ;
16260 wxString *arg3 = 0 ;
16261 void *argp1 = 0 ;
16262 int res1 = 0 ;
16263 bool temp2 = false ;
16264 bool temp3 = false ;
16265 PyObject * obj0 = 0 ;
16266 PyObject * obj1 = 0 ;
16267 PyObject * obj2 = 0 ;
16268 char * kwnames[] = {
16269 (char *) "self",(char *) "name",(char *) "value", NULL
16270 };
16271
16272 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16273 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16274 if (!SWIG_IsOK(res1)) {
16275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOption" "', expected argument " "1"" of type '" "wxImage *""'");
16276 }
16277 arg1 = reinterpret_cast< wxImage * >(argp1);
16278 {
16279 arg2 = wxString_in_helper(obj1);
16280 if (arg2 == NULL) SWIG_fail;
16281 temp2 = true;
16282 }
16283 {
16284 arg3 = wxString_in_helper(obj2);
16285 if (arg3 == NULL) SWIG_fail;
16286 temp3 = true;
16287 }
16288 {
16289 PyThreadState* __tstate = wxPyBeginAllowThreads();
16290 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
16291 wxPyEndAllowThreads(__tstate);
16292 if (PyErr_Occurred()) SWIG_fail;
16293 }
16294 resultobj = SWIG_Py_Void();
16295 {
16296 if (temp2)
16297 delete arg2;
16298 }
16299 {
16300 if (temp3)
16301 delete arg3;
16302 }
16303 return resultobj;
16304 fail:
16305 {
16306 if (temp2)
16307 delete arg2;
16308 }
16309 {
16310 if (temp3)
16311 delete arg3;
16312 }
16313 return NULL;
16314 }
16315
16316
16317 SWIGINTERN PyObject *_wrap_Image_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16318 PyObject *resultobj = 0;
16319 wxImage *arg1 = (wxImage *) 0 ;
16320 wxString *arg2 = 0 ;
16321 int arg3 ;
16322 void *argp1 = 0 ;
16323 int res1 = 0 ;
16324 bool temp2 = false ;
16325 int val3 ;
16326 int ecode3 = 0 ;
16327 PyObject * obj0 = 0 ;
16328 PyObject * obj1 = 0 ;
16329 PyObject * obj2 = 0 ;
16330 char * kwnames[] = {
16331 (char *) "self",(char *) "name",(char *) "value", NULL
16332 };
16333
16334 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16335 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16336 if (!SWIG_IsOK(res1)) {
16337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOptionInt" "', expected argument " "1"" of type '" "wxImage *""'");
16338 }
16339 arg1 = reinterpret_cast< wxImage * >(argp1);
16340 {
16341 arg2 = wxString_in_helper(obj1);
16342 if (arg2 == NULL) SWIG_fail;
16343 temp2 = true;
16344 }
16345 ecode3 = SWIG_AsVal_int(obj2, &val3);
16346 if (!SWIG_IsOK(ecode3)) {
16347 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetOptionInt" "', expected argument " "3"" of type '" "int""'");
16348 }
16349 arg3 = static_cast< int >(val3);
16350 {
16351 PyThreadState* __tstate = wxPyBeginAllowThreads();
16352 (arg1)->SetOption((wxString const &)*arg2,arg3);
16353 wxPyEndAllowThreads(__tstate);
16354 if (PyErr_Occurred()) SWIG_fail;
16355 }
16356 resultobj = SWIG_Py_Void();
16357 {
16358 if (temp2)
16359 delete arg2;
16360 }
16361 return resultobj;
16362 fail:
16363 {
16364 if (temp2)
16365 delete arg2;
16366 }
16367 return NULL;
16368 }
16369
16370
16371 SWIGINTERN PyObject *_wrap_Image_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16372 PyObject *resultobj = 0;
16373 wxImage *arg1 = (wxImage *) 0 ;
16374 wxString *arg2 = 0 ;
16375 wxString result;
16376 void *argp1 = 0 ;
16377 int res1 = 0 ;
16378 bool temp2 = false ;
16379 PyObject * obj0 = 0 ;
16380 PyObject * obj1 = 0 ;
16381 char * kwnames[] = {
16382 (char *) "self",(char *) "name", NULL
16383 };
16384
16385 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) SWIG_fail;
16386 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16387 if (!SWIG_IsOK(res1)) {
16388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16389 }
16390 arg1 = reinterpret_cast< wxImage * >(argp1);
16391 {
16392 arg2 = wxString_in_helper(obj1);
16393 if (arg2 == NULL) SWIG_fail;
16394 temp2 = true;
16395 }
16396 {
16397 PyThreadState* __tstate = wxPyBeginAllowThreads();
16398 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
16399 wxPyEndAllowThreads(__tstate);
16400 if (PyErr_Occurred()) SWIG_fail;
16401 }
16402 {
16403 #if wxUSE_UNICODE
16404 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16405 #else
16406 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16407 #endif
16408 }
16409 {
16410 if (temp2)
16411 delete arg2;
16412 }
16413 return resultobj;
16414 fail:
16415 {
16416 if (temp2)
16417 delete arg2;
16418 }
16419 return NULL;
16420 }
16421
16422
16423 SWIGINTERN PyObject *_wrap_Image_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16424 PyObject *resultobj = 0;
16425 wxImage *arg1 = (wxImage *) 0 ;
16426 wxString *arg2 = 0 ;
16427 int result;
16428 void *argp1 = 0 ;
16429 int res1 = 0 ;
16430 bool temp2 = false ;
16431 PyObject * obj0 = 0 ;
16432 PyObject * obj1 = 0 ;
16433 char * kwnames[] = {
16434 (char *) "self",(char *) "name", NULL
16435 };
16436
16437 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
16438 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16439 if (!SWIG_IsOK(res1)) {
16440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOptionInt" "', expected argument " "1"" of type '" "wxImage const *""'");
16441 }
16442 arg1 = reinterpret_cast< wxImage * >(argp1);
16443 {
16444 arg2 = wxString_in_helper(obj1);
16445 if (arg2 == NULL) SWIG_fail;
16446 temp2 = true;
16447 }
16448 {
16449 PyThreadState* __tstate = wxPyBeginAllowThreads();
16450 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
16451 wxPyEndAllowThreads(__tstate);
16452 if (PyErr_Occurred()) SWIG_fail;
16453 }
16454 resultobj = SWIG_From_int(static_cast< int >(result));
16455 {
16456 if (temp2)
16457 delete arg2;
16458 }
16459 return resultobj;
16460 fail:
16461 {
16462 if (temp2)
16463 delete arg2;
16464 }
16465 return NULL;
16466 }
16467
16468
16469 SWIGINTERN PyObject *_wrap_Image_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16470 PyObject *resultobj = 0;
16471 wxImage *arg1 = (wxImage *) 0 ;
16472 wxString *arg2 = 0 ;
16473 bool result;
16474 void *argp1 = 0 ;
16475 int res1 = 0 ;
16476 bool temp2 = false ;
16477 PyObject * obj0 = 0 ;
16478 PyObject * obj1 = 0 ;
16479 char * kwnames[] = {
16480 (char *) "self",(char *) "name", NULL
16481 };
16482
16483 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) SWIG_fail;
16484 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16485 if (!SWIG_IsOK(res1)) {
16486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16487 }
16488 arg1 = reinterpret_cast< wxImage * >(argp1);
16489 {
16490 arg2 = wxString_in_helper(obj1);
16491 if (arg2 == NULL) SWIG_fail;
16492 temp2 = true;
16493 }
16494 {
16495 PyThreadState* __tstate = wxPyBeginAllowThreads();
16496 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
16497 wxPyEndAllowThreads(__tstate);
16498 if (PyErr_Occurred()) SWIG_fail;
16499 }
16500 {
16501 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16502 }
16503 {
16504 if (temp2)
16505 delete arg2;
16506 }
16507 return resultobj;
16508 fail:
16509 {
16510 if (temp2)
16511 delete arg2;
16512 }
16513 return NULL;
16514 }
16515
16516
16517 SWIGINTERN PyObject *_wrap_Image_CountColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16518 PyObject *resultobj = 0;
16519 wxImage *arg1 = (wxImage *) 0 ;
16520 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
16521 unsigned long result;
16522 void *argp1 = 0 ;
16523 int res1 = 0 ;
16524 unsigned long val2 ;
16525 int ecode2 = 0 ;
16526 PyObject * obj0 = 0 ;
16527 PyObject * obj1 = 0 ;
16528 char * kwnames[] = {
16529 (char *) "self",(char *) "stopafter", NULL
16530 };
16531
16532 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) SWIG_fail;
16533 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16534 if (!SWIG_IsOK(res1)) {
16535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_CountColours" "', expected argument " "1"" of type '" "wxImage *""'");
16536 }
16537 arg1 = reinterpret_cast< wxImage * >(argp1);
16538 if (obj1) {
16539 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
16540 if (!SWIG_IsOK(ecode2)) {
16541 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_CountColours" "', expected argument " "2"" of type '" "unsigned long""'");
16542 }
16543 arg2 = static_cast< unsigned long >(val2);
16544 }
16545 {
16546 PyThreadState* __tstate = wxPyBeginAllowThreads();
16547 result = (unsigned long)(arg1)->CountColours(arg2);
16548 wxPyEndAllowThreads(__tstate);
16549 if (PyErr_Occurred()) SWIG_fail;
16550 }
16551 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16552 return resultobj;
16553 fail:
16554 return NULL;
16555 }
16556
16557
16558 SWIGINTERN PyObject *_wrap_Image_ComputeHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16559 PyObject *resultobj = 0;
16560 wxImage *arg1 = (wxImage *) 0 ;
16561 wxImageHistogram *arg2 = 0 ;
16562 unsigned long result;
16563 void *argp1 = 0 ;
16564 int res1 = 0 ;
16565 void *argp2 = 0 ;
16566 int res2 = 0 ;
16567 PyObject * obj0 = 0 ;
16568 PyObject * obj1 = 0 ;
16569 char * kwnames[] = {
16570 (char *) "self",(char *) "h", NULL
16571 };
16572
16573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) SWIG_fail;
16574 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16575 if (!SWIG_IsOK(res1)) {
16576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ComputeHistogram" "', expected argument " "1"" of type '" "wxImage *""'");
16577 }
16578 arg1 = reinterpret_cast< wxImage * >(argp1);
16579 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImageHistogram, 0 );
16580 if (!SWIG_IsOK(res2)) {
16581 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16582 }
16583 if (!argp2) {
16584 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16585 }
16586 arg2 = reinterpret_cast< wxImageHistogram * >(argp2);
16587 {
16588 PyThreadState* __tstate = wxPyBeginAllowThreads();
16589 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
16590 wxPyEndAllowThreads(__tstate);
16591 if (PyErr_Occurred()) SWIG_fail;
16592 }
16593 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16594 return resultobj;
16595 fail:
16596 return NULL;
16597 }
16598
16599
16600 SWIGINTERN PyObject *_wrap_Image_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16601 PyObject *resultobj = 0;
16602 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16603 void *argp1 = 0 ;
16604 int res1 = 0 ;
16605 PyObject * obj0 = 0 ;
16606 char * kwnames[] = {
16607 (char *) "handler", NULL
16608 };
16609
16610 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) SWIG_fail;
16611 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16612 if (!SWIG_IsOK(res1)) {
16613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_AddHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16614 }
16615 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16616 {
16617 PyThreadState* __tstate = wxPyBeginAllowThreads();
16618 wxImage::AddHandler(arg1);
16619 wxPyEndAllowThreads(__tstate);
16620 if (PyErr_Occurred()) SWIG_fail;
16621 }
16622 resultobj = SWIG_Py_Void();
16623 return resultobj;
16624 fail:
16625 return NULL;
16626 }
16627
16628
16629 SWIGINTERN PyObject *_wrap_Image_InsertHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16630 PyObject *resultobj = 0;
16631 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16632 void *argp1 = 0 ;
16633 int res1 = 0 ;
16634 PyObject * obj0 = 0 ;
16635 char * kwnames[] = {
16636 (char *) "handler", NULL
16637 };
16638
16639 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) SWIG_fail;
16640 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16641 if (!SWIG_IsOK(res1)) {
16642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InsertHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16643 }
16644 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16645 {
16646 PyThreadState* __tstate = wxPyBeginAllowThreads();
16647 wxImage::InsertHandler(arg1);
16648 wxPyEndAllowThreads(__tstate);
16649 if (PyErr_Occurred()) SWIG_fail;
16650 }
16651 resultobj = SWIG_Py_Void();
16652 return resultobj;
16653 fail:
16654 return NULL;
16655 }
16656
16657
16658 SWIGINTERN PyObject *_wrap_Image_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16659 PyObject *resultobj = 0;
16660 wxString *arg1 = 0 ;
16661 bool result;
16662 bool temp1 = false ;
16663 PyObject * obj0 = 0 ;
16664 char * kwnames[] = {
16665 (char *) "name", NULL
16666 };
16667
16668 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) SWIG_fail;
16669 {
16670 arg1 = wxString_in_helper(obj0);
16671 if (arg1 == NULL) SWIG_fail;
16672 temp1 = true;
16673 }
16674 {
16675 PyThreadState* __tstate = wxPyBeginAllowThreads();
16676 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
16677 wxPyEndAllowThreads(__tstate);
16678 if (PyErr_Occurred()) SWIG_fail;
16679 }
16680 {
16681 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16682 }
16683 {
16684 if (temp1)
16685 delete arg1;
16686 }
16687 return resultobj;
16688 fail:
16689 {
16690 if (temp1)
16691 delete arg1;
16692 }
16693 return NULL;
16694 }
16695
16696
16697 SWIGINTERN PyObject *_wrap_Image_GetHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16698 PyObject *resultobj = 0;
16699 PyObject *result = 0 ;
16700
16701 if (!SWIG_Python_UnpackTuple(args,"Image_GetHandlers",0,0,0)) SWIG_fail;
16702 {
16703 PyThreadState* __tstate = wxPyBeginAllowThreads();
16704 result = (PyObject *)wxImage_GetHandlers();
16705 wxPyEndAllowThreads(__tstate);
16706 if (PyErr_Occurred()) SWIG_fail;
16707 }
16708 resultobj = result;
16709 return resultobj;
16710 fail:
16711 return NULL;
16712 }
16713
16714
16715 SWIGINTERN PyObject *_wrap_Image_GetImageExtWildcard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16716 PyObject *resultobj = 0;
16717 wxString result;
16718
16719 if (!SWIG_Python_UnpackTuple(args,"Image_GetImageExtWildcard",0,0,0)) SWIG_fail;
16720 {
16721 PyThreadState* __tstate = wxPyBeginAllowThreads();
16722 result = wxImage::GetImageExtWildcard();
16723 wxPyEndAllowThreads(__tstate);
16724 if (PyErr_Occurred()) SWIG_fail;
16725 }
16726 {
16727 #if wxUSE_UNICODE
16728 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16729 #else
16730 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16731 #endif
16732 }
16733 return resultobj;
16734 fail:
16735 return NULL;
16736 }
16737
16738
16739 SWIGINTERN PyObject *_wrap_Image_ConvertToBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16740 PyObject *resultobj = 0;
16741 wxImage *arg1 = (wxImage *) 0 ;
16742 int arg2 = (int) -1 ;
16743 wxBitmap result;
16744 void *argp1 = 0 ;
16745 int res1 = 0 ;
16746 int val2 ;
16747 int ecode2 = 0 ;
16748 PyObject * obj0 = 0 ;
16749 PyObject * obj1 = 0 ;
16750 char * kwnames[] = {
16751 (char *) "self",(char *) "depth", NULL
16752 };
16753
16754 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
16755 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16756 if (!SWIG_IsOK(res1)) {
16757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
16758 }
16759 arg1 = reinterpret_cast< wxImage * >(argp1);
16760 if (obj1) {
16761 ecode2 = SWIG_AsVal_int(obj1, &val2);
16762 if (!SWIG_IsOK(ecode2)) {
16763 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToBitmap" "', expected argument " "2"" of type '" "int""'");
16764 }
16765 arg2 = static_cast< int >(val2);
16766 }
16767 {
16768 if (!wxPyCheckForApp()) SWIG_fail;
16769 PyThreadState* __tstate = wxPyBeginAllowThreads();
16770 result = wxImage_ConvertToBitmap(arg1,arg2);
16771 wxPyEndAllowThreads(__tstate);
16772 if (PyErr_Occurred()) SWIG_fail;
16773 }
16774 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
16775 return resultobj;
16776 fail:
16777 return NULL;
16778 }
16779
16780
16781 SWIGINTERN PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16782 PyObject *resultobj = 0;
16783 wxImage *arg1 = (wxImage *) 0 ;
16784 byte arg2 ;
16785 byte arg3 ;
16786 byte arg4 ;
16787 wxBitmap result;
16788 void *argp1 = 0 ;
16789 int res1 = 0 ;
16790 unsigned char val2 ;
16791 int ecode2 = 0 ;
16792 unsigned char val3 ;
16793 int ecode3 = 0 ;
16794 unsigned char val4 ;
16795 int ecode4 = 0 ;
16796 PyObject * obj0 = 0 ;
16797 PyObject * obj1 = 0 ;
16798 PyObject * obj2 = 0 ;
16799 PyObject * obj3 = 0 ;
16800 char * kwnames[] = {
16801 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
16802 };
16803
16804 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16805 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16806 if (!SWIG_IsOK(res1)) {
16807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
16808 }
16809 arg1 = reinterpret_cast< wxImage * >(argp1);
16810 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16811 if (!SWIG_IsOK(ecode2)) {
16812 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "2"" of type '" "byte""'");
16813 }
16814 arg2 = static_cast< byte >(val2);
16815 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16816 if (!SWIG_IsOK(ecode3)) {
16817 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "3"" of type '" "byte""'");
16818 }
16819 arg3 = static_cast< byte >(val3);
16820 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16821 if (!SWIG_IsOK(ecode4)) {
16822 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "4"" of type '" "byte""'");
16823 }
16824 arg4 = static_cast< byte >(val4);
16825 {
16826 if (!wxPyCheckForApp()) SWIG_fail;
16827 PyThreadState* __tstate = wxPyBeginAllowThreads();
16828 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
16829 wxPyEndAllowThreads(__tstate);
16830 if (PyErr_Occurred()) SWIG_fail;
16831 }
16832 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
16833 return resultobj;
16834 fail:
16835 return NULL;
16836 }
16837
16838
16839 SWIGINTERN PyObject *_wrap_Image_RotateHue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16840 PyObject *resultobj = 0;
16841 wxImage *arg1 = (wxImage *) 0 ;
16842 double arg2 ;
16843 void *argp1 = 0 ;
16844 int res1 = 0 ;
16845 double val2 ;
16846 int ecode2 = 0 ;
16847 PyObject * obj0 = 0 ;
16848 PyObject * obj1 = 0 ;
16849 char * kwnames[] = {
16850 (char *) "self",(char *) "angle", NULL
16851 };
16852
16853 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RotateHue",kwnames,&obj0,&obj1)) SWIG_fail;
16854 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16855 if (!SWIG_IsOK(res1)) {
16856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RotateHue" "', expected argument " "1"" of type '" "wxImage *""'");
16857 }
16858 arg1 = reinterpret_cast< wxImage * >(argp1);
16859 ecode2 = SWIG_AsVal_double(obj1, &val2);
16860 if (!SWIG_IsOK(ecode2)) {
16861 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RotateHue" "', expected argument " "2"" of type '" "double""'");
16862 }
16863 arg2 = static_cast< double >(val2);
16864 {
16865 PyThreadState* __tstate = wxPyBeginAllowThreads();
16866 (arg1)->RotateHue(arg2);
16867 wxPyEndAllowThreads(__tstate);
16868 if (PyErr_Occurred()) SWIG_fail;
16869 }
16870 resultobj = SWIG_Py_Void();
16871 return resultobj;
16872 fail:
16873 return NULL;
16874 }
16875
16876
16877 SWIGINTERN PyObject *_wrap_Image_RGBtoHSV(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16878 PyObject *resultobj = 0;
16879 wxImage_RGBValue arg1 ;
16880 wxImage_HSVValue result;
16881 void *argp1 ;
16882 int res1 = 0 ;
16883 PyObject * obj0 = 0 ;
16884 char * kwnames[] = {
16885 (char *) "rgb", NULL
16886 };
16887
16888 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBtoHSV",kwnames,&obj0)) SWIG_fail;
16889 {
16890 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_RGBValue, 0 | 0);
16891 if (!SWIG_IsOK(res1)) {
16892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
16893 }
16894 if (!argp1) {
16895 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
16896 } else {
16897 wxImage_RGBValue * temp = reinterpret_cast< wxImage_RGBValue * >(argp1);
16898 arg1 = *temp;
16899 if (SWIG_IsNewObj(res1)) delete temp;
16900 }
16901 }
16902 {
16903 PyThreadState* __tstate = wxPyBeginAllowThreads();
16904 result = wxImage::RGBtoHSV(arg1);
16905 wxPyEndAllowThreads(__tstate);
16906 if (PyErr_Occurred()) SWIG_fail;
16907 }
16908 resultobj = SWIG_NewPointerObj((new wxImage_HSVValue(static_cast< const wxImage_HSVValue& >(result))), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_OWN | 0 );
16909 return resultobj;
16910 fail:
16911 return NULL;
16912 }
16913
16914
16915 SWIGINTERN PyObject *_wrap_Image_HSVtoRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16916 PyObject *resultobj = 0;
16917 wxImage_HSVValue arg1 ;
16918 wxImage_RGBValue result;
16919 void *argp1 ;
16920 int res1 = 0 ;
16921 PyObject * obj0 = 0 ;
16922 char * kwnames[] = {
16923 (char *) "hsv", NULL
16924 };
16925
16926 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVtoRGB",kwnames,&obj0)) SWIG_fail;
16927 {
16928 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_HSVValue, 0 | 0);
16929 if (!SWIG_IsOK(res1)) {
16930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
16931 }
16932 if (!argp1) {
16933 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
16934 } else {
16935 wxImage_HSVValue * temp = reinterpret_cast< wxImage_HSVValue * >(argp1);
16936 arg1 = *temp;
16937 if (SWIG_IsNewObj(res1)) delete temp;
16938 }
16939 }
16940 {
16941 PyThreadState* __tstate = wxPyBeginAllowThreads();
16942 result = wxImage::HSVtoRGB(arg1);
16943 wxPyEndAllowThreads(__tstate);
16944 if (PyErr_Occurred()) SWIG_fail;
16945 }
16946 resultobj = SWIG_NewPointerObj((new wxImage_RGBValue(static_cast< const wxImage_RGBValue& >(result))), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_OWN | 0 );
16947 return resultobj;
16948 fail:
16949 return NULL;
16950 }
16951
16952
16953 SWIGINTERN PyObject *Image_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16954 PyObject *obj;
16955 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16956 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage, SWIG_NewClientData(obj));
16957 return SWIG_Py_Void();
16958 }
16959
16960 SWIGINTERN PyObject *Image_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16961 return SWIG_Python_InitShadowInstance(args);
16962 }
16963
16964 SWIGINTERN int NullImage_set(PyObject *) {
16965 SWIG_Error(SWIG_AttributeError,"Variable NullImage is read-only.");
16966 return 1;
16967 }
16968
16969
16970 SWIGINTERN PyObject *NullImage_get(void) {
16971 PyObject *pyobj = 0;
16972
16973 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullImage), SWIGTYPE_p_wxImage, 0 );
16974 return pyobj;
16975 }
16976
16977
16978 SWIGINTERN int IMAGE_OPTION_FILENAME_set(PyObject *) {
16979 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
16980 return 1;
16981 }
16982
16983
16984 SWIGINTERN PyObject *IMAGE_OPTION_FILENAME_get(void) {
16985 PyObject *pyobj = 0;
16986
16987 {
16988 #if wxUSE_UNICODE
16989 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
16990 #else
16991 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
16992 #endif
16993 }
16994 return pyobj;
16995 }
16996
16997
16998 SWIGINTERN int IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
16999 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
17000 return 1;
17001 }
17002
17003
17004 SWIGINTERN PyObject *IMAGE_OPTION_BMP_FORMAT_get(void) {
17005 PyObject *pyobj = 0;
17006
17007 {
17008 #if wxUSE_UNICODE
17009 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
17010 #else
17011 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
17012 #endif
17013 }
17014 return pyobj;
17015 }
17016
17017
17018 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
17019 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
17020 return 1;
17021 }
17022
17023
17024 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
17025 PyObject *pyobj = 0;
17026
17027 {
17028 #if wxUSE_UNICODE
17029 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
17030 #else
17031 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
17032 #endif
17033 }
17034 return pyobj;
17035 }
17036
17037
17038 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
17039 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
17040 return 1;
17041 }
17042
17043
17044 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
17045 PyObject *pyobj = 0;
17046
17047 {
17048 #if wxUSE_UNICODE
17049 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
17050 #else
17051 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
17052 #endif
17053 }
17054 return pyobj;
17055 }
17056
17057
17058 SWIGINTERN int IMAGE_OPTION_RESOLUTION_set(PyObject *) {
17059 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
17060 return 1;
17061 }
17062
17063
17064 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTION_get(void) {
17065 PyObject *pyobj = 0;
17066
17067 {
17068 #if wxUSE_UNICODE
17069 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
17070 #else
17071 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
17072 #endif
17073 }
17074 return pyobj;
17075 }
17076
17077
17078 SWIGINTERN int IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
17079 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
17080 return 1;
17081 }
17082
17083
17084 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONX_get(void) {
17085 PyObject *pyobj = 0;
17086
17087 {
17088 #if wxUSE_UNICODE
17089 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
17090 #else
17091 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
17092 #endif
17093 }
17094 return pyobj;
17095 }
17096
17097
17098 SWIGINTERN int IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
17099 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
17100 return 1;
17101 }
17102
17103
17104 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONY_get(void) {
17105 PyObject *pyobj = 0;
17106
17107 {
17108 #if wxUSE_UNICODE
17109 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
17110 #else
17111 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
17112 #endif
17113 }
17114 return pyobj;
17115 }
17116
17117
17118 SWIGINTERN int IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
17119 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
17120 return 1;
17121 }
17122
17123
17124 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
17125 PyObject *pyobj = 0;
17126
17127 {
17128 #if wxUSE_UNICODE
17129 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17130 #else
17131 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17132 #endif
17133 }
17134 return pyobj;
17135 }
17136
17137
17138 SWIGINTERN int IMAGE_OPTION_QUALITY_set(PyObject *) {
17139 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
17140 return 1;
17141 }
17142
17143
17144 SWIGINTERN PyObject *IMAGE_OPTION_QUALITY_get(void) {
17145 PyObject *pyobj = 0;
17146
17147 {
17148 #if wxUSE_UNICODE
17149 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17150 #else
17151 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17152 #endif
17153 }
17154 return pyobj;
17155 }
17156
17157
17158 SWIGINTERN int IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
17159 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
17160 return 1;
17161 }
17162
17163
17164 SWIGINTERN PyObject *IMAGE_OPTION_BITSPERSAMPLE_get(void) {
17165 PyObject *pyobj = 0;
17166
17167 {
17168 #if wxUSE_UNICODE
17169 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17170 #else
17171 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17172 #endif
17173 }
17174 return pyobj;
17175 }
17176
17177
17178 SWIGINTERN int IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
17179 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
17180 return 1;
17181 }
17182
17183
17184 SWIGINTERN PyObject *IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
17185 PyObject *pyobj = 0;
17186
17187 {
17188 #if wxUSE_UNICODE
17189 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17190 #else
17191 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17192 #endif
17193 }
17194 return pyobj;
17195 }
17196
17197
17198 SWIGINTERN int IMAGE_OPTION_COMPRESSION_set(PyObject *) {
17199 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
17200 return 1;
17201 }
17202
17203
17204 SWIGINTERN PyObject *IMAGE_OPTION_COMPRESSION_get(void) {
17205 PyObject *pyobj = 0;
17206
17207 {
17208 #if wxUSE_UNICODE
17209 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17210 #else
17211 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17212 #endif
17213 }
17214 return pyobj;
17215 }
17216
17217
17218 SWIGINTERN int IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
17219 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
17220 return 1;
17221 }
17222
17223
17224 SWIGINTERN PyObject *IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
17225 PyObject *pyobj = 0;
17226
17227 {
17228 #if wxUSE_UNICODE
17229 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17230 #else
17231 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17232 #endif
17233 }
17234 return pyobj;
17235 }
17236
17237
17238 SWIGINTERN int IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
17239 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
17240 return 1;
17241 }
17242
17243
17244 SWIGINTERN PyObject *IMAGE_OPTION_PNG_FORMAT_get(void) {
17245 PyObject *pyobj = 0;
17246
17247 {
17248 #if wxUSE_UNICODE
17249 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17250 #else
17251 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17252 #endif
17253 }
17254 return pyobj;
17255 }
17256
17257
17258 SWIGINTERN int IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
17259 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
17260 return 1;
17261 }
17262
17263
17264 SWIGINTERN PyObject *IMAGE_OPTION_PNG_BITDEPTH_get(void) {
17265 PyObject *pyobj = 0;
17266
17267 {
17268 #if wxUSE_UNICODE
17269 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17270 #else
17271 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17272 #endif
17273 }
17274 return pyobj;
17275 }
17276
17277
17278 SWIGINTERN PyObject *_wrap_new_BMPHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17279 PyObject *resultobj = 0;
17280 wxBMPHandler *result = 0 ;
17281
17282 if (!SWIG_Python_UnpackTuple(args,"new_BMPHandler",0,0,0)) SWIG_fail;
17283 {
17284 PyThreadState* __tstate = wxPyBeginAllowThreads();
17285 result = (wxBMPHandler *)new wxBMPHandler();
17286 wxPyEndAllowThreads(__tstate);
17287 if (PyErr_Occurred()) SWIG_fail;
17288 }
17289 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBMPHandler, SWIG_POINTER_NEW | 0 );
17290 return resultobj;
17291 fail:
17292 return NULL;
17293 }
17294
17295
17296 SWIGINTERN PyObject *BMPHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17297 PyObject *obj;
17298 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17299 SWIG_TypeNewClientData(SWIGTYPE_p_wxBMPHandler, SWIG_NewClientData(obj));
17300 return SWIG_Py_Void();
17301 }
17302
17303 SWIGINTERN PyObject *BMPHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17304 return SWIG_Python_InitShadowInstance(args);
17305 }
17306
17307 SWIGINTERN PyObject *_wrap_new_ICOHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17308 PyObject *resultobj = 0;
17309 wxICOHandler *result = 0 ;
17310
17311 if (!SWIG_Python_UnpackTuple(args,"new_ICOHandler",0,0,0)) SWIG_fail;
17312 {
17313 PyThreadState* __tstate = wxPyBeginAllowThreads();
17314 result = (wxICOHandler *)new wxICOHandler();
17315 wxPyEndAllowThreads(__tstate);
17316 if (PyErr_Occurred()) SWIG_fail;
17317 }
17318 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxICOHandler, SWIG_POINTER_NEW | 0 );
17319 return resultobj;
17320 fail:
17321 return NULL;
17322 }
17323
17324
17325 SWIGINTERN PyObject *ICOHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17326 PyObject *obj;
17327 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17328 SWIG_TypeNewClientData(SWIGTYPE_p_wxICOHandler, SWIG_NewClientData(obj));
17329 return SWIG_Py_Void();
17330 }
17331
17332 SWIGINTERN PyObject *ICOHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17333 return SWIG_Python_InitShadowInstance(args);
17334 }
17335
17336 SWIGINTERN PyObject *_wrap_new_CURHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17337 PyObject *resultobj = 0;
17338 wxCURHandler *result = 0 ;
17339
17340 if (!SWIG_Python_UnpackTuple(args,"new_CURHandler",0,0,0)) SWIG_fail;
17341 {
17342 PyThreadState* __tstate = wxPyBeginAllowThreads();
17343 result = (wxCURHandler *)new wxCURHandler();
17344 wxPyEndAllowThreads(__tstate);
17345 if (PyErr_Occurred()) SWIG_fail;
17346 }
17347 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCURHandler, SWIG_POINTER_NEW | 0 );
17348 return resultobj;
17349 fail:
17350 return NULL;
17351 }
17352
17353
17354 SWIGINTERN PyObject *CURHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17355 PyObject *obj;
17356 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17357 SWIG_TypeNewClientData(SWIGTYPE_p_wxCURHandler, SWIG_NewClientData(obj));
17358 return SWIG_Py_Void();
17359 }
17360
17361 SWIGINTERN PyObject *CURHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17362 return SWIG_Python_InitShadowInstance(args);
17363 }
17364
17365 SWIGINTERN PyObject *_wrap_new_ANIHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17366 PyObject *resultobj = 0;
17367 wxANIHandler *result = 0 ;
17368
17369 if (!SWIG_Python_UnpackTuple(args,"new_ANIHandler",0,0,0)) SWIG_fail;
17370 {
17371 PyThreadState* __tstate = wxPyBeginAllowThreads();
17372 result = (wxANIHandler *)new wxANIHandler();
17373 wxPyEndAllowThreads(__tstate);
17374 if (PyErr_Occurred()) SWIG_fail;
17375 }
17376 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxANIHandler, SWIG_POINTER_NEW | 0 );
17377 return resultobj;
17378 fail:
17379 return NULL;
17380 }
17381
17382
17383 SWIGINTERN PyObject *ANIHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17384 PyObject *obj;
17385 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17386 SWIG_TypeNewClientData(SWIGTYPE_p_wxANIHandler, SWIG_NewClientData(obj));
17387 return SWIG_Py_Void();
17388 }
17389
17390 SWIGINTERN PyObject *ANIHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17391 return SWIG_Python_InitShadowInstance(args);
17392 }
17393
17394 SWIGINTERN PyObject *_wrap_new_PNGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17395 PyObject *resultobj = 0;
17396 wxPNGHandler *result = 0 ;
17397
17398 if (!SWIG_Python_UnpackTuple(args,"new_PNGHandler",0,0,0)) SWIG_fail;
17399 {
17400 PyThreadState* __tstate = wxPyBeginAllowThreads();
17401 result = (wxPNGHandler *)new wxPNGHandler();
17402 wxPyEndAllowThreads(__tstate);
17403 if (PyErr_Occurred()) SWIG_fail;
17404 }
17405 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNGHandler, SWIG_POINTER_NEW | 0 );
17406 return resultobj;
17407 fail:
17408 return NULL;
17409 }
17410
17411
17412 SWIGINTERN PyObject *PNGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17413 PyObject *obj;
17414 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17415 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNGHandler, SWIG_NewClientData(obj));
17416 return SWIG_Py_Void();
17417 }
17418
17419 SWIGINTERN PyObject *PNGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17420 return SWIG_Python_InitShadowInstance(args);
17421 }
17422
17423 SWIGINTERN PyObject *_wrap_new_GIFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17424 PyObject *resultobj = 0;
17425 wxGIFHandler *result = 0 ;
17426
17427 if (!SWIG_Python_UnpackTuple(args,"new_GIFHandler",0,0,0)) SWIG_fail;
17428 {
17429 PyThreadState* __tstate = wxPyBeginAllowThreads();
17430 result = (wxGIFHandler *)new wxGIFHandler();
17431 wxPyEndAllowThreads(__tstate);
17432 if (PyErr_Occurred()) SWIG_fail;
17433 }
17434 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGIFHandler, SWIG_POINTER_NEW | 0 );
17435 return resultobj;
17436 fail:
17437 return NULL;
17438 }
17439
17440
17441 SWIGINTERN PyObject *GIFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17442 PyObject *obj;
17443 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17444 SWIG_TypeNewClientData(SWIGTYPE_p_wxGIFHandler, SWIG_NewClientData(obj));
17445 return SWIG_Py_Void();
17446 }
17447
17448 SWIGINTERN PyObject *GIFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17449 return SWIG_Python_InitShadowInstance(args);
17450 }
17451
17452 SWIGINTERN PyObject *_wrap_new_PCXHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17453 PyObject *resultobj = 0;
17454 wxPCXHandler *result = 0 ;
17455
17456 if (!SWIG_Python_UnpackTuple(args,"new_PCXHandler",0,0,0)) SWIG_fail;
17457 {
17458 PyThreadState* __tstate = wxPyBeginAllowThreads();
17459 result = (wxPCXHandler *)new wxPCXHandler();
17460 wxPyEndAllowThreads(__tstate);
17461 if (PyErr_Occurred()) SWIG_fail;
17462 }
17463 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPCXHandler, SWIG_POINTER_NEW | 0 );
17464 return resultobj;
17465 fail:
17466 return NULL;
17467 }
17468
17469
17470 SWIGINTERN PyObject *PCXHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17471 PyObject *obj;
17472 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17473 SWIG_TypeNewClientData(SWIGTYPE_p_wxPCXHandler, SWIG_NewClientData(obj));
17474 return SWIG_Py_Void();
17475 }
17476
17477 SWIGINTERN PyObject *PCXHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17478 return SWIG_Python_InitShadowInstance(args);
17479 }
17480
17481 SWIGINTERN PyObject *_wrap_new_JPEGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17482 PyObject *resultobj = 0;
17483 wxJPEGHandler *result = 0 ;
17484
17485 if (!SWIG_Python_UnpackTuple(args,"new_JPEGHandler",0,0,0)) SWIG_fail;
17486 {
17487 PyThreadState* __tstate = wxPyBeginAllowThreads();
17488 result = (wxJPEGHandler *)new wxJPEGHandler();
17489 wxPyEndAllowThreads(__tstate);
17490 if (PyErr_Occurred()) SWIG_fail;
17491 }
17492 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJPEGHandler, SWIG_POINTER_NEW | 0 );
17493 return resultobj;
17494 fail:
17495 return NULL;
17496 }
17497
17498
17499 SWIGINTERN PyObject *JPEGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17500 PyObject *obj;
17501 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17502 SWIG_TypeNewClientData(SWIGTYPE_p_wxJPEGHandler, SWIG_NewClientData(obj));
17503 return SWIG_Py_Void();
17504 }
17505
17506 SWIGINTERN PyObject *JPEGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17507 return SWIG_Python_InitShadowInstance(args);
17508 }
17509
17510 SWIGINTERN PyObject *_wrap_new_PNMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17511 PyObject *resultobj = 0;
17512 wxPNMHandler *result = 0 ;
17513
17514 if (!SWIG_Python_UnpackTuple(args,"new_PNMHandler",0,0,0)) SWIG_fail;
17515 {
17516 PyThreadState* __tstate = wxPyBeginAllowThreads();
17517 result = (wxPNMHandler *)new wxPNMHandler();
17518 wxPyEndAllowThreads(__tstate);
17519 if (PyErr_Occurred()) SWIG_fail;
17520 }
17521 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNMHandler, SWIG_POINTER_NEW | 0 );
17522 return resultobj;
17523 fail:
17524 return NULL;
17525 }
17526
17527
17528 SWIGINTERN PyObject *PNMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17529 PyObject *obj;
17530 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17531 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNMHandler, SWIG_NewClientData(obj));
17532 return SWIG_Py_Void();
17533 }
17534
17535 SWIGINTERN PyObject *PNMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17536 return SWIG_Python_InitShadowInstance(args);
17537 }
17538
17539 SWIGINTERN PyObject *_wrap_new_XPMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17540 PyObject *resultobj = 0;
17541 wxXPMHandler *result = 0 ;
17542
17543 if (!SWIG_Python_UnpackTuple(args,"new_XPMHandler",0,0,0)) SWIG_fail;
17544 {
17545 PyThreadState* __tstate = wxPyBeginAllowThreads();
17546 result = (wxXPMHandler *)new wxXPMHandler();
17547 wxPyEndAllowThreads(__tstate);
17548 if (PyErr_Occurred()) SWIG_fail;
17549 }
17550 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXPMHandler, SWIG_POINTER_NEW | 0 );
17551 return resultobj;
17552 fail:
17553 return NULL;
17554 }
17555
17556
17557 SWIGINTERN PyObject *XPMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17558 PyObject *obj;
17559 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17560 SWIG_TypeNewClientData(SWIGTYPE_p_wxXPMHandler, SWIG_NewClientData(obj));
17561 return SWIG_Py_Void();
17562 }
17563
17564 SWIGINTERN PyObject *XPMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17565 return SWIG_Python_InitShadowInstance(args);
17566 }
17567
17568 SWIGINTERN PyObject *_wrap_new_TIFFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17569 PyObject *resultobj = 0;
17570 wxTIFFHandler *result = 0 ;
17571
17572 if (!SWIG_Python_UnpackTuple(args,"new_TIFFHandler",0,0,0)) SWIG_fail;
17573 {
17574 PyThreadState* __tstate = wxPyBeginAllowThreads();
17575 result = (wxTIFFHandler *)new wxTIFFHandler();
17576 wxPyEndAllowThreads(__tstate);
17577 if (PyErr_Occurred()) SWIG_fail;
17578 }
17579 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTIFFHandler, SWIG_POINTER_NEW | 0 );
17580 return resultobj;
17581 fail:
17582 return NULL;
17583 }
17584
17585
17586 SWIGINTERN PyObject *TIFFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17587 PyObject *obj;
17588 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17589 SWIG_TypeNewClientData(SWIGTYPE_p_wxTIFFHandler, SWIG_NewClientData(obj));
17590 return SWIG_Py_Void();
17591 }
17592
17593 SWIGINTERN PyObject *TIFFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17594 return SWIG_Python_InitShadowInstance(args);
17595 }
17596
17597 SWIGINTERN PyObject *_wrap_Quantize_Quantize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17598 PyObject *resultobj = 0;
17599 wxImage *arg1 = 0 ;
17600 wxImage *arg2 = 0 ;
17601 int arg3 = (int) 236 ;
17602 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
17603 bool result;
17604 void *argp1 = 0 ;
17605 int res1 = 0 ;
17606 void *argp2 = 0 ;
17607 int res2 = 0 ;
17608 int val3 ;
17609 int ecode3 = 0 ;
17610 int val4 ;
17611 int ecode4 = 0 ;
17612 PyObject * obj0 = 0 ;
17613 PyObject * obj1 = 0 ;
17614 PyObject * obj2 = 0 ;
17615 PyObject * obj3 = 0 ;
17616 char * kwnames[] = {
17617 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
17618 };
17619
17620 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17621 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage, 0 | 0);
17622 if (!SWIG_IsOK(res1)) {
17623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17624 }
17625 if (!argp1) {
17626 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17627 }
17628 arg1 = reinterpret_cast< wxImage * >(argp1);
17629 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
17630 if (!SWIG_IsOK(res2)) {
17631 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17632 }
17633 if (!argp2) {
17634 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17635 }
17636 arg2 = reinterpret_cast< wxImage * >(argp2);
17637 if (obj2) {
17638 ecode3 = SWIG_AsVal_int(obj2, &val3);
17639 if (!SWIG_IsOK(ecode3)) {
17640 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Quantize_Quantize" "', expected argument " "3"" of type '" "int""'");
17641 }
17642 arg3 = static_cast< int >(val3);
17643 }
17644 if (obj3) {
17645 ecode4 = SWIG_AsVal_int(obj3, &val4);
17646 if (!SWIG_IsOK(ecode4)) {
17647 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Quantize_Quantize" "', expected argument " "4"" of type '" "int""'");
17648 }
17649 arg4 = static_cast< int >(val4);
17650 }
17651 {
17652 PyThreadState* __tstate = wxPyBeginAllowThreads();
17653 result = (bool)wxQuantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
17654 wxPyEndAllowThreads(__tstate);
17655 if (PyErr_Occurred()) SWIG_fail;
17656 }
17657 {
17658 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17659 }
17660 return resultobj;
17661 fail:
17662 return NULL;
17663 }
17664
17665
17666 SWIGINTERN PyObject *Quantize_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17667 PyObject *obj;
17668 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17669 SWIG_TypeNewClientData(SWIGTYPE_p_wxQuantize, SWIG_NewClientData(obj));
17670 return SWIG_Py_Void();
17671 }
17672
17673 SWIGINTERN PyObject *_wrap_new_EvtHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17674 PyObject *resultobj = 0;
17675 wxEvtHandler *result = 0 ;
17676
17677 if (!SWIG_Python_UnpackTuple(args,"new_EvtHandler",0,0,0)) SWIG_fail;
17678 {
17679 PyThreadState* __tstate = wxPyBeginAllowThreads();
17680 result = (wxEvtHandler *)new wxEvtHandler();
17681 wxPyEndAllowThreads(__tstate);
17682 if (PyErr_Occurred()) SWIG_fail;
17683 }
17684 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_NEW | 0 );
17685 return resultobj;
17686 fail:
17687 return NULL;
17688 }
17689
17690
17691 SWIGINTERN PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17692 PyObject *resultobj = 0;
17693 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17694 wxEvtHandler *result = 0 ;
17695 void *argp1 = 0 ;
17696 int res1 = 0 ;
17697 PyObject *swig_obj[1] ;
17698
17699 if (!args) SWIG_fail;
17700 swig_obj[0] = args;
17701 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17702 if (!SWIG_IsOK(res1)) {
17703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17704 }
17705 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17706 {
17707 PyThreadState* __tstate = wxPyBeginAllowThreads();
17708 result = (wxEvtHandler *)(arg1)->GetNextHandler();
17709 wxPyEndAllowThreads(__tstate);
17710 if (PyErr_Occurred()) SWIG_fail;
17711 }
17712 {
17713 resultobj = wxPyMake_wxObject(result, 0);
17714 }
17715 return resultobj;
17716 fail:
17717 return NULL;
17718 }
17719
17720
17721 SWIGINTERN PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17722 PyObject *resultobj = 0;
17723 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17724 wxEvtHandler *result = 0 ;
17725 void *argp1 = 0 ;
17726 int res1 = 0 ;
17727 PyObject *swig_obj[1] ;
17728
17729 if (!args) SWIG_fail;
17730 swig_obj[0] = args;
17731 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17732 if (!SWIG_IsOK(res1)) {
17733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17734 }
17735 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17736 {
17737 PyThreadState* __tstate = wxPyBeginAllowThreads();
17738 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
17739 wxPyEndAllowThreads(__tstate);
17740 if (PyErr_Occurred()) SWIG_fail;
17741 }
17742 {
17743 resultobj = wxPyMake_wxObject(result, 0);
17744 }
17745 return resultobj;
17746 fail:
17747 return NULL;
17748 }
17749
17750
17751 SWIGINTERN PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17752 PyObject *resultobj = 0;
17753 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17754 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
17755 void *argp1 = 0 ;
17756 int res1 = 0 ;
17757 void *argp2 = 0 ;
17758 int res2 = 0 ;
17759 PyObject * obj0 = 0 ;
17760 PyObject * obj1 = 0 ;
17761 char * kwnames[] = {
17762 (char *) "self",(char *) "handler", NULL
17763 };
17764
17765 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) SWIG_fail;
17766 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17767 if (!SWIG_IsOK(res1)) {
17768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17769 }
17770 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17771 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17772 if (!SWIG_IsOK(res2)) {
17773 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
17774 }
17775 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
17776 {
17777 PyThreadState* __tstate = wxPyBeginAllowThreads();
17778 (arg1)->SetNextHandler(arg2);
17779 wxPyEndAllowThreads(__tstate);
17780 if (PyErr_Occurred()) SWIG_fail;
17781 }
17782 resultobj = SWIG_Py_Void();
17783 return resultobj;
17784 fail:
17785 return NULL;
17786 }
17787
17788
17789 SWIGINTERN PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17790 PyObject *resultobj = 0;
17791 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17792 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
17793 void *argp1 = 0 ;
17794 int res1 = 0 ;
17795 void *argp2 = 0 ;
17796 int res2 = 0 ;
17797 PyObject * obj0 = 0 ;
17798 PyObject * obj1 = 0 ;
17799 char * kwnames[] = {
17800 (char *) "self",(char *) "handler", NULL
17801 };
17802
17803 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) SWIG_fail;
17804 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17805 if (!SWIG_IsOK(res1)) {
17806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17807 }
17808 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17809 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17810 if (!SWIG_IsOK(res2)) {
17811 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
17812 }
17813 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
17814 {
17815 PyThreadState* __tstate = wxPyBeginAllowThreads();
17816 (arg1)->SetPreviousHandler(arg2);
17817 wxPyEndAllowThreads(__tstate);
17818 if (PyErr_Occurred()) SWIG_fail;
17819 }
17820 resultobj = SWIG_Py_Void();
17821 return resultobj;
17822 fail:
17823 return NULL;
17824 }
17825
17826
17827 SWIGINTERN PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17828 PyObject *resultobj = 0;
17829 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17830 bool result;
17831 void *argp1 = 0 ;
17832 int res1 = 0 ;
17833 PyObject *swig_obj[1] ;
17834
17835 if (!args) SWIG_fail;
17836 swig_obj[0] = args;
17837 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17838 if (!SWIG_IsOK(res1)) {
17839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17840 }
17841 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17842 {
17843 PyThreadState* __tstate = wxPyBeginAllowThreads();
17844 result = (bool)(arg1)->GetEvtHandlerEnabled();
17845 wxPyEndAllowThreads(__tstate);
17846 if (PyErr_Occurred()) SWIG_fail;
17847 }
17848 {
17849 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17850 }
17851 return resultobj;
17852 fail:
17853 return NULL;
17854 }
17855
17856
17857 SWIGINTERN PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17858 PyObject *resultobj = 0;
17859 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17860 bool arg2 ;
17861 void *argp1 = 0 ;
17862 int res1 = 0 ;
17863 bool val2 ;
17864 int ecode2 = 0 ;
17865 PyObject * obj0 = 0 ;
17866 PyObject * obj1 = 0 ;
17867 char * kwnames[] = {
17868 (char *) "self",(char *) "enabled", NULL
17869 };
17870
17871 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
17872 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17873 if (!SWIG_IsOK(res1)) {
17874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17875 }
17876 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17877 ecode2 = SWIG_AsVal_bool(obj1, &val2);
17878 if (!SWIG_IsOK(ecode2)) {
17879 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "2"" of type '" "bool""'");
17880 }
17881 arg2 = static_cast< bool >(val2);
17882 {
17883 PyThreadState* __tstate = wxPyBeginAllowThreads();
17884 (arg1)->SetEvtHandlerEnabled(arg2);
17885 wxPyEndAllowThreads(__tstate);
17886 if (PyErr_Occurred()) SWIG_fail;
17887 }
17888 resultobj = SWIG_Py_Void();
17889 return resultobj;
17890 fail:
17891 return NULL;
17892 }
17893
17894
17895 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17896 PyObject *resultobj = 0;
17897 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17898 wxEvent *arg2 = 0 ;
17899 bool result;
17900 void *argp1 = 0 ;
17901 int res1 = 0 ;
17902 void *argp2 = 0 ;
17903 int res2 = 0 ;
17904 PyObject * obj0 = 0 ;
17905 PyObject * obj1 = 0 ;
17906 char * kwnames[] = {
17907 (char *) "self",(char *) "event", NULL
17908 };
17909
17910 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) SWIG_fail;
17911 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17912 if (!SWIG_IsOK(res1)) {
17913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17914 }
17915 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17916 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
17917 if (!SWIG_IsOK(res2)) {
17918 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17919 }
17920 if (!argp2) {
17921 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17922 }
17923 arg2 = reinterpret_cast< wxEvent * >(argp2);
17924 {
17925 PyThreadState* __tstate = wxPyBeginAllowThreads();
17926 result = (bool)(arg1)->ProcessEvent(*arg2);
17927 wxPyEndAllowThreads(__tstate);
17928 if (PyErr_Occurred()) SWIG_fail;
17929 }
17930 {
17931 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17932 }
17933 return resultobj;
17934 fail:
17935 return NULL;
17936 }
17937
17938
17939 SWIGINTERN PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17940 PyObject *resultobj = 0;
17941 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17942 wxEvent *arg2 = 0 ;
17943 void *argp1 = 0 ;
17944 int res1 = 0 ;
17945 void *argp2 = 0 ;
17946 int res2 = 0 ;
17947 PyObject * obj0 = 0 ;
17948 PyObject * obj1 = 0 ;
17949 char * kwnames[] = {
17950 (char *) "self",(char *) "event", NULL
17951 };
17952
17953 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) SWIG_fail;
17954 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17955 if (!SWIG_IsOK(res1)) {
17956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17957 }
17958 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17959 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
17960 if (!SWIG_IsOK(res2)) {
17961 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17962 }
17963 if (!argp2) {
17964 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17965 }
17966 arg2 = reinterpret_cast< wxEvent * >(argp2);
17967 {
17968 PyThreadState* __tstate = wxPyBeginAllowThreads();
17969 (arg1)->AddPendingEvent(*arg2);
17970 wxPyEndAllowThreads(__tstate);
17971 if (PyErr_Occurred()) SWIG_fail;
17972 }
17973 resultobj = SWIG_Py_Void();
17974 return resultobj;
17975 fail:
17976 return NULL;
17977 }
17978
17979
17980 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17981 PyObject *resultobj = 0;
17982 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17983 void *argp1 = 0 ;
17984 int res1 = 0 ;
17985 PyObject *swig_obj[1] ;
17986
17987 if (!args) SWIG_fail;
17988 swig_obj[0] = args;
17989 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17990 if (!SWIG_IsOK(res1)) {
17991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17992 }
17993 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17994 {
17995 PyThreadState* __tstate = wxPyBeginAllowThreads();
17996 (arg1)->ProcessPendingEvents();
17997 wxPyEndAllowThreads(__tstate);
17998 if (PyErr_Occurred()) SWIG_fail;
17999 }
18000 resultobj = SWIG_Py_Void();
18001 return resultobj;
18002 fail:
18003 return NULL;
18004 }
18005
18006
18007 SWIGINTERN PyObject *_wrap_EvtHandler_Connect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18008 PyObject *resultobj = 0;
18009 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18010 int arg2 ;
18011 int arg3 ;
18012 int arg4 ;
18013 PyObject *arg5 = (PyObject *) 0 ;
18014 void *argp1 = 0 ;
18015 int res1 = 0 ;
18016 int val2 ;
18017 int ecode2 = 0 ;
18018 int val3 ;
18019 int ecode3 = 0 ;
18020 int val4 ;
18021 int ecode4 = 0 ;
18022 PyObject * obj0 = 0 ;
18023 PyObject * obj1 = 0 ;
18024 PyObject * obj2 = 0 ;
18025 PyObject * obj3 = 0 ;
18026 PyObject * obj4 = 0 ;
18027 char * kwnames[] = {
18028 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
18029 };
18030
18031 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
18032 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18033 if (!SWIG_IsOK(res1)) {
18034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Connect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18035 }
18036 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18037 ecode2 = SWIG_AsVal_int(obj1, &val2);
18038 if (!SWIG_IsOK(ecode2)) {
18039 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Connect" "', expected argument " "2"" of type '" "int""'");
18040 }
18041 arg2 = static_cast< int >(val2);
18042 ecode3 = SWIG_AsVal_int(obj2, &val3);
18043 if (!SWIG_IsOK(ecode3)) {
18044 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Connect" "', expected argument " "3"" of type '" "int""'");
18045 }
18046 arg3 = static_cast< int >(val3);
18047 ecode4 = SWIG_AsVal_int(obj3, &val4);
18048 if (!SWIG_IsOK(ecode4)) {
18049 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Connect" "', expected argument " "4"" of type '" "int""'");
18050 }
18051 arg4 = static_cast< int >(val4);
18052 arg5 = obj4;
18053 {
18054 PyThreadState* __tstate = wxPyBeginAllowThreads();
18055 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
18056 wxPyEndAllowThreads(__tstate);
18057 if (PyErr_Occurred()) SWIG_fail;
18058 }
18059 resultobj = SWIG_Py_Void();
18060 return resultobj;
18061 fail:
18062 return NULL;
18063 }
18064
18065
18066 SWIGINTERN PyObject *_wrap_EvtHandler_Disconnect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18067 PyObject *resultobj = 0;
18068 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18069 int arg2 ;
18070 int arg3 = (int) -1 ;
18071 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
18072 bool result;
18073 void *argp1 = 0 ;
18074 int res1 = 0 ;
18075 int val2 ;
18076 int ecode2 = 0 ;
18077 int val3 ;
18078 int ecode3 = 0 ;
18079 int val4 ;
18080 int ecode4 = 0 ;
18081 PyObject * obj0 = 0 ;
18082 PyObject * obj1 = 0 ;
18083 PyObject * obj2 = 0 ;
18084 PyObject * obj3 = 0 ;
18085 char * kwnames[] = {
18086 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
18087 };
18088
18089 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18090 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18091 if (!SWIG_IsOK(res1)) {
18092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Disconnect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18093 }
18094 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18095 ecode2 = SWIG_AsVal_int(obj1, &val2);
18096 if (!SWIG_IsOK(ecode2)) {
18097 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Disconnect" "', expected argument " "2"" of type '" "int""'");
18098 }
18099 arg2 = static_cast< int >(val2);
18100 if (obj2) {
18101 ecode3 = SWIG_AsVal_int(obj2, &val3);
18102 if (!SWIG_IsOK(ecode3)) {
18103 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Disconnect" "', expected argument " "3"" of type '" "int""'");
18104 }
18105 arg3 = static_cast< int >(val3);
18106 }
18107 if (obj3) {
18108 ecode4 = SWIG_AsVal_int(obj3, &val4);
18109 if (!SWIG_IsOK(ecode4)) {
18110 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Disconnect" "', expected argument " "4"" of type '" "wxEventType""'");
18111 }
18112 arg4 = static_cast< wxEventType >(val4);
18113 }
18114 {
18115 PyThreadState* __tstate = wxPyBeginAllowThreads();
18116 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
18117 wxPyEndAllowThreads(__tstate);
18118 if (PyErr_Occurred()) SWIG_fail;
18119 }
18120 {
18121 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18122 }
18123 return resultobj;
18124 fail:
18125 return NULL;
18126 }
18127
18128
18129 SWIGINTERN PyObject *_wrap_EvtHandler__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18130 PyObject *resultobj = 0;
18131 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18132 PyObject *arg2 = (PyObject *) 0 ;
18133 bool arg3 = (bool) true ;
18134 void *argp1 = 0 ;
18135 int res1 = 0 ;
18136 bool val3 ;
18137 int ecode3 = 0 ;
18138 PyObject * obj0 = 0 ;
18139 PyObject * obj1 = 0 ;
18140 PyObject * obj2 = 0 ;
18141 char * kwnames[] = {
18142 (char *) "self",(char *) "_self",(char *) "incref", NULL
18143 };
18144
18145 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18146 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18147 if (!SWIG_IsOK(res1)) {
18148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler__setOORInfo" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18149 }
18150 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18151 arg2 = obj1;
18152 if (obj2) {
18153 ecode3 = SWIG_AsVal_bool(obj2, &val3);
18154 if (!SWIG_IsOK(ecode3)) {
18155 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler__setOORInfo" "', expected argument " "3"" of type '" "bool""'");
18156 }
18157 arg3 = static_cast< bool >(val3);
18158 }
18159 {
18160 PyThreadState* __tstate = wxPyBeginAllowThreads();
18161 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
18162 wxPyEndAllowThreads(__tstate);
18163 if (PyErr_Occurred()) SWIG_fail;
18164 }
18165 resultobj = SWIG_Py_Void();
18166 return resultobj;
18167 fail:
18168 return NULL;
18169 }
18170
18171
18172 SWIGINTERN PyObject *EvtHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18173 PyObject *obj;
18174 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18175 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvtHandler, SWIG_NewClientData(obj));
18176 return SWIG_Py_Void();
18177 }
18178
18179 SWIGINTERN PyObject *EvtHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18180 return SWIG_Python_InitShadowInstance(args);
18181 }
18182
18183 SWIGINTERN PyObject *_wrap_NewEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18184 PyObject *resultobj = 0;
18185 wxEventType result;
18186
18187 if (!SWIG_Python_UnpackTuple(args,"NewEventType",0,0,0)) SWIG_fail;
18188 {
18189 PyThreadState* __tstate = wxPyBeginAllowThreads();
18190 result = (wxEventType)wxNewEventType();
18191 wxPyEndAllowThreads(__tstate);
18192 if (PyErr_Occurred()) SWIG_fail;
18193 }
18194 resultobj = SWIG_From_int(static_cast< int >(result));
18195 return resultobj;
18196 fail:
18197 return NULL;
18198 }
18199
18200
18201 SWIGINTERN PyObject *_wrap_delete_Event(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18202 PyObject *resultobj = 0;
18203 wxEvent *arg1 = (wxEvent *) 0 ;
18204 void *argp1 = 0 ;
18205 int res1 = 0 ;
18206 PyObject *swig_obj[1] ;
18207
18208 if (!args) SWIG_fail;
18209 swig_obj[0] = args;
18210 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, SWIG_POINTER_DISOWN | 0 );
18211 if (!SWIG_IsOK(res1)) {
18212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Event" "', expected argument " "1"" of type '" "wxEvent *""'");
18213 }
18214 arg1 = reinterpret_cast< wxEvent * >(argp1);
18215 {
18216 PyThreadState* __tstate = wxPyBeginAllowThreads();
18217 delete arg1;
18218
18219 wxPyEndAllowThreads(__tstate);
18220 if (PyErr_Occurred()) SWIG_fail;
18221 }
18222 resultobj = SWIG_Py_Void();
18223 return resultobj;
18224 fail:
18225 return NULL;
18226 }
18227
18228
18229 SWIGINTERN PyObject *_wrap_Event_SetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18230 PyObject *resultobj = 0;
18231 wxEvent *arg1 = (wxEvent *) 0 ;
18232 wxEventType arg2 ;
18233 void *argp1 = 0 ;
18234 int res1 = 0 ;
18235 int val2 ;
18236 int ecode2 = 0 ;
18237 PyObject * obj0 = 0 ;
18238 PyObject * obj1 = 0 ;
18239 char * kwnames[] = {
18240 (char *) "self",(char *) "typ", NULL
18241 };
18242
18243 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) SWIG_fail;
18244 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18245 if (!SWIG_IsOK(res1)) {
18246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventType" "', expected argument " "1"" of type '" "wxEvent *""'");
18247 }
18248 arg1 = reinterpret_cast< wxEvent * >(argp1);
18249 ecode2 = SWIG_AsVal_int(obj1, &val2);
18250 if (!SWIG_IsOK(ecode2)) {
18251 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetEventType" "', expected argument " "2"" of type '" "wxEventType""'");
18252 }
18253 arg2 = static_cast< wxEventType >(val2);
18254 {
18255 PyThreadState* __tstate = wxPyBeginAllowThreads();
18256 (arg1)->SetEventType(arg2);
18257 wxPyEndAllowThreads(__tstate);
18258 if (PyErr_Occurred()) SWIG_fail;
18259 }
18260 resultobj = SWIG_Py_Void();
18261 return resultobj;
18262 fail:
18263 return NULL;
18264 }
18265
18266
18267 SWIGINTERN PyObject *_wrap_Event_GetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18268 PyObject *resultobj = 0;
18269 wxEvent *arg1 = (wxEvent *) 0 ;
18270 wxEventType result;
18271 void *argp1 = 0 ;
18272 int res1 = 0 ;
18273 PyObject *swig_obj[1] ;
18274
18275 if (!args) SWIG_fail;
18276 swig_obj[0] = args;
18277 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18278 if (!SWIG_IsOK(res1)) {
18279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventType" "', expected argument " "1"" of type '" "wxEvent const *""'");
18280 }
18281 arg1 = reinterpret_cast< wxEvent * >(argp1);
18282 {
18283 PyThreadState* __tstate = wxPyBeginAllowThreads();
18284 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
18285 wxPyEndAllowThreads(__tstate);
18286 if (PyErr_Occurred()) SWIG_fail;
18287 }
18288 resultobj = SWIG_From_int(static_cast< int >(result));
18289 return resultobj;
18290 fail:
18291 return NULL;
18292 }
18293
18294
18295 SWIGINTERN PyObject *_wrap_Event_GetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18296 PyObject *resultobj = 0;
18297 wxEvent *arg1 = (wxEvent *) 0 ;
18298 wxObject *result = 0 ;
18299 void *argp1 = 0 ;
18300 int res1 = 0 ;
18301 PyObject *swig_obj[1] ;
18302
18303 if (!args) SWIG_fail;
18304 swig_obj[0] = args;
18305 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18306 if (!SWIG_IsOK(res1)) {
18307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventObject" "', expected argument " "1"" of type '" "wxEvent const *""'");
18308 }
18309 arg1 = reinterpret_cast< wxEvent * >(argp1);
18310 {
18311 PyThreadState* __tstate = wxPyBeginAllowThreads();
18312 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
18313 wxPyEndAllowThreads(__tstate);
18314 if (PyErr_Occurred()) SWIG_fail;
18315 }
18316 {
18317 resultobj = wxPyMake_wxObject(result, (bool)0);
18318 }
18319 return resultobj;
18320 fail:
18321 return NULL;
18322 }
18323
18324
18325 SWIGINTERN PyObject *_wrap_Event_SetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18326 PyObject *resultobj = 0;
18327 wxEvent *arg1 = (wxEvent *) 0 ;
18328 wxObject *arg2 = (wxObject *) 0 ;
18329 void *argp1 = 0 ;
18330 int res1 = 0 ;
18331 void *argp2 = 0 ;
18332 int res2 = 0 ;
18333 PyObject * obj0 = 0 ;
18334 PyObject * obj1 = 0 ;
18335 char * kwnames[] = {
18336 (char *) "self",(char *) "obj", NULL
18337 };
18338
18339 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) SWIG_fail;
18340 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18341 if (!SWIG_IsOK(res1)) {
18342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventObject" "', expected argument " "1"" of type '" "wxEvent *""'");
18343 }
18344 arg1 = reinterpret_cast< wxEvent * >(argp1);
18345 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxObject, 0 | 0 );
18346 if (!SWIG_IsOK(res2)) {
18347 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_SetEventObject" "', expected argument " "2"" of type '" "wxObject *""'");
18348 }
18349 arg2 = reinterpret_cast< wxObject * >(argp2);
18350 {
18351 PyThreadState* __tstate = wxPyBeginAllowThreads();
18352 (arg1)->SetEventObject(arg2);
18353 wxPyEndAllowThreads(__tstate);
18354 if (PyErr_Occurred()) SWIG_fail;
18355 }
18356 resultobj = SWIG_Py_Void();
18357 return resultobj;
18358 fail:
18359 return NULL;
18360 }
18361
18362
18363 SWIGINTERN PyObject *_wrap_Event_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18364 PyObject *resultobj = 0;
18365 wxEvent *arg1 = (wxEvent *) 0 ;
18366 long result;
18367 void *argp1 = 0 ;
18368 int res1 = 0 ;
18369 PyObject *swig_obj[1] ;
18370
18371 if (!args) SWIG_fail;
18372 swig_obj[0] = args;
18373 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18374 if (!SWIG_IsOK(res1)) {
18375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetTimestamp" "', expected argument " "1"" of type '" "wxEvent const *""'");
18376 }
18377 arg1 = reinterpret_cast< wxEvent * >(argp1);
18378 {
18379 PyThreadState* __tstate = wxPyBeginAllowThreads();
18380 result = (long)((wxEvent const *)arg1)->GetTimestamp();
18381 wxPyEndAllowThreads(__tstate);
18382 if (PyErr_Occurred()) SWIG_fail;
18383 }
18384 resultobj = SWIG_From_long(static_cast< long >(result));
18385 return resultobj;
18386 fail:
18387 return NULL;
18388 }
18389
18390
18391 SWIGINTERN PyObject *_wrap_Event_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18392 PyObject *resultobj = 0;
18393 wxEvent *arg1 = (wxEvent *) 0 ;
18394 long arg2 = (long) 0 ;
18395 void *argp1 = 0 ;
18396 int res1 = 0 ;
18397 long val2 ;
18398 int ecode2 = 0 ;
18399 PyObject * obj0 = 0 ;
18400 PyObject * obj1 = 0 ;
18401 char * kwnames[] = {
18402 (char *) "self",(char *) "ts", NULL
18403 };
18404
18405 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) SWIG_fail;
18406 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18407 if (!SWIG_IsOK(res1)) {
18408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetTimestamp" "', expected argument " "1"" of type '" "wxEvent *""'");
18409 }
18410 arg1 = reinterpret_cast< wxEvent * >(argp1);
18411 if (obj1) {
18412 ecode2 = SWIG_AsVal_long(obj1, &val2);
18413 if (!SWIG_IsOK(ecode2)) {
18414 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetTimestamp" "', expected argument " "2"" of type '" "long""'");
18415 }
18416 arg2 = static_cast< long >(val2);
18417 }
18418 {
18419 PyThreadState* __tstate = wxPyBeginAllowThreads();
18420 (arg1)->SetTimestamp(arg2);
18421 wxPyEndAllowThreads(__tstate);
18422 if (PyErr_Occurred()) SWIG_fail;
18423 }
18424 resultobj = SWIG_Py_Void();
18425 return resultobj;
18426 fail:
18427 return NULL;
18428 }
18429
18430
18431 SWIGINTERN PyObject *_wrap_Event_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18432 PyObject *resultobj = 0;
18433 wxEvent *arg1 = (wxEvent *) 0 ;
18434 int result;
18435 void *argp1 = 0 ;
18436 int res1 = 0 ;
18437 PyObject *swig_obj[1] ;
18438
18439 if (!args) SWIG_fail;
18440 swig_obj[0] = args;
18441 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18442 if (!SWIG_IsOK(res1)) {
18443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetId" "', expected argument " "1"" of type '" "wxEvent const *""'");
18444 }
18445 arg1 = reinterpret_cast< wxEvent * >(argp1);
18446 {
18447 PyThreadState* __tstate = wxPyBeginAllowThreads();
18448 result = (int)((wxEvent const *)arg1)->GetId();
18449 wxPyEndAllowThreads(__tstate);
18450 if (PyErr_Occurred()) SWIG_fail;
18451 }
18452 resultobj = SWIG_From_int(static_cast< int >(result));
18453 return resultobj;
18454 fail:
18455 return NULL;
18456 }
18457
18458
18459 SWIGINTERN PyObject *_wrap_Event_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18460 PyObject *resultobj = 0;
18461 wxEvent *arg1 = (wxEvent *) 0 ;
18462 int arg2 ;
18463 void *argp1 = 0 ;
18464 int res1 = 0 ;
18465 int val2 ;
18466 int ecode2 = 0 ;
18467 PyObject * obj0 = 0 ;
18468 PyObject * obj1 = 0 ;
18469 char * kwnames[] = {
18470 (char *) "self",(char *) "Id", NULL
18471 };
18472
18473 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
18474 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18475 if (!SWIG_IsOK(res1)) {
18476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetId" "', expected argument " "1"" of type '" "wxEvent *""'");
18477 }
18478 arg1 = reinterpret_cast< wxEvent * >(argp1);
18479 ecode2 = SWIG_AsVal_int(obj1, &val2);
18480 if (!SWIG_IsOK(ecode2)) {
18481 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetId" "', expected argument " "2"" of type '" "int""'");
18482 }
18483 arg2 = static_cast< int >(val2);
18484 {
18485 PyThreadState* __tstate = wxPyBeginAllowThreads();
18486 (arg1)->SetId(arg2);
18487 wxPyEndAllowThreads(__tstate);
18488 if (PyErr_Occurred()) SWIG_fail;
18489 }
18490 resultobj = SWIG_Py_Void();
18491 return resultobj;
18492 fail:
18493 return NULL;
18494 }
18495
18496
18497 SWIGINTERN PyObject *_wrap_Event_IsCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18498 PyObject *resultobj = 0;
18499 wxEvent *arg1 = (wxEvent *) 0 ;
18500 bool result;
18501 void *argp1 = 0 ;
18502 int res1 = 0 ;
18503 PyObject *swig_obj[1] ;
18504
18505 if (!args) SWIG_fail;
18506 swig_obj[0] = args;
18507 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18508 if (!SWIG_IsOK(res1)) {
18509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_IsCommandEvent" "', expected argument " "1"" of type '" "wxEvent const *""'");
18510 }
18511 arg1 = reinterpret_cast< wxEvent * >(argp1);
18512 {
18513 PyThreadState* __tstate = wxPyBeginAllowThreads();
18514 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
18515 wxPyEndAllowThreads(__tstate);
18516 if (PyErr_Occurred()) SWIG_fail;
18517 }
18518 {
18519 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18520 }
18521 return resultobj;
18522 fail:
18523 return NULL;
18524 }
18525
18526
18527 SWIGINTERN PyObject *_wrap_Event_Skip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18528 PyObject *resultobj = 0;
18529 wxEvent *arg1 = (wxEvent *) 0 ;
18530 bool arg2 = (bool) true ;
18531 void *argp1 = 0 ;
18532 int res1 = 0 ;
18533 bool val2 ;
18534 int ecode2 = 0 ;
18535 PyObject * obj0 = 0 ;
18536 PyObject * obj1 = 0 ;
18537 char * kwnames[] = {
18538 (char *) "self",(char *) "skip", NULL
18539 };
18540
18541 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) SWIG_fail;
18542 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18543 if (!SWIG_IsOK(res1)) {
18544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Skip" "', expected argument " "1"" of type '" "wxEvent *""'");
18545 }
18546 arg1 = reinterpret_cast< wxEvent * >(argp1);
18547 if (obj1) {
18548 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18549 if (!SWIG_IsOK(ecode2)) {
18550 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_Skip" "', expected argument " "2"" of type '" "bool""'");
18551 }
18552 arg2 = static_cast< bool >(val2);
18553 }
18554 {
18555 PyThreadState* __tstate = wxPyBeginAllowThreads();
18556 (arg1)->Skip(arg2);
18557 wxPyEndAllowThreads(__tstate);
18558 if (PyErr_Occurred()) SWIG_fail;
18559 }
18560 resultobj = SWIG_Py_Void();
18561 return resultobj;
18562 fail:
18563 return NULL;
18564 }
18565
18566
18567 SWIGINTERN PyObject *_wrap_Event_GetSkipped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18568 PyObject *resultobj = 0;
18569 wxEvent *arg1 = (wxEvent *) 0 ;
18570 bool result;
18571 void *argp1 = 0 ;
18572 int res1 = 0 ;
18573 PyObject *swig_obj[1] ;
18574
18575 if (!args) SWIG_fail;
18576 swig_obj[0] = args;
18577 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18578 if (!SWIG_IsOK(res1)) {
18579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetSkipped" "', expected argument " "1"" of type '" "wxEvent const *""'");
18580 }
18581 arg1 = reinterpret_cast< wxEvent * >(argp1);
18582 {
18583 PyThreadState* __tstate = wxPyBeginAllowThreads();
18584 result = (bool)((wxEvent const *)arg1)->GetSkipped();
18585 wxPyEndAllowThreads(__tstate);
18586 if (PyErr_Occurred()) SWIG_fail;
18587 }
18588 {
18589 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18590 }
18591 return resultobj;
18592 fail:
18593 return NULL;
18594 }
18595
18596
18597 SWIGINTERN PyObject *_wrap_Event_ShouldPropagate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18598 PyObject *resultobj = 0;
18599 wxEvent *arg1 = (wxEvent *) 0 ;
18600 bool result;
18601 void *argp1 = 0 ;
18602 int res1 = 0 ;
18603 PyObject *swig_obj[1] ;
18604
18605 if (!args) SWIG_fail;
18606 swig_obj[0] = args;
18607 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18608 if (!SWIG_IsOK(res1)) {
18609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ShouldPropagate" "', expected argument " "1"" of type '" "wxEvent const *""'");
18610 }
18611 arg1 = reinterpret_cast< wxEvent * >(argp1);
18612 {
18613 PyThreadState* __tstate = wxPyBeginAllowThreads();
18614 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
18615 wxPyEndAllowThreads(__tstate);
18616 if (PyErr_Occurred()) SWIG_fail;
18617 }
18618 {
18619 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18620 }
18621 return resultobj;
18622 fail:
18623 return NULL;
18624 }
18625
18626
18627 SWIGINTERN PyObject *_wrap_Event_StopPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18628 PyObject *resultobj = 0;
18629 wxEvent *arg1 = (wxEvent *) 0 ;
18630 int result;
18631 void *argp1 = 0 ;
18632 int res1 = 0 ;
18633 PyObject *swig_obj[1] ;
18634
18635 if (!args) SWIG_fail;
18636 swig_obj[0] = args;
18637 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18638 if (!SWIG_IsOK(res1)) {
18639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_StopPropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18640 }
18641 arg1 = reinterpret_cast< wxEvent * >(argp1);
18642 {
18643 PyThreadState* __tstate = wxPyBeginAllowThreads();
18644 result = (int)(arg1)->StopPropagation();
18645 wxPyEndAllowThreads(__tstate);
18646 if (PyErr_Occurred()) SWIG_fail;
18647 }
18648 resultobj = SWIG_From_int(static_cast< int >(result));
18649 return resultobj;
18650 fail:
18651 return NULL;
18652 }
18653
18654
18655 SWIGINTERN PyObject *_wrap_Event_ResumePropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18656 PyObject *resultobj = 0;
18657 wxEvent *arg1 = (wxEvent *) 0 ;
18658 int arg2 ;
18659 void *argp1 = 0 ;
18660 int res1 = 0 ;
18661 int val2 ;
18662 int ecode2 = 0 ;
18663 PyObject * obj0 = 0 ;
18664 PyObject * obj1 = 0 ;
18665 char * kwnames[] = {
18666 (char *) "self",(char *) "propagationLevel", NULL
18667 };
18668
18669 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) SWIG_fail;
18670 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18671 if (!SWIG_IsOK(res1)) {
18672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ResumePropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18673 }
18674 arg1 = reinterpret_cast< wxEvent * >(argp1);
18675 ecode2 = SWIG_AsVal_int(obj1, &val2);
18676 if (!SWIG_IsOK(ecode2)) {
18677 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_ResumePropagation" "', expected argument " "2"" of type '" "int""'");
18678 }
18679 arg2 = static_cast< int >(val2);
18680 {
18681 PyThreadState* __tstate = wxPyBeginAllowThreads();
18682 (arg1)->ResumePropagation(arg2);
18683 wxPyEndAllowThreads(__tstate);
18684 if (PyErr_Occurred()) SWIG_fail;
18685 }
18686 resultobj = SWIG_Py_Void();
18687 return resultobj;
18688 fail:
18689 return NULL;
18690 }
18691
18692
18693 SWIGINTERN PyObject *_wrap_Event_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18694 PyObject *resultobj = 0;
18695 wxEvent *arg1 = (wxEvent *) 0 ;
18696 wxEvent *result = 0 ;
18697 void *argp1 = 0 ;
18698 int res1 = 0 ;
18699 PyObject *swig_obj[1] ;
18700
18701 if (!args) SWIG_fail;
18702 swig_obj[0] = args;
18703 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18704 if (!SWIG_IsOK(res1)) {
18705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Clone" "', expected argument " "1"" of type '" "wxEvent *""'");
18706 }
18707 arg1 = reinterpret_cast< wxEvent * >(argp1);
18708 {
18709 PyThreadState* __tstate = wxPyBeginAllowThreads();
18710 result = (wxEvent *)(arg1)->Clone();
18711 wxPyEndAllowThreads(__tstate);
18712 if (PyErr_Occurred()) SWIG_fail;
18713 }
18714 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
18715 return resultobj;
18716 fail:
18717 return NULL;
18718 }
18719
18720
18721 SWIGINTERN PyObject *Event_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18722 PyObject *obj;
18723 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18724 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvent, SWIG_NewClientData(obj));
18725 return SWIG_Py_Void();
18726 }
18727
18728 SWIGINTERN PyObject *_wrap_new_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18729 PyObject *resultobj = 0;
18730 wxEvent *arg1 = 0 ;
18731 wxPropagationDisabler *result = 0 ;
18732 void *argp1 = 0 ;
18733 int res1 = 0 ;
18734 PyObject * obj0 = 0 ;
18735 char * kwnames[] = {
18736 (char *) "event", NULL
18737 };
18738
18739 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) SWIG_fail;
18740 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
18741 if (!SWIG_IsOK(res1)) {
18742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
18743 }
18744 if (!argp1) {
18745 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
18746 }
18747 arg1 = reinterpret_cast< wxEvent * >(argp1);
18748 {
18749 PyThreadState* __tstate = wxPyBeginAllowThreads();
18750 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
18751 wxPyEndAllowThreads(__tstate);
18752 if (PyErr_Occurred()) SWIG_fail;
18753 }
18754 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_NEW | 0 );
18755 return resultobj;
18756 fail:
18757 return NULL;
18758 }
18759
18760
18761 SWIGINTERN PyObject *_wrap_delete_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18762 PyObject *resultobj = 0;
18763 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
18764 void *argp1 = 0 ;
18765 int res1 = 0 ;
18766 PyObject *swig_obj[1] ;
18767
18768 if (!args) SWIG_fail;
18769 swig_obj[0] = args;
18770 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_DISOWN | 0 );
18771 if (!SWIG_IsOK(res1)) {
18772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagationDisabler" "', expected argument " "1"" of type '" "wxPropagationDisabler *""'");
18773 }
18774 arg1 = reinterpret_cast< wxPropagationDisabler * >(argp1);
18775 {
18776 PyThreadState* __tstate = wxPyBeginAllowThreads();
18777 delete arg1;
18778
18779 wxPyEndAllowThreads(__tstate);
18780 if (PyErr_Occurred()) SWIG_fail;
18781 }
18782 resultobj = SWIG_Py_Void();
18783 return resultobj;
18784 fail:
18785 return NULL;
18786 }
18787
18788
18789 SWIGINTERN PyObject *PropagationDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18790 PyObject *obj;
18791 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18792 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagationDisabler, SWIG_NewClientData(obj));
18793 return SWIG_Py_Void();
18794 }
18795
18796 SWIGINTERN PyObject *PropagationDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18797 return SWIG_Python_InitShadowInstance(args);
18798 }
18799
18800 SWIGINTERN PyObject *_wrap_new_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18801 PyObject *resultobj = 0;
18802 wxEvent *arg1 = 0 ;
18803 wxPropagateOnce *result = 0 ;
18804 void *argp1 = 0 ;
18805 int res1 = 0 ;
18806 PyObject * obj0 = 0 ;
18807 char * kwnames[] = {
18808 (char *) "event", NULL
18809 };
18810
18811 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) SWIG_fail;
18812 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
18813 if (!SWIG_IsOK(res1)) {
18814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
18815 }
18816 if (!argp1) {
18817 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
18818 }
18819 arg1 = reinterpret_cast< wxEvent * >(argp1);
18820 {
18821 PyThreadState* __tstate = wxPyBeginAllowThreads();
18822 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
18823 wxPyEndAllowThreads(__tstate);
18824 if (PyErr_Occurred()) SWIG_fail;
18825 }
18826 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_NEW | 0 );
18827 return resultobj;
18828 fail:
18829 return NULL;
18830 }
18831
18832
18833 SWIGINTERN PyObject *_wrap_delete_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18834 PyObject *resultobj = 0;
18835 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
18836 void *argp1 = 0 ;
18837 int res1 = 0 ;
18838 PyObject *swig_obj[1] ;
18839
18840 if (!args) SWIG_fail;
18841 swig_obj[0] = args;
18842 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_DISOWN | 0 );
18843 if (!SWIG_IsOK(res1)) {
18844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagateOnce" "', expected argument " "1"" of type '" "wxPropagateOnce *""'");
18845 }
18846 arg1 = reinterpret_cast< wxPropagateOnce * >(argp1);
18847 {
18848 PyThreadState* __tstate = wxPyBeginAllowThreads();
18849 delete arg1;
18850
18851 wxPyEndAllowThreads(__tstate);
18852 if (PyErr_Occurred()) SWIG_fail;
18853 }
18854 resultobj = SWIG_Py_Void();
18855 return resultobj;
18856 fail:
18857 return NULL;
18858 }
18859
18860
18861 SWIGINTERN PyObject *PropagateOnce_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18862 PyObject *obj;
18863 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18864 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagateOnce, SWIG_NewClientData(obj));
18865 return SWIG_Py_Void();
18866 }
18867
18868 SWIGINTERN PyObject *PropagateOnce_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18869 return SWIG_Python_InitShadowInstance(args);
18870 }
18871
18872 SWIGINTERN PyObject *_wrap_new_CommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18873 PyObject *resultobj = 0;
18874 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
18875 int arg2 = (int) 0 ;
18876 wxCommandEvent *result = 0 ;
18877 int val1 ;
18878 int ecode1 = 0 ;
18879 int val2 ;
18880 int ecode2 = 0 ;
18881 PyObject * obj0 = 0 ;
18882 PyObject * obj1 = 0 ;
18883 char * kwnames[] = {
18884 (char *) "commandType",(char *) "winid", NULL
18885 };
18886
18887 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
18888 if (obj0) {
18889 ecode1 = SWIG_AsVal_int(obj0, &val1);
18890 if (!SWIG_IsOK(ecode1)) {
18891 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
18892 }
18893 arg1 = static_cast< wxEventType >(val1);
18894 }
18895 if (obj1) {
18896 ecode2 = SWIG_AsVal_int(obj1, &val2);
18897 if (!SWIG_IsOK(ecode2)) {
18898 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CommandEvent" "', expected argument " "2"" of type '" "int""'");
18899 }
18900 arg2 = static_cast< int >(val2);
18901 }
18902 {
18903 PyThreadState* __tstate = wxPyBeginAllowThreads();
18904 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
18905 wxPyEndAllowThreads(__tstate);
18906 if (PyErr_Occurred()) SWIG_fail;
18907 }
18908 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_NEW | 0 );
18909 return resultobj;
18910 fail:
18911 return NULL;
18912 }
18913
18914
18915 SWIGINTERN PyObject *_wrap_CommandEvent_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18916 PyObject *resultobj = 0;
18917 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18918 int result;
18919 void *argp1 = 0 ;
18920 int res1 = 0 ;
18921 PyObject *swig_obj[1] ;
18922
18923 if (!args) SWIG_fail;
18924 swig_obj[0] = args;
18925 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18926 if (!SWIG_IsOK(res1)) {
18927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18928 }
18929 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18930 {
18931 PyThreadState* __tstate = wxPyBeginAllowThreads();
18932 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
18933 wxPyEndAllowThreads(__tstate);
18934 if (PyErr_Occurred()) SWIG_fail;
18935 }
18936 resultobj = SWIG_From_int(static_cast< int >(result));
18937 return resultobj;
18938 fail:
18939 return NULL;
18940 }
18941
18942
18943 SWIGINTERN PyObject *_wrap_CommandEvent_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18944 PyObject *resultobj = 0;
18945 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18946 wxString *arg2 = 0 ;
18947 void *argp1 = 0 ;
18948 int res1 = 0 ;
18949 bool temp2 = false ;
18950 PyObject * obj0 = 0 ;
18951 PyObject * obj1 = 0 ;
18952 char * kwnames[] = {
18953 (char *) "self",(char *) "s", NULL
18954 };
18955
18956 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) SWIG_fail;
18957 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18958 if (!SWIG_IsOK(res1)) {
18959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetString" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
18960 }
18961 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18962 {
18963 arg2 = wxString_in_helper(obj1);
18964 if (arg2 == NULL) SWIG_fail;
18965 temp2 = true;
18966 }
18967 {
18968 PyThreadState* __tstate = wxPyBeginAllowThreads();
18969 (arg1)->SetString((wxString const &)*arg2);
18970 wxPyEndAllowThreads(__tstate);
18971 if (PyErr_Occurred()) SWIG_fail;
18972 }
18973 resultobj = SWIG_Py_Void();
18974 {
18975 if (temp2)
18976 delete arg2;
18977 }
18978 return resultobj;
18979 fail:
18980 {
18981 if (temp2)
18982 delete arg2;
18983 }
18984 return NULL;
18985 }
18986
18987
18988 SWIGINTERN PyObject *_wrap_CommandEvent_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18989 PyObject *resultobj = 0;
18990 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18991 wxString result;
18992 void *argp1 = 0 ;
18993 int res1 = 0 ;
18994 PyObject *swig_obj[1] ;
18995
18996 if (!args) SWIG_fail;
18997 swig_obj[0] = args;
18998 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18999 if (!SWIG_IsOK(res1)) {
19000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetString" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19001 }
19002 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19003 {
19004 PyThreadState* __tstate = wxPyBeginAllowThreads();
19005 result = ((wxCommandEvent const *)arg1)->GetString();
19006 wxPyEndAllowThreads(__tstate);
19007 if (PyErr_Occurred()) SWIG_fail;
19008 }
19009 {
19010 #if wxUSE_UNICODE
19011 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19012 #else
19013 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19014 #endif
19015 }
19016 return resultobj;
19017 fail:
19018 return NULL;
19019 }
19020
19021
19022 SWIGINTERN PyObject *_wrap_CommandEvent_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19023 PyObject *resultobj = 0;
19024 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19025 bool result;
19026 void *argp1 = 0 ;
19027 int res1 = 0 ;
19028 PyObject *swig_obj[1] ;
19029
19030 if (!args) SWIG_fail;
19031 swig_obj[0] = args;
19032 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19033 if (!SWIG_IsOK(res1)) {
19034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsChecked" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19035 }
19036 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19037 {
19038 PyThreadState* __tstate = wxPyBeginAllowThreads();
19039 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
19040 wxPyEndAllowThreads(__tstate);
19041 if (PyErr_Occurred()) SWIG_fail;
19042 }
19043 {
19044 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19045 }
19046 return resultobj;
19047 fail:
19048 return NULL;
19049 }
19050
19051
19052 SWIGINTERN PyObject *_wrap_CommandEvent_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19053 PyObject *resultobj = 0;
19054 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19055 bool result;
19056 void *argp1 = 0 ;
19057 int res1 = 0 ;
19058 PyObject *swig_obj[1] ;
19059
19060 if (!args) SWIG_fail;
19061 swig_obj[0] = args;
19062 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19063 if (!SWIG_IsOK(res1)) {
19064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19065 }
19066 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19067 {
19068 PyThreadState* __tstate = wxPyBeginAllowThreads();
19069 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
19070 wxPyEndAllowThreads(__tstate);
19071 if (PyErr_Occurred()) SWIG_fail;
19072 }
19073 {
19074 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19075 }
19076 return resultobj;
19077 fail:
19078 return NULL;
19079 }
19080
19081
19082 SWIGINTERN PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19083 PyObject *resultobj = 0;
19084 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19085 long arg2 ;
19086 void *argp1 = 0 ;
19087 int res1 = 0 ;
19088 long val2 ;
19089 int ecode2 = 0 ;
19090 PyObject * obj0 = 0 ;
19091 PyObject * obj1 = 0 ;
19092 char * kwnames[] = {
19093 (char *) "self",(char *) "extraLong", NULL
19094 };
19095
19096 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) SWIG_fail;
19097 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19098 if (!SWIG_IsOK(res1)) {
19099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19100 }
19101 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19102 ecode2 = SWIG_AsVal_long(obj1, &val2);
19103 if (!SWIG_IsOK(ecode2)) {
19104 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "2"" of type '" "long""'");
19105 }
19106 arg2 = static_cast< long >(val2);
19107 {
19108 PyThreadState* __tstate = wxPyBeginAllowThreads();
19109 (arg1)->SetExtraLong(arg2);
19110 wxPyEndAllowThreads(__tstate);
19111 if (PyErr_Occurred()) SWIG_fail;
19112 }
19113 resultobj = SWIG_Py_Void();
19114 return resultobj;
19115 fail:
19116 return NULL;
19117 }
19118
19119
19120 SWIGINTERN PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19121 PyObject *resultobj = 0;
19122 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19123 long result;
19124 void *argp1 = 0 ;
19125 int res1 = 0 ;
19126 PyObject *swig_obj[1] ;
19127
19128 if (!args) SWIG_fail;
19129 swig_obj[0] = args;
19130 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19131 if (!SWIG_IsOK(res1)) {
19132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19133 }
19134 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19135 {
19136 PyThreadState* __tstate = wxPyBeginAllowThreads();
19137 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
19138 wxPyEndAllowThreads(__tstate);
19139 if (PyErr_Occurred()) SWIG_fail;
19140 }
19141 resultobj = SWIG_From_long(static_cast< long >(result));
19142 return resultobj;
19143 fail:
19144 return NULL;
19145 }
19146
19147
19148 SWIGINTERN PyObject *_wrap_CommandEvent_SetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19149 PyObject *resultobj = 0;
19150 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19151 int arg2 ;
19152 void *argp1 = 0 ;
19153 int res1 = 0 ;
19154 int val2 ;
19155 int ecode2 = 0 ;
19156 PyObject * obj0 = 0 ;
19157 PyObject * obj1 = 0 ;
19158 char * kwnames[] = {
19159 (char *) "self",(char *) "i", NULL
19160 };
19161
19162 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) SWIG_fail;
19163 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19164 if (!SWIG_IsOK(res1)) {
19165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetInt" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19166 }
19167 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19168 ecode2 = SWIG_AsVal_int(obj1, &val2);
19169 if (!SWIG_IsOK(ecode2)) {
19170 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetInt" "', expected argument " "2"" of type '" "int""'");
19171 }
19172 arg2 = static_cast< int >(val2);
19173 {
19174 PyThreadState* __tstate = wxPyBeginAllowThreads();
19175 (arg1)->SetInt(arg2);
19176 wxPyEndAllowThreads(__tstate);
19177 if (PyErr_Occurred()) SWIG_fail;
19178 }
19179 resultobj = SWIG_Py_Void();
19180 return resultobj;
19181 fail:
19182 return NULL;
19183 }
19184
19185
19186 SWIGINTERN PyObject *_wrap_CommandEvent_GetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19187 PyObject *resultobj = 0;
19188 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19189 int result;
19190 void *argp1 = 0 ;
19191 int res1 = 0 ;
19192 PyObject *swig_obj[1] ;
19193
19194 if (!args) SWIG_fail;
19195 swig_obj[0] = args;
19196 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19197 if (!SWIG_IsOK(res1)) {
19198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetInt" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19199 }
19200 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19201 {
19202 PyThreadState* __tstate = wxPyBeginAllowThreads();
19203 result = (int)((wxCommandEvent const *)arg1)->GetInt();
19204 wxPyEndAllowThreads(__tstate);
19205 if (PyErr_Occurred()) SWIG_fail;
19206 }
19207 resultobj = SWIG_From_int(static_cast< int >(result));
19208 return resultobj;
19209 fail:
19210 return NULL;
19211 }
19212
19213
19214 SWIGINTERN PyObject *_wrap_CommandEvent_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19215 PyObject *resultobj = 0;
19216 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19217 PyObject *result = 0 ;
19218 void *argp1 = 0 ;
19219 int res1 = 0 ;
19220 PyObject *swig_obj[1] ;
19221
19222 if (!args) SWIG_fail;
19223 swig_obj[0] = args;
19224 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19225 if (!SWIG_IsOK(res1)) {
19226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19227 }
19228 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19229 {
19230 PyThreadState* __tstate = wxPyBeginAllowThreads();
19231 result = (PyObject *)wxCommandEvent_GetClientData(arg1);
19232 wxPyEndAllowThreads(__tstate);
19233 if (PyErr_Occurred()) SWIG_fail;
19234 }
19235 resultobj = result;
19236 return resultobj;
19237 fail:
19238 return NULL;
19239 }
19240
19241
19242 SWIGINTERN PyObject *_wrap_CommandEvent_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19243 PyObject *resultobj = 0;
19244 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19245 PyObject *arg2 = (PyObject *) 0 ;
19246 void *argp1 = 0 ;
19247 int res1 = 0 ;
19248 PyObject * obj0 = 0 ;
19249 PyObject * obj1 = 0 ;
19250 char * kwnames[] = {
19251 (char *) "self",(char *) "clientData", NULL
19252 };
19253
19254 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
19255 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19256 if (!SWIG_IsOK(res1)) {
19257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19258 }
19259 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19260 arg2 = obj1;
19261 {
19262 PyThreadState* __tstate = wxPyBeginAllowThreads();
19263 wxCommandEvent_SetClientData(arg1,arg2);
19264 wxPyEndAllowThreads(__tstate);
19265 if (PyErr_Occurred()) SWIG_fail;
19266 }
19267 resultobj = SWIG_Py_Void();
19268 return resultobj;
19269 fail:
19270 return NULL;
19271 }
19272
19273
19274 SWIGINTERN PyObject *_wrap_CommandEvent_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19275 PyObject *resultobj = 0;
19276 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19277 wxEvent *result = 0 ;
19278 void *argp1 = 0 ;
19279 int res1 = 0 ;
19280 PyObject *swig_obj[1] ;
19281
19282 if (!args) SWIG_fail;
19283 swig_obj[0] = args;
19284 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19285 if (!SWIG_IsOK(res1)) {
19286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_Clone" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19287 }
19288 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19289 {
19290 PyThreadState* __tstate = wxPyBeginAllowThreads();
19291 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
19292 wxPyEndAllowThreads(__tstate);
19293 if (PyErr_Occurred()) SWIG_fail;
19294 }
19295 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
19296 return resultobj;
19297 fail:
19298 return NULL;
19299 }
19300
19301
19302 SWIGINTERN PyObject *CommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19303 PyObject *obj;
19304 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19305 SWIG_TypeNewClientData(SWIGTYPE_p_wxCommandEvent, SWIG_NewClientData(obj));
19306 return SWIG_Py_Void();
19307 }
19308
19309 SWIGINTERN PyObject *CommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19310 return SWIG_Python_InitShadowInstance(args);
19311 }
19312
19313 SWIGINTERN PyObject *_wrap_new_NotifyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19314 PyObject *resultobj = 0;
19315 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19316 int arg2 = (int) 0 ;
19317 wxNotifyEvent *result = 0 ;
19318 int val1 ;
19319 int ecode1 = 0 ;
19320 int val2 ;
19321 int ecode2 = 0 ;
19322 PyObject * obj0 = 0 ;
19323 PyObject * obj1 = 0 ;
19324 char * kwnames[] = {
19325 (char *) "commandType",(char *) "winid", NULL
19326 };
19327
19328 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
19329 if (obj0) {
19330 ecode1 = SWIG_AsVal_int(obj0, &val1);
19331 if (!SWIG_IsOK(ecode1)) {
19332 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NotifyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19333 }
19334 arg1 = static_cast< wxEventType >(val1);
19335 }
19336 if (obj1) {
19337 ecode2 = SWIG_AsVal_int(obj1, &val2);
19338 if (!SWIG_IsOK(ecode2)) {
19339 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NotifyEvent" "', expected argument " "2"" of type '" "int""'");
19340 }
19341 arg2 = static_cast< int >(val2);
19342 }
19343 {
19344 PyThreadState* __tstate = wxPyBeginAllowThreads();
19345 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
19346 wxPyEndAllowThreads(__tstate);
19347 if (PyErr_Occurred()) SWIG_fail;
19348 }
19349 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_NEW | 0 );
19350 return resultobj;
19351 fail:
19352 return NULL;
19353 }
19354
19355
19356 SWIGINTERN PyObject *_wrap_NotifyEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19357 PyObject *resultobj = 0;
19358 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19359 void *argp1 = 0 ;
19360 int res1 = 0 ;
19361 PyObject *swig_obj[1] ;
19362
19363 if (!args) SWIG_fail;
19364 swig_obj[0] = args;
19365 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19366 if (!SWIG_IsOK(res1)) {
19367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Veto" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19368 }
19369 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19370 {
19371 PyThreadState* __tstate = wxPyBeginAllowThreads();
19372 (arg1)->Veto();
19373 wxPyEndAllowThreads(__tstate);
19374 if (PyErr_Occurred()) SWIG_fail;
19375 }
19376 resultobj = SWIG_Py_Void();
19377 return resultobj;
19378 fail:
19379 return NULL;
19380 }
19381
19382
19383 SWIGINTERN PyObject *_wrap_NotifyEvent_Allow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19384 PyObject *resultobj = 0;
19385 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19386 void *argp1 = 0 ;
19387 int res1 = 0 ;
19388 PyObject *swig_obj[1] ;
19389
19390 if (!args) SWIG_fail;
19391 swig_obj[0] = args;
19392 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19393 if (!SWIG_IsOK(res1)) {
19394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Allow" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19395 }
19396 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19397 {
19398 PyThreadState* __tstate = wxPyBeginAllowThreads();
19399 (arg1)->Allow();
19400 wxPyEndAllowThreads(__tstate);
19401 if (PyErr_Occurred()) SWIG_fail;
19402 }
19403 resultobj = SWIG_Py_Void();
19404 return resultobj;
19405 fail:
19406 return NULL;
19407 }
19408
19409
19410 SWIGINTERN PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19411 PyObject *resultobj = 0;
19412 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19413 bool result;
19414 void *argp1 = 0 ;
19415 int res1 = 0 ;
19416 PyObject *swig_obj[1] ;
19417
19418 if (!args) SWIG_fail;
19419 swig_obj[0] = args;
19420 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19421 if (!SWIG_IsOK(res1)) {
19422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_IsAllowed" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19423 }
19424 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19425 {
19426 PyThreadState* __tstate = wxPyBeginAllowThreads();
19427 result = (bool)(arg1)->IsAllowed();
19428 wxPyEndAllowThreads(__tstate);
19429 if (PyErr_Occurred()) SWIG_fail;
19430 }
19431 {
19432 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19433 }
19434 return resultobj;
19435 fail:
19436 return NULL;
19437 }
19438
19439
19440 SWIGINTERN PyObject *NotifyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19441 PyObject *obj;
19442 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19443 SWIG_TypeNewClientData(SWIGTYPE_p_wxNotifyEvent, SWIG_NewClientData(obj));
19444 return SWIG_Py_Void();
19445 }
19446
19447 SWIGINTERN PyObject *NotifyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19448 return SWIG_Python_InitShadowInstance(args);
19449 }
19450
19451 SWIGINTERN PyObject *_wrap_new_ScrollEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19452 PyObject *resultobj = 0;
19453 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19454 int arg2 = (int) 0 ;
19455 int arg3 = (int) 0 ;
19456 int arg4 = (int) 0 ;
19457 wxScrollEvent *result = 0 ;
19458 int val1 ;
19459 int ecode1 = 0 ;
19460 int val2 ;
19461 int ecode2 = 0 ;
19462 int val3 ;
19463 int ecode3 = 0 ;
19464 int val4 ;
19465 int ecode4 = 0 ;
19466 PyObject * obj0 = 0 ;
19467 PyObject * obj1 = 0 ;
19468 PyObject * obj2 = 0 ;
19469 PyObject * obj3 = 0 ;
19470 char * kwnames[] = {
19471 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
19472 };
19473
19474 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19475 if (obj0) {
19476 ecode1 = SWIG_AsVal_int(obj0, &val1);
19477 if (!SWIG_IsOK(ecode1)) {
19478 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19479 }
19480 arg1 = static_cast< wxEventType >(val1);
19481 }
19482 if (obj1) {
19483 ecode2 = SWIG_AsVal_int(obj1, &val2);
19484 if (!SWIG_IsOK(ecode2)) {
19485 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollEvent" "', expected argument " "2"" of type '" "int""'");
19486 }
19487 arg2 = static_cast< int >(val2);
19488 }
19489 if (obj2) {
19490 ecode3 = SWIG_AsVal_int(obj2, &val3);
19491 if (!SWIG_IsOK(ecode3)) {
19492 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollEvent" "', expected argument " "3"" of type '" "int""'");
19493 }
19494 arg3 = static_cast< int >(val3);
19495 }
19496 if (obj3) {
19497 ecode4 = SWIG_AsVal_int(obj3, &val4);
19498 if (!SWIG_IsOK(ecode4)) {
19499 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ScrollEvent" "', expected argument " "4"" of type '" "int""'");
19500 }
19501 arg4 = static_cast< int >(val4);
19502 }
19503 {
19504 PyThreadState* __tstate = wxPyBeginAllowThreads();
19505 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
19506 wxPyEndAllowThreads(__tstate);
19507 if (PyErr_Occurred()) SWIG_fail;
19508 }
19509 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_NEW | 0 );
19510 return resultobj;
19511 fail:
19512 return NULL;
19513 }
19514
19515
19516 SWIGINTERN PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19517 PyObject *resultobj = 0;
19518 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19519 int result;
19520 void *argp1 = 0 ;
19521 int res1 = 0 ;
19522 PyObject *swig_obj[1] ;
19523
19524 if (!args) SWIG_fail;
19525 swig_obj[0] = args;
19526 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19527 if (!SWIG_IsOK(res1)) {
19528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19529 }
19530 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19531 {
19532 PyThreadState* __tstate = wxPyBeginAllowThreads();
19533 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
19534 wxPyEndAllowThreads(__tstate);
19535 if (PyErr_Occurred()) SWIG_fail;
19536 }
19537 resultobj = SWIG_From_int(static_cast< int >(result));
19538 return resultobj;
19539 fail:
19540 return NULL;
19541 }
19542
19543
19544 SWIGINTERN PyObject *_wrap_ScrollEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19545 PyObject *resultobj = 0;
19546 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19547 int result;
19548 void *argp1 = 0 ;
19549 int res1 = 0 ;
19550 PyObject *swig_obj[1] ;
19551
19552 if (!args) SWIG_fail;
19553 swig_obj[0] = args;
19554 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19555 if (!SWIG_IsOK(res1)) {
19556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19557 }
19558 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19559 {
19560 PyThreadState* __tstate = wxPyBeginAllowThreads();
19561 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
19562 wxPyEndAllowThreads(__tstate);
19563 if (PyErr_Occurred()) SWIG_fail;
19564 }
19565 resultobj = SWIG_From_int(static_cast< int >(result));
19566 return resultobj;
19567 fail:
19568 return NULL;
19569 }
19570
19571
19572 SWIGINTERN PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19573 PyObject *resultobj = 0;
19574 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19575 int arg2 ;
19576 void *argp1 = 0 ;
19577 int res1 = 0 ;
19578 int val2 ;
19579 int ecode2 = 0 ;
19580 PyObject * obj0 = 0 ;
19581 PyObject * obj1 = 0 ;
19582 char * kwnames[] = {
19583 (char *) "self",(char *) "orient", NULL
19584 };
19585
19586 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19587 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19588 if (!SWIG_IsOK(res1)) {
19589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19590 }
19591 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19592 ecode2 = SWIG_AsVal_int(obj1, &val2);
19593 if (!SWIG_IsOK(ecode2)) {
19594 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
19595 }
19596 arg2 = static_cast< int >(val2);
19597 {
19598 PyThreadState* __tstate = wxPyBeginAllowThreads();
19599 (arg1)->SetOrientation(arg2);
19600 wxPyEndAllowThreads(__tstate);
19601 if (PyErr_Occurred()) SWIG_fail;
19602 }
19603 resultobj = SWIG_Py_Void();
19604 return resultobj;
19605 fail:
19606 return NULL;
19607 }
19608
19609
19610 SWIGINTERN PyObject *_wrap_ScrollEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19611 PyObject *resultobj = 0;
19612 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19613 int arg2 ;
19614 void *argp1 = 0 ;
19615 int res1 = 0 ;
19616 int val2 ;
19617 int ecode2 = 0 ;
19618 PyObject * obj0 = 0 ;
19619 PyObject * obj1 = 0 ;
19620 char * kwnames[] = {
19621 (char *) "self",(char *) "pos", NULL
19622 };
19623
19624 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
19625 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19626 if (!SWIG_IsOK(res1)) {
19627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19628 }
19629 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19630 ecode2 = SWIG_AsVal_int(obj1, &val2);
19631 if (!SWIG_IsOK(ecode2)) {
19632 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
19633 }
19634 arg2 = static_cast< int >(val2);
19635 {
19636 PyThreadState* __tstate = wxPyBeginAllowThreads();
19637 (arg1)->SetPosition(arg2);
19638 wxPyEndAllowThreads(__tstate);
19639 if (PyErr_Occurred()) SWIG_fail;
19640 }
19641 resultobj = SWIG_Py_Void();
19642 return resultobj;
19643 fail:
19644 return NULL;
19645 }
19646
19647
19648 SWIGINTERN PyObject *ScrollEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19649 PyObject *obj;
19650 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19651 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollEvent, SWIG_NewClientData(obj));
19652 return SWIG_Py_Void();
19653 }
19654
19655 SWIGINTERN PyObject *ScrollEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19656 return SWIG_Python_InitShadowInstance(args);
19657 }
19658
19659 SWIGINTERN PyObject *_wrap_new_ScrollWinEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19660 PyObject *resultobj = 0;
19661 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19662 int arg2 = (int) 0 ;
19663 int arg3 = (int) 0 ;
19664 wxScrollWinEvent *result = 0 ;
19665 int val1 ;
19666 int ecode1 = 0 ;
19667 int val2 ;
19668 int ecode2 = 0 ;
19669 int val3 ;
19670 int ecode3 = 0 ;
19671 PyObject * obj0 = 0 ;
19672 PyObject * obj1 = 0 ;
19673 PyObject * obj2 = 0 ;
19674 char * kwnames[] = {
19675 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
19676 };
19677
19678 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19679 if (obj0) {
19680 ecode1 = SWIG_AsVal_int(obj0, &val1);
19681 if (!SWIG_IsOK(ecode1)) {
19682 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollWinEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19683 }
19684 arg1 = static_cast< wxEventType >(val1);
19685 }
19686 if (obj1) {
19687 ecode2 = SWIG_AsVal_int(obj1, &val2);
19688 if (!SWIG_IsOK(ecode2)) {
19689 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollWinEvent" "', expected argument " "2"" of type '" "int""'");
19690 }
19691 arg2 = static_cast< int >(val2);
19692 }
19693 if (obj2) {
19694 ecode3 = SWIG_AsVal_int(obj2, &val3);
19695 if (!SWIG_IsOK(ecode3)) {
19696 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollWinEvent" "', expected argument " "3"" of type '" "int""'");
19697 }
19698 arg3 = static_cast< int >(val3);
19699 }
19700 {
19701 PyThreadState* __tstate = wxPyBeginAllowThreads();
19702 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
19703 wxPyEndAllowThreads(__tstate);
19704 if (PyErr_Occurred()) SWIG_fail;
19705 }
19706 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_NEW | 0 );
19707 return resultobj;
19708 fail:
19709 return NULL;
19710 }
19711
19712
19713 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19714 PyObject *resultobj = 0;
19715 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19716 int result;
19717 void *argp1 = 0 ;
19718 int res1 = 0 ;
19719 PyObject *swig_obj[1] ;
19720
19721 if (!args) SWIG_fail;
19722 swig_obj[0] = args;
19723 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19724 if (!SWIG_IsOK(res1)) {
19725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
19726 }
19727 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19728 {
19729 PyThreadState* __tstate = wxPyBeginAllowThreads();
19730 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
19731 wxPyEndAllowThreads(__tstate);
19732 if (PyErr_Occurred()) SWIG_fail;
19733 }
19734 resultobj = SWIG_From_int(static_cast< int >(result));
19735 return resultobj;
19736 fail:
19737 return NULL;
19738 }
19739
19740
19741 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19742 PyObject *resultobj = 0;
19743 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19744 int result;
19745 void *argp1 = 0 ;
19746 int res1 = 0 ;
19747 PyObject *swig_obj[1] ;
19748
19749 if (!args) SWIG_fail;
19750 swig_obj[0] = args;
19751 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19752 if (!SWIG_IsOK(res1)) {
19753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
19754 }
19755 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19756 {
19757 PyThreadState* __tstate = wxPyBeginAllowThreads();
19758 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
19759 wxPyEndAllowThreads(__tstate);
19760 if (PyErr_Occurred()) SWIG_fail;
19761 }
19762 resultobj = SWIG_From_int(static_cast< int >(result));
19763 return resultobj;
19764 fail:
19765 return NULL;
19766 }
19767
19768
19769 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19770 PyObject *resultobj = 0;
19771 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19772 int arg2 ;
19773 void *argp1 = 0 ;
19774 int res1 = 0 ;
19775 int val2 ;
19776 int ecode2 = 0 ;
19777 PyObject * obj0 = 0 ;
19778 PyObject * obj1 = 0 ;
19779 char * kwnames[] = {
19780 (char *) "self",(char *) "orient", NULL
19781 };
19782
19783 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19784 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19785 if (!SWIG_IsOK(res1)) {
19786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
19787 }
19788 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19789 ecode2 = SWIG_AsVal_int(obj1, &val2);
19790 if (!SWIG_IsOK(ecode2)) {
19791 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
19792 }
19793 arg2 = static_cast< int >(val2);
19794 {
19795 PyThreadState* __tstate = wxPyBeginAllowThreads();
19796 (arg1)->SetOrientation(arg2);
19797 wxPyEndAllowThreads(__tstate);
19798 if (PyErr_Occurred()) SWIG_fail;
19799 }
19800 resultobj = SWIG_Py_Void();
19801 return resultobj;
19802 fail:
19803 return NULL;
19804 }
19805
19806
19807 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19808 PyObject *resultobj = 0;
19809 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19810 int arg2 ;
19811 void *argp1 = 0 ;
19812 int res1 = 0 ;
19813 int val2 ;
19814 int ecode2 = 0 ;
19815 PyObject * obj0 = 0 ;
19816 PyObject * obj1 = 0 ;
19817 char * kwnames[] = {
19818 (char *) "self",(char *) "pos", NULL
19819 };
19820
19821 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
19822 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19823 if (!SWIG_IsOK(res1)) {
19824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
19825 }
19826 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19827 ecode2 = SWIG_AsVal_int(obj1, &val2);
19828 if (!SWIG_IsOK(ecode2)) {
19829 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
19830 }
19831 arg2 = static_cast< int >(val2);
19832 {
19833 PyThreadState* __tstate = wxPyBeginAllowThreads();
19834 (arg1)->SetPosition(arg2);
19835 wxPyEndAllowThreads(__tstate);
19836 if (PyErr_Occurred()) SWIG_fail;
19837 }
19838 resultobj = SWIG_Py_Void();
19839 return resultobj;
19840 fail:
19841 return NULL;
19842 }
19843
19844
19845 SWIGINTERN PyObject *ScrollWinEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19846 PyObject *obj;
19847 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19848 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollWinEvent, SWIG_NewClientData(obj));
19849 return SWIG_Py_Void();
19850 }
19851
19852 SWIGINTERN PyObject *ScrollWinEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19853 return SWIG_Python_InitShadowInstance(args);
19854 }
19855
19856 SWIGINTERN PyObject *_wrap_new_MouseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19857 PyObject *resultobj = 0;
19858 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19859 wxMouseEvent *result = 0 ;
19860 int val1 ;
19861 int ecode1 = 0 ;
19862 PyObject * obj0 = 0 ;
19863 char * kwnames[] = {
19864 (char *) "mouseType", NULL
19865 };
19866
19867 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) SWIG_fail;
19868 if (obj0) {
19869 ecode1 = SWIG_AsVal_int(obj0, &val1);
19870 if (!SWIG_IsOK(ecode1)) {
19871 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19872 }
19873 arg1 = static_cast< wxEventType >(val1);
19874 }
19875 {
19876 PyThreadState* __tstate = wxPyBeginAllowThreads();
19877 result = (wxMouseEvent *)new wxMouseEvent(arg1);
19878 wxPyEndAllowThreads(__tstate);
19879 if (PyErr_Occurred()) SWIG_fail;
19880 }
19881 {
19882 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
19883 }
19884 return resultobj;
19885 fail:
19886 return NULL;
19887 }
19888
19889
19890 SWIGINTERN PyObject *_wrap_MouseEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19891 PyObject *resultobj = 0;
19892 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19893 bool result;
19894 void *argp1 = 0 ;
19895 int res1 = 0 ;
19896 PyObject *swig_obj[1] ;
19897
19898 if (!args) SWIG_fail;
19899 swig_obj[0] = args;
19900 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19901 if (!SWIG_IsOK(res1)) {
19902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19903 }
19904 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19905 {
19906 PyThreadState* __tstate = wxPyBeginAllowThreads();
19907 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
19908 wxPyEndAllowThreads(__tstate);
19909 if (PyErr_Occurred()) SWIG_fail;
19910 }
19911 {
19912 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19913 }
19914 return resultobj;
19915 fail:
19916 return NULL;
19917 }
19918
19919
19920 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19921 PyObject *resultobj = 0;
19922 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19923 int arg2 = (int) wxMOUSE_BTN_ANY ;
19924 bool result;
19925 void *argp1 = 0 ;
19926 int res1 = 0 ;
19927 int val2 ;
19928 int ecode2 = 0 ;
19929 PyObject * obj0 = 0 ;
19930 PyObject * obj1 = 0 ;
19931 char * kwnames[] = {
19932 (char *) "self",(char *) "but", NULL
19933 };
19934
19935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
19936 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19937 if (!SWIG_IsOK(res1)) {
19938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19939 }
19940 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19941 if (obj1) {
19942 ecode2 = SWIG_AsVal_int(obj1, &val2);
19943 if (!SWIG_IsOK(ecode2)) {
19944 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
19945 }
19946 arg2 = static_cast< int >(val2);
19947 }
19948 {
19949 PyThreadState* __tstate = wxPyBeginAllowThreads();
19950 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
19951 wxPyEndAllowThreads(__tstate);
19952 if (PyErr_Occurred()) SWIG_fail;
19953 }
19954 {
19955 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19956 }
19957 return resultobj;
19958 fail:
19959 return NULL;
19960 }
19961
19962
19963 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19964 PyObject *resultobj = 0;
19965 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19966 int arg2 = (int) wxMOUSE_BTN_ANY ;
19967 bool result;
19968 void *argp1 = 0 ;
19969 int res1 = 0 ;
19970 int val2 ;
19971 int ecode2 = 0 ;
19972 PyObject * obj0 = 0 ;
19973 PyObject * obj1 = 0 ;
19974 char * kwnames[] = {
19975 (char *) "self",(char *) "but", NULL
19976 };
19977
19978 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) SWIG_fail;
19979 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19980 if (!SWIG_IsOK(res1)) {
19981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19982 }
19983 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19984 if (obj1) {
19985 ecode2 = SWIG_AsVal_int(obj1, &val2);
19986 if (!SWIG_IsOK(ecode2)) {
19987 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "2"" of type '" "int""'");
19988 }
19989 arg2 = static_cast< int >(val2);
19990 }
19991 {
19992 PyThreadState* __tstate = wxPyBeginAllowThreads();
19993 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
19994 wxPyEndAllowThreads(__tstate);
19995 if (PyErr_Occurred()) SWIG_fail;
19996 }
19997 {
19998 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19999 }
20000 return resultobj;
20001 fail:
20002 return NULL;
20003 }
20004
20005
20006 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20007 PyObject *resultobj = 0;
20008 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20009 int arg2 = (int) wxMOUSE_BTN_ANY ;
20010 bool result;
20011 void *argp1 = 0 ;
20012 int res1 = 0 ;
20013 int val2 ;
20014 int ecode2 = 0 ;
20015 PyObject * obj0 = 0 ;
20016 PyObject * obj1 = 0 ;
20017 char * kwnames[] = {
20018 (char *) "self",(char *) "but", NULL
20019 };
20020
20021 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
20022 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20023 if (!SWIG_IsOK(res1)) {
20024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20025 }
20026 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20027 if (obj1) {
20028 ecode2 = SWIG_AsVal_int(obj1, &val2);
20029 if (!SWIG_IsOK(ecode2)) {
20030 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
20031 }
20032 arg2 = static_cast< int >(val2);
20033 }
20034 {
20035 PyThreadState* __tstate = wxPyBeginAllowThreads();
20036 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
20037 wxPyEndAllowThreads(__tstate);
20038 if (PyErr_Occurred()) SWIG_fail;
20039 }
20040 {
20041 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20042 }
20043 return resultobj;
20044 fail:
20045 return NULL;
20046 }
20047
20048
20049 SWIGINTERN PyObject *_wrap_MouseEvent_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20050 PyObject *resultobj = 0;
20051 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20052 int arg2 ;
20053 bool result;
20054 void *argp1 = 0 ;
20055 int res1 = 0 ;
20056 int val2 ;
20057 int ecode2 = 0 ;
20058 PyObject * obj0 = 0 ;
20059 PyObject * obj1 = 0 ;
20060 char * kwnames[] = {
20061 (char *) "self",(char *) "button", NULL
20062 };
20063
20064 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) SWIG_fail;
20065 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20066 if (!SWIG_IsOK(res1)) {
20067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Button" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20068 }
20069 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20070 ecode2 = SWIG_AsVal_int(obj1, &val2);
20071 if (!SWIG_IsOK(ecode2)) {
20072 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_Button" "', expected argument " "2"" of type '" "int""'");
20073 }
20074 arg2 = static_cast< int >(val2);
20075 {
20076 PyThreadState* __tstate = wxPyBeginAllowThreads();
20077 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
20078 wxPyEndAllowThreads(__tstate);
20079 if (PyErr_Occurred()) SWIG_fail;
20080 }
20081 {
20082 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20083 }
20084 return resultobj;
20085 fail:
20086 return NULL;
20087 }
20088
20089
20090 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20091 PyObject *resultobj = 0;
20092 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20093 int arg2 ;
20094 bool result;
20095 void *argp1 = 0 ;
20096 int res1 = 0 ;
20097 int val2 ;
20098 int ecode2 = 0 ;
20099 PyObject * obj0 = 0 ;
20100 PyObject * obj1 = 0 ;
20101 char * kwnames[] = {
20102 (char *) "self",(char *) "but", NULL
20103 };
20104
20105 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
20106 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20107 if (!SWIG_IsOK(res1)) {
20108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20109 }
20110 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20111 ecode2 = SWIG_AsVal_int(obj1, &val2);
20112 if (!SWIG_IsOK(ecode2)) {
20113 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
20114 }
20115 arg2 = static_cast< int >(val2);
20116 {
20117 PyThreadState* __tstate = wxPyBeginAllowThreads();
20118 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
20119 wxPyEndAllowThreads(__tstate);
20120 if (PyErr_Occurred()) SWIG_fail;
20121 }
20122 {
20123 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20124 }
20125 return resultobj;
20126 fail:
20127 return NULL;
20128 }
20129
20130
20131 SWIGINTERN PyObject *_wrap_MouseEvent_GetButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20132 PyObject *resultobj = 0;
20133 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20134 int result;
20135 void *argp1 = 0 ;
20136 int res1 = 0 ;
20137 PyObject *swig_obj[1] ;
20138
20139 if (!args) SWIG_fail;
20140 swig_obj[0] = args;
20141 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20142 if (!SWIG_IsOK(res1)) {
20143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20144 }
20145 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20146 {
20147 PyThreadState* __tstate = wxPyBeginAllowThreads();
20148 result = (int)((wxMouseEvent const *)arg1)->GetButton();
20149 wxPyEndAllowThreads(__tstate);
20150 if (PyErr_Occurred()) SWIG_fail;
20151 }
20152 resultobj = SWIG_From_int(static_cast< int >(result));
20153 return resultobj;
20154 fail:
20155 return NULL;
20156 }
20157
20158
20159 SWIGINTERN PyObject *_wrap_MouseEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20160 PyObject *resultobj = 0;
20161 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20162 bool result;
20163 void *argp1 = 0 ;
20164 int res1 = 0 ;
20165 PyObject *swig_obj[1] ;
20166
20167 if (!args) SWIG_fail;
20168 swig_obj[0] = args;
20169 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20170 if (!SWIG_IsOK(res1)) {
20171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ControlDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20172 }
20173 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20174 {
20175 PyThreadState* __tstate = wxPyBeginAllowThreads();
20176 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
20177 wxPyEndAllowThreads(__tstate);
20178 if (PyErr_Occurred()) SWIG_fail;
20179 }
20180 {
20181 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20182 }
20183 return resultobj;
20184 fail:
20185 return NULL;
20186 }
20187
20188
20189 SWIGINTERN PyObject *_wrap_MouseEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20190 PyObject *resultobj = 0;
20191 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20192 bool result;
20193 void *argp1 = 0 ;
20194 int res1 = 0 ;
20195 PyObject *swig_obj[1] ;
20196
20197 if (!args) SWIG_fail;
20198 swig_obj[0] = args;
20199 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20200 if (!SWIG_IsOK(res1)) {
20201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MetaDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20202 }
20203 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20204 {
20205 PyThreadState* __tstate = wxPyBeginAllowThreads();
20206 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
20207 wxPyEndAllowThreads(__tstate);
20208 if (PyErr_Occurred()) SWIG_fail;
20209 }
20210 {
20211 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20212 }
20213 return resultobj;
20214 fail:
20215 return NULL;
20216 }
20217
20218
20219 SWIGINTERN PyObject *_wrap_MouseEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20220 PyObject *resultobj = 0;
20221 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20222 bool result;
20223 void *argp1 = 0 ;
20224 int res1 = 0 ;
20225 PyObject *swig_obj[1] ;
20226
20227 if (!args) SWIG_fail;
20228 swig_obj[0] = args;
20229 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20230 if (!SWIG_IsOK(res1)) {
20231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_AltDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20232 }
20233 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20234 {
20235 PyThreadState* __tstate = wxPyBeginAllowThreads();
20236 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
20237 wxPyEndAllowThreads(__tstate);
20238 if (PyErr_Occurred()) SWIG_fail;
20239 }
20240 {
20241 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20242 }
20243 return resultobj;
20244 fail:
20245 return NULL;
20246 }
20247
20248
20249 SWIGINTERN PyObject *_wrap_MouseEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20250 PyObject *resultobj = 0;
20251 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20252 bool result;
20253 void *argp1 = 0 ;
20254 int res1 = 0 ;
20255 PyObject *swig_obj[1] ;
20256
20257 if (!args) SWIG_fail;
20258 swig_obj[0] = args;
20259 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20260 if (!SWIG_IsOK(res1)) {
20261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ShiftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20262 }
20263 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20264 {
20265 PyThreadState* __tstate = wxPyBeginAllowThreads();
20266 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
20267 wxPyEndAllowThreads(__tstate);
20268 if (PyErr_Occurred()) SWIG_fail;
20269 }
20270 {
20271 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20272 }
20273 return resultobj;
20274 fail:
20275 return NULL;
20276 }
20277
20278
20279 SWIGINTERN PyObject *_wrap_MouseEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20280 PyObject *resultobj = 0;
20281 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20282 bool result;
20283 void *argp1 = 0 ;
20284 int res1 = 0 ;
20285 PyObject *swig_obj[1] ;
20286
20287 if (!args) SWIG_fail;
20288 swig_obj[0] = args;
20289 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20290 if (!SWIG_IsOK(res1)) {
20291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_CmdDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20292 }
20293 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20294 {
20295 PyThreadState* __tstate = wxPyBeginAllowThreads();
20296 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
20297 wxPyEndAllowThreads(__tstate);
20298 if (PyErr_Occurred()) SWIG_fail;
20299 }
20300 {
20301 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20302 }
20303 return resultobj;
20304 fail:
20305 return NULL;
20306 }
20307
20308
20309 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20310 PyObject *resultobj = 0;
20311 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20312 bool result;
20313 void *argp1 = 0 ;
20314 int res1 = 0 ;
20315 PyObject *swig_obj[1] ;
20316
20317 if (!args) SWIG_fail;
20318 swig_obj[0] = args;
20319 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20320 if (!SWIG_IsOK(res1)) {
20321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20322 }
20323 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20324 {
20325 PyThreadState* __tstate = wxPyBeginAllowThreads();
20326 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
20327 wxPyEndAllowThreads(__tstate);
20328 if (PyErr_Occurred()) SWIG_fail;
20329 }
20330 {
20331 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20332 }
20333 return resultobj;
20334 fail:
20335 return NULL;
20336 }
20337
20338
20339 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20340 PyObject *resultobj = 0;
20341 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20342 bool result;
20343 void *argp1 = 0 ;
20344 int res1 = 0 ;
20345 PyObject *swig_obj[1] ;
20346
20347 if (!args) SWIG_fail;
20348 swig_obj[0] = args;
20349 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20350 if (!SWIG_IsOK(res1)) {
20351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20352 }
20353 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20354 {
20355 PyThreadState* __tstate = wxPyBeginAllowThreads();
20356 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
20357 wxPyEndAllowThreads(__tstate);
20358 if (PyErr_Occurred()) SWIG_fail;
20359 }
20360 {
20361 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20362 }
20363 return resultobj;
20364 fail:
20365 return NULL;
20366 }
20367
20368
20369 SWIGINTERN PyObject *_wrap_MouseEvent_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20370 PyObject *resultobj = 0;
20371 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20372 bool result;
20373 void *argp1 = 0 ;
20374 int res1 = 0 ;
20375 PyObject *swig_obj[1] ;
20376
20377 if (!args) SWIG_fail;
20378 swig_obj[0] = args;
20379 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20380 if (!SWIG_IsOK(res1)) {
20381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20382 }
20383 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20384 {
20385 PyThreadState* __tstate = wxPyBeginAllowThreads();
20386 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
20387 wxPyEndAllowThreads(__tstate);
20388 if (PyErr_Occurred()) SWIG_fail;
20389 }
20390 {
20391 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20392 }
20393 return resultobj;
20394 fail:
20395 return NULL;
20396 }
20397
20398
20399 SWIGINTERN PyObject *_wrap_MouseEvent_LeftUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20400 PyObject *resultobj = 0;
20401 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20402 bool result;
20403 void *argp1 = 0 ;
20404 int res1 = 0 ;
20405 PyObject *swig_obj[1] ;
20406
20407 if (!args) SWIG_fail;
20408 swig_obj[0] = args;
20409 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20410 if (!SWIG_IsOK(res1)) {
20411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20412 }
20413 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20414 {
20415 PyThreadState* __tstate = wxPyBeginAllowThreads();
20416 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
20417 wxPyEndAllowThreads(__tstate);
20418 if (PyErr_Occurred()) SWIG_fail;
20419 }
20420 {
20421 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20422 }
20423 return resultobj;
20424 fail:
20425 return NULL;
20426 }
20427
20428
20429 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20430 PyObject *resultobj = 0;
20431 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20432 bool result;
20433 void *argp1 = 0 ;
20434 int res1 = 0 ;
20435 PyObject *swig_obj[1] ;
20436
20437 if (!args) SWIG_fail;
20438 swig_obj[0] = args;
20439 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20440 if (!SWIG_IsOK(res1)) {
20441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20442 }
20443 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20444 {
20445 PyThreadState* __tstate = wxPyBeginAllowThreads();
20446 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
20447 wxPyEndAllowThreads(__tstate);
20448 if (PyErr_Occurred()) SWIG_fail;
20449 }
20450 {
20451 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20452 }
20453 return resultobj;
20454 fail:
20455 return NULL;
20456 }
20457
20458
20459 SWIGINTERN PyObject *_wrap_MouseEvent_RightUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20460 PyObject *resultobj = 0;
20461 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20462 bool result;
20463 void *argp1 = 0 ;
20464 int res1 = 0 ;
20465 PyObject *swig_obj[1] ;
20466
20467 if (!args) SWIG_fail;
20468 swig_obj[0] = args;
20469 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20470 if (!SWIG_IsOK(res1)) {
20471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20472 }
20473 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20474 {
20475 PyThreadState* __tstate = wxPyBeginAllowThreads();
20476 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
20477 wxPyEndAllowThreads(__tstate);
20478 if (PyErr_Occurred()) SWIG_fail;
20479 }
20480 {
20481 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20482 }
20483 return resultobj;
20484 fail:
20485 return NULL;
20486 }
20487
20488
20489 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20490 PyObject *resultobj = 0;
20491 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20492 bool result;
20493 void *argp1 = 0 ;
20494 int res1 = 0 ;
20495 PyObject *swig_obj[1] ;
20496
20497 if (!args) SWIG_fail;
20498 swig_obj[0] = args;
20499 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20500 if (!SWIG_IsOK(res1)) {
20501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20502 }
20503 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20504 {
20505 PyThreadState* __tstate = wxPyBeginAllowThreads();
20506 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
20507 wxPyEndAllowThreads(__tstate);
20508 if (PyErr_Occurred()) SWIG_fail;
20509 }
20510 {
20511 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20512 }
20513 return resultobj;
20514 fail:
20515 return NULL;
20516 }
20517
20518
20519 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20520 PyObject *resultobj = 0;
20521 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20522 bool result;
20523 void *argp1 = 0 ;
20524 int res1 = 0 ;
20525 PyObject *swig_obj[1] ;
20526
20527 if (!args) SWIG_fail;
20528 swig_obj[0] = args;
20529 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20530 if (!SWIG_IsOK(res1)) {
20531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20532 }
20533 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20534 {
20535 PyThreadState* __tstate = wxPyBeginAllowThreads();
20536 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
20537 wxPyEndAllowThreads(__tstate);
20538 if (PyErr_Occurred()) SWIG_fail;
20539 }
20540 {
20541 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20542 }
20543 return resultobj;
20544 fail:
20545 return NULL;
20546 }
20547
20548
20549 SWIGINTERN PyObject *_wrap_MouseEvent_RightDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20550 PyObject *resultobj = 0;
20551 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20552 bool result;
20553 void *argp1 = 0 ;
20554 int res1 = 0 ;
20555 PyObject *swig_obj[1] ;
20556
20557 if (!args) SWIG_fail;
20558 swig_obj[0] = args;
20559 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20560 if (!SWIG_IsOK(res1)) {
20561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20562 }
20563 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20564 {
20565 PyThreadState* __tstate = wxPyBeginAllowThreads();
20566 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
20567 wxPyEndAllowThreads(__tstate);
20568 if (PyErr_Occurred()) SWIG_fail;
20569 }
20570 {
20571 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20572 }
20573 return resultobj;
20574 fail:
20575 return NULL;
20576 }
20577
20578
20579 SWIGINTERN PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20580 PyObject *resultobj = 0;
20581 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20582 bool result;
20583 void *argp1 = 0 ;
20584 int res1 = 0 ;
20585 PyObject *swig_obj[1] ;
20586
20587 if (!args) SWIG_fail;
20588 swig_obj[0] = args;
20589 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20590 if (!SWIG_IsOK(res1)) {
20591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20592 }
20593 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20594 {
20595 PyThreadState* __tstate = wxPyBeginAllowThreads();
20596 result = (bool)(arg1)->LeftIsDown();
20597 wxPyEndAllowThreads(__tstate);
20598 if (PyErr_Occurred()) SWIG_fail;
20599 }
20600 {
20601 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20602 }
20603 return resultobj;
20604 fail:
20605 return NULL;
20606 }
20607
20608
20609 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20610 PyObject *resultobj = 0;
20611 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20612 bool result;
20613 void *argp1 = 0 ;
20614 int res1 = 0 ;
20615 PyObject *swig_obj[1] ;
20616
20617 if (!args) SWIG_fail;
20618 swig_obj[0] = args;
20619 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20620 if (!SWIG_IsOK(res1)) {
20621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20622 }
20623 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20624 {
20625 PyThreadState* __tstate = wxPyBeginAllowThreads();
20626 result = (bool)(arg1)->MiddleIsDown();
20627 wxPyEndAllowThreads(__tstate);
20628 if (PyErr_Occurred()) SWIG_fail;
20629 }
20630 {
20631 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20632 }
20633 return resultobj;
20634 fail:
20635 return NULL;
20636 }
20637
20638
20639 SWIGINTERN PyObject *_wrap_MouseEvent_RightIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20640 PyObject *resultobj = 0;
20641 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20642 bool result;
20643 void *argp1 = 0 ;
20644 int res1 = 0 ;
20645 PyObject *swig_obj[1] ;
20646
20647 if (!args) SWIG_fail;
20648 swig_obj[0] = args;
20649 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20650 if (!SWIG_IsOK(res1)) {
20651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20652 }
20653 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20654 {
20655 PyThreadState* __tstate = wxPyBeginAllowThreads();
20656 result = (bool)(arg1)->RightIsDown();
20657 wxPyEndAllowThreads(__tstate);
20658 if (PyErr_Occurred()) SWIG_fail;
20659 }
20660 {
20661 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20662 }
20663 return resultobj;
20664 fail:
20665 return NULL;
20666 }
20667
20668
20669 SWIGINTERN PyObject *_wrap_MouseEvent_Dragging(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20670 PyObject *resultobj = 0;
20671 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20672 bool result;
20673 void *argp1 = 0 ;
20674 int res1 = 0 ;
20675 PyObject *swig_obj[1] ;
20676
20677 if (!args) SWIG_fail;
20678 swig_obj[0] = args;
20679 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20680 if (!SWIG_IsOK(res1)) {
20681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Dragging" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20682 }
20683 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20684 {
20685 PyThreadState* __tstate = wxPyBeginAllowThreads();
20686 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
20687 wxPyEndAllowThreads(__tstate);
20688 if (PyErr_Occurred()) SWIG_fail;
20689 }
20690 {
20691 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20692 }
20693 return resultobj;
20694 fail:
20695 return NULL;
20696 }
20697
20698
20699 SWIGINTERN PyObject *_wrap_MouseEvent_Moving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20700 PyObject *resultobj = 0;
20701 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20702 bool result;
20703 void *argp1 = 0 ;
20704 int res1 = 0 ;
20705 PyObject *swig_obj[1] ;
20706
20707 if (!args) SWIG_fail;
20708 swig_obj[0] = args;
20709 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20710 if (!SWIG_IsOK(res1)) {
20711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Moving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20712 }
20713 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20714 {
20715 PyThreadState* __tstate = wxPyBeginAllowThreads();
20716 result = (bool)((wxMouseEvent const *)arg1)->Moving();
20717 wxPyEndAllowThreads(__tstate);
20718 if (PyErr_Occurred()) SWIG_fail;
20719 }
20720 {
20721 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20722 }
20723 return resultobj;
20724 fail:
20725 return NULL;
20726 }
20727
20728
20729 SWIGINTERN PyObject *_wrap_MouseEvent_Entering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20730 PyObject *resultobj = 0;
20731 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20732 bool result;
20733 void *argp1 = 0 ;
20734 int res1 = 0 ;
20735 PyObject *swig_obj[1] ;
20736
20737 if (!args) SWIG_fail;
20738 swig_obj[0] = args;
20739 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20740 if (!SWIG_IsOK(res1)) {
20741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Entering" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20742 }
20743 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20744 {
20745 PyThreadState* __tstate = wxPyBeginAllowThreads();
20746 result = (bool)((wxMouseEvent const *)arg1)->Entering();
20747 wxPyEndAllowThreads(__tstate);
20748 if (PyErr_Occurred()) SWIG_fail;
20749 }
20750 {
20751 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20752 }
20753 return resultobj;
20754 fail:
20755 return NULL;
20756 }
20757
20758
20759 SWIGINTERN PyObject *_wrap_MouseEvent_Leaving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20760 PyObject *resultobj = 0;
20761 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20762 bool result;
20763 void *argp1 = 0 ;
20764 int res1 = 0 ;
20765 PyObject *swig_obj[1] ;
20766
20767 if (!args) SWIG_fail;
20768 swig_obj[0] = args;
20769 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20770 if (!SWIG_IsOK(res1)) {
20771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Leaving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20772 }
20773 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20774 {
20775 PyThreadState* __tstate = wxPyBeginAllowThreads();
20776 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
20777 wxPyEndAllowThreads(__tstate);
20778 if (PyErr_Occurred()) SWIG_fail;
20779 }
20780 {
20781 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20782 }
20783 return resultobj;
20784 fail:
20785 return NULL;
20786 }
20787
20788
20789 SWIGINTERN PyObject *_wrap_MouseEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20790 PyObject *resultobj = 0;
20791 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20792 wxPoint result;
20793 void *argp1 = 0 ;
20794 int res1 = 0 ;
20795 PyObject *swig_obj[1] ;
20796
20797 if (!args) SWIG_fail;
20798 swig_obj[0] = args;
20799 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20800 if (!SWIG_IsOK(res1)) {
20801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPosition" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20802 }
20803 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20804 {
20805 PyThreadState* __tstate = wxPyBeginAllowThreads();
20806 result = (arg1)->GetPosition();
20807 wxPyEndAllowThreads(__tstate);
20808 if (PyErr_Occurred()) SWIG_fail;
20809 }
20810 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
20811 return resultobj;
20812 fail:
20813 return NULL;
20814 }
20815
20816
20817 SWIGINTERN PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20818 PyObject *resultobj = 0;
20819 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20820 long *arg2 = (long *) 0 ;
20821 long *arg3 = (long *) 0 ;
20822 void *argp1 = 0 ;
20823 int res1 = 0 ;
20824 long temp2 ;
20825 int res2 = SWIG_TMPOBJ ;
20826 long temp3 ;
20827 int res3 = SWIG_TMPOBJ ;
20828 PyObject *swig_obj[1] ;
20829
20830 arg2 = &temp2;
20831 arg3 = &temp3;
20832 if (!args) SWIG_fail;
20833 swig_obj[0] = args;
20834 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20835 if (!SWIG_IsOK(res1)) {
20836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20837 }
20838 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20839 {
20840 PyThreadState* __tstate = wxPyBeginAllowThreads();
20841 (arg1)->GetPosition(arg2,arg3);
20842 wxPyEndAllowThreads(__tstate);
20843 if (PyErr_Occurred()) SWIG_fail;
20844 }
20845 resultobj = SWIG_Py_Void();
20846 if (SWIG_IsTmpObj(res2)) {
20847 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
20848 } else {
20849 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20850 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
20851 }
20852 if (SWIG_IsTmpObj(res3)) {
20853 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
20854 } else {
20855 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20856 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
20857 }
20858 return resultobj;
20859 fail:
20860 return NULL;
20861 }
20862
20863
20864 SWIGINTERN PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20865 PyObject *resultobj = 0;
20866 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20867 wxDC *arg2 = 0 ;
20868 wxPoint result;
20869 void *argp1 = 0 ;
20870 int res1 = 0 ;
20871 void *argp2 = 0 ;
20872 int res2 = 0 ;
20873 PyObject * obj0 = 0 ;
20874 PyObject * obj1 = 0 ;
20875 char * kwnames[] = {
20876 (char *) "self",(char *) "dc", NULL
20877 };
20878
20879 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) SWIG_fail;
20880 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20881 if (!SWIG_IsOK(res1)) {
20882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20883 }
20884 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20885 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
20886 if (!SWIG_IsOK(res2)) {
20887 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
20888 }
20889 if (!argp2) {
20890 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
20891 }
20892 arg2 = reinterpret_cast< wxDC * >(argp2);
20893 {
20894 PyThreadState* __tstate = wxPyBeginAllowThreads();
20895 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
20896 wxPyEndAllowThreads(__tstate);
20897 if (PyErr_Occurred()) SWIG_fail;
20898 }
20899 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
20900 return resultobj;
20901 fail:
20902 return NULL;
20903 }
20904
20905
20906 SWIGINTERN PyObject *_wrap_MouseEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20907 PyObject *resultobj = 0;
20908 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20909 int result;
20910 void *argp1 = 0 ;
20911 int res1 = 0 ;
20912 PyObject *swig_obj[1] ;
20913
20914 if (!args) SWIG_fail;
20915 swig_obj[0] = args;
20916 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20917 if (!SWIG_IsOK(res1)) {
20918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetX" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20919 }
20920 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20921 {
20922 PyThreadState* __tstate = wxPyBeginAllowThreads();
20923 result = (int)((wxMouseEvent const *)arg1)->GetX();
20924 wxPyEndAllowThreads(__tstate);
20925 if (PyErr_Occurred()) SWIG_fail;
20926 }
20927 resultobj = SWIG_From_int(static_cast< int >(result));
20928 return resultobj;
20929 fail:
20930 return NULL;
20931 }
20932
20933
20934 SWIGINTERN PyObject *_wrap_MouseEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20935 PyObject *resultobj = 0;
20936 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20937 int result;
20938 void *argp1 = 0 ;
20939 int res1 = 0 ;
20940 PyObject *swig_obj[1] ;
20941
20942 if (!args) SWIG_fail;
20943 swig_obj[0] = args;
20944 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20945 if (!SWIG_IsOK(res1)) {
20946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetY" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20947 }
20948 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20949 {
20950 PyThreadState* __tstate = wxPyBeginAllowThreads();
20951 result = (int)((wxMouseEvent const *)arg1)->GetY();
20952 wxPyEndAllowThreads(__tstate);
20953 if (PyErr_Occurred()) SWIG_fail;
20954 }
20955 resultobj = SWIG_From_int(static_cast< int >(result));
20956 return resultobj;
20957 fail:
20958 return NULL;
20959 }
20960
20961
20962 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20963 PyObject *resultobj = 0;
20964 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20965 int result;
20966 void *argp1 = 0 ;
20967 int res1 = 0 ;
20968 PyObject *swig_obj[1] ;
20969
20970 if (!args) SWIG_fail;
20971 swig_obj[0] = args;
20972 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20973 if (!SWIG_IsOK(res1)) {
20974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelRotation" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20975 }
20976 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20977 {
20978 PyThreadState* __tstate = wxPyBeginAllowThreads();
20979 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
20980 wxPyEndAllowThreads(__tstate);
20981 if (PyErr_Occurred()) SWIG_fail;
20982 }
20983 resultobj = SWIG_From_int(static_cast< int >(result));
20984 return resultobj;
20985 fail:
20986 return NULL;
20987 }
20988
20989
20990 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20991 PyObject *resultobj = 0;
20992 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20993 int result;
20994 void *argp1 = 0 ;
20995 int res1 = 0 ;
20996 PyObject *swig_obj[1] ;
20997
20998 if (!args) SWIG_fail;
20999 swig_obj[0] = args;
21000 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21001 if (!SWIG_IsOK(res1)) {
21002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelDelta" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21003 }
21004 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21005 {
21006 PyThreadState* __tstate = wxPyBeginAllowThreads();
21007 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
21008 wxPyEndAllowThreads(__tstate);
21009 if (PyErr_Occurred()) SWIG_fail;
21010 }
21011 resultobj = SWIG_From_int(static_cast< int >(result));
21012 return resultobj;
21013 fail:
21014 return NULL;
21015 }
21016
21017
21018 SWIGINTERN PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21019 PyObject *resultobj = 0;
21020 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21021 int result;
21022 void *argp1 = 0 ;
21023 int res1 = 0 ;
21024 PyObject *swig_obj[1] ;
21025
21026 if (!args) SWIG_fail;
21027 swig_obj[0] = args;
21028 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21029 if (!SWIG_IsOK(res1)) {
21030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLinesPerAction" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21031 }
21032 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21033 {
21034 PyThreadState* __tstate = wxPyBeginAllowThreads();
21035 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
21036 wxPyEndAllowThreads(__tstate);
21037 if (PyErr_Occurred()) SWIG_fail;
21038 }
21039 resultobj = SWIG_From_int(static_cast< int >(result));
21040 return resultobj;
21041 fail:
21042 return NULL;
21043 }
21044
21045
21046 SWIGINTERN PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21047 PyObject *resultobj = 0;
21048 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21049 bool result;
21050 void *argp1 = 0 ;
21051 int res1 = 0 ;
21052 PyObject *swig_obj[1] ;
21053
21054 if (!args) SWIG_fail;
21055 swig_obj[0] = args;
21056 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21057 if (!SWIG_IsOK(res1)) {
21058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsPageScroll" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21059 }
21060 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21061 {
21062 PyThreadState* __tstate = wxPyBeginAllowThreads();
21063 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
21064 wxPyEndAllowThreads(__tstate);
21065 if (PyErr_Occurred()) SWIG_fail;
21066 }
21067 {
21068 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21069 }
21070 return resultobj;
21071 fail:
21072 return NULL;
21073 }
21074
21075
21076 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21077 PyObject *resultobj = 0;
21078 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21079 int arg2 ;
21080 void *argp1 = 0 ;
21081 int res1 = 0 ;
21082 int val2 ;
21083 int ecode2 = 0 ;
21084 PyObject *swig_obj[2] ;
21085
21086 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
21087 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21088 if (!SWIG_IsOK(res1)) {
21089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21090 }
21091 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21092 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21093 if (!SWIG_IsOK(ecode2)) {
21094 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
21095 }
21096 arg2 = static_cast< int >(val2);
21097 if (arg1) (arg1)->m_x = arg2;
21098
21099 resultobj = SWIG_Py_Void();
21100 return resultobj;
21101 fail:
21102 return NULL;
21103 }
21104
21105
21106 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21107 PyObject *resultobj = 0;
21108 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21109 int result;
21110 void *argp1 = 0 ;
21111 int res1 = 0 ;
21112 PyObject *swig_obj[1] ;
21113
21114 if (!args) SWIG_fail;
21115 swig_obj[0] = args;
21116 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21117 if (!SWIG_IsOK(res1)) {
21118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21119 }
21120 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21121 result = (int) ((arg1)->m_x);
21122 resultobj = SWIG_From_int(static_cast< int >(result));
21123 return resultobj;
21124 fail:
21125 return NULL;
21126 }
21127
21128
21129 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21130 PyObject *resultobj = 0;
21131 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21132 int arg2 ;
21133 void *argp1 = 0 ;
21134 int res1 = 0 ;
21135 int val2 ;
21136 int ecode2 = 0 ;
21137 PyObject *swig_obj[2] ;
21138
21139 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
21140 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21141 if (!SWIG_IsOK(res1)) {
21142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21143 }
21144 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21145 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21146 if (!SWIG_IsOK(ecode2)) {
21147 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
21148 }
21149 arg2 = static_cast< int >(val2);
21150 if (arg1) (arg1)->m_y = arg2;
21151
21152 resultobj = SWIG_Py_Void();
21153 return resultobj;
21154 fail:
21155 return NULL;
21156 }
21157
21158
21159 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21160 PyObject *resultobj = 0;
21161 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21162 int result;
21163 void *argp1 = 0 ;
21164 int res1 = 0 ;
21165 PyObject *swig_obj[1] ;
21166
21167 if (!args) SWIG_fail;
21168 swig_obj[0] = args;
21169 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21170 if (!SWIG_IsOK(res1)) {
21171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21172 }
21173 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21174 result = (int) ((arg1)->m_y);
21175 resultobj = SWIG_From_int(static_cast< int >(result));
21176 return resultobj;
21177 fail:
21178 return NULL;
21179 }
21180
21181
21182 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21183 PyObject *resultobj = 0;
21184 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21185 bool arg2 ;
21186 void *argp1 = 0 ;
21187 int res1 = 0 ;
21188 bool val2 ;
21189 int ecode2 = 0 ;
21190 PyObject *swig_obj[2] ;
21191
21192 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_leftDown_set",2,2,swig_obj)) SWIG_fail;
21193 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21194 if (!SWIG_IsOK(res1)) {
21195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21196 }
21197 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21198 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21199 if (!SWIG_IsOK(ecode2)) {
21200 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "2"" of type '" "bool""'");
21201 }
21202 arg2 = static_cast< bool >(val2);
21203 if (arg1) (arg1)->m_leftDown = arg2;
21204
21205 resultobj = SWIG_Py_Void();
21206 return resultobj;
21207 fail:
21208 return NULL;
21209 }
21210
21211
21212 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21213 PyObject *resultobj = 0;
21214 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21215 bool result;
21216 void *argp1 = 0 ;
21217 int res1 = 0 ;
21218 PyObject *swig_obj[1] ;
21219
21220 if (!args) SWIG_fail;
21221 swig_obj[0] = args;
21222 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21223 if (!SWIG_IsOK(res1)) {
21224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21225 }
21226 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21227 result = (bool) ((arg1)->m_leftDown);
21228 {
21229 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21230 }
21231 return resultobj;
21232 fail:
21233 return NULL;
21234 }
21235
21236
21237 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21238 PyObject *resultobj = 0;
21239 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21240 bool arg2 ;
21241 void *argp1 = 0 ;
21242 int res1 = 0 ;
21243 bool val2 ;
21244 int ecode2 = 0 ;
21245 PyObject *swig_obj[2] ;
21246
21247 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_middleDown_set",2,2,swig_obj)) SWIG_fail;
21248 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21249 if (!SWIG_IsOK(res1)) {
21250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21251 }
21252 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21253 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21254 if (!SWIG_IsOK(ecode2)) {
21255 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "2"" of type '" "bool""'");
21256 }
21257 arg2 = static_cast< bool >(val2);
21258 if (arg1) (arg1)->m_middleDown = arg2;
21259
21260 resultobj = SWIG_Py_Void();
21261 return resultobj;
21262 fail:
21263 return NULL;
21264 }
21265
21266
21267 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21268 PyObject *resultobj = 0;
21269 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21270 bool result;
21271 void *argp1 = 0 ;
21272 int res1 = 0 ;
21273 PyObject *swig_obj[1] ;
21274
21275 if (!args) SWIG_fail;
21276 swig_obj[0] = args;
21277 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21278 if (!SWIG_IsOK(res1)) {
21279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21280 }
21281 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21282 result = (bool) ((arg1)->m_middleDown);
21283 {
21284 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21285 }
21286 return resultobj;
21287 fail:
21288 return NULL;
21289 }
21290
21291
21292 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21293 PyObject *resultobj = 0;
21294 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21295 bool arg2 ;
21296 void *argp1 = 0 ;
21297 int res1 = 0 ;
21298 bool val2 ;
21299 int ecode2 = 0 ;
21300 PyObject *swig_obj[2] ;
21301
21302 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_rightDown_set",2,2,swig_obj)) SWIG_fail;
21303 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21304 if (!SWIG_IsOK(res1)) {
21305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21306 }
21307 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21308 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21309 if (!SWIG_IsOK(ecode2)) {
21310 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "2"" of type '" "bool""'");
21311 }
21312 arg2 = static_cast< bool >(val2);
21313 if (arg1) (arg1)->m_rightDown = arg2;
21314
21315 resultobj = SWIG_Py_Void();
21316 return resultobj;
21317 fail:
21318 return NULL;
21319 }
21320
21321
21322 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21323 PyObject *resultobj = 0;
21324 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21325 bool result;
21326 void *argp1 = 0 ;
21327 int res1 = 0 ;
21328 PyObject *swig_obj[1] ;
21329
21330 if (!args) SWIG_fail;
21331 swig_obj[0] = args;
21332 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21333 if (!SWIG_IsOK(res1)) {
21334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21335 }
21336 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21337 result = (bool) ((arg1)->m_rightDown);
21338 {
21339 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21340 }
21341 return resultobj;
21342 fail:
21343 return NULL;
21344 }
21345
21346
21347 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21348 PyObject *resultobj = 0;
21349 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21350 bool arg2 ;
21351 void *argp1 = 0 ;
21352 int res1 = 0 ;
21353 bool val2 ;
21354 int ecode2 = 0 ;
21355 PyObject *swig_obj[2] ;
21356
21357 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
21358 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21359 if (!SWIG_IsOK(res1)) {
21360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21361 }
21362 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21363 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21364 if (!SWIG_IsOK(ecode2)) {
21365 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
21366 }
21367 arg2 = static_cast< bool >(val2);
21368 if (arg1) (arg1)->m_controlDown = arg2;
21369
21370 resultobj = SWIG_Py_Void();
21371 return resultobj;
21372 fail:
21373 return NULL;
21374 }
21375
21376
21377 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21378 PyObject *resultobj = 0;
21379 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21380 bool result;
21381 void *argp1 = 0 ;
21382 int res1 = 0 ;
21383 PyObject *swig_obj[1] ;
21384
21385 if (!args) SWIG_fail;
21386 swig_obj[0] = args;
21387 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21388 if (!SWIG_IsOK(res1)) {
21389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21390 }
21391 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21392 result = (bool) ((arg1)->m_controlDown);
21393 {
21394 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21395 }
21396 return resultobj;
21397 fail:
21398 return NULL;
21399 }
21400
21401
21402 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21403 PyObject *resultobj = 0;
21404 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21405 bool arg2 ;
21406 void *argp1 = 0 ;
21407 int res1 = 0 ;
21408 bool val2 ;
21409 int ecode2 = 0 ;
21410 PyObject *swig_obj[2] ;
21411
21412 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
21413 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21414 if (!SWIG_IsOK(res1)) {
21415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21416 }
21417 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21418 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21419 if (!SWIG_IsOK(ecode2)) {
21420 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
21421 }
21422 arg2 = static_cast< bool >(val2);
21423 if (arg1) (arg1)->m_shiftDown = arg2;
21424
21425 resultobj = SWIG_Py_Void();
21426 return resultobj;
21427 fail:
21428 return NULL;
21429 }
21430
21431
21432 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21433 PyObject *resultobj = 0;
21434 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21435 bool result;
21436 void *argp1 = 0 ;
21437 int res1 = 0 ;
21438 PyObject *swig_obj[1] ;
21439
21440 if (!args) SWIG_fail;
21441 swig_obj[0] = args;
21442 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21443 if (!SWIG_IsOK(res1)) {
21444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21445 }
21446 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21447 result = (bool) ((arg1)->m_shiftDown);
21448 {
21449 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21450 }
21451 return resultobj;
21452 fail:
21453 return NULL;
21454 }
21455
21456
21457 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21458 PyObject *resultobj = 0;
21459 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21460 bool arg2 ;
21461 void *argp1 = 0 ;
21462 int res1 = 0 ;
21463 bool val2 ;
21464 int ecode2 = 0 ;
21465 PyObject *swig_obj[2] ;
21466
21467 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
21468 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21469 if (!SWIG_IsOK(res1)) {
21470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21471 }
21472 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21473 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21474 if (!SWIG_IsOK(ecode2)) {
21475 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
21476 }
21477 arg2 = static_cast< bool >(val2);
21478 if (arg1) (arg1)->m_altDown = arg2;
21479
21480 resultobj = SWIG_Py_Void();
21481 return resultobj;
21482 fail:
21483 return NULL;
21484 }
21485
21486
21487 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21488 PyObject *resultobj = 0;
21489 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21490 bool result;
21491 void *argp1 = 0 ;
21492 int res1 = 0 ;
21493 PyObject *swig_obj[1] ;
21494
21495 if (!args) SWIG_fail;
21496 swig_obj[0] = args;
21497 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21498 if (!SWIG_IsOK(res1)) {
21499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21500 }
21501 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21502 result = (bool) ((arg1)->m_altDown);
21503 {
21504 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21505 }
21506 return resultobj;
21507 fail:
21508 return NULL;
21509 }
21510
21511
21512 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21513 PyObject *resultobj = 0;
21514 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21515 bool arg2 ;
21516 void *argp1 = 0 ;
21517 int res1 = 0 ;
21518 bool val2 ;
21519 int ecode2 = 0 ;
21520 PyObject *swig_obj[2] ;
21521
21522 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
21523 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21524 if (!SWIG_IsOK(res1)) {
21525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21526 }
21527 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21528 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21529 if (!SWIG_IsOK(ecode2)) {
21530 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
21531 }
21532 arg2 = static_cast< bool >(val2);
21533 if (arg1) (arg1)->m_metaDown = arg2;
21534
21535 resultobj = SWIG_Py_Void();
21536 return resultobj;
21537 fail:
21538 return NULL;
21539 }
21540
21541
21542 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21543 PyObject *resultobj = 0;
21544 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21545 bool result;
21546 void *argp1 = 0 ;
21547 int res1 = 0 ;
21548 PyObject *swig_obj[1] ;
21549
21550 if (!args) SWIG_fail;
21551 swig_obj[0] = args;
21552 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21553 if (!SWIG_IsOK(res1)) {
21554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21555 }
21556 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21557 result = (bool) ((arg1)->m_metaDown);
21558 {
21559 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21560 }
21561 return resultobj;
21562 fail:
21563 return NULL;
21564 }
21565
21566
21567 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21568 PyObject *resultobj = 0;
21569 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21570 int arg2 ;
21571 void *argp1 = 0 ;
21572 int res1 = 0 ;
21573 int val2 ;
21574 int ecode2 = 0 ;
21575 PyObject *swig_obj[2] ;
21576
21577 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelRotation_set",2,2,swig_obj)) SWIG_fail;
21578 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21579 if (!SWIG_IsOK(res1)) {
21580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21581 }
21582 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21583 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21584 if (!SWIG_IsOK(ecode2)) {
21585 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "2"" of type '" "int""'");
21586 }
21587 arg2 = static_cast< int >(val2);
21588 if (arg1) (arg1)->m_wheelRotation = arg2;
21589
21590 resultobj = SWIG_Py_Void();
21591 return resultobj;
21592 fail:
21593 return NULL;
21594 }
21595
21596
21597 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21598 PyObject *resultobj = 0;
21599 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21600 int result;
21601 void *argp1 = 0 ;
21602 int res1 = 0 ;
21603 PyObject *swig_obj[1] ;
21604
21605 if (!args) SWIG_fail;
21606 swig_obj[0] = args;
21607 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21608 if (!SWIG_IsOK(res1)) {
21609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21610 }
21611 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21612 result = (int) ((arg1)->m_wheelRotation);
21613 resultobj = SWIG_From_int(static_cast< int >(result));
21614 return resultobj;
21615 fail:
21616 return NULL;
21617 }
21618
21619
21620 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21621 PyObject *resultobj = 0;
21622 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21623 int arg2 ;
21624 void *argp1 = 0 ;
21625 int res1 = 0 ;
21626 int val2 ;
21627 int ecode2 = 0 ;
21628 PyObject *swig_obj[2] ;
21629
21630 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelDelta_set",2,2,swig_obj)) SWIG_fail;
21631 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21632 if (!SWIG_IsOK(res1)) {
21633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21634 }
21635 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21636 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21637 if (!SWIG_IsOK(ecode2)) {
21638 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "2"" of type '" "int""'");
21639 }
21640 arg2 = static_cast< int >(val2);
21641 if (arg1) (arg1)->m_wheelDelta = arg2;
21642
21643 resultobj = SWIG_Py_Void();
21644 return resultobj;
21645 fail:
21646 return NULL;
21647 }
21648
21649
21650 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21651 PyObject *resultobj = 0;
21652 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21653 int result;
21654 void *argp1 = 0 ;
21655 int res1 = 0 ;
21656 PyObject *swig_obj[1] ;
21657
21658 if (!args) SWIG_fail;
21659 swig_obj[0] = args;
21660 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21661 if (!SWIG_IsOK(res1)) {
21662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21663 }
21664 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21665 result = (int) ((arg1)->m_wheelDelta);
21666 resultobj = SWIG_From_int(static_cast< int >(result));
21667 return resultobj;
21668 fail:
21669 return NULL;
21670 }
21671
21672
21673 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21674 PyObject *resultobj = 0;
21675 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21676 int arg2 ;
21677 void *argp1 = 0 ;
21678 int res1 = 0 ;
21679 int val2 ;
21680 int ecode2 = 0 ;
21681 PyObject *swig_obj[2] ;
21682
21683 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_linesPerAction_set",2,2,swig_obj)) SWIG_fail;
21684 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21685 if (!SWIG_IsOK(res1)) {
21686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21687 }
21688 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21689 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21690 if (!SWIG_IsOK(ecode2)) {
21691 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "2"" of type '" "int""'");
21692 }
21693 arg2 = static_cast< int >(val2);
21694 if (arg1) (arg1)->m_linesPerAction = arg2;
21695
21696 resultobj = SWIG_Py_Void();
21697 return resultobj;
21698 fail:
21699 return NULL;
21700 }
21701
21702
21703 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21704 PyObject *resultobj = 0;
21705 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21706 int result;
21707 void *argp1 = 0 ;
21708 int res1 = 0 ;
21709 PyObject *swig_obj[1] ;
21710
21711 if (!args) SWIG_fail;
21712 swig_obj[0] = args;
21713 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21714 if (!SWIG_IsOK(res1)) {
21715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21716 }
21717 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21718 result = (int) ((arg1)->m_linesPerAction);
21719 resultobj = SWIG_From_int(static_cast< int >(result));
21720 return resultobj;
21721 fail:
21722 return NULL;
21723 }
21724
21725
21726 SWIGINTERN PyObject *MouseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21727 PyObject *obj;
21728 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21729 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseEvent, SWIG_NewClientData(obj));
21730 return SWIG_Py_Void();
21731 }
21732
21733 SWIGINTERN PyObject *MouseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21734 return SWIG_Python_InitShadowInstance(args);
21735 }
21736
21737 SWIGINTERN PyObject *_wrap_new_SetCursorEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21738 PyObject *resultobj = 0;
21739 int arg1 = (int) 0 ;
21740 int arg2 = (int) 0 ;
21741 wxSetCursorEvent *result = 0 ;
21742 int val1 ;
21743 int ecode1 = 0 ;
21744 int val2 ;
21745 int ecode2 = 0 ;
21746 PyObject * obj0 = 0 ;
21747 PyObject * obj1 = 0 ;
21748 char * kwnames[] = {
21749 (char *) "x",(char *) "y", NULL
21750 };
21751
21752 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) SWIG_fail;
21753 if (obj0) {
21754 ecode1 = SWIG_AsVal_int(obj0, &val1);
21755 if (!SWIG_IsOK(ecode1)) {
21756 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SetCursorEvent" "', expected argument " "1"" of type '" "int""'");
21757 }
21758 arg1 = static_cast< int >(val1);
21759 }
21760 if (obj1) {
21761 ecode2 = SWIG_AsVal_int(obj1, &val2);
21762 if (!SWIG_IsOK(ecode2)) {
21763 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SetCursorEvent" "', expected argument " "2"" of type '" "int""'");
21764 }
21765 arg2 = static_cast< int >(val2);
21766 }
21767 {
21768 PyThreadState* __tstate = wxPyBeginAllowThreads();
21769 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
21770 wxPyEndAllowThreads(__tstate);
21771 if (PyErr_Occurred()) SWIG_fail;
21772 }
21773 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_NEW | 0 );
21774 return resultobj;
21775 fail:
21776 return NULL;
21777 }
21778
21779
21780 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21781 PyObject *resultobj = 0;
21782 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21783 int result;
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_GetX" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21793 }
21794 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21795 {
21796 PyThreadState* __tstate = wxPyBeginAllowThreads();
21797 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
21798 wxPyEndAllowThreads(__tstate);
21799 if (PyErr_Occurred()) SWIG_fail;
21800 }
21801 resultobj = SWIG_From_int(static_cast< int >(result));
21802 return resultobj;
21803 fail:
21804 return NULL;
21805 }
21806
21807
21808 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21809 PyObject *resultobj = 0;
21810 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21811 int result;
21812 void *argp1 = 0 ;
21813 int res1 = 0 ;
21814 PyObject *swig_obj[1] ;
21815
21816 if (!args) SWIG_fail;
21817 swig_obj[0] = args;
21818 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21819 if (!SWIG_IsOK(res1)) {
21820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetY" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21821 }
21822 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21823 {
21824 PyThreadState* __tstate = wxPyBeginAllowThreads();
21825 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
21826 wxPyEndAllowThreads(__tstate);
21827 if (PyErr_Occurred()) SWIG_fail;
21828 }
21829 resultobj = SWIG_From_int(static_cast< int >(result));
21830 return resultobj;
21831 fail:
21832 return NULL;
21833 }
21834
21835
21836 SWIGINTERN PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21837 PyObject *resultobj = 0;
21838 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21839 wxCursor *arg2 = 0 ;
21840 void *argp1 = 0 ;
21841 int res1 = 0 ;
21842 void *argp2 = 0 ;
21843 int res2 = 0 ;
21844 PyObject * obj0 = 0 ;
21845 PyObject * obj1 = 0 ;
21846 char * kwnames[] = {
21847 (char *) "self",(char *) "cursor", NULL
21848 };
21849
21850 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
21851 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21852 if (!SWIG_IsOK(res1)) {
21853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent *""'");
21854 }
21855 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21856 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
21857 if (!SWIG_IsOK(res2)) {
21858 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
21859 }
21860 if (!argp2) {
21861 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
21862 }
21863 arg2 = reinterpret_cast< wxCursor * >(argp2);
21864 {
21865 PyThreadState* __tstate = wxPyBeginAllowThreads();
21866 (arg1)->SetCursor((wxCursor const &)*arg2);
21867 wxPyEndAllowThreads(__tstate);
21868 if (PyErr_Occurred()) SWIG_fail;
21869 }
21870 resultobj = SWIG_Py_Void();
21871 return resultobj;
21872 fail:
21873 return NULL;
21874 }
21875
21876
21877 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21878 PyObject *resultobj = 0;
21879 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21880 wxCursor *result = 0 ;
21881 void *argp1 = 0 ;
21882 int res1 = 0 ;
21883 PyObject *swig_obj[1] ;
21884
21885 if (!args) SWIG_fail;
21886 swig_obj[0] = args;
21887 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21888 if (!SWIG_IsOK(res1)) {
21889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21890 }
21891 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21892 {
21893 PyThreadState* __tstate = wxPyBeginAllowThreads();
21894 {
21895 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
21896 result = (wxCursor *) &_result_ref;
21897 }
21898 wxPyEndAllowThreads(__tstate);
21899 if (PyErr_Occurred()) SWIG_fail;
21900 }
21901 {
21902 wxCursor* resultptr = new wxCursor(*result);
21903 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
21904 }
21905 return resultobj;
21906 fail:
21907 return NULL;
21908 }
21909
21910
21911 SWIGINTERN PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21912 PyObject *resultobj = 0;
21913 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21914 bool result;
21915 void *argp1 = 0 ;
21916 int res1 = 0 ;
21917 PyObject *swig_obj[1] ;
21918
21919 if (!args) SWIG_fail;
21920 swig_obj[0] = args;
21921 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21922 if (!SWIG_IsOK(res1)) {
21923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_HasCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21924 }
21925 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21926 {
21927 PyThreadState* __tstate = wxPyBeginAllowThreads();
21928 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
21929 wxPyEndAllowThreads(__tstate);
21930 if (PyErr_Occurred()) SWIG_fail;
21931 }
21932 {
21933 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21934 }
21935 return resultobj;
21936 fail:
21937 return NULL;
21938 }
21939
21940
21941 SWIGINTERN PyObject *SetCursorEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21942 PyObject *obj;
21943 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21944 SWIG_TypeNewClientData(SWIGTYPE_p_wxSetCursorEvent, SWIG_NewClientData(obj));
21945 return SWIG_Py_Void();
21946 }
21947
21948 SWIGINTERN PyObject *SetCursorEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21949 return SWIG_Python_InitShadowInstance(args);
21950 }
21951
21952 SWIGINTERN PyObject *_wrap_new_KeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21953 PyObject *resultobj = 0;
21954 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21955 wxKeyEvent *result = 0 ;
21956 int val1 ;
21957 int ecode1 = 0 ;
21958 PyObject * obj0 = 0 ;
21959 char * kwnames[] = {
21960 (char *) "eventType", NULL
21961 };
21962
21963 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) SWIG_fail;
21964 if (obj0) {
21965 ecode1 = SWIG_AsVal_int(obj0, &val1);
21966 if (!SWIG_IsOK(ecode1)) {
21967 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_KeyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
21968 }
21969 arg1 = static_cast< wxEventType >(val1);
21970 }
21971 {
21972 PyThreadState* __tstate = wxPyBeginAllowThreads();
21973 result = (wxKeyEvent *)new wxKeyEvent(arg1);
21974 wxPyEndAllowThreads(__tstate);
21975 if (PyErr_Occurred()) SWIG_fail;
21976 }
21977 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_NEW | 0 );
21978 return resultobj;
21979 fail:
21980 return NULL;
21981 }
21982
21983
21984 SWIGINTERN PyObject *_wrap_KeyEvent_GetModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21985 PyObject *resultobj = 0;
21986 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21987 int result;
21988 void *argp1 = 0 ;
21989 int res1 = 0 ;
21990 PyObject *swig_obj[1] ;
21991
21992 if (!args) SWIG_fail;
21993 swig_obj[0] = args;
21994 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21995 if (!SWIG_IsOK(res1)) {
21996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21997 }
21998 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21999 {
22000 PyThreadState* __tstate = wxPyBeginAllowThreads();
22001 result = (int)((wxKeyEvent const *)arg1)->GetModifiers();
22002 wxPyEndAllowThreads(__tstate);
22003 if (PyErr_Occurred()) SWIG_fail;
22004 }
22005 resultobj = SWIG_From_int(static_cast< int >(result));
22006 return resultobj;
22007 fail:
22008 return NULL;
22009 }
22010
22011
22012 SWIGINTERN PyObject *_wrap_KeyEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22013 PyObject *resultobj = 0;
22014 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22015 bool result;
22016 void *argp1 = 0 ;
22017 int res1 = 0 ;
22018 PyObject *swig_obj[1] ;
22019
22020 if (!args) SWIG_fail;
22021 swig_obj[0] = args;
22022 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22023 if (!SWIG_IsOK(res1)) {
22024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ControlDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22025 }
22026 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22027 {
22028 PyThreadState* __tstate = wxPyBeginAllowThreads();
22029 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
22030 wxPyEndAllowThreads(__tstate);
22031 if (PyErr_Occurred()) SWIG_fail;
22032 }
22033 {
22034 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22035 }
22036 return resultobj;
22037 fail:
22038 return NULL;
22039 }
22040
22041
22042 SWIGINTERN PyObject *_wrap_KeyEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22043 PyObject *resultobj = 0;
22044 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22045 bool result;
22046 void *argp1 = 0 ;
22047 int res1 = 0 ;
22048 PyObject *swig_obj[1] ;
22049
22050 if (!args) SWIG_fail;
22051 swig_obj[0] = args;
22052 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22053 if (!SWIG_IsOK(res1)) {
22054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_MetaDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22055 }
22056 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22057 {
22058 PyThreadState* __tstate = wxPyBeginAllowThreads();
22059 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
22060 wxPyEndAllowThreads(__tstate);
22061 if (PyErr_Occurred()) SWIG_fail;
22062 }
22063 {
22064 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22065 }
22066 return resultobj;
22067 fail:
22068 return NULL;
22069 }
22070
22071
22072 SWIGINTERN PyObject *_wrap_KeyEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22073 PyObject *resultobj = 0;
22074 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22075 bool result;
22076 void *argp1 = 0 ;
22077 int res1 = 0 ;
22078 PyObject *swig_obj[1] ;
22079
22080 if (!args) SWIG_fail;
22081 swig_obj[0] = args;
22082 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22083 if (!SWIG_IsOK(res1)) {
22084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_AltDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22085 }
22086 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22087 {
22088 PyThreadState* __tstate = wxPyBeginAllowThreads();
22089 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
22090 wxPyEndAllowThreads(__tstate);
22091 if (PyErr_Occurred()) SWIG_fail;
22092 }
22093 {
22094 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22095 }
22096 return resultobj;
22097 fail:
22098 return NULL;
22099 }
22100
22101
22102 SWIGINTERN PyObject *_wrap_KeyEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22103 PyObject *resultobj = 0;
22104 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22105 bool result;
22106 void *argp1 = 0 ;
22107 int res1 = 0 ;
22108 PyObject *swig_obj[1] ;
22109
22110 if (!args) SWIG_fail;
22111 swig_obj[0] = args;
22112 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22113 if (!SWIG_IsOK(res1)) {
22114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ShiftDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22115 }
22116 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22117 {
22118 PyThreadState* __tstate = wxPyBeginAllowThreads();
22119 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
22120 wxPyEndAllowThreads(__tstate);
22121 if (PyErr_Occurred()) SWIG_fail;
22122 }
22123 {
22124 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22125 }
22126 return resultobj;
22127 fail:
22128 return NULL;
22129 }
22130
22131
22132 SWIGINTERN PyObject *_wrap_KeyEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22133 PyObject *resultobj = 0;
22134 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22135 bool result;
22136 void *argp1 = 0 ;
22137 int res1 = 0 ;
22138 PyObject *swig_obj[1] ;
22139
22140 if (!args) SWIG_fail;
22141 swig_obj[0] = args;
22142 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22143 if (!SWIG_IsOK(res1)) {
22144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_CmdDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22145 }
22146 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22147 {
22148 PyThreadState* __tstate = wxPyBeginAllowThreads();
22149 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
22150 wxPyEndAllowThreads(__tstate);
22151 if (PyErr_Occurred()) SWIG_fail;
22152 }
22153 {
22154 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22155 }
22156 return resultobj;
22157 fail:
22158 return NULL;
22159 }
22160
22161
22162 SWIGINTERN PyObject *_wrap_KeyEvent_HasModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22163 PyObject *resultobj = 0;
22164 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22165 bool result;
22166 void *argp1 = 0 ;
22167 int res1 = 0 ;
22168 PyObject *swig_obj[1] ;
22169
22170 if (!args) SWIG_fail;
22171 swig_obj[0] = args;
22172 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22173 if (!SWIG_IsOK(res1)) {
22174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_HasModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22175 }
22176 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22177 {
22178 PyThreadState* __tstate = wxPyBeginAllowThreads();
22179 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
22180 wxPyEndAllowThreads(__tstate);
22181 if (PyErr_Occurred()) SWIG_fail;
22182 }
22183 {
22184 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22185 }
22186 return resultobj;
22187 fail:
22188 return NULL;
22189 }
22190
22191
22192 SWIGINTERN PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22193 PyObject *resultobj = 0;
22194 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22195 int result;
22196 void *argp1 = 0 ;
22197 int res1 = 0 ;
22198 PyObject *swig_obj[1] ;
22199
22200 if (!args) SWIG_fail;
22201 swig_obj[0] = args;
22202 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22203 if (!SWIG_IsOK(res1)) {
22204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22205 }
22206 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22207 {
22208 PyThreadState* __tstate = wxPyBeginAllowThreads();
22209 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
22210 wxPyEndAllowThreads(__tstate);
22211 if (PyErr_Occurred()) SWIG_fail;
22212 }
22213 resultobj = SWIG_From_int(static_cast< int >(result));
22214 return resultobj;
22215 fail:
22216 return NULL;
22217 }
22218
22219
22220 SWIGINTERN PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22221 PyObject *resultobj = 0;
22222 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22223 int result;
22224 void *argp1 = 0 ;
22225 int res1 = 0 ;
22226 PyObject *swig_obj[1] ;
22227
22228 if (!args) SWIG_fail;
22229 swig_obj[0] = args;
22230 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22231 if (!SWIG_IsOK(res1)) {
22232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22233 }
22234 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22235 {
22236 PyThreadState* __tstate = wxPyBeginAllowThreads();
22237 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
22238 wxPyEndAllowThreads(__tstate);
22239 if (PyErr_Occurred()) SWIG_fail;
22240 }
22241 resultobj = SWIG_From_int(static_cast< int >(result));
22242 return resultobj;
22243 fail:
22244 return NULL;
22245 }
22246
22247
22248 SWIGINTERN PyObject *_wrap_KeyEvent_SetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22249 PyObject *resultobj = 0;
22250 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22251 int arg2 ;
22252 void *argp1 = 0 ;
22253 int res1 = 0 ;
22254 int val2 ;
22255 int ecode2 = 0 ;
22256 PyObject * obj0 = 0 ;
22257 PyObject * obj1 = 0 ;
22258 char * kwnames[] = {
22259 (char *) "self",(char *) "uniChar", NULL
22260 };
22261
22262 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_SetUnicodeKey",kwnames,&obj0,&obj1)) SWIG_fail;
22263 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22264 if (!SWIG_IsOK(res1)) {
22265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22266 }
22267 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22268 ecode2 = SWIG_AsVal_int(obj1, &val2);
22269 if (!SWIG_IsOK(ecode2)) {
22270 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "2"" of type '" "int""'");
22271 }
22272 arg2 = static_cast< int >(val2);
22273 {
22274 PyThreadState* __tstate = wxPyBeginAllowThreads();
22275 wxKeyEvent_SetUnicodeKey(arg1,arg2);
22276 wxPyEndAllowThreads(__tstate);
22277 if (PyErr_Occurred()) SWIG_fail;
22278 }
22279 resultobj = SWIG_Py_Void();
22280 return resultobj;
22281 fail:
22282 return NULL;
22283 }
22284
22285
22286 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22287 PyObject *resultobj = 0;
22288 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22289 unsigned int result;
22290 void *argp1 = 0 ;
22291 int res1 = 0 ;
22292 PyObject *swig_obj[1] ;
22293
22294 if (!args) SWIG_fail;
22295 swig_obj[0] = args;
22296 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22297 if (!SWIG_IsOK(res1)) {
22298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22299 }
22300 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22301 {
22302 PyThreadState* __tstate = wxPyBeginAllowThreads();
22303 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
22304 wxPyEndAllowThreads(__tstate);
22305 if (PyErr_Occurred()) SWIG_fail;
22306 }
22307 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22308 return resultobj;
22309 fail:
22310 return NULL;
22311 }
22312
22313
22314 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22315 PyObject *resultobj = 0;
22316 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22317 unsigned int result;
22318 void *argp1 = 0 ;
22319 int res1 = 0 ;
22320 PyObject *swig_obj[1] ;
22321
22322 if (!args) SWIG_fail;
22323 swig_obj[0] = args;
22324 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22325 if (!SWIG_IsOK(res1)) {
22326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyFlags" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22327 }
22328 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22329 {
22330 PyThreadState* __tstate = wxPyBeginAllowThreads();
22331 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
22332 wxPyEndAllowThreads(__tstate);
22333 if (PyErr_Occurred()) SWIG_fail;
22334 }
22335 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22336 return resultobj;
22337 fail:
22338 return NULL;
22339 }
22340
22341
22342 SWIGINTERN PyObject *_wrap_KeyEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22343 PyObject *resultobj = 0;
22344 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22345 wxPoint result;
22346 void *argp1 = 0 ;
22347 int res1 = 0 ;
22348 PyObject *swig_obj[1] ;
22349
22350 if (!args) SWIG_fail;
22351 swig_obj[0] = args;
22352 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22353 if (!SWIG_IsOK(res1)) {
22354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPosition" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22355 }
22356 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22357 {
22358 PyThreadState* __tstate = wxPyBeginAllowThreads();
22359 result = (arg1)->GetPosition();
22360 wxPyEndAllowThreads(__tstate);
22361 if (PyErr_Occurred()) SWIG_fail;
22362 }
22363 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
22364 return resultobj;
22365 fail:
22366 return NULL;
22367 }
22368
22369
22370 SWIGINTERN PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22371 PyObject *resultobj = 0;
22372 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22373 long *arg2 = (long *) 0 ;
22374 long *arg3 = (long *) 0 ;
22375 void *argp1 = 0 ;
22376 int res1 = 0 ;
22377 long temp2 ;
22378 int res2 = SWIG_TMPOBJ ;
22379 long temp3 ;
22380 int res3 = SWIG_TMPOBJ ;
22381 PyObject *swig_obj[1] ;
22382
22383 arg2 = &temp2;
22384 arg3 = &temp3;
22385 if (!args) SWIG_fail;
22386 swig_obj[0] = args;
22387 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22388 if (!SWIG_IsOK(res1)) {
22389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22390 }
22391 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22392 {
22393 PyThreadState* __tstate = wxPyBeginAllowThreads();
22394 (arg1)->GetPosition(arg2,arg3);
22395 wxPyEndAllowThreads(__tstate);
22396 if (PyErr_Occurred()) SWIG_fail;
22397 }
22398 resultobj = SWIG_Py_Void();
22399 if (SWIG_IsTmpObj(res2)) {
22400 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
22401 } else {
22402 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22403 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
22404 }
22405 if (SWIG_IsTmpObj(res3)) {
22406 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
22407 } else {
22408 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22409 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
22410 }
22411 return resultobj;
22412 fail:
22413 return NULL;
22414 }
22415
22416
22417 SWIGINTERN PyObject *_wrap_KeyEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22418 PyObject *resultobj = 0;
22419 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22420 int result;
22421 void *argp1 = 0 ;
22422 int res1 = 0 ;
22423 PyObject *swig_obj[1] ;
22424
22425 if (!args) SWIG_fail;
22426 swig_obj[0] = args;
22427 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22428 if (!SWIG_IsOK(res1)) {
22429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetX" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22430 }
22431 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22432 {
22433 PyThreadState* __tstate = wxPyBeginAllowThreads();
22434 result = (int)((wxKeyEvent const *)arg1)->GetX();
22435 wxPyEndAllowThreads(__tstate);
22436 if (PyErr_Occurred()) SWIG_fail;
22437 }
22438 resultobj = SWIG_From_int(static_cast< int >(result));
22439 return resultobj;
22440 fail:
22441 return NULL;
22442 }
22443
22444
22445 SWIGINTERN PyObject *_wrap_KeyEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22446 PyObject *resultobj = 0;
22447 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22448 int result;
22449 void *argp1 = 0 ;
22450 int res1 = 0 ;
22451 PyObject *swig_obj[1] ;
22452
22453 if (!args) SWIG_fail;
22454 swig_obj[0] = args;
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_GetY" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22458 }
22459 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22460 {
22461 PyThreadState* __tstate = wxPyBeginAllowThreads();
22462 result = (int)((wxKeyEvent const *)arg1)->GetY();
22463 wxPyEndAllowThreads(__tstate);
22464 if (PyErr_Occurred()) SWIG_fail;
22465 }
22466 resultobj = SWIG_From_int(static_cast< int >(result));
22467 return resultobj;
22468 fail:
22469 return NULL;
22470 }
22471
22472
22473 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22474 PyObject *resultobj = 0;
22475 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22476 int arg2 ;
22477 void *argp1 = 0 ;
22478 int res1 = 0 ;
22479 int val2 ;
22480 int ecode2 = 0 ;
22481 PyObject *swig_obj[2] ;
22482
22483 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
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_x_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22487 }
22488 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22489 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22490 if (!SWIG_IsOK(ecode2)) {
22491 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
22492 }
22493 arg2 = static_cast< int >(val2);
22494 if (arg1) (arg1)->m_x = arg2;
22495
22496 resultobj = SWIG_Py_Void();
22497 return resultobj;
22498 fail:
22499 return NULL;
22500 }
22501
22502
22503 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22504 PyObject *resultobj = 0;
22505 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22506 int result;
22507 void *argp1 = 0 ;
22508 int res1 = 0 ;
22509 PyObject *swig_obj[1] ;
22510
22511 if (!args) SWIG_fail;
22512 swig_obj[0] = args;
22513 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22514 if (!SWIG_IsOK(res1)) {
22515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22516 }
22517 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22518 result = (int) ((arg1)->m_x);
22519 resultobj = SWIG_From_int(static_cast< int >(result));
22520 return resultobj;
22521 fail:
22522 return NULL;
22523 }
22524
22525
22526 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22527 PyObject *resultobj = 0;
22528 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22529 int arg2 ;
22530 void *argp1 = 0 ;
22531 int res1 = 0 ;
22532 int val2 ;
22533 int ecode2 = 0 ;
22534 PyObject *swig_obj[2] ;
22535
22536 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
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_y_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22540 }
22541 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22542 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22543 if (!SWIG_IsOK(ecode2)) {
22544 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
22545 }
22546 arg2 = static_cast< int >(val2);
22547 if (arg1) (arg1)->m_y = arg2;
22548
22549 resultobj = SWIG_Py_Void();
22550 return resultobj;
22551 fail:
22552 return NULL;
22553 }
22554
22555
22556 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22557 PyObject *resultobj = 0;
22558 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22559 int result;
22560 void *argp1 = 0 ;
22561 int res1 = 0 ;
22562 PyObject *swig_obj[1] ;
22563
22564 if (!args) SWIG_fail;
22565 swig_obj[0] = args;
22566 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22567 if (!SWIG_IsOK(res1)) {
22568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22569 }
22570 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22571 result = (int) ((arg1)->m_y);
22572 resultobj = SWIG_From_int(static_cast< int >(result));
22573 return resultobj;
22574 fail:
22575 return NULL;
22576 }
22577
22578
22579 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22580 PyObject *resultobj = 0;
22581 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22582 long arg2 ;
22583 void *argp1 = 0 ;
22584 int res1 = 0 ;
22585 long val2 ;
22586 int ecode2 = 0 ;
22587 PyObject *swig_obj[2] ;
22588
22589 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_keyCode_set",2,2,swig_obj)) SWIG_fail;
22590 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22591 if (!SWIG_IsOK(res1)) {
22592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22593 }
22594 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22595 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
22596 if (!SWIG_IsOK(ecode2)) {
22597 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "2"" of type '" "long""'");
22598 }
22599 arg2 = static_cast< long >(val2);
22600 if (arg1) (arg1)->m_keyCode = arg2;
22601
22602 resultobj = SWIG_Py_Void();
22603 return resultobj;
22604 fail:
22605 return NULL;
22606 }
22607
22608
22609 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22610 PyObject *resultobj = 0;
22611 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22612 long result;
22613 void *argp1 = 0 ;
22614 int res1 = 0 ;
22615 PyObject *swig_obj[1] ;
22616
22617 if (!args) SWIG_fail;
22618 swig_obj[0] = args;
22619 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22620 if (!SWIG_IsOK(res1)) {
22621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22622 }
22623 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22624 result = (long) ((arg1)->m_keyCode);
22625 resultobj = SWIG_From_long(static_cast< long >(result));
22626 return resultobj;
22627 fail:
22628 return NULL;
22629 }
22630
22631
22632 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22633 PyObject *resultobj = 0;
22634 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22635 bool arg2 ;
22636 void *argp1 = 0 ;
22637 int res1 = 0 ;
22638 bool val2 ;
22639 int ecode2 = 0 ;
22640 PyObject *swig_obj[2] ;
22641
22642 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
22643 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22644 if (!SWIG_IsOK(res1)) {
22645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22646 }
22647 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22648 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22649 if (!SWIG_IsOK(ecode2)) {
22650 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
22651 }
22652 arg2 = static_cast< bool >(val2);
22653 if (arg1) (arg1)->m_controlDown = arg2;
22654
22655 resultobj = SWIG_Py_Void();
22656 return resultobj;
22657 fail:
22658 return NULL;
22659 }
22660
22661
22662 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22663 PyObject *resultobj = 0;
22664 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22665 bool result;
22666 void *argp1 = 0 ;
22667 int res1 = 0 ;
22668 PyObject *swig_obj[1] ;
22669
22670 if (!args) SWIG_fail;
22671 swig_obj[0] = args;
22672 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22673 if (!SWIG_IsOK(res1)) {
22674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22675 }
22676 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22677 result = (bool) ((arg1)->m_controlDown);
22678 {
22679 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22680 }
22681 return resultobj;
22682 fail:
22683 return NULL;
22684 }
22685
22686
22687 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22688 PyObject *resultobj = 0;
22689 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22690 bool arg2 ;
22691 void *argp1 = 0 ;
22692 int res1 = 0 ;
22693 bool val2 ;
22694 int ecode2 = 0 ;
22695 PyObject *swig_obj[2] ;
22696
22697 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
22698 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22699 if (!SWIG_IsOK(res1)) {
22700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22701 }
22702 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22703 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22704 if (!SWIG_IsOK(ecode2)) {
22705 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
22706 }
22707 arg2 = static_cast< bool >(val2);
22708 if (arg1) (arg1)->m_shiftDown = arg2;
22709
22710 resultobj = SWIG_Py_Void();
22711 return resultobj;
22712 fail:
22713 return NULL;
22714 }
22715
22716
22717 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22718 PyObject *resultobj = 0;
22719 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22720 bool result;
22721 void *argp1 = 0 ;
22722 int res1 = 0 ;
22723 PyObject *swig_obj[1] ;
22724
22725 if (!args) SWIG_fail;
22726 swig_obj[0] = args;
22727 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22728 if (!SWIG_IsOK(res1)) {
22729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22730 }
22731 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22732 result = (bool) ((arg1)->m_shiftDown);
22733 {
22734 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22735 }
22736 return resultobj;
22737 fail:
22738 return NULL;
22739 }
22740
22741
22742 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22743 PyObject *resultobj = 0;
22744 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22745 bool arg2 ;
22746 void *argp1 = 0 ;
22747 int res1 = 0 ;
22748 bool val2 ;
22749 int ecode2 = 0 ;
22750 PyObject *swig_obj[2] ;
22751
22752 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
22753 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22754 if (!SWIG_IsOK(res1)) {
22755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22756 }
22757 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22758 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22759 if (!SWIG_IsOK(ecode2)) {
22760 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
22761 }
22762 arg2 = static_cast< bool >(val2);
22763 if (arg1) (arg1)->m_altDown = arg2;
22764
22765 resultobj = SWIG_Py_Void();
22766 return resultobj;
22767 fail:
22768 return NULL;
22769 }
22770
22771
22772 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22773 PyObject *resultobj = 0;
22774 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22775 bool result;
22776 void *argp1 = 0 ;
22777 int res1 = 0 ;
22778 PyObject *swig_obj[1] ;
22779
22780 if (!args) SWIG_fail;
22781 swig_obj[0] = args;
22782 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22783 if (!SWIG_IsOK(res1)) {
22784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22785 }
22786 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22787 result = (bool) ((arg1)->m_altDown);
22788 {
22789 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22790 }
22791 return resultobj;
22792 fail:
22793 return NULL;
22794 }
22795
22796
22797 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22798 PyObject *resultobj = 0;
22799 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22800 bool arg2 ;
22801 void *argp1 = 0 ;
22802 int res1 = 0 ;
22803 bool val2 ;
22804 int ecode2 = 0 ;
22805 PyObject *swig_obj[2] ;
22806
22807 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
22808 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22809 if (!SWIG_IsOK(res1)) {
22810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22811 }
22812 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22813 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22814 if (!SWIG_IsOK(ecode2)) {
22815 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
22816 }
22817 arg2 = static_cast< bool >(val2);
22818 if (arg1) (arg1)->m_metaDown = arg2;
22819
22820 resultobj = SWIG_Py_Void();
22821 return resultobj;
22822 fail:
22823 return NULL;
22824 }
22825
22826
22827 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22828 PyObject *resultobj = 0;
22829 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22830 bool result;
22831 void *argp1 = 0 ;
22832 int res1 = 0 ;
22833 PyObject *swig_obj[1] ;
22834
22835 if (!args) SWIG_fail;
22836 swig_obj[0] = args;
22837 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22838 if (!SWIG_IsOK(res1)) {
22839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22840 }
22841 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22842 result = (bool) ((arg1)->m_metaDown);
22843 {
22844 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22845 }
22846 return resultobj;
22847 fail:
22848 return NULL;
22849 }
22850
22851
22852 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22853 PyObject *resultobj = 0;
22854 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22855 bool arg2 ;
22856 void *argp1 = 0 ;
22857 int res1 = 0 ;
22858 bool val2 ;
22859 int ecode2 = 0 ;
22860 PyObject *swig_obj[2] ;
22861
22862 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_scanCode_set",2,2,swig_obj)) SWIG_fail;
22863 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22864 if (!SWIG_IsOK(res1)) {
22865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22866 }
22867 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22868 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22869 if (!SWIG_IsOK(ecode2)) {
22870 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "2"" of type '" "bool""'");
22871 }
22872 arg2 = static_cast< bool >(val2);
22873 if (arg1) (arg1)->m_scanCode = arg2;
22874
22875 resultobj = SWIG_Py_Void();
22876 return resultobj;
22877 fail:
22878 return NULL;
22879 }
22880
22881
22882 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22883 PyObject *resultobj = 0;
22884 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22885 bool result;
22886 void *argp1 = 0 ;
22887 int res1 = 0 ;
22888 PyObject *swig_obj[1] ;
22889
22890 if (!args) SWIG_fail;
22891 swig_obj[0] = args;
22892 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22893 if (!SWIG_IsOK(res1)) {
22894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22895 }
22896 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22897 result = (bool) ((arg1)->m_scanCode);
22898 {
22899 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22900 }
22901 return resultobj;
22902 fail:
22903 return NULL;
22904 }
22905
22906
22907 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22908 PyObject *resultobj = 0;
22909 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22910 unsigned int arg2 ;
22911 void *argp1 = 0 ;
22912 int res1 = 0 ;
22913 unsigned int val2 ;
22914 int ecode2 = 0 ;
22915 PyObject *swig_obj[2] ;
22916
22917 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawCode_set",2,2,swig_obj)) SWIG_fail;
22918 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22919 if (!SWIG_IsOK(res1)) {
22920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22921 }
22922 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22923 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
22924 if (!SWIG_IsOK(ecode2)) {
22925 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "2"" of type '" "unsigned int""'");
22926 }
22927 arg2 = static_cast< unsigned int >(val2);
22928 if (arg1) (arg1)->m_rawCode = arg2;
22929
22930 resultobj = SWIG_Py_Void();
22931 return resultobj;
22932 fail:
22933 return NULL;
22934 }
22935
22936
22937 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22938 PyObject *resultobj = 0;
22939 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22940 unsigned int result;
22941 void *argp1 = 0 ;
22942 int res1 = 0 ;
22943 PyObject *swig_obj[1] ;
22944
22945 if (!args) SWIG_fail;
22946 swig_obj[0] = args;
22947 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22948 if (!SWIG_IsOK(res1)) {
22949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22950 }
22951 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22952 result = (unsigned int) ((arg1)->m_rawCode);
22953 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22954 return resultobj;
22955 fail:
22956 return NULL;
22957 }
22958
22959
22960 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22961 PyObject *resultobj = 0;
22962 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22963 unsigned int arg2 ;
22964 void *argp1 = 0 ;
22965 int res1 = 0 ;
22966 unsigned int val2 ;
22967 int ecode2 = 0 ;
22968 PyObject *swig_obj[2] ;
22969
22970 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawFlags_set",2,2,swig_obj)) SWIG_fail;
22971 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22972 if (!SWIG_IsOK(res1)) {
22973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22974 }
22975 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22976 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
22977 if (!SWIG_IsOK(ecode2)) {
22978 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "2"" of type '" "unsigned int""'");
22979 }
22980 arg2 = static_cast< unsigned int >(val2);
22981 if (arg1) (arg1)->m_rawFlags = arg2;
22982
22983 resultobj = SWIG_Py_Void();
22984 return resultobj;
22985 fail:
22986 return NULL;
22987 }
22988
22989
22990 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22991 PyObject *resultobj = 0;
22992 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22993 unsigned int result;
22994 void *argp1 = 0 ;
22995 int res1 = 0 ;
22996 PyObject *swig_obj[1] ;
22997
22998 if (!args) SWIG_fail;
22999 swig_obj[0] = args;
23000 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23001 if (!SWIG_IsOK(res1)) {
23002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23003 }
23004 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23005 result = (unsigned int) ((arg1)->m_rawFlags);
23006 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
23007 return resultobj;
23008 fail:
23009 return NULL;
23010 }
23011
23012
23013 SWIGINTERN PyObject *KeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23014 PyObject *obj;
23015 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23016 SWIG_TypeNewClientData(SWIGTYPE_p_wxKeyEvent, SWIG_NewClientData(obj));
23017 return SWIG_Py_Void();
23018 }
23019
23020 SWIGINTERN PyObject *KeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23021 return SWIG_Python_InitShadowInstance(args);
23022 }
23023
23024 SWIGINTERN PyObject *_wrap_new_SizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23025 PyObject *resultobj = 0;
23026 wxSize const &arg1_defvalue = wxDefaultSize ;
23027 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
23028 int arg2 = (int) 0 ;
23029 wxSizeEvent *result = 0 ;
23030 wxSize temp1 ;
23031 int val2 ;
23032 int ecode2 = 0 ;
23033 PyObject * obj0 = 0 ;
23034 PyObject * obj1 = 0 ;
23035 char * kwnames[] = {
23036 (char *) "sz",(char *) "winid", NULL
23037 };
23038
23039 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23040 if (obj0) {
23041 {
23042 arg1 = &temp1;
23043 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
23044 }
23045 }
23046 if (obj1) {
23047 ecode2 = SWIG_AsVal_int(obj1, &val2);
23048 if (!SWIG_IsOK(ecode2)) {
23049 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizeEvent" "', expected argument " "2"" of type '" "int""'");
23050 }
23051 arg2 = static_cast< int >(val2);
23052 }
23053 {
23054 PyThreadState* __tstate = wxPyBeginAllowThreads();
23055 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
23056 wxPyEndAllowThreads(__tstate);
23057 if (PyErr_Occurred()) SWIG_fail;
23058 }
23059 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_NEW | 0 );
23060 return resultobj;
23061 fail:
23062 return NULL;
23063 }
23064
23065
23066 SWIGINTERN PyObject *_wrap_SizeEvent_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23067 PyObject *resultobj = 0;
23068 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23069 wxSize result;
23070 void *argp1 = 0 ;
23071 int res1 = 0 ;
23072 PyObject *swig_obj[1] ;
23073
23074 if (!args) SWIG_fail;
23075 swig_obj[0] = args;
23076 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23077 if (!SWIG_IsOK(res1)) {
23078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetSize" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
23079 }
23080 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23081 {
23082 PyThreadState* __tstate = wxPyBeginAllowThreads();
23083 result = ((wxSizeEvent const *)arg1)->GetSize();
23084 wxPyEndAllowThreads(__tstate);
23085 if (PyErr_Occurred()) SWIG_fail;
23086 }
23087 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
23088 return resultobj;
23089 fail:
23090 return NULL;
23091 }
23092
23093
23094 SWIGINTERN PyObject *_wrap_SizeEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23095 PyObject *resultobj = 0;
23096 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23097 wxRect result;
23098 void *argp1 = 0 ;
23099 int res1 = 0 ;
23100 PyObject *swig_obj[1] ;
23101
23102 if (!args) SWIG_fail;
23103 swig_obj[0] = args;
23104 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23105 if (!SWIG_IsOK(res1)) {
23106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetRect" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
23107 }
23108 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23109 {
23110 PyThreadState* __tstate = wxPyBeginAllowThreads();
23111 result = ((wxSizeEvent const *)arg1)->GetRect();
23112 wxPyEndAllowThreads(__tstate);
23113 if (PyErr_Occurred()) SWIG_fail;
23114 }
23115 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
23116 return resultobj;
23117 fail:
23118 return NULL;
23119 }
23120
23121
23122 SWIGINTERN PyObject *_wrap_SizeEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23123 PyObject *resultobj = 0;
23124 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23125 wxRect arg2 ;
23126 void *argp1 = 0 ;
23127 int res1 = 0 ;
23128 void *argp2 ;
23129 int res2 = 0 ;
23130 PyObject * obj0 = 0 ;
23131 PyObject * obj1 = 0 ;
23132 char * kwnames[] = {
23133 (char *) "self",(char *) "rect", NULL
23134 };
23135
23136 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
23137 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23138 if (!SWIG_IsOK(res1)) {
23139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetRect" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23140 }
23141 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23142 {
23143 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRect, 0 | 0);
23144 if (!SWIG_IsOK(res2)) {
23145 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
23146 }
23147 if (!argp2) {
23148 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
23149 } else {
23150 wxRect * temp = reinterpret_cast< wxRect * >(argp2);
23151 arg2 = *temp;
23152 if (SWIG_IsNewObj(res2)) delete temp;
23153 }
23154 }
23155 {
23156 PyThreadState* __tstate = wxPyBeginAllowThreads();
23157 (arg1)->SetRect(arg2);
23158 wxPyEndAllowThreads(__tstate);
23159 if (PyErr_Occurred()) SWIG_fail;
23160 }
23161 resultobj = SWIG_Py_Void();
23162 return resultobj;
23163 fail:
23164 return NULL;
23165 }
23166
23167
23168 SWIGINTERN PyObject *_wrap_SizeEvent_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23169 PyObject *resultobj = 0;
23170 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23171 wxSize arg2 ;
23172 void *argp1 = 0 ;
23173 int res1 = 0 ;
23174 void *argp2 ;
23175 int res2 = 0 ;
23176 PyObject * obj0 = 0 ;
23177 PyObject * obj1 = 0 ;
23178 char * kwnames[] = {
23179 (char *) "self",(char *) "size", NULL
23180 };
23181
23182 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
23183 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23184 if (!SWIG_IsOK(res1)) {
23185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetSize" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23186 }
23187 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23188 {
23189 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxSize, 0 | 0);
23190 if (!SWIG_IsOK(res2)) {
23191 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23192 }
23193 if (!argp2) {
23194 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23195 } else {
23196 wxSize * temp = reinterpret_cast< wxSize * >(argp2);
23197 arg2 = *temp;
23198 if (SWIG_IsNewObj(res2)) delete temp;
23199 }
23200 }
23201 {
23202 PyThreadState* __tstate = wxPyBeginAllowThreads();
23203 wxSizeEvent_SetSize(arg1,arg2);
23204 wxPyEndAllowThreads(__tstate);
23205 if (PyErr_Occurred()) SWIG_fail;
23206 }
23207 resultobj = SWIG_Py_Void();
23208 return resultobj;
23209 fail:
23210 return NULL;
23211 }
23212
23213
23214 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23215 PyObject *resultobj = 0;
23216 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23217 wxSize *arg2 = (wxSize *) 0 ;
23218 void *argp1 = 0 ;
23219 int res1 = 0 ;
23220 void *argp2 = 0 ;
23221 int res2 = 0 ;
23222 PyObject *swig_obj[2] ;
23223
23224 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_size_set",2,2,swig_obj)) SWIG_fail;
23225 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23226 if (!SWIG_IsOK(res1)) {
23227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23228 }
23229 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23230 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSize, 0 | 0 );
23231 if (!SWIG_IsOK(res2)) {
23232 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_size_set" "', expected argument " "2"" of type '" "wxSize *""'");
23233 }
23234 arg2 = reinterpret_cast< wxSize * >(argp2);
23235 if (arg1) (arg1)->m_size = *arg2;
23236
23237 resultobj = SWIG_Py_Void();
23238 return resultobj;
23239 fail:
23240 return NULL;
23241 }
23242
23243
23244 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23245 PyObject *resultobj = 0;
23246 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23247 wxSize *result = 0 ;
23248 void *argp1 = 0 ;
23249 int res1 = 0 ;
23250 PyObject *swig_obj[1] ;
23251
23252 if (!args) SWIG_fail;
23253 swig_obj[0] = args;
23254 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23255 if (!SWIG_IsOK(res1)) {
23256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23257 }
23258 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23259 result = (wxSize *)& ((arg1)->m_size);
23260 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
23261 return resultobj;
23262 fail:
23263 return NULL;
23264 }
23265
23266
23267 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23268 PyObject *resultobj = 0;
23269 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23270 wxRect *arg2 = (wxRect *) 0 ;
23271 void *argp1 = 0 ;
23272 int res1 = 0 ;
23273 void *argp2 = 0 ;
23274 int res2 = 0 ;
23275 PyObject *swig_obj[2] ;
23276
23277 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_rect_set",2,2,swig_obj)) SWIG_fail;
23278 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23279 if (!SWIG_IsOK(res1)) {
23280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23281 }
23282 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23283 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
23284 if (!SWIG_IsOK(res2)) {
23285 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_rect_set" "', expected argument " "2"" of type '" "wxRect *""'");
23286 }
23287 arg2 = reinterpret_cast< wxRect * >(argp2);
23288 if (arg1) (arg1)->m_rect = *arg2;
23289
23290 resultobj = SWIG_Py_Void();
23291 return resultobj;
23292 fail:
23293 return NULL;
23294 }
23295
23296
23297 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23298 PyObject *resultobj = 0;
23299 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23300 wxRect *result = 0 ;
23301 void *argp1 = 0 ;
23302 int res1 = 0 ;
23303 PyObject *swig_obj[1] ;
23304
23305 if (!args) SWIG_fail;
23306 swig_obj[0] = args;
23307 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23308 if (!SWIG_IsOK(res1)) {
23309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23310 }
23311 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23312 result = (wxRect *)& ((arg1)->m_rect);
23313 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
23314 return resultobj;
23315 fail:
23316 return NULL;
23317 }
23318
23319
23320 SWIGINTERN PyObject *SizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23321 PyObject *obj;
23322 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23323 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizeEvent, SWIG_NewClientData(obj));
23324 return SWIG_Py_Void();
23325 }
23326
23327 SWIGINTERN PyObject *SizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23328 return SWIG_Python_InitShadowInstance(args);
23329 }
23330
23331 SWIGINTERN PyObject *_wrap_new_MoveEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23332 PyObject *resultobj = 0;
23333 wxPoint const &arg1_defvalue = wxDefaultPosition ;
23334 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
23335 int arg2 = (int) 0 ;
23336 wxMoveEvent *result = 0 ;
23337 wxPoint temp1 ;
23338 int val2 ;
23339 int ecode2 = 0 ;
23340 PyObject * obj0 = 0 ;
23341 PyObject * obj1 = 0 ;
23342 char * kwnames[] = {
23343 (char *) "pos",(char *) "winid", NULL
23344 };
23345
23346 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23347 if (obj0) {
23348 {
23349 arg1 = &temp1;
23350 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
23351 }
23352 }
23353 if (obj1) {
23354 ecode2 = SWIG_AsVal_int(obj1, &val2);
23355 if (!SWIG_IsOK(ecode2)) {
23356 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MoveEvent" "', expected argument " "2"" of type '" "int""'");
23357 }
23358 arg2 = static_cast< int >(val2);
23359 }
23360 {
23361 PyThreadState* __tstate = wxPyBeginAllowThreads();
23362 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
23363 wxPyEndAllowThreads(__tstate);
23364 if (PyErr_Occurred()) SWIG_fail;
23365 }
23366 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_NEW | 0 );
23367 return resultobj;
23368 fail:
23369 return NULL;
23370 }
23371
23372
23373 SWIGINTERN PyObject *_wrap_MoveEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23374 PyObject *resultobj = 0;
23375 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23376 wxPoint result;
23377 void *argp1 = 0 ;
23378 int res1 = 0 ;
23379 PyObject *swig_obj[1] ;
23380
23381 if (!args) SWIG_fail;
23382 swig_obj[0] = args;
23383 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23384 if (!SWIG_IsOK(res1)) {
23385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetPosition" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23386 }
23387 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23388 {
23389 PyThreadState* __tstate = wxPyBeginAllowThreads();
23390 result = ((wxMoveEvent const *)arg1)->GetPosition();
23391 wxPyEndAllowThreads(__tstate);
23392 if (PyErr_Occurred()) SWIG_fail;
23393 }
23394 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23395 return resultobj;
23396 fail:
23397 return NULL;
23398 }
23399
23400
23401 SWIGINTERN PyObject *_wrap_MoveEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23402 PyObject *resultobj = 0;
23403 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23404 wxRect result;
23405 void *argp1 = 0 ;
23406 int res1 = 0 ;
23407 PyObject *swig_obj[1] ;
23408
23409 if (!args) SWIG_fail;
23410 swig_obj[0] = args;
23411 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23412 if (!SWIG_IsOK(res1)) {
23413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetRect" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23414 }
23415 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23416 {
23417 PyThreadState* __tstate = wxPyBeginAllowThreads();
23418 result = ((wxMoveEvent const *)arg1)->GetRect();
23419 wxPyEndAllowThreads(__tstate);
23420 if (PyErr_Occurred()) SWIG_fail;
23421 }
23422 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
23423 return resultobj;
23424 fail:
23425 return NULL;
23426 }
23427
23428
23429 SWIGINTERN PyObject *_wrap_MoveEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23430 PyObject *resultobj = 0;
23431 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23432 wxRect *arg2 = 0 ;
23433 void *argp1 = 0 ;
23434 int res1 = 0 ;
23435 wxRect temp2 ;
23436 PyObject * obj0 = 0 ;
23437 PyObject * obj1 = 0 ;
23438 char * kwnames[] = {
23439 (char *) "self",(char *) "rect", NULL
23440 };
23441
23442 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
23443 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23444 if (!SWIG_IsOK(res1)) {
23445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetRect" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23446 }
23447 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23448 {
23449 arg2 = &temp2;
23450 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
23451 }
23452 {
23453 PyThreadState* __tstate = wxPyBeginAllowThreads();
23454 (arg1)->SetRect((wxRect const &)*arg2);
23455 wxPyEndAllowThreads(__tstate);
23456 if (PyErr_Occurred()) SWIG_fail;
23457 }
23458 resultobj = SWIG_Py_Void();
23459 return resultobj;
23460 fail:
23461 return NULL;
23462 }
23463
23464
23465 SWIGINTERN PyObject *_wrap_MoveEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23466 PyObject *resultobj = 0;
23467 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23468 wxPoint *arg2 = 0 ;
23469 void *argp1 = 0 ;
23470 int res1 = 0 ;
23471 wxPoint temp2 ;
23472 PyObject * obj0 = 0 ;
23473 PyObject * obj1 = 0 ;
23474 char * kwnames[] = {
23475 (char *) "self",(char *) "pos", NULL
23476 };
23477
23478 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
23479 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23480 if (!SWIG_IsOK(res1)) {
23481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetPosition" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23482 }
23483 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23484 {
23485 arg2 = &temp2;
23486 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
23487 }
23488 {
23489 PyThreadState* __tstate = wxPyBeginAllowThreads();
23490 (arg1)->SetPosition((wxPoint const &)*arg2);
23491 wxPyEndAllowThreads(__tstate);
23492 if (PyErr_Occurred()) SWIG_fail;
23493 }
23494 resultobj = SWIG_Py_Void();
23495 return resultobj;
23496 fail:
23497 return NULL;
23498 }
23499
23500
23501 SWIGINTERN PyObject *MoveEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23502 PyObject *obj;
23503 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23504 SWIG_TypeNewClientData(SWIGTYPE_p_wxMoveEvent, SWIG_NewClientData(obj));
23505 return SWIG_Py_Void();
23506 }
23507
23508 SWIGINTERN PyObject *MoveEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23509 return SWIG_Python_InitShadowInstance(args);
23510 }
23511
23512 SWIGINTERN PyObject *_wrap_new_PaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23513 PyObject *resultobj = 0;
23514 int arg1 = (int) 0 ;
23515 wxPaintEvent *result = 0 ;
23516 int val1 ;
23517 int ecode1 = 0 ;
23518 PyObject * obj0 = 0 ;
23519 char * kwnames[] = {
23520 (char *) "Id", NULL
23521 };
23522
23523 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) SWIG_fail;
23524 if (obj0) {
23525 ecode1 = SWIG_AsVal_int(obj0, &val1);
23526 if (!SWIG_IsOK(ecode1)) {
23527 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaintEvent" "', expected argument " "1"" of type '" "int""'");
23528 }
23529 arg1 = static_cast< int >(val1);
23530 }
23531 {
23532 PyThreadState* __tstate = wxPyBeginAllowThreads();
23533 result = (wxPaintEvent *)new wxPaintEvent(arg1);
23534 wxPyEndAllowThreads(__tstate);
23535 if (PyErr_Occurred()) SWIG_fail;
23536 }
23537 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_NEW | 0 );
23538 return resultobj;
23539 fail:
23540 return NULL;
23541 }
23542
23543
23544 SWIGINTERN PyObject *PaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23545 PyObject *obj;
23546 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23547 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaintEvent, SWIG_NewClientData(obj));
23548 return SWIG_Py_Void();
23549 }
23550
23551 SWIGINTERN PyObject *PaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23552 return SWIG_Python_InitShadowInstance(args);
23553 }
23554
23555 SWIGINTERN PyObject *_wrap_new_NcPaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23556 PyObject *resultobj = 0;
23557 int arg1 = (int) 0 ;
23558 wxNcPaintEvent *result = 0 ;
23559 int val1 ;
23560 int ecode1 = 0 ;
23561 PyObject * obj0 = 0 ;
23562 char * kwnames[] = {
23563 (char *) "winid", NULL
23564 };
23565
23566 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) SWIG_fail;
23567 if (obj0) {
23568 ecode1 = SWIG_AsVal_int(obj0, &val1);
23569 if (!SWIG_IsOK(ecode1)) {
23570 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NcPaintEvent" "', expected argument " "1"" of type '" "int""'");
23571 }
23572 arg1 = static_cast< int >(val1);
23573 }
23574 {
23575 PyThreadState* __tstate = wxPyBeginAllowThreads();
23576 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
23577 wxPyEndAllowThreads(__tstate);
23578 if (PyErr_Occurred()) SWIG_fail;
23579 }
23580 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNcPaintEvent, SWIG_POINTER_NEW | 0 );
23581 return resultobj;
23582 fail:
23583 return NULL;
23584 }
23585
23586
23587 SWIGINTERN PyObject *NcPaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23588 PyObject *obj;
23589 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23590 SWIG_TypeNewClientData(SWIGTYPE_p_wxNcPaintEvent, SWIG_NewClientData(obj));
23591 return SWIG_Py_Void();
23592 }
23593
23594 SWIGINTERN PyObject *NcPaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23595 return SWIG_Python_InitShadowInstance(args);
23596 }
23597
23598 SWIGINTERN PyObject *_wrap_new_EraseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23599 PyObject *resultobj = 0;
23600 int arg1 = (int) 0 ;
23601 wxDC *arg2 = (wxDC *) NULL ;
23602 wxEraseEvent *result = 0 ;
23603 int val1 ;
23604 int ecode1 = 0 ;
23605 void *argp2 = 0 ;
23606 int res2 = 0 ;
23607 PyObject * obj0 = 0 ;
23608 PyObject * obj1 = 0 ;
23609 char * kwnames[] = {
23610 (char *) "Id",(char *) "dc", NULL
23611 };
23612
23613 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23614 if (obj0) {
23615 ecode1 = SWIG_AsVal_int(obj0, &val1);
23616 if (!SWIG_IsOK(ecode1)) {
23617 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EraseEvent" "', expected argument " "1"" of type '" "int""'");
23618 }
23619 arg1 = static_cast< int >(val1);
23620 }
23621 if (obj1) {
23622 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDC, 0 | 0 );
23623 if (!SWIG_IsOK(res2)) {
23624 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EraseEvent" "', expected argument " "2"" of type '" "wxDC *""'");
23625 }
23626 arg2 = reinterpret_cast< wxDC * >(argp2);
23627 }
23628 {
23629 PyThreadState* __tstate = wxPyBeginAllowThreads();
23630 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
23631 wxPyEndAllowThreads(__tstate);
23632 if (PyErr_Occurred()) SWIG_fail;
23633 }
23634 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_NEW | 0 );
23635 return resultobj;
23636 fail:
23637 return NULL;
23638 }
23639
23640
23641 SWIGINTERN PyObject *_wrap_EraseEvent_GetDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23642 PyObject *resultobj = 0;
23643 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
23644 wxDC *result = 0 ;
23645 void *argp1 = 0 ;
23646 int res1 = 0 ;
23647 PyObject *swig_obj[1] ;
23648
23649 if (!args) SWIG_fail;
23650 swig_obj[0] = args;
23651 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEraseEvent, 0 | 0 );
23652 if (!SWIG_IsOK(res1)) {
23653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EraseEvent_GetDC" "', expected argument " "1"" of type '" "wxEraseEvent const *""'");
23654 }
23655 arg1 = reinterpret_cast< wxEraseEvent * >(argp1);
23656 {
23657 PyThreadState* __tstate = wxPyBeginAllowThreads();
23658 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
23659 wxPyEndAllowThreads(__tstate);
23660 if (PyErr_Occurred()) SWIG_fail;
23661 }
23662 {
23663 resultobj = wxPyMake_wxObject(result, (bool)0);
23664 }
23665 return resultobj;
23666 fail:
23667 return NULL;
23668 }
23669
23670
23671 SWIGINTERN PyObject *EraseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23672 PyObject *obj;
23673 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23674 SWIG_TypeNewClientData(SWIGTYPE_p_wxEraseEvent, SWIG_NewClientData(obj));
23675 return SWIG_Py_Void();
23676 }
23677
23678 SWIGINTERN PyObject *EraseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23679 return SWIG_Python_InitShadowInstance(args);
23680 }
23681
23682 SWIGINTERN PyObject *_wrap_new_FocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23683 PyObject *resultobj = 0;
23684 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23685 int arg2 = (int) 0 ;
23686 wxFocusEvent *result = 0 ;
23687 int val1 ;
23688 int ecode1 = 0 ;
23689 int val2 ;
23690 int ecode2 = 0 ;
23691 PyObject * obj0 = 0 ;
23692 PyObject * obj1 = 0 ;
23693 char * kwnames[] = {
23694 (char *) "type",(char *) "winid", NULL
23695 };
23696
23697 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23698 if (obj0) {
23699 ecode1 = SWIG_AsVal_int(obj0, &val1);
23700 if (!SWIG_IsOK(ecode1)) {
23701 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FocusEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23702 }
23703 arg1 = static_cast< wxEventType >(val1);
23704 }
23705 if (obj1) {
23706 ecode2 = SWIG_AsVal_int(obj1, &val2);
23707 if (!SWIG_IsOK(ecode2)) {
23708 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FocusEvent" "', expected argument " "2"" of type '" "int""'");
23709 }
23710 arg2 = static_cast< int >(val2);
23711 }
23712 {
23713 PyThreadState* __tstate = wxPyBeginAllowThreads();
23714 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
23715 wxPyEndAllowThreads(__tstate);
23716 if (PyErr_Occurred()) SWIG_fail;
23717 }
23718 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_NEW | 0 );
23719 return resultobj;
23720 fail:
23721 return NULL;
23722 }
23723
23724
23725 SWIGINTERN PyObject *_wrap_FocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23726 PyObject *resultobj = 0;
23727 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
23728 wxWindow *result = 0 ;
23729 void *argp1 = 0 ;
23730 int res1 = 0 ;
23731 PyObject *swig_obj[1] ;
23732
23733 if (!args) SWIG_fail;
23734 swig_obj[0] = args;
23735 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
23736 if (!SWIG_IsOK(res1)) {
23737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxFocusEvent const *""'");
23738 }
23739 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
23740 {
23741 PyThreadState* __tstate = wxPyBeginAllowThreads();
23742 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
23743 wxPyEndAllowThreads(__tstate);
23744 if (PyErr_Occurred()) SWIG_fail;
23745 }
23746 {
23747 resultobj = wxPyMake_wxObject(result, (bool)0);
23748 }
23749 return resultobj;
23750 fail:
23751 return NULL;
23752 }
23753
23754
23755 SWIGINTERN PyObject *_wrap_FocusEvent_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23756 PyObject *resultobj = 0;
23757 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
23758 wxWindow *arg2 = (wxWindow *) 0 ;
23759 void *argp1 = 0 ;
23760 int res1 = 0 ;
23761 void *argp2 = 0 ;
23762 int res2 = 0 ;
23763 PyObject * obj0 = 0 ;
23764 PyObject * obj1 = 0 ;
23765 char * kwnames[] = {
23766 (char *) "self",(char *) "win", NULL
23767 };
23768
23769 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
23770 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
23771 if (!SWIG_IsOK(res1)) {
23772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_SetWindow" "', expected argument " "1"" of type '" "wxFocusEvent *""'");
23773 }
23774 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
23775 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
23776 if (!SWIG_IsOK(res2)) {
23777 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FocusEvent_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
23778 }
23779 arg2 = reinterpret_cast< wxWindow * >(argp2);
23780 {
23781 PyThreadState* __tstate = wxPyBeginAllowThreads();
23782 (arg1)->SetWindow(arg2);
23783 wxPyEndAllowThreads(__tstate);
23784 if (PyErr_Occurred()) SWIG_fail;
23785 }
23786 resultobj = SWIG_Py_Void();
23787 return resultobj;
23788 fail:
23789 return NULL;
23790 }
23791
23792
23793 SWIGINTERN PyObject *FocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23794 PyObject *obj;
23795 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23796 SWIG_TypeNewClientData(SWIGTYPE_p_wxFocusEvent, SWIG_NewClientData(obj));
23797 return SWIG_Py_Void();
23798 }
23799
23800 SWIGINTERN PyObject *FocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23801 return SWIG_Python_InitShadowInstance(args);
23802 }
23803
23804 SWIGINTERN PyObject *_wrap_new_ChildFocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23805 PyObject *resultobj = 0;
23806 wxWindow *arg1 = (wxWindow *) NULL ;
23807 wxChildFocusEvent *result = 0 ;
23808 void *argp1 = 0 ;
23809 int res1 = 0 ;
23810 PyObject * obj0 = 0 ;
23811 char * kwnames[] = {
23812 (char *) "win", NULL
23813 };
23814
23815 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) SWIG_fail;
23816 if (obj0) {
23817 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
23818 if (!SWIG_IsOK(res1)) {
23819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ChildFocusEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
23820 }
23821 arg1 = reinterpret_cast< wxWindow * >(argp1);
23822 }
23823 {
23824 PyThreadState* __tstate = wxPyBeginAllowThreads();
23825 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
23826 wxPyEndAllowThreads(__tstate);
23827 if (PyErr_Occurred()) SWIG_fail;
23828 }
23829 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_NEW | 0 );
23830 return resultobj;
23831 fail:
23832 return NULL;
23833 }
23834
23835
23836 SWIGINTERN PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23837 PyObject *resultobj = 0;
23838 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
23839 wxWindow *result = 0 ;
23840 void *argp1 = 0 ;
23841 int res1 = 0 ;
23842 PyObject *swig_obj[1] ;
23843
23844 if (!args) SWIG_fail;
23845 swig_obj[0] = args;
23846 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxChildFocusEvent, 0 | 0 );
23847 if (!SWIG_IsOK(res1)) {
23848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChildFocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxChildFocusEvent const *""'");
23849 }
23850 arg1 = reinterpret_cast< wxChildFocusEvent * >(argp1);
23851 {
23852 PyThreadState* __tstate = wxPyBeginAllowThreads();
23853 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
23854 wxPyEndAllowThreads(__tstate);
23855 if (PyErr_Occurred()) SWIG_fail;
23856 }
23857 {
23858 resultobj = wxPyMake_wxObject(result, (bool)0);
23859 }
23860 return resultobj;
23861 fail:
23862 return NULL;
23863 }
23864
23865
23866 SWIGINTERN PyObject *ChildFocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23867 PyObject *obj;
23868 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23869 SWIG_TypeNewClientData(SWIGTYPE_p_wxChildFocusEvent, SWIG_NewClientData(obj));
23870 return SWIG_Py_Void();
23871 }
23872
23873 SWIGINTERN PyObject *ChildFocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23874 return SWIG_Python_InitShadowInstance(args);
23875 }
23876
23877 SWIGINTERN PyObject *_wrap_new_ActivateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23878 PyObject *resultobj = 0;
23879 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23880 bool arg2 = (bool) true ;
23881 int arg3 = (int) 0 ;
23882 wxActivateEvent *result = 0 ;
23883 int val1 ;
23884 int ecode1 = 0 ;
23885 bool val2 ;
23886 int ecode2 = 0 ;
23887 int val3 ;
23888 int ecode3 = 0 ;
23889 PyObject * obj0 = 0 ;
23890 PyObject * obj1 = 0 ;
23891 PyObject * obj2 = 0 ;
23892 char * kwnames[] = {
23893 (char *) "type",(char *) "active",(char *) "Id", NULL
23894 };
23895
23896 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23897 if (obj0) {
23898 ecode1 = SWIG_AsVal_int(obj0, &val1);
23899 if (!SWIG_IsOK(ecode1)) {
23900 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ActivateEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23901 }
23902 arg1 = static_cast< wxEventType >(val1);
23903 }
23904 if (obj1) {
23905 ecode2 = SWIG_AsVal_bool(obj1, &val2);
23906 if (!SWIG_IsOK(ecode2)) {
23907 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ActivateEvent" "', expected argument " "2"" of type '" "bool""'");
23908 }
23909 arg2 = static_cast< bool >(val2);
23910 }
23911 if (obj2) {
23912 ecode3 = SWIG_AsVal_int(obj2, &val3);
23913 if (!SWIG_IsOK(ecode3)) {
23914 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ActivateEvent" "', expected argument " "3"" of type '" "int""'");
23915 }
23916 arg3 = static_cast< int >(val3);
23917 }
23918 {
23919 PyThreadState* __tstate = wxPyBeginAllowThreads();
23920 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
23921 wxPyEndAllowThreads(__tstate);
23922 if (PyErr_Occurred()) SWIG_fail;
23923 }
23924 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_NEW | 0 );
23925 return resultobj;
23926 fail:
23927 return NULL;
23928 }
23929
23930
23931 SWIGINTERN PyObject *_wrap_ActivateEvent_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23932 PyObject *resultobj = 0;
23933 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
23934 bool result;
23935 void *argp1 = 0 ;
23936 int res1 = 0 ;
23937 PyObject *swig_obj[1] ;
23938
23939 if (!args) SWIG_fail;
23940 swig_obj[0] = args;
23941 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxActivateEvent, 0 | 0 );
23942 if (!SWIG_IsOK(res1)) {
23943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActivateEvent_GetActive" "', expected argument " "1"" of type '" "wxActivateEvent const *""'");
23944 }
23945 arg1 = reinterpret_cast< wxActivateEvent * >(argp1);
23946 {
23947 PyThreadState* __tstate = wxPyBeginAllowThreads();
23948 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
23949 wxPyEndAllowThreads(__tstate);
23950 if (PyErr_Occurred()) SWIG_fail;
23951 }
23952 {
23953 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23954 }
23955 return resultobj;
23956 fail:
23957 return NULL;
23958 }
23959
23960
23961 SWIGINTERN PyObject *ActivateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23962 PyObject *obj;
23963 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23964 SWIG_TypeNewClientData(SWIGTYPE_p_wxActivateEvent, SWIG_NewClientData(obj));
23965 return SWIG_Py_Void();
23966 }
23967
23968 SWIGINTERN PyObject *ActivateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23969 return SWIG_Python_InitShadowInstance(args);
23970 }
23971
23972 SWIGINTERN PyObject *_wrap_new_InitDialogEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23973 PyObject *resultobj = 0;
23974 int arg1 = (int) 0 ;
23975 wxInitDialogEvent *result = 0 ;
23976 int val1 ;
23977 int ecode1 = 0 ;
23978 PyObject * obj0 = 0 ;
23979 char * kwnames[] = {
23980 (char *) "Id", NULL
23981 };
23982
23983 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) SWIG_fail;
23984 if (obj0) {
23985 ecode1 = SWIG_AsVal_int(obj0, &val1);
23986 if (!SWIG_IsOK(ecode1)) {
23987 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InitDialogEvent" "', expected argument " "1"" of type '" "int""'");
23988 }
23989 arg1 = static_cast< int >(val1);
23990 }
23991 {
23992 PyThreadState* __tstate = wxPyBeginAllowThreads();
23993 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
23994 wxPyEndAllowThreads(__tstate);
23995 if (PyErr_Occurred()) SWIG_fail;
23996 }
23997 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInitDialogEvent, SWIG_POINTER_NEW | 0 );
23998 return resultobj;
23999 fail:
24000 return NULL;
24001 }
24002
24003
24004 SWIGINTERN PyObject *InitDialogEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24005 PyObject *obj;
24006 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24007 SWIG_TypeNewClientData(SWIGTYPE_p_wxInitDialogEvent, SWIG_NewClientData(obj));
24008 return SWIG_Py_Void();
24009 }
24010
24011 SWIGINTERN PyObject *InitDialogEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24012 return SWIG_Python_InitShadowInstance(args);
24013 }
24014
24015 SWIGINTERN PyObject *_wrap_new_MenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24016 PyObject *resultobj = 0;
24017 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24018 int arg2 = (int) 0 ;
24019 wxMenu *arg3 = (wxMenu *) NULL ;
24020 wxMenuEvent *result = 0 ;
24021 int val1 ;
24022 int ecode1 = 0 ;
24023 int val2 ;
24024 int ecode2 = 0 ;
24025 void *argp3 = 0 ;
24026 int res3 = 0 ;
24027 PyObject * obj0 = 0 ;
24028 PyObject * obj1 = 0 ;
24029 PyObject * obj2 = 0 ;
24030 char * kwnames[] = {
24031 (char *) "type",(char *) "winid",(char *) "menu", NULL
24032 };
24033
24034 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24035 if (obj0) {
24036 ecode1 = SWIG_AsVal_int(obj0, &val1);
24037 if (!SWIG_IsOK(ecode1)) {
24038 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24039 }
24040 arg1 = static_cast< wxEventType >(val1);
24041 }
24042 if (obj1) {
24043 ecode2 = SWIG_AsVal_int(obj1, &val2);
24044 if (!SWIG_IsOK(ecode2)) {
24045 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuEvent" "', expected argument " "2"" of type '" "int""'");
24046 }
24047 arg2 = static_cast< int >(val2);
24048 }
24049 if (obj2) {
24050 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
24051 if (!SWIG_IsOK(res3)) {
24052 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MenuEvent" "', expected argument " "3"" of type '" "wxMenu *""'");
24053 }
24054 arg3 = reinterpret_cast< wxMenu * >(argp3);
24055 }
24056 {
24057 PyThreadState* __tstate = wxPyBeginAllowThreads();
24058 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
24059 wxPyEndAllowThreads(__tstate);
24060 if (PyErr_Occurred()) SWIG_fail;
24061 }
24062 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_NEW | 0 );
24063 return resultobj;
24064 fail:
24065 return NULL;
24066 }
24067
24068
24069 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenuId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24070 PyObject *resultobj = 0;
24071 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24072 int result;
24073 void *argp1 = 0 ;
24074 int res1 = 0 ;
24075 PyObject *swig_obj[1] ;
24076
24077 if (!args) SWIG_fail;
24078 swig_obj[0] = args;
24079 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24080 if (!SWIG_IsOK(res1)) {
24081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenuId" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24082 }
24083 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24084 {
24085 PyThreadState* __tstate = wxPyBeginAllowThreads();
24086 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
24087 wxPyEndAllowThreads(__tstate);
24088 if (PyErr_Occurred()) SWIG_fail;
24089 }
24090 resultobj = SWIG_From_int(static_cast< int >(result));
24091 return resultobj;
24092 fail:
24093 return NULL;
24094 }
24095
24096
24097 SWIGINTERN PyObject *_wrap_MenuEvent_IsPopup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24098 PyObject *resultobj = 0;
24099 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24100 bool result;
24101 void *argp1 = 0 ;
24102 int res1 = 0 ;
24103 PyObject *swig_obj[1] ;
24104
24105 if (!args) SWIG_fail;
24106 swig_obj[0] = args;
24107 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24108 if (!SWIG_IsOK(res1)) {
24109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_IsPopup" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24110 }
24111 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24112 {
24113 PyThreadState* __tstate = wxPyBeginAllowThreads();
24114 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
24115 wxPyEndAllowThreads(__tstate);
24116 if (PyErr_Occurred()) SWIG_fail;
24117 }
24118 {
24119 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24120 }
24121 return resultobj;
24122 fail:
24123 return NULL;
24124 }
24125
24126
24127 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24128 PyObject *resultobj = 0;
24129 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24130 wxMenu *result = 0 ;
24131 void *argp1 = 0 ;
24132 int res1 = 0 ;
24133 PyObject *swig_obj[1] ;
24134
24135 if (!args) SWIG_fail;
24136 swig_obj[0] = args;
24137 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24138 if (!SWIG_IsOK(res1)) {
24139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenu" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24140 }
24141 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24142 {
24143 PyThreadState* __tstate = wxPyBeginAllowThreads();
24144 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
24145 wxPyEndAllowThreads(__tstate);
24146 if (PyErr_Occurred()) SWIG_fail;
24147 }
24148 {
24149 resultobj = wxPyMake_wxObject(result, (bool)0);
24150 }
24151 return resultobj;
24152 fail:
24153 return NULL;
24154 }
24155
24156
24157 SWIGINTERN PyObject *MenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24158 PyObject *obj;
24159 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24160 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuEvent, SWIG_NewClientData(obj));
24161 return SWIG_Py_Void();
24162 }
24163
24164 SWIGINTERN PyObject *MenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24165 return SWIG_Python_InitShadowInstance(args);
24166 }
24167
24168 SWIGINTERN PyObject *_wrap_new_CloseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24169 PyObject *resultobj = 0;
24170 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24171 int arg2 = (int) 0 ;
24172 wxCloseEvent *result = 0 ;
24173 int val1 ;
24174 int ecode1 = 0 ;
24175 int val2 ;
24176 int ecode2 = 0 ;
24177 PyObject * obj0 = 0 ;
24178 PyObject * obj1 = 0 ;
24179 char * kwnames[] = {
24180 (char *) "type",(char *) "winid", NULL
24181 };
24182
24183 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24184 if (obj0) {
24185 ecode1 = SWIG_AsVal_int(obj0, &val1);
24186 if (!SWIG_IsOK(ecode1)) {
24187 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CloseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24188 }
24189 arg1 = static_cast< wxEventType >(val1);
24190 }
24191 if (obj1) {
24192 ecode2 = SWIG_AsVal_int(obj1, &val2);
24193 if (!SWIG_IsOK(ecode2)) {
24194 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CloseEvent" "', expected argument " "2"" of type '" "int""'");
24195 }
24196 arg2 = static_cast< int >(val2);
24197 }
24198 {
24199 PyThreadState* __tstate = wxPyBeginAllowThreads();
24200 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
24201 wxPyEndAllowThreads(__tstate);
24202 if (PyErr_Occurred()) SWIG_fail;
24203 }
24204 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_NEW | 0 );
24205 return resultobj;
24206 fail:
24207 return NULL;
24208 }
24209
24210
24211 SWIGINTERN PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24212 PyObject *resultobj = 0;
24213 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24214 bool arg2 ;
24215 void *argp1 = 0 ;
24216 int res1 = 0 ;
24217 bool val2 ;
24218 int ecode2 = 0 ;
24219 PyObject * obj0 = 0 ;
24220 PyObject * obj1 = 0 ;
24221 char * kwnames[] = {
24222 (char *) "self",(char *) "logOff", NULL
24223 };
24224
24225 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) SWIG_fail;
24226 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24227 if (!SWIG_IsOK(res1)) {
24228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24229 }
24230 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24231 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24232 if (!SWIG_IsOK(ecode2)) {
24233 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "2"" of type '" "bool""'");
24234 }
24235 arg2 = static_cast< bool >(val2);
24236 {
24237 PyThreadState* __tstate = wxPyBeginAllowThreads();
24238 (arg1)->SetLoggingOff(arg2);
24239 wxPyEndAllowThreads(__tstate);
24240 if (PyErr_Occurred()) SWIG_fail;
24241 }
24242 resultobj = SWIG_Py_Void();
24243 return resultobj;
24244 fail:
24245 return NULL;
24246 }
24247
24248
24249 SWIGINTERN PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24250 PyObject *resultobj = 0;
24251 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24252 bool result;
24253 void *argp1 = 0 ;
24254 int res1 = 0 ;
24255 PyObject *swig_obj[1] ;
24256
24257 if (!args) SWIG_fail;
24258 swig_obj[0] = args;
24259 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24260 if (!SWIG_IsOK(res1)) {
24261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24262 }
24263 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24264 {
24265 PyThreadState* __tstate = wxPyBeginAllowThreads();
24266 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
24267 wxPyEndAllowThreads(__tstate);
24268 if (PyErr_Occurred()) SWIG_fail;
24269 }
24270 {
24271 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24272 }
24273 return resultobj;
24274 fail:
24275 return NULL;
24276 }
24277
24278
24279 SWIGINTERN PyObject *_wrap_CloseEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24280 PyObject *resultobj = 0;
24281 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24282 bool arg2 = (bool) true ;
24283 void *argp1 = 0 ;
24284 int res1 = 0 ;
24285 bool val2 ;
24286 int ecode2 = 0 ;
24287 PyObject * obj0 = 0 ;
24288 PyObject * obj1 = 0 ;
24289 char * kwnames[] = {
24290 (char *) "self",(char *) "veto", NULL
24291 };
24292
24293 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) SWIG_fail;
24294 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24295 if (!SWIG_IsOK(res1)) {
24296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_Veto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24297 }
24298 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24299 if (obj1) {
24300 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24301 if (!SWIG_IsOK(ecode2)) {
24302 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_Veto" "', expected argument " "2"" of type '" "bool""'");
24303 }
24304 arg2 = static_cast< bool >(val2);
24305 }
24306 {
24307 PyThreadState* __tstate = wxPyBeginAllowThreads();
24308 (arg1)->Veto(arg2);
24309 wxPyEndAllowThreads(__tstate);
24310 if (PyErr_Occurred()) SWIG_fail;
24311 }
24312 resultobj = SWIG_Py_Void();
24313 return resultobj;
24314 fail:
24315 return NULL;
24316 }
24317
24318
24319 SWIGINTERN PyObject *_wrap_CloseEvent_GetVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24320 PyObject *resultobj = 0;
24321 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24322 bool result;
24323 void *argp1 = 0 ;
24324 int res1 = 0 ;
24325 PyObject *swig_obj[1] ;
24326
24327 if (!args) SWIG_fail;
24328 swig_obj[0] = args;
24329 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24330 if (!SWIG_IsOK(res1)) {
24331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24332 }
24333 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24334 {
24335 PyThreadState* __tstate = wxPyBeginAllowThreads();
24336 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
24337 wxPyEndAllowThreads(__tstate);
24338 if (PyErr_Occurred()) SWIG_fail;
24339 }
24340 {
24341 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24342 }
24343 return resultobj;
24344 fail:
24345 return NULL;
24346 }
24347
24348
24349 SWIGINTERN PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24350 PyObject *resultobj = 0;
24351 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24352 bool arg2 ;
24353 void *argp1 = 0 ;
24354 int res1 = 0 ;
24355 bool val2 ;
24356 int ecode2 = 0 ;
24357 PyObject * obj0 = 0 ;
24358 PyObject * obj1 = 0 ;
24359 char * kwnames[] = {
24360 (char *) "self",(char *) "canVeto", NULL
24361 };
24362
24363 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) SWIG_fail;
24364 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24365 if (!SWIG_IsOK(res1)) {
24366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24367 }
24368 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24369 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24370 if (!SWIG_IsOK(ecode2)) {
24371 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "2"" of type '" "bool""'");
24372 }
24373 arg2 = static_cast< bool >(val2);
24374 {
24375 PyThreadState* __tstate = wxPyBeginAllowThreads();
24376 (arg1)->SetCanVeto(arg2);
24377 wxPyEndAllowThreads(__tstate);
24378 if (PyErr_Occurred()) SWIG_fail;
24379 }
24380 resultobj = SWIG_Py_Void();
24381 return resultobj;
24382 fail:
24383 return NULL;
24384 }
24385
24386
24387 SWIGINTERN PyObject *_wrap_CloseEvent_CanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24388 PyObject *resultobj = 0;
24389 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24390 bool result;
24391 void *argp1 = 0 ;
24392 int res1 = 0 ;
24393 PyObject *swig_obj[1] ;
24394
24395 if (!args) SWIG_fail;
24396 swig_obj[0] = args;
24397 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24398 if (!SWIG_IsOK(res1)) {
24399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_CanVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24400 }
24401 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24402 {
24403 PyThreadState* __tstate = wxPyBeginAllowThreads();
24404 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
24405 wxPyEndAllowThreads(__tstate);
24406 if (PyErr_Occurred()) SWIG_fail;
24407 }
24408 {
24409 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24410 }
24411 return resultobj;
24412 fail:
24413 return NULL;
24414 }
24415
24416
24417 SWIGINTERN PyObject *CloseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24418 PyObject *obj;
24419 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24420 SWIG_TypeNewClientData(SWIGTYPE_p_wxCloseEvent, SWIG_NewClientData(obj));
24421 return SWIG_Py_Void();
24422 }
24423
24424 SWIGINTERN PyObject *CloseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24425 return SWIG_Python_InitShadowInstance(args);
24426 }
24427
24428 SWIGINTERN PyObject *_wrap_new_ShowEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24429 PyObject *resultobj = 0;
24430 int arg1 = (int) 0 ;
24431 bool arg2 = (bool) false ;
24432 wxShowEvent *result = 0 ;
24433 int val1 ;
24434 int ecode1 = 0 ;
24435 bool val2 ;
24436 int ecode2 = 0 ;
24437 PyObject * obj0 = 0 ;
24438 PyObject * obj1 = 0 ;
24439 char * kwnames[] = {
24440 (char *) "winid",(char *) "show", NULL
24441 };
24442
24443 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24444 if (obj0) {
24445 ecode1 = SWIG_AsVal_int(obj0, &val1);
24446 if (!SWIG_IsOK(ecode1)) {
24447 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ShowEvent" "', expected argument " "1"" of type '" "int""'");
24448 }
24449 arg1 = static_cast< int >(val1);
24450 }
24451 if (obj1) {
24452 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24453 if (!SWIG_IsOK(ecode2)) {
24454 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ShowEvent" "', expected argument " "2"" of type '" "bool""'");
24455 }
24456 arg2 = static_cast< bool >(val2);
24457 }
24458 {
24459 PyThreadState* __tstate = wxPyBeginAllowThreads();
24460 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
24461 wxPyEndAllowThreads(__tstate);
24462 if (PyErr_Occurred()) SWIG_fail;
24463 }
24464 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxShowEvent, SWIG_POINTER_NEW | 0 );
24465 return resultobj;
24466 fail:
24467 return NULL;
24468 }
24469
24470
24471 SWIGINTERN PyObject *_wrap_ShowEvent_SetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24472 PyObject *resultobj = 0;
24473 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24474 bool arg2 ;
24475 void *argp1 = 0 ;
24476 int res1 = 0 ;
24477 bool val2 ;
24478 int ecode2 = 0 ;
24479 PyObject * obj0 = 0 ;
24480 PyObject * obj1 = 0 ;
24481 char * kwnames[] = {
24482 (char *) "self",(char *) "show", NULL
24483 };
24484
24485 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) SWIG_fail;
24486 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24487 if (!SWIG_IsOK(res1)) {
24488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_SetShow" "', expected argument " "1"" of type '" "wxShowEvent *""'");
24489 }
24490 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24491 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24492 if (!SWIG_IsOK(ecode2)) {
24493 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShowEvent_SetShow" "', expected argument " "2"" of type '" "bool""'");
24494 }
24495 arg2 = static_cast< bool >(val2);
24496 {
24497 PyThreadState* __tstate = wxPyBeginAllowThreads();
24498 (arg1)->SetShow(arg2);
24499 wxPyEndAllowThreads(__tstate);
24500 if (PyErr_Occurred()) SWIG_fail;
24501 }
24502 resultobj = SWIG_Py_Void();
24503 return resultobj;
24504 fail:
24505 return NULL;
24506 }
24507
24508
24509 SWIGINTERN PyObject *_wrap_ShowEvent_GetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24510 PyObject *resultobj = 0;
24511 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24512 bool result;
24513 void *argp1 = 0 ;
24514 int res1 = 0 ;
24515 PyObject *swig_obj[1] ;
24516
24517 if (!args) SWIG_fail;
24518 swig_obj[0] = args;
24519 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24520 if (!SWIG_IsOK(res1)) {
24521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_GetShow" "', expected argument " "1"" of type '" "wxShowEvent const *""'");
24522 }
24523 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24524 {
24525 PyThreadState* __tstate = wxPyBeginAllowThreads();
24526 result = (bool)((wxShowEvent const *)arg1)->GetShow();
24527 wxPyEndAllowThreads(__tstate);
24528 if (PyErr_Occurred()) SWIG_fail;
24529 }
24530 {
24531 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24532 }
24533 return resultobj;
24534 fail:
24535 return NULL;
24536 }
24537
24538
24539 SWIGINTERN PyObject *ShowEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24540 PyObject *obj;
24541 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24542 SWIG_TypeNewClientData(SWIGTYPE_p_wxShowEvent, SWIG_NewClientData(obj));
24543 return SWIG_Py_Void();
24544 }
24545
24546 SWIGINTERN PyObject *ShowEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24547 return SWIG_Python_InitShadowInstance(args);
24548 }
24549
24550 SWIGINTERN PyObject *_wrap_new_IconizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24551 PyObject *resultobj = 0;
24552 int arg1 = (int) 0 ;
24553 bool arg2 = (bool) true ;
24554 wxIconizeEvent *result = 0 ;
24555 int val1 ;
24556 int ecode1 = 0 ;
24557 bool val2 ;
24558 int ecode2 = 0 ;
24559 PyObject * obj0 = 0 ;
24560 PyObject * obj1 = 0 ;
24561 char * kwnames[] = {
24562 (char *) "id",(char *) "iconized", NULL
24563 };
24564
24565 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24566 if (obj0) {
24567 ecode1 = SWIG_AsVal_int(obj0, &val1);
24568 if (!SWIG_IsOK(ecode1)) {
24569 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IconizeEvent" "', expected argument " "1"" of type '" "int""'");
24570 }
24571 arg1 = static_cast< int >(val1);
24572 }
24573 if (obj1) {
24574 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24575 if (!SWIG_IsOK(ecode2)) {
24576 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IconizeEvent" "', expected argument " "2"" of type '" "bool""'");
24577 }
24578 arg2 = static_cast< bool >(val2);
24579 }
24580 {
24581 PyThreadState* __tstate = wxPyBeginAllowThreads();
24582 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
24583 wxPyEndAllowThreads(__tstate);
24584 if (PyErr_Occurred()) SWIG_fail;
24585 }
24586 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_NEW | 0 );
24587 return resultobj;
24588 fail:
24589 return NULL;
24590 }
24591
24592
24593 SWIGINTERN PyObject *_wrap_IconizeEvent_Iconized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24594 PyObject *resultobj = 0;
24595 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
24596 bool result;
24597 void *argp1 = 0 ;
24598 int res1 = 0 ;
24599 PyObject *swig_obj[1] ;
24600
24601 if (!args) SWIG_fail;
24602 swig_obj[0] = args;
24603 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconizeEvent, 0 | 0 );
24604 if (!SWIG_IsOK(res1)) {
24605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconizeEvent_Iconized" "', expected argument " "1"" of type '" "wxIconizeEvent *""'");
24606 }
24607 arg1 = reinterpret_cast< wxIconizeEvent * >(argp1);
24608 {
24609 PyThreadState* __tstate = wxPyBeginAllowThreads();
24610 result = (bool)(arg1)->Iconized();
24611 wxPyEndAllowThreads(__tstate);
24612 if (PyErr_Occurred()) SWIG_fail;
24613 }
24614 {
24615 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24616 }
24617 return resultobj;
24618 fail:
24619 return NULL;
24620 }
24621
24622
24623 SWIGINTERN PyObject *IconizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24624 PyObject *obj;
24625 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24626 SWIG_TypeNewClientData(SWIGTYPE_p_wxIconizeEvent, SWIG_NewClientData(obj));
24627 return SWIG_Py_Void();
24628 }
24629
24630 SWIGINTERN PyObject *IconizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24631 return SWIG_Python_InitShadowInstance(args);
24632 }
24633
24634 SWIGINTERN PyObject *_wrap_new_MaximizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24635 PyObject *resultobj = 0;
24636 int arg1 = (int) 0 ;
24637 wxMaximizeEvent *result = 0 ;
24638 int val1 ;
24639 int ecode1 = 0 ;
24640 PyObject * obj0 = 0 ;
24641 char * kwnames[] = {
24642 (char *) "id", NULL
24643 };
24644
24645 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) SWIG_fail;
24646 if (obj0) {
24647 ecode1 = SWIG_AsVal_int(obj0, &val1);
24648 if (!SWIG_IsOK(ecode1)) {
24649 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MaximizeEvent" "', expected argument " "1"" of type '" "int""'");
24650 }
24651 arg1 = static_cast< int >(val1);
24652 }
24653 {
24654 PyThreadState* __tstate = wxPyBeginAllowThreads();
24655 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
24656 wxPyEndAllowThreads(__tstate);
24657 if (PyErr_Occurred()) SWIG_fail;
24658 }
24659 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMaximizeEvent, SWIG_POINTER_NEW | 0 );
24660 return resultobj;
24661 fail:
24662 return NULL;
24663 }
24664
24665
24666 SWIGINTERN PyObject *MaximizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24667 PyObject *obj;
24668 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24669 SWIG_TypeNewClientData(SWIGTYPE_p_wxMaximizeEvent, SWIG_NewClientData(obj));
24670 return SWIG_Py_Void();
24671 }
24672
24673 SWIGINTERN PyObject *MaximizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24674 return SWIG_Python_InitShadowInstance(args);
24675 }
24676
24677 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24678 PyObject *resultobj = 0;
24679 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24680 wxPoint result;
24681 void *argp1 = 0 ;
24682 int res1 = 0 ;
24683 PyObject *swig_obj[1] ;
24684
24685 if (!args) SWIG_fail;
24686 swig_obj[0] = args;
24687 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24688 if (!SWIG_IsOK(res1)) {
24689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetPosition" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24690 }
24691 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24692 {
24693 PyThreadState* __tstate = wxPyBeginAllowThreads();
24694 result = (arg1)->GetPosition();
24695 wxPyEndAllowThreads(__tstate);
24696 if (PyErr_Occurred()) SWIG_fail;
24697 }
24698 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
24699 return resultobj;
24700 fail:
24701 return NULL;
24702 }
24703
24704
24705 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24706 PyObject *resultobj = 0;
24707 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24708 int result;
24709 void *argp1 = 0 ;
24710 int res1 = 0 ;
24711 PyObject *swig_obj[1] ;
24712
24713 if (!args) SWIG_fail;
24714 swig_obj[0] = args;
24715 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24716 if (!SWIG_IsOK(res1)) {
24717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetNumberOfFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24718 }
24719 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24720 {
24721 PyThreadState* __tstate = wxPyBeginAllowThreads();
24722 result = (int)(arg1)->GetNumberOfFiles();
24723 wxPyEndAllowThreads(__tstate);
24724 if (PyErr_Occurred()) SWIG_fail;
24725 }
24726 resultobj = SWIG_From_int(static_cast< int >(result));
24727 return resultobj;
24728 fail:
24729 return NULL;
24730 }
24731
24732
24733 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24734 PyObject *resultobj = 0;
24735 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24736 PyObject *result = 0 ;
24737 void *argp1 = 0 ;
24738 int res1 = 0 ;
24739 PyObject *swig_obj[1] ;
24740
24741 if (!args) SWIG_fail;
24742 swig_obj[0] = args;
24743 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24744 if (!SWIG_IsOK(res1)) {
24745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24746 }
24747 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24748 {
24749 PyThreadState* __tstate = wxPyBeginAllowThreads();
24750 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
24751 wxPyEndAllowThreads(__tstate);
24752 if (PyErr_Occurred()) SWIG_fail;
24753 }
24754 resultobj = result;
24755 return resultobj;
24756 fail:
24757 return NULL;
24758 }
24759
24760
24761 SWIGINTERN PyObject *DropFilesEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24762 PyObject *obj;
24763 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24764 SWIG_TypeNewClientData(SWIGTYPE_p_wxDropFilesEvent, SWIG_NewClientData(obj));
24765 return SWIG_Py_Void();
24766 }
24767
24768 SWIGINTERN PyObject *_wrap_new_UpdateUIEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24769 PyObject *resultobj = 0;
24770 int arg1 = (int) 0 ;
24771 wxUpdateUIEvent *result = 0 ;
24772 int val1 ;
24773 int ecode1 = 0 ;
24774 PyObject * obj0 = 0 ;
24775 char * kwnames[] = {
24776 (char *) "commandId", NULL
24777 };
24778
24779 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) SWIG_fail;
24780 if (obj0) {
24781 ecode1 = SWIG_AsVal_int(obj0, &val1);
24782 if (!SWIG_IsOK(ecode1)) {
24783 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UpdateUIEvent" "', expected argument " "1"" of type '" "int""'");
24784 }
24785 arg1 = static_cast< int >(val1);
24786 }
24787 {
24788 PyThreadState* __tstate = wxPyBeginAllowThreads();
24789 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
24790 wxPyEndAllowThreads(__tstate);
24791 if (PyErr_Occurred()) SWIG_fail;
24792 }
24793 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_NEW | 0 );
24794 return resultobj;
24795 fail:
24796 return NULL;
24797 }
24798
24799
24800 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24801 PyObject *resultobj = 0;
24802 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24803 bool result;
24804 void *argp1 = 0 ;
24805 int res1 = 0 ;
24806 PyObject *swig_obj[1] ;
24807
24808 if (!args) SWIG_fail;
24809 swig_obj[0] = args;
24810 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24811 if (!SWIG_IsOK(res1)) {
24812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24813 }
24814 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24815 {
24816 PyThreadState* __tstate = wxPyBeginAllowThreads();
24817 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
24818 wxPyEndAllowThreads(__tstate);
24819 if (PyErr_Occurred()) SWIG_fail;
24820 }
24821 {
24822 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24823 }
24824 return resultobj;
24825 fail:
24826 return NULL;
24827 }
24828
24829
24830 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24831 PyObject *resultobj = 0;
24832 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24833 bool result;
24834 void *argp1 = 0 ;
24835 int res1 = 0 ;
24836 PyObject *swig_obj[1] ;
24837
24838 if (!args) SWIG_fail;
24839 swig_obj[0] = args;
24840 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24841 if (!SWIG_IsOK(res1)) {
24842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24843 }
24844 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24845 {
24846 PyThreadState* __tstate = wxPyBeginAllowThreads();
24847 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
24848 wxPyEndAllowThreads(__tstate);
24849 if (PyErr_Occurred()) SWIG_fail;
24850 }
24851 {
24852 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24853 }
24854 return resultobj;
24855 fail:
24856 return NULL;
24857 }
24858
24859
24860 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24861 PyObject *resultobj = 0;
24862 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24863 bool result;
24864 void *argp1 = 0 ;
24865 int res1 = 0 ;
24866 PyObject *swig_obj[1] ;
24867
24868 if (!args) SWIG_fail;
24869 swig_obj[0] = args;
24870 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24871 if (!SWIG_IsOK(res1)) {
24872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24873 }
24874 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24875 {
24876 PyThreadState* __tstate = wxPyBeginAllowThreads();
24877 result = (bool)((wxUpdateUIEvent const *)arg1)->GetShown();
24878 wxPyEndAllowThreads(__tstate);
24879 if (PyErr_Occurred()) SWIG_fail;
24880 }
24881 {
24882 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24883 }
24884 return resultobj;
24885 fail:
24886 return NULL;
24887 }
24888
24889
24890 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24891 PyObject *resultobj = 0;
24892 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24893 wxString result;
24894 void *argp1 = 0 ;
24895 int res1 = 0 ;
24896 PyObject *swig_obj[1] ;
24897
24898 if (!args) SWIG_fail;
24899 swig_obj[0] = args;
24900 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24901 if (!SWIG_IsOK(res1)) {
24902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24903 }
24904 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24905 {
24906 PyThreadState* __tstate = wxPyBeginAllowThreads();
24907 result = ((wxUpdateUIEvent const *)arg1)->GetText();
24908 wxPyEndAllowThreads(__tstate);
24909 if (PyErr_Occurred()) SWIG_fail;
24910 }
24911 {
24912 #if wxUSE_UNICODE
24913 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24914 #else
24915 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24916 #endif
24917 }
24918 return resultobj;
24919 fail:
24920 return NULL;
24921 }
24922
24923
24924 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24925 PyObject *resultobj = 0;
24926 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24927 bool result;
24928 void *argp1 = 0 ;
24929 int res1 = 0 ;
24930 PyObject *swig_obj[1] ;
24931
24932 if (!args) SWIG_fail;
24933 swig_obj[0] = args;
24934 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24935 if (!SWIG_IsOK(res1)) {
24936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24937 }
24938 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24939 {
24940 PyThreadState* __tstate = wxPyBeginAllowThreads();
24941 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
24942 wxPyEndAllowThreads(__tstate);
24943 if (PyErr_Occurred()) SWIG_fail;
24944 }
24945 {
24946 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24947 }
24948 return resultobj;
24949 fail:
24950 return NULL;
24951 }
24952
24953
24954 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24955 PyObject *resultobj = 0;
24956 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24957 bool result;
24958 void *argp1 = 0 ;
24959 int res1 = 0 ;
24960 PyObject *swig_obj[1] ;
24961
24962 if (!args) SWIG_fail;
24963 swig_obj[0] = args;
24964 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24965 if (!SWIG_IsOK(res1)) {
24966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24967 }
24968 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24969 {
24970 PyThreadState* __tstate = wxPyBeginAllowThreads();
24971 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
24972 wxPyEndAllowThreads(__tstate);
24973 if (PyErr_Occurred()) SWIG_fail;
24974 }
24975 {
24976 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24977 }
24978 return resultobj;
24979 fail:
24980 return NULL;
24981 }
24982
24983
24984 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24985 PyObject *resultobj = 0;
24986 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24987 bool result;
24988 void *argp1 = 0 ;
24989 int res1 = 0 ;
24990 PyObject *swig_obj[1] ;
24991
24992 if (!args) SWIG_fail;
24993 swig_obj[0] = args;
24994 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24995 if (!SWIG_IsOK(res1)) {
24996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24997 }
24998 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24999 {
25000 PyThreadState* __tstate = wxPyBeginAllowThreads();
25001 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
25002 wxPyEndAllowThreads(__tstate);
25003 if (PyErr_Occurred()) SWIG_fail;
25004 }
25005 {
25006 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25007 }
25008 return resultobj;
25009 fail:
25010 return NULL;
25011 }
25012
25013
25014 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25015 PyObject *resultobj = 0;
25016 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25017 bool result;
25018 void *argp1 = 0 ;
25019 int res1 = 0 ;
25020 PyObject *swig_obj[1] ;
25021
25022 if (!args) SWIG_fail;
25023 swig_obj[0] = args;
25024 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25025 if (!SWIG_IsOK(res1)) {
25026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25027 }
25028 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25029 {
25030 PyThreadState* __tstate = wxPyBeginAllowThreads();
25031 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetShown();
25032 wxPyEndAllowThreads(__tstate);
25033 if (PyErr_Occurred()) SWIG_fail;
25034 }
25035 {
25036 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25037 }
25038 return resultobj;
25039 fail:
25040 return NULL;
25041 }
25042
25043
25044 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25045 PyObject *resultobj = 0;
25046 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25047 bool arg2 ;
25048 void *argp1 = 0 ;
25049 int res1 = 0 ;
25050 bool val2 ;
25051 int ecode2 = 0 ;
25052 PyObject * obj0 = 0 ;
25053 PyObject * obj1 = 0 ;
25054 char * kwnames[] = {
25055 (char *) "self",(char *) "check", NULL
25056 };
25057
25058 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) SWIG_fail;
25059 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25060 if (!SWIG_IsOK(res1)) {
25061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Check" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25062 }
25063 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25064 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25065 if (!SWIG_IsOK(ecode2)) {
25066 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Check" "', expected argument " "2"" of type '" "bool""'");
25067 }
25068 arg2 = static_cast< bool >(val2);
25069 {
25070 PyThreadState* __tstate = wxPyBeginAllowThreads();
25071 (arg1)->Check(arg2);
25072 wxPyEndAllowThreads(__tstate);
25073 if (PyErr_Occurred()) SWIG_fail;
25074 }
25075 resultobj = SWIG_Py_Void();
25076 return resultobj;
25077 fail:
25078 return NULL;
25079 }
25080
25081
25082 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25083 PyObject *resultobj = 0;
25084 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25085 bool arg2 ;
25086 void *argp1 = 0 ;
25087 int res1 = 0 ;
25088 bool val2 ;
25089 int ecode2 = 0 ;
25090 PyObject * obj0 = 0 ;
25091 PyObject * obj1 = 0 ;
25092 char * kwnames[] = {
25093 (char *) "self",(char *) "enable", NULL
25094 };
25095
25096 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
25097 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25098 if (!SWIG_IsOK(res1)) {
25099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Enable" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25100 }
25101 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25102 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25103 if (!SWIG_IsOK(ecode2)) {
25104 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Enable" "', expected argument " "2"" of type '" "bool""'");
25105 }
25106 arg2 = static_cast< bool >(val2);
25107 {
25108 PyThreadState* __tstate = wxPyBeginAllowThreads();
25109 (arg1)->Enable(arg2);
25110 wxPyEndAllowThreads(__tstate);
25111 if (PyErr_Occurred()) SWIG_fail;
25112 }
25113 resultobj = SWIG_Py_Void();
25114 return resultobj;
25115 fail:
25116 return NULL;
25117 }
25118
25119
25120 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25121 PyObject *resultobj = 0;
25122 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25123 bool arg2 ;
25124 void *argp1 = 0 ;
25125 int res1 = 0 ;
25126 bool val2 ;
25127 int ecode2 = 0 ;
25128 PyObject * obj0 = 0 ;
25129 PyObject * obj1 = 0 ;
25130 char * kwnames[] = {
25131 (char *) "self",(char *) "show", NULL
25132 };
25133
25134 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Show",kwnames,&obj0,&obj1)) SWIG_fail;
25135 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25136 if (!SWIG_IsOK(res1)) {
25137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Show" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25138 }
25139 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25140 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25141 if (!SWIG_IsOK(ecode2)) {
25142 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Show" "', expected argument " "2"" of type '" "bool""'");
25143 }
25144 arg2 = static_cast< bool >(val2);
25145 {
25146 PyThreadState* __tstate = wxPyBeginAllowThreads();
25147 (arg1)->Show(arg2);
25148 wxPyEndAllowThreads(__tstate);
25149 if (PyErr_Occurred()) SWIG_fail;
25150 }
25151 resultobj = SWIG_Py_Void();
25152 return resultobj;
25153 fail:
25154 return NULL;
25155 }
25156
25157
25158 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25159 PyObject *resultobj = 0;
25160 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25161 wxString *arg2 = 0 ;
25162 void *argp1 = 0 ;
25163 int res1 = 0 ;
25164 bool temp2 = false ;
25165 PyObject * obj0 = 0 ;
25166 PyObject * obj1 = 0 ;
25167 char * kwnames[] = {
25168 (char *) "self",(char *) "text", NULL
25169 };
25170
25171 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
25172 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25173 if (!SWIG_IsOK(res1)) {
25174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_SetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25175 }
25176 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25177 {
25178 arg2 = wxString_in_helper(obj1);
25179 if (arg2 == NULL) SWIG_fail;
25180 temp2 = true;
25181 }
25182 {
25183 PyThreadState* __tstate = wxPyBeginAllowThreads();
25184 (arg1)->SetText((wxString const &)*arg2);
25185 wxPyEndAllowThreads(__tstate);
25186 if (PyErr_Occurred()) SWIG_fail;
25187 }
25188 resultobj = SWIG_Py_Void();
25189 {
25190 if (temp2)
25191 delete arg2;
25192 }
25193 return resultobj;
25194 fail:
25195 {
25196 if (temp2)
25197 delete arg2;
25198 }
25199 return NULL;
25200 }
25201
25202
25203 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25204 PyObject *resultobj = 0;
25205 long arg1 ;
25206 long val1 ;
25207 int ecode1 = 0 ;
25208 PyObject * obj0 = 0 ;
25209 char * kwnames[] = {
25210 (char *) "updateInterval", NULL
25211 };
25212
25213 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) SWIG_fail;
25214 ecode1 = SWIG_AsVal_long(obj0, &val1);
25215 if (!SWIG_IsOK(ecode1)) {
25216 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetUpdateInterval" "', expected argument " "1"" of type '" "long""'");
25217 }
25218 arg1 = static_cast< long >(val1);
25219 {
25220 PyThreadState* __tstate = wxPyBeginAllowThreads();
25221 wxUpdateUIEvent::SetUpdateInterval(arg1);
25222 wxPyEndAllowThreads(__tstate);
25223 if (PyErr_Occurred()) SWIG_fail;
25224 }
25225 resultobj = SWIG_Py_Void();
25226 return resultobj;
25227 fail:
25228 return NULL;
25229 }
25230
25231
25232 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25233 PyObject *resultobj = 0;
25234 long result;
25235
25236 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetUpdateInterval",0,0,0)) SWIG_fail;
25237 {
25238 PyThreadState* __tstate = wxPyBeginAllowThreads();
25239 result = (long)wxUpdateUIEvent::GetUpdateInterval();
25240 wxPyEndAllowThreads(__tstate);
25241 if (PyErr_Occurred()) SWIG_fail;
25242 }
25243 resultobj = SWIG_From_long(static_cast< long >(result));
25244 return resultobj;
25245 fail:
25246 return NULL;
25247 }
25248
25249
25250 SWIGINTERN PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25251 PyObject *resultobj = 0;
25252 wxWindow *arg1 = (wxWindow *) 0 ;
25253 bool result;
25254 void *argp1 = 0 ;
25255 int res1 = 0 ;
25256 PyObject * obj0 = 0 ;
25257 char * kwnames[] = {
25258 (char *) "win", NULL
25259 };
25260
25261 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) SWIG_fail;
25262 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
25263 if (!SWIG_IsOK(res1)) {
25264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_CanUpdate" "', expected argument " "1"" of type '" "wxWindow *""'");
25265 }
25266 arg1 = reinterpret_cast< wxWindow * >(argp1);
25267 {
25268 PyThreadState* __tstate = wxPyBeginAllowThreads();
25269 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
25270 wxPyEndAllowThreads(__tstate);
25271 if (PyErr_Occurred()) SWIG_fail;
25272 }
25273 {
25274 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25275 }
25276 return resultobj;
25277 fail:
25278 return NULL;
25279 }
25280
25281
25282 SWIGINTERN PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25283 PyObject *resultobj = 0;
25284
25285 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_ResetUpdateTime",0,0,0)) SWIG_fail;
25286 {
25287 PyThreadState* __tstate = wxPyBeginAllowThreads();
25288 wxUpdateUIEvent::ResetUpdateTime();
25289 wxPyEndAllowThreads(__tstate);
25290 if (PyErr_Occurred()) SWIG_fail;
25291 }
25292 resultobj = SWIG_Py_Void();
25293 return resultobj;
25294 fail:
25295 return NULL;
25296 }
25297
25298
25299 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25300 PyObject *resultobj = 0;
25301 wxUpdateUIMode arg1 ;
25302 int val1 ;
25303 int ecode1 = 0 ;
25304 PyObject * obj0 = 0 ;
25305 char * kwnames[] = {
25306 (char *) "mode", NULL
25307 };
25308
25309 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) SWIG_fail;
25310 ecode1 = SWIG_AsVal_int(obj0, &val1);
25311 if (!SWIG_IsOK(ecode1)) {
25312 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetMode" "', expected argument " "1"" of type '" "wxUpdateUIMode""'");
25313 }
25314 arg1 = static_cast< wxUpdateUIMode >(val1);
25315 {
25316 PyThreadState* __tstate = wxPyBeginAllowThreads();
25317 wxUpdateUIEvent::SetMode(arg1);
25318 wxPyEndAllowThreads(__tstate);
25319 if (PyErr_Occurred()) SWIG_fail;
25320 }
25321 resultobj = SWIG_Py_Void();
25322 return resultobj;
25323 fail:
25324 return NULL;
25325 }
25326
25327
25328 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25329 PyObject *resultobj = 0;
25330 wxUpdateUIMode result;
25331
25332 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetMode",0,0,0)) SWIG_fail;
25333 {
25334 PyThreadState* __tstate = wxPyBeginAllowThreads();
25335 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
25336 wxPyEndAllowThreads(__tstate);
25337 if (PyErr_Occurred()) SWIG_fail;
25338 }
25339 resultobj = SWIG_From_int(static_cast< int >(result));
25340 return resultobj;
25341 fail:
25342 return NULL;
25343 }
25344
25345
25346 SWIGINTERN PyObject *UpdateUIEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25347 PyObject *obj;
25348 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25349 SWIG_TypeNewClientData(SWIGTYPE_p_wxUpdateUIEvent, SWIG_NewClientData(obj));
25350 return SWIG_Py_Void();
25351 }
25352
25353 SWIGINTERN PyObject *UpdateUIEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25354 return SWIG_Python_InitShadowInstance(args);
25355 }
25356
25357 SWIGINTERN PyObject *_wrap_new_SysColourChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25358 PyObject *resultobj = 0;
25359 wxSysColourChangedEvent *result = 0 ;
25360
25361 if (!SWIG_Python_UnpackTuple(args,"new_SysColourChangedEvent",0,0,0)) SWIG_fail;
25362 {
25363 PyThreadState* __tstate = wxPyBeginAllowThreads();
25364 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
25365 wxPyEndAllowThreads(__tstate);
25366 if (PyErr_Occurred()) SWIG_fail;
25367 }
25368 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSysColourChangedEvent, SWIG_POINTER_NEW | 0 );
25369 return resultobj;
25370 fail:
25371 return NULL;
25372 }
25373
25374
25375 SWIGINTERN PyObject *SysColourChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25376 PyObject *obj;
25377 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25378 SWIG_TypeNewClientData(SWIGTYPE_p_wxSysColourChangedEvent, SWIG_NewClientData(obj));
25379 return SWIG_Py_Void();
25380 }
25381
25382 SWIGINTERN PyObject *SysColourChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25383 return SWIG_Python_InitShadowInstance(args);
25384 }
25385
25386 SWIGINTERN PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25387 PyObject *resultobj = 0;
25388 int arg1 = (int) 0 ;
25389 wxWindow *arg2 = (wxWindow *) NULL ;
25390 wxMouseCaptureChangedEvent *result = 0 ;
25391 int val1 ;
25392 int ecode1 = 0 ;
25393 void *argp2 = 0 ;
25394 int res2 = 0 ;
25395 PyObject * obj0 = 0 ;
25396 PyObject * obj1 = 0 ;
25397 char * kwnames[] = {
25398 (char *) "winid",(char *) "gainedCapture", NULL
25399 };
25400
25401 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) SWIG_fail;
25402 if (obj0) {
25403 ecode1 = SWIG_AsVal_int(obj0, &val1);
25404 if (!SWIG_IsOK(ecode1)) {
25405 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "1"" of type '" "int""'");
25406 }
25407 arg1 = static_cast< int >(val1);
25408 }
25409 if (obj1) {
25410 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25411 if (!SWIG_IsOK(res2)) {
25412 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "2"" of type '" "wxWindow *""'");
25413 }
25414 arg2 = reinterpret_cast< wxWindow * >(argp2);
25415 }
25416 {
25417 PyThreadState* __tstate = wxPyBeginAllowThreads();
25418 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
25419 wxPyEndAllowThreads(__tstate);
25420 if (PyErr_Occurred()) SWIG_fail;
25421 }
25422 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_NEW | 0 );
25423 return resultobj;
25424 fail:
25425 return NULL;
25426 }
25427
25428
25429 SWIGINTERN PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25430 PyObject *resultobj = 0;
25431 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
25432 wxWindow *result = 0 ;
25433 void *argp1 = 0 ;
25434 int res1 = 0 ;
25435 PyObject *swig_obj[1] ;
25436
25437 if (!args) SWIG_fail;
25438 swig_obj[0] = args;
25439 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseCaptureChangedEvent, 0 | 0 );
25440 if (!SWIG_IsOK(res1)) {
25441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseCaptureChangedEvent_GetCapturedWindow" "', expected argument " "1"" of type '" "wxMouseCaptureChangedEvent const *""'");
25442 }
25443 arg1 = reinterpret_cast< wxMouseCaptureChangedEvent * >(argp1);
25444 {
25445 PyThreadState* __tstate = wxPyBeginAllowThreads();
25446 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
25447 wxPyEndAllowThreads(__tstate);
25448 if (PyErr_Occurred()) SWIG_fail;
25449 }
25450 {
25451 resultobj = wxPyMake_wxObject(result, (bool)0);
25452 }
25453 return resultobj;
25454 fail:
25455 return NULL;
25456 }
25457
25458
25459 SWIGINTERN PyObject *MouseCaptureChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25460 PyObject *obj;
25461 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25462 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_NewClientData(obj));
25463 return SWIG_Py_Void();
25464 }
25465
25466 SWIGINTERN PyObject *MouseCaptureChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25467 return SWIG_Python_InitShadowInstance(args);
25468 }
25469
25470 SWIGINTERN PyObject *_wrap_new_MouseCaptureLostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25471 PyObject *resultobj = 0;
25472 int arg1 = (int) 0 ;
25473 wxMouseCaptureLostEvent *result = 0 ;
25474 int val1 ;
25475 int ecode1 = 0 ;
25476 PyObject * obj0 = 0 ;
25477 char * kwnames[] = {
25478 (char *) "winid", NULL
25479 };
25480
25481 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseCaptureLostEvent",kwnames,&obj0)) SWIG_fail;
25482 if (obj0) {
25483 ecode1 = SWIG_AsVal_int(obj0, &val1);
25484 if (!SWIG_IsOK(ecode1)) {
25485 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureLostEvent" "', expected argument " "1"" of type '" "int""'");
25486 }
25487 arg1 = static_cast< int >(val1);
25488 }
25489 {
25490 PyThreadState* __tstate = wxPyBeginAllowThreads();
25491 result = (wxMouseCaptureLostEvent *)new wxMouseCaptureLostEvent(arg1);
25492 wxPyEndAllowThreads(__tstate);
25493 if (PyErr_Occurred()) SWIG_fail;
25494 }
25495 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_POINTER_NEW | 0 );
25496 return resultobj;
25497 fail:
25498 return NULL;
25499 }
25500
25501
25502 SWIGINTERN PyObject *MouseCaptureLostEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25503 PyObject *obj;
25504 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25505 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_NewClientData(obj));
25506 return SWIG_Py_Void();
25507 }
25508
25509 SWIGINTERN PyObject *MouseCaptureLostEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25510 return SWIG_Python_InitShadowInstance(args);
25511 }
25512
25513 SWIGINTERN PyObject *_wrap_new_DisplayChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25514 PyObject *resultobj = 0;
25515 wxDisplayChangedEvent *result = 0 ;
25516
25517 if (!SWIG_Python_UnpackTuple(args,"new_DisplayChangedEvent",0,0,0)) SWIG_fail;
25518 {
25519 PyThreadState* __tstate = wxPyBeginAllowThreads();
25520 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
25521 wxPyEndAllowThreads(__tstate);
25522 if (PyErr_Occurred()) SWIG_fail;
25523 }
25524 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplayChangedEvent, SWIG_POINTER_NEW | 0 );
25525 return resultobj;
25526 fail:
25527 return NULL;
25528 }
25529
25530
25531 SWIGINTERN PyObject *DisplayChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25532 PyObject *obj;
25533 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25534 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplayChangedEvent, SWIG_NewClientData(obj));
25535 return SWIG_Py_Void();
25536 }
25537
25538 SWIGINTERN PyObject *DisplayChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25539 return SWIG_Python_InitShadowInstance(args);
25540 }
25541
25542 SWIGINTERN PyObject *_wrap_new_PaletteChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25543 PyObject *resultobj = 0;
25544 int arg1 = (int) 0 ;
25545 wxPaletteChangedEvent *result = 0 ;
25546 int val1 ;
25547 int ecode1 = 0 ;
25548 PyObject * obj0 = 0 ;
25549 char * kwnames[] = {
25550 (char *) "id", NULL
25551 };
25552
25553 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) SWIG_fail;
25554 if (obj0) {
25555 ecode1 = SWIG_AsVal_int(obj0, &val1);
25556 if (!SWIG_IsOK(ecode1)) {
25557 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaletteChangedEvent" "', expected argument " "1"" of type '" "int""'");
25558 }
25559 arg1 = static_cast< int >(val1);
25560 }
25561 {
25562 PyThreadState* __tstate = wxPyBeginAllowThreads();
25563 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
25564 wxPyEndAllowThreads(__tstate);
25565 if (PyErr_Occurred()) SWIG_fail;
25566 }
25567 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_NEW | 0 );
25568 return resultobj;
25569 fail:
25570 return NULL;
25571 }
25572
25573
25574 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25575 PyObject *resultobj = 0;
25576 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25577 wxWindow *arg2 = (wxWindow *) 0 ;
25578 void *argp1 = 0 ;
25579 int res1 = 0 ;
25580 void *argp2 = 0 ;
25581 int res2 = 0 ;
25582 PyObject * obj0 = 0 ;
25583 PyObject * obj1 = 0 ;
25584 char * kwnames[] = {
25585 (char *) "self",(char *) "win", NULL
25586 };
25587
25588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) SWIG_fail;
25589 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25590 if (!SWIG_IsOK(res1)) {
25591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25592 }
25593 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25594 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25595 if (!SWIG_IsOK(res2)) {
25596 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
25597 }
25598 arg2 = reinterpret_cast< wxWindow * >(argp2);
25599 {
25600 PyThreadState* __tstate = wxPyBeginAllowThreads();
25601 (arg1)->SetChangedWindow(arg2);
25602 wxPyEndAllowThreads(__tstate);
25603 if (PyErr_Occurred()) SWIG_fail;
25604 }
25605 resultobj = SWIG_Py_Void();
25606 return resultobj;
25607 fail:
25608 return NULL;
25609 }
25610
25611
25612 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25613 PyObject *resultobj = 0;
25614 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25615 wxWindow *result = 0 ;
25616 void *argp1 = 0 ;
25617 int res1 = 0 ;
25618 PyObject *swig_obj[1] ;
25619
25620 if (!args) SWIG_fail;
25621 swig_obj[0] = args;
25622 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25623 if (!SWIG_IsOK(res1)) {
25624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_GetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25625 }
25626 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25627 {
25628 PyThreadState* __tstate = wxPyBeginAllowThreads();
25629 result = (wxWindow *)(arg1)->GetChangedWindow();
25630 wxPyEndAllowThreads(__tstate);
25631 if (PyErr_Occurred()) SWIG_fail;
25632 }
25633 {
25634 resultobj = wxPyMake_wxObject(result, (bool)0);
25635 }
25636 return resultobj;
25637 fail:
25638 return NULL;
25639 }
25640
25641
25642 SWIGINTERN PyObject *PaletteChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25643 PyObject *obj;
25644 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25645 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaletteChangedEvent, SWIG_NewClientData(obj));
25646 return SWIG_Py_Void();
25647 }
25648
25649 SWIGINTERN PyObject *PaletteChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25650 return SWIG_Python_InitShadowInstance(args);
25651 }
25652
25653 SWIGINTERN PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25654 PyObject *resultobj = 0;
25655 int arg1 = (int) 0 ;
25656 wxQueryNewPaletteEvent *result = 0 ;
25657 int val1 ;
25658 int ecode1 = 0 ;
25659 PyObject * obj0 = 0 ;
25660 char * kwnames[] = {
25661 (char *) "winid", NULL
25662 };
25663
25664 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) SWIG_fail;
25665 if (obj0) {
25666 ecode1 = SWIG_AsVal_int(obj0, &val1);
25667 if (!SWIG_IsOK(ecode1)) {
25668 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_QueryNewPaletteEvent" "', expected argument " "1"" of type '" "int""'");
25669 }
25670 arg1 = static_cast< int >(val1);
25671 }
25672 {
25673 PyThreadState* __tstate = wxPyBeginAllowThreads();
25674 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
25675 wxPyEndAllowThreads(__tstate);
25676 if (PyErr_Occurred()) SWIG_fail;
25677 }
25678 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_NEW | 0 );
25679 return resultobj;
25680 fail:
25681 return NULL;
25682 }
25683
25684
25685 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25686 PyObject *resultobj = 0;
25687 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
25688 bool arg2 ;
25689 void *argp1 = 0 ;
25690 int res1 = 0 ;
25691 bool val2 ;
25692 int ecode2 = 0 ;
25693 PyObject * obj0 = 0 ;
25694 PyObject * obj1 = 0 ;
25695 char * kwnames[] = {
25696 (char *) "self",(char *) "realized", NULL
25697 };
25698
25699 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) SWIG_fail;
25700 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
25701 if (!SWIG_IsOK(res1)) {
25702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent *""'");
25703 }
25704 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
25705 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25706 if (!SWIG_IsOK(ecode2)) {
25707 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "2"" of type '" "bool""'");
25708 }
25709 arg2 = static_cast< bool >(val2);
25710 {
25711 PyThreadState* __tstate = wxPyBeginAllowThreads();
25712 (arg1)->SetPaletteRealized(arg2);
25713 wxPyEndAllowThreads(__tstate);
25714 if (PyErr_Occurred()) SWIG_fail;
25715 }
25716 resultobj = SWIG_Py_Void();
25717 return resultobj;
25718 fail:
25719 return NULL;
25720 }
25721
25722
25723 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25724 PyObject *resultobj = 0;
25725 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
25726 bool result;
25727 void *argp1 = 0 ;
25728 int res1 = 0 ;
25729 PyObject *swig_obj[1] ;
25730
25731 if (!args) SWIG_fail;
25732 swig_obj[0] = args;
25733 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
25734 if (!SWIG_IsOK(res1)) {
25735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_GetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent const *""'");
25736 }
25737 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
25738 {
25739 PyThreadState* __tstate = wxPyBeginAllowThreads();
25740 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
25741 wxPyEndAllowThreads(__tstate);
25742 if (PyErr_Occurred()) SWIG_fail;
25743 }
25744 {
25745 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25746 }
25747 return resultobj;
25748 fail:
25749 return NULL;
25750 }
25751
25752
25753 SWIGINTERN PyObject *QueryNewPaletteEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25754 PyObject *obj;
25755 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25756 SWIG_TypeNewClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_NewClientData(obj));
25757 return SWIG_Py_Void();
25758 }
25759
25760 SWIGINTERN PyObject *QueryNewPaletteEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25761 return SWIG_Python_InitShadowInstance(args);
25762 }
25763
25764 SWIGINTERN PyObject *_wrap_new_NavigationKeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25765 PyObject *resultobj = 0;
25766 wxNavigationKeyEvent *result = 0 ;
25767
25768 if (!SWIG_Python_UnpackTuple(args,"new_NavigationKeyEvent",0,0,0)) SWIG_fail;
25769 {
25770 PyThreadState* __tstate = wxPyBeginAllowThreads();
25771 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
25772 wxPyEndAllowThreads(__tstate);
25773 if (PyErr_Occurred()) SWIG_fail;
25774 }
25775 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_NEW | 0 );
25776 return resultobj;
25777 fail:
25778 return NULL;
25779 }
25780
25781
25782 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25783 PyObject *resultobj = 0;
25784 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25785 bool result;
25786 void *argp1 = 0 ;
25787 int res1 = 0 ;
25788 PyObject *swig_obj[1] ;
25789
25790 if (!args) SWIG_fail;
25791 swig_obj[0] = args;
25792 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25793 if (!SWIG_IsOK(res1)) {
25794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25795 }
25796 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25797 {
25798 PyThreadState* __tstate = wxPyBeginAllowThreads();
25799 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
25800 wxPyEndAllowThreads(__tstate);
25801 if (PyErr_Occurred()) SWIG_fail;
25802 }
25803 {
25804 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25805 }
25806 return resultobj;
25807 fail:
25808 return NULL;
25809 }
25810
25811
25812 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25813 PyObject *resultobj = 0;
25814 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25815 bool arg2 ;
25816 void *argp1 = 0 ;
25817 int res1 = 0 ;
25818 bool val2 ;
25819 int ecode2 = 0 ;
25820 PyObject * obj0 = 0 ;
25821 PyObject * obj1 = 0 ;
25822 char * kwnames[] = {
25823 (char *) "self",(char *) "forward", NULL
25824 };
25825
25826 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) SWIG_fail;
25827 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25828 if (!SWIG_IsOK(res1)) {
25829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25830 }
25831 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25832 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25833 if (!SWIG_IsOK(ecode2)) {
25834 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "2"" of type '" "bool""'");
25835 }
25836 arg2 = static_cast< bool >(val2);
25837 {
25838 PyThreadState* __tstate = wxPyBeginAllowThreads();
25839 (arg1)->SetDirection(arg2);
25840 wxPyEndAllowThreads(__tstate);
25841 if (PyErr_Occurred()) SWIG_fail;
25842 }
25843 resultobj = SWIG_Py_Void();
25844 return resultobj;
25845 fail:
25846 return NULL;
25847 }
25848
25849
25850 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25851 PyObject *resultobj = 0;
25852 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25853 bool result;
25854 void *argp1 = 0 ;
25855 int res1 = 0 ;
25856 PyObject *swig_obj[1] ;
25857
25858 if (!args) SWIG_fail;
25859 swig_obj[0] = args;
25860 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25861 if (!SWIG_IsOK(res1)) {
25862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25863 }
25864 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25865 {
25866 PyThreadState* __tstate = wxPyBeginAllowThreads();
25867 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
25868 wxPyEndAllowThreads(__tstate);
25869 if (PyErr_Occurred()) SWIG_fail;
25870 }
25871 {
25872 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25873 }
25874 return resultobj;
25875 fail:
25876 return NULL;
25877 }
25878
25879
25880 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25881 PyObject *resultobj = 0;
25882 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25883 bool arg2 ;
25884 void *argp1 = 0 ;
25885 int res1 = 0 ;
25886 bool val2 ;
25887 int ecode2 = 0 ;
25888 PyObject * obj0 = 0 ;
25889 PyObject * obj1 = 0 ;
25890 char * kwnames[] = {
25891 (char *) "self",(char *) "ischange", NULL
25892 };
25893
25894 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) SWIG_fail;
25895 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25896 if (!SWIG_IsOK(res1)) {
25897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25898 }
25899 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25900 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25901 if (!SWIG_IsOK(ecode2)) {
25902 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "2"" of type '" "bool""'");
25903 }
25904 arg2 = static_cast< bool >(val2);
25905 {
25906 PyThreadState* __tstate = wxPyBeginAllowThreads();
25907 (arg1)->SetWindowChange(arg2);
25908 wxPyEndAllowThreads(__tstate);
25909 if (PyErr_Occurred()) SWIG_fail;
25910 }
25911 resultobj = SWIG_Py_Void();
25912 return resultobj;
25913 fail:
25914 return NULL;
25915 }
25916
25917
25918 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25919 PyObject *resultobj = 0;
25920 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25921 bool result;
25922 void *argp1 = 0 ;
25923 int res1 = 0 ;
25924 PyObject *swig_obj[1] ;
25925
25926 if (!args) SWIG_fail;
25927 swig_obj[0] = args;
25928 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25929 if (!SWIG_IsOK(res1)) {
25930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25931 }
25932 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25933 {
25934 PyThreadState* __tstate = wxPyBeginAllowThreads();
25935 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
25936 wxPyEndAllowThreads(__tstate);
25937 if (PyErr_Occurred()) SWIG_fail;
25938 }
25939 {
25940 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25941 }
25942 return resultobj;
25943 fail:
25944 return NULL;
25945 }
25946
25947
25948 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25949 PyObject *resultobj = 0;
25950 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25951 bool arg2 ;
25952 void *argp1 = 0 ;
25953 int res1 = 0 ;
25954 bool val2 ;
25955 int ecode2 = 0 ;
25956 PyObject * obj0 = 0 ;
25957 PyObject * obj1 = 0 ;
25958 char * kwnames[] = {
25959 (char *) "self",(char *) "bIs", NULL
25960 };
25961
25962 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) SWIG_fail;
25963 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25964 if (!SWIG_IsOK(res1)) {
25965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25966 }
25967 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25968 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25969 if (!SWIG_IsOK(ecode2)) {
25970 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "2"" of type '" "bool""'");
25971 }
25972 arg2 = static_cast< bool >(val2);
25973 {
25974 PyThreadState* __tstate = wxPyBeginAllowThreads();
25975 (arg1)->SetFromTab(arg2);
25976 wxPyEndAllowThreads(__tstate);
25977 if (PyErr_Occurred()) SWIG_fail;
25978 }
25979 resultobj = SWIG_Py_Void();
25980 return resultobj;
25981 fail:
25982 return NULL;
25983 }
25984
25985
25986 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25987 PyObject *resultobj = 0;
25988 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25989 long arg2 ;
25990 void *argp1 = 0 ;
25991 int res1 = 0 ;
25992 long val2 ;
25993 int ecode2 = 0 ;
25994 PyObject * obj0 = 0 ;
25995 PyObject * obj1 = 0 ;
25996 char * kwnames[] = {
25997 (char *) "self",(char *) "flags", NULL
25998 };
25999
26000 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) SWIG_fail;
26001 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26002 if (!SWIG_IsOK(res1)) {
26003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26004 }
26005 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26006 ecode2 = SWIG_AsVal_long(obj1, &val2);
26007 if (!SWIG_IsOK(ecode2)) {
26008 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "2"" of type '" "long""'");
26009 }
26010 arg2 = static_cast< long >(val2);
26011 {
26012 PyThreadState* __tstate = wxPyBeginAllowThreads();
26013 (arg1)->SetFlags(arg2);
26014 wxPyEndAllowThreads(__tstate);
26015 if (PyErr_Occurred()) SWIG_fail;
26016 }
26017 resultobj = SWIG_Py_Void();
26018 return resultobj;
26019 fail:
26020 return NULL;
26021 }
26022
26023
26024 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26025 PyObject *resultobj = 0;
26026 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26027 wxWindow *result = 0 ;
26028 void *argp1 = 0 ;
26029 int res1 = 0 ;
26030 PyObject *swig_obj[1] ;
26031
26032 if (!args) SWIG_fail;
26033 swig_obj[0] = args;
26034 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26035 if (!SWIG_IsOK(res1)) {
26036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
26037 }
26038 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26039 {
26040 PyThreadState* __tstate = wxPyBeginAllowThreads();
26041 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
26042 wxPyEndAllowThreads(__tstate);
26043 if (PyErr_Occurred()) SWIG_fail;
26044 }
26045 {
26046 resultobj = wxPyMake_wxObject(result, (bool)0);
26047 }
26048 return resultobj;
26049 fail:
26050 return NULL;
26051 }
26052
26053
26054 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26055 PyObject *resultobj = 0;
26056 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26057 wxWindow *arg2 = (wxWindow *) 0 ;
26058 void *argp1 = 0 ;
26059 int res1 = 0 ;
26060 void *argp2 = 0 ;
26061 int res2 = 0 ;
26062 PyObject * obj0 = 0 ;
26063 PyObject * obj1 = 0 ;
26064 char * kwnames[] = {
26065 (char *) "self",(char *) "win", NULL
26066 };
26067
26068 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) SWIG_fail;
26069 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26070 if (!SWIG_IsOK(res1)) {
26071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26072 }
26073 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26074 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
26075 if (!SWIG_IsOK(res2)) {
26076 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "2"" of type '" "wxWindow *""'");
26077 }
26078 arg2 = reinterpret_cast< wxWindow * >(argp2);
26079 {
26080 PyThreadState* __tstate = wxPyBeginAllowThreads();
26081 (arg1)->SetCurrentFocus(arg2);
26082 wxPyEndAllowThreads(__tstate);
26083 if (PyErr_Occurred()) SWIG_fail;
26084 }
26085 resultobj = SWIG_Py_Void();
26086 return resultobj;
26087 fail:
26088 return NULL;
26089 }
26090
26091
26092 SWIGINTERN PyObject *NavigationKeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26093 PyObject *obj;
26094 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26095 SWIG_TypeNewClientData(SWIGTYPE_p_wxNavigationKeyEvent, SWIG_NewClientData(obj));
26096 return SWIG_Py_Void();
26097 }
26098
26099 SWIGINTERN PyObject *NavigationKeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26100 return SWIG_Python_InitShadowInstance(args);
26101 }
26102
26103 SWIGINTERN PyObject *_wrap_new_WindowCreateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26104 PyObject *resultobj = 0;
26105 wxWindow *arg1 = (wxWindow *) NULL ;
26106 wxWindowCreateEvent *result = 0 ;
26107 void *argp1 = 0 ;
26108 int res1 = 0 ;
26109 PyObject * obj0 = 0 ;
26110 char * kwnames[] = {
26111 (char *) "win", NULL
26112 };
26113
26114 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) SWIG_fail;
26115 if (obj0) {
26116 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26117 if (!SWIG_IsOK(res1)) {
26118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowCreateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26119 }
26120 arg1 = reinterpret_cast< wxWindow * >(argp1);
26121 }
26122 {
26123 PyThreadState* __tstate = wxPyBeginAllowThreads();
26124 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
26125 wxPyEndAllowThreads(__tstate);
26126 if (PyErr_Occurred()) SWIG_fail;
26127 }
26128 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_NEW | 0 );
26129 return resultobj;
26130 fail:
26131 return NULL;
26132 }
26133
26134
26135 SWIGINTERN PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26136 PyObject *resultobj = 0;
26137 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
26138 wxWindow *result = 0 ;
26139 void *argp1 = 0 ;
26140 int res1 = 0 ;
26141 PyObject *swig_obj[1] ;
26142
26143 if (!args) SWIG_fail;
26144 swig_obj[0] = args;
26145 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowCreateEvent, 0 | 0 );
26146 if (!SWIG_IsOK(res1)) {
26147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowCreateEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowCreateEvent const *""'");
26148 }
26149 arg1 = reinterpret_cast< wxWindowCreateEvent * >(argp1);
26150 {
26151 PyThreadState* __tstate = wxPyBeginAllowThreads();
26152 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
26153 wxPyEndAllowThreads(__tstate);
26154 if (PyErr_Occurred()) SWIG_fail;
26155 }
26156 {
26157 resultobj = wxPyMake_wxObject(result, (bool)0);
26158 }
26159 return resultobj;
26160 fail:
26161 return NULL;
26162 }
26163
26164
26165 SWIGINTERN PyObject *WindowCreateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26166 PyObject *obj;
26167 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26168 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowCreateEvent, SWIG_NewClientData(obj));
26169 return SWIG_Py_Void();
26170 }
26171
26172 SWIGINTERN PyObject *WindowCreateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26173 return SWIG_Python_InitShadowInstance(args);
26174 }
26175
26176 SWIGINTERN PyObject *_wrap_new_WindowDestroyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26177 PyObject *resultobj = 0;
26178 wxWindow *arg1 = (wxWindow *) NULL ;
26179 wxWindowDestroyEvent *result = 0 ;
26180 void *argp1 = 0 ;
26181 int res1 = 0 ;
26182 PyObject * obj0 = 0 ;
26183 char * kwnames[] = {
26184 (char *) "win", NULL
26185 };
26186
26187 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) SWIG_fail;
26188 if (obj0) {
26189 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26190 if (!SWIG_IsOK(res1)) {
26191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDestroyEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26192 }
26193 arg1 = reinterpret_cast< wxWindow * >(argp1);
26194 }
26195 {
26196 PyThreadState* __tstate = wxPyBeginAllowThreads();
26197 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
26198 wxPyEndAllowThreads(__tstate);
26199 if (PyErr_Occurred()) SWIG_fail;
26200 }
26201 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_NEW | 0 );
26202 return resultobj;
26203 fail:
26204 return NULL;
26205 }
26206
26207
26208 SWIGINTERN PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26209 PyObject *resultobj = 0;
26210 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
26211 wxWindow *result = 0 ;
26212 void *argp1 = 0 ;
26213 int res1 = 0 ;
26214 PyObject *swig_obj[1] ;
26215
26216 if (!args) SWIG_fail;
26217 swig_obj[0] = args;
26218 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDestroyEvent, 0 | 0 );
26219 if (!SWIG_IsOK(res1)) {
26220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowDestroyEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowDestroyEvent const *""'");
26221 }
26222 arg1 = reinterpret_cast< wxWindowDestroyEvent * >(argp1);
26223 {
26224 PyThreadState* __tstate = wxPyBeginAllowThreads();
26225 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
26226 wxPyEndAllowThreads(__tstate);
26227 if (PyErr_Occurred()) SWIG_fail;
26228 }
26229 {
26230 resultobj = wxPyMake_wxObject(result, (bool)0);
26231 }
26232 return resultobj;
26233 fail:
26234 return NULL;
26235 }
26236
26237
26238 SWIGINTERN PyObject *WindowDestroyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26239 PyObject *obj;
26240 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26241 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDestroyEvent, SWIG_NewClientData(obj));
26242 return SWIG_Py_Void();
26243 }
26244
26245 SWIGINTERN PyObject *WindowDestroyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26246 return SWIG_Python_InitShadowInstance(args);
26247 }
26248
26249 SWIGINTERN PyObject *_wrap_new_ContextMenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26250 PyObject *resultobj = 0;
26251 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26252 int arg2 = (int) 0 ;
26253 wxPoint const &arg3_defvalue = wxDefaultPosition ;
26254 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
26255 wxContextMenuEvent *result = 0 ;
26256 int val1 ;
26257 int ecode1 = 0 ;
26258 int val2 ;
26259 int ecode2 = 0 ;
26260 wxPoint temp3 ;
26261 PyObject * obj0 = 0 ;
26262 PyObject * obj1 = 0 ;
26263 PyObject * obj2 = 0 ;
26264 char * kwnames[] = {
26265 (char *) "type",(char *) "winid",(char *) "pt", NULL
26266 };
26267
26268 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26269 if (obj0) {
26270 ecode1 = SWIG_AsVal_int(obj0, &val1);
26271 if (!SWIG_IsOK(ecode1)) {
26272 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ContextMenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26273 }
26274 arg1 = static_cast< wxEventType >(val1);
26275 }
26276 if (obj1) {
26277 ecode2 = SWIG_AsVal_int(obj1, &val2);
26278 if (!SWIG_IsOK(ecode2)) {
26279 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ContextMenuEvent" "', expected argument " "2"" of type '" "int""'");
26280 }
26281 arg2 = static_cast< int >(val2);
26282 }
26283 if (obj2) {
26284 {
26285 arg3 = &temp3;
26286 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
26287 }
26288 }
26289 {
26290 PyThreadState* __tstate = wxPyBeginAllowThreads();
26291 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
26292 wxPyEndAllowThreads(__tstate);
26293 if (PyErr_Occurred()) SWIG_fail;
26294 }
26295 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_NEW | 0 );
26296 return resultobj;
26297 fail:
26298 return NULL;
26299 }
26300
26301
26302 SWIGINTERN PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26303 PyObject *resultobj = 0;
26304 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26305 wxPoint *result = 0 ;
26306 void *argp1 = 0 ;
26307 int res1 = 0 ;
26308 PyObject *swig_obj[1] ;
26309
26310 if (!args) SWIG_fail;
26311 swig_obj[0] = args;
26312 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26313 if (!SWIG_IsOK(res1)) {
26314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_GetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent const *""'");
26315 }
26316 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26317 {
26318 PyThreadState* __tstate = wxPyBeginAllowThreads();
26319 {
26320 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
26321 result = (wxPoint *) &_result_ref;
26322 }
26323 wxPyEndAllowThreads(__tstate);
26324 if (PyErr_Occurred()) SWIG_fail;
26325 }
26326 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, 0 | 0 );
26327 return resultobj;
26328 fail:
26329 return NULL;
26330 }
26331
26332
26333 SWIGINTERN PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26334 PyObject *resultobj = 0;
26335 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26336 wxPoint *arg2 = 0 ;
26337 void *argp1 = 0 ;
26338 int res1 = 0 ;
26339 wxPoint temp2 ;
26340 PyObject * obj0 = 0 ;
26341 PyObject * obj1 = 0 ;
26342 char * kwnames[] = {
26343 (char *) "self",(char *) "pos", NULL
26344 };
26345
26346 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
26347 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26348 if (!SWIG_IsOK(res1)) {
26349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_SetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent *""'");
26350 }
26351 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26352 {
26353 arg2 = &temp2;
26354 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
26355 }
26356 {
26357 PyThreadState* __tstate = wxPyBeginAllowThreads();
26358 (arg1)->SetPosition((wxPoint const &)*arg2);
26359 wxPyEndAllowThreads(__tstate);
26360 if (PyErr_Occurred()) SWIG_fail;
26361 }
26362 resultobj = SWIG_Py_Void();
26363 return resultobj;
26364 fail:
26365 return NULL;
26366 }
26367
26368
26369 SWIGINTERN PyObject *ContextMenuEvent_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_wxContextMenuEvent, SWIG_NewClientData(obj));
26373 return SWIG_Py_Void();
26374 }
26375
26376 SWIGINTERN PyObject *ContextMenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26377 return SWIG_Python_InitShadowInstance(args);
26378 }
26379
26380 SWIGINTERN PyObject *_wrap_new_IdleEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26381 PyObject *resultobj = 0;
26382 wxIdleEvent *result = 0 ;
26383
26384 if (!SWIG_Python_UnpackTuple(args,"new_IdleEvent",0,0,0)) SWIG_fail;
26385 {
26386 PyThreadState* __tstate = wxPyBeginAllowThreads();
26387 result = (wxIdleEvent *)new wxIdleEvent();
26388 wxPyEndAllowThreads(__tstate);
26389 if (PyErr_Occurred()) SWIG_fail;
26390 }
26391 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_NEW | 0 );
26392 return resultobj;
26393 fail:
26394 return NULL;
26395 }
26396
26397
26398 SWIGINTERN PyObject *_wrap_IdleEvent_RequestMore(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26399 PyObject *resultobj = 0;
26400 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26401 bool arg2 = (bool) true ;
26402 void *argp1 = 0 ;
26403 int res1 = 0 ;
26404 bool val2 ;
26405 int ecode2 = 0 ;
26406 PyObject * obj0 = 0 ;
26407 PyObject * obj1 = 0 ;
26408 char * kwnames[] = {
26409 (char *) "self",(char *) "needMore", NULL
26410 };
26411
26412 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) SWIG_fail;
26413 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26414 if (!SWIG_IsOK(res1)) {
26415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_RequestMore" "', expected argument " "1"" of type '" "wxIdleEvent *""'");
26416 }
26417 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26418 if (obj1) {
26419 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26420 if (!SWIG_IsOK(ecode2)) {
26421 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IdleEvent_RequestMore" "', expected argument " "2"" of type '" "bool""'");
26422 }
26423 arg2 = static_cast< bool >(val2);
26424 }
26425 {
26426 PyThreadState* __tstate = wxPyBeginAllowThreads();
26427 (arg1)->RequestMore(arg2);
26428 wxPyEndAllowThreads(__tstate);
26429 if (PyErr_Occurred()) SWIG_fail;
26430 }
26431 resultobj = SWIG_Py_Void();
26432 return resultobj;
26433 fail:
26434 return NULL;
26435 }
26436
26437
26438 SWIGINTERN PyObject *_wrap_IdleEvent_MoreRequested(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26439 PyObject *resultobj = 0;
26440 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26441 bool result;
26442 void *argp1 = 0 ;
26443 int res1 = 0 ;
26444 PyObject *swig_obj[1] ;
26445
26446 if (!args) SWIG_fail;
26447 swig_obj[0] = args;
26448 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26449 if (!SWIG_IsOK(res1)) {
26450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_MoreRequested" "', expected argument " "1"" of type '" "wxIdleEvent const *""'");
26451 }
26452 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26453 {
26454 PyThreadState* __tstate = wxPyBeginAllowThreads();
26455 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
26456 wxPyEndAllowThreads(__tstate);
26457 if (PyErr_Occurred()) SWIG_fail;
26458 }
26459 {
26460 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26461 }
26462 return resultobj;
26463 fail:
26464 return NULL;
26465 }
26466
26467
26468 SWIGINTERN PyObject *_wrap_IdleEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26469 PyObject *resultobj = 0;
26470 wxIdleMode arg1 ;
26471 int val1 ;
26472 int ecode1 = 0 ;
26473 PyObject * obj0 = 0 ;
26474 char * kwnames[] = {
26475 (char *) "mode", NULL
26476 };
26477
26478 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) SWIG_fail;
26479 ecode1 = SWIG_AsVal_int(obj0, &val1);
26480 if (!SWIG_IsOK(ecode1)) {
26481 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IdleEvent_SetMode" "', expected argument " "1"" of type '" "wxIdleMode""'");
26482 }
26483 arg1 = static_cast< wxIdleMode >(val1);
26484 {
26485 PyThreadState* __tstate = wxPyBeginAllowThreads();
26486 wxIdleEvent::SetMode(arg1);
26487 wxPyEndAllowThreads(__tstate);
26488 if (PyErr_Occurred()) SWIG_fail;
26489 }
26490 resultobj = SWIG_Py_Void();
26491 return resultobj;
26492 fail:
26493 return NULL;
26494 }
26495
26496
26497 SWIGINTERN PyObject *_wrap_IdleEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26498 PyObject *resultobj = 0;
26499 wxIdleMode result;
26500
26501 if (!SWIG_Python_UnpackTuple(args,"IdleEvent_GetMode",0,0,0)) SWIG_fail;
26502 {
26503 PyThreadState* __tstate = wxPyBeginAllowThreads();
26504 result = (wxIdleMode)wxIdleEvent::GetMode();
26505 wxPyEndAllowThreads(__tstate);
26506 if (PyErr_Occurred()) SWIG_fail;
26507 }
26508 resultobj = SWIG_From_int(static_cast< int >(result));
26509 return resultobj;
26510 fail:
26511 return NULL;
26512 }
26513
26514
26515 SWIGINTERN PyObject *_wrap_IdleEvent_CanSend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26516 PyObject *resultobj = 0;
26517 wxWindow *arg1 = (wxWindow *) 0 ;
26518 bool result;
26519 void *argp1 = 0 ;
26520 int res1 = 0 ;
26521 PyObject * obj0 = 0 ;
26522 char * kwnames[] = {
26523 (char *) "win", NULL
26524 };
26525
26526 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) SWIG_fail;
26527 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26528 if (!SWIG_IsOK(res1)) {
26529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_CanSend" "', expected argument " "1"" of type '" "wxWindow *""'");
26530 }
26531 arg1 = reinterpret_cast< wxWindow * >(argp1);
26532 {
26533 PyThreadState* __tstate = wxPyBeginAllowThreads();
26534 result = (bool)wxIdleEvent::CanSend(arg1);
26535 wxPyEndAllowThreads(__tstate);
26536 if (PyErr_Occurred()) SWIG_fail;
26537 }
26538 {
26539 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26540 }
26541 return resultobj;
26542 fail:
26543 return NULL;
26544 }
26545
26546
26547 SWIGINTERN PyObject *IdleEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26548 PyObject *obj;
26549 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26550 SWIG_TypeNewClientData(SWIGTYPE_p_wxIdleEvent, SWIG_NewClientData(obj));
26551 return SWIG_Py_Void();
26552 }
26553
26554 SWIGINTERN PyObject *IdleEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26555 return SWIG_Python_InitShadowInstance(args);
26556 }
26557
26558 SWIGINTERN PyObject *_wrap_new_ClipboardTextEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26559 PyObject *resultobj = 0;
26560 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26561 int arg2 = (int) 0 ;
26562 wxClipboardTextEvent *result = 0 ;
26563 int val1 ;
26564 int ecode1 = 0 ;
26565 int val2 ;
26566 int ecode2 = 0 ;
26567 PyObject * obj0 = 0 ;
26568 PyObject * obj1 = 0 ;
26569 char * kwnames[] = {
26570 (char *) "type",(char *) "winid", NULL
26571 };
26572
26573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ClipboardTextEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26574 if (obj0) {
26575 ecode1 = SWIG_AsVal_int(obj0, &val1);
26576 if (!SWIG_IsOK(ecode1)) {
26577 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ClipboardTextEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26578 }
26579 arg1 = static_cast< wxEventType >(val1);
26580 }
26581 if (obj1) {
26582 ecode2 = SWIG_AsVal_int(obj1, &val2);
26583 if (!SWIG_IsOK(ecode2)) {
26584 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ClipboardTextEvent" "', expected argument " "2"" of type '" "int""'");
26585 }
26586 arg2 = static_cast< int >(val2);
26587 }
26588 {
26589 PyThreadState* __tstate = wxPyBeginAllowThreads();
26590 result = (wxClipboardTextEvent *)new wxClipboardTextEvent(arg1,arg2);
26591 wxPyEndAllowThreads(__tstate);
26592 if (PyErr_Occurred()) SWIG_fail;
26593 }
26594 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardTextEvent, SWIG_POINTER_NEW | 0 );
26595 return resultobj;
26596 fail:
26597 return NULL;
26598 }
26599
26600
26601 SWIGINTERN PyObject *ClipboardTextEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26602 PyObject *obj;
26603 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26604 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardTextEvent, SWIG_NewClientData(obj));
26605 return SWIG_Py_Void();
26606 }
26607
26608 SWIGINTERN PyObject *ClipboardTextEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26609 return SWIG_Python_InitShadowInstance(args);
26610 }
26611
26612 SWIGINTERN PyObject *_wrap_new_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26613 PyObject *resultobj = 0;
26614 int arg1 = (int) 0 ;
26615 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
26616 wxPyEvent *result = 0 ;
26617 int val1 ;
26618 int ecode1 = 0 ;
26619 int val2 ;
26620 int ecode2 = 0 ;
26621 PyObject * obj0 = 0 ;
26622 PyObject * obj1 = 0 ;
26623 char * kwnames[] = {
26624 (char *) "winid",(char *) "eventType", NULL
26625 };
26626
26627 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26628 if (obj0) {
26629 ecode1 = SWIG_AsVal_int(obj0, &val1);
26630 if (!SWIG_IsOK(ecode1)) {
26631 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyEvent" "', expected argument " "1"" of type '" "int""'");
26632 }
26633 arg1 = static_cast< int >(val1);
26634 }
26635 if (obj1) {
26636 ecode2 = SWIG_AsVal_int(obj1, &val2);
26637 if (!SWIG_IsOK(ecode2)) {
26638 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyEvent" "', expected argument " "2"" of type '" "wxEventType""'");
26639 }
26640 arg2 = static_cast< wxEventType >(val2);
26641 }
26642 {
26643 PyThreadState* __tstate = wxPyBeginAllowThreads();
26644 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
26645 wxPyEndAllowThreads(__tstate);
26646 if (PyErr_Occurred()) SWIG_fail;
26647 }
26648 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyEvent, SWIG_POINTER_NEW | 0 );
26649 return resultobj;
26650 fail:
26651 return NULL;
26652 }
26653
26654
26655 SWIGINTERN PyObject *_wrap_delete_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26656 PyObject *resultobj = 0;
26657 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26658 void *argp1 = 0 ;
26659 int res1 = 0 ;
26660 PyObject *swig_obj[1] ;
26661
26662 if (!args) SWIG_fail;
26663 swig_obj[0] = args;
26664 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, SWIG_POINTER_DISOWN | 0 );
26665 if (!SWIG_IsOK(res1)) {
26666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyEvent" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26667 }
26668 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26669 {
26670 PyThreadState* __tstate = wxPyBeginAllowThreads();
26671 delete arg1;
26672
26673 wxPyEndAllowThreads(__tstate);
26674 if (PyErr_Occurred()) SWIG_fail;
26675 }
26676 resultobj = SWIG_Py_Void();
26677 return resultobj;
26678 fail:
26679 return NULL;
26680 }
26681
26682
26683 SWIGINTERN PyObject *_wrap_PyEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26684 PyObject *resultobj = 0;
26685 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26686 PyObject *arg2 = (PyObject *) 0 ;
26687 void *argp1 = 0 ;
26688 int res1 = 0 ;
26689 PyObject * obj0 = 0 ;
26690 PyObject * obj1 = 0 ;
26691 char * kwnames[] = {
26692 (char *) "self",(char *) "self", NULL
26693 };
26694
26695 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
26696 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
26697 if (!SWIG_IsOK(res1)) {
26698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26699 }
26700 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26701 arg2 = obj1;
26702 {
26703 PyThreadState* __tstate = wxPyBeginAllowThreads();
26704 (arg1)->SetSelf(arg2);
26705 wxPyEndAllowThreads(__tstate);
26706 if (PyErr_Occurred()) SWIG_fail;
26707 }
26708 resultobj = SWIG_Py_Void();
26709 return resultobj;
26710 fail:
26711 return NULL;
26712 }
26713
26714
26715 SWIGINTERN PyObject *_wrap_PyEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26716 PyObject *resultobj = 0;
26717 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26718 PyObject *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_wxPyEvent, 0 | 0 );
26726 if (!SWIG_IsOK(res1)) {
26727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26728 }
26729 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26730 {
26731 PyThreadState* __tstate = wxPyBeginAllowThreads();
26732 result = (PyObject *)(arg1)->GetSelf();
26733 wxPyEndAllowThreads(__tstate);
26734 if (PyErr_Occurred()) SWIG_fail;
26735 }
26736 resultobj = result;
26737 return resultobj;
26738 fail:
26739 return NULL;
26740 }
26741
26742
26743 SWIGINTERN PyObject *PyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26744 PyObject *obj;
26745 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26746 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyEvent, SWIG_NewClientData(obj));
26747 return SWIG_Py_Void();
26748 }
26749
26750 SWIGINTERN PyObject *PyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26751 return SWIG_Python_InitShadowInstance(args);
26752 }
26753
26754 SWIGINTERN PyObject *_wrap_new_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26755 PyObject *resultobj = 0;
26756 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26757 int arg2 = (int) 0 ;
26758 wxPyCommandEvent *result = 0 ;
26759 int val1 ;
26760 int ecode1 = 0 ;
26761 int val2 ;
26762 int ecode2 = 0 ;
26763 PyObject * obj0 = 0 ;
26764 PyObject * obj1 = 0 ;
26765 char * kwnames[] = {
26766 (char *) "eventType",(char *) "id", NULL
26767 };
26768
26769 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26770 if (obj0) {
26771 ecode1 = SWIG_AsVal_int(obj0, &val1);
26772 if (!SWIG_IsOK(ecode1)) {
26773 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyCommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26774 }
26775 arg1 = static_cast< wxEventType >(val1);
26776 }
26777 if (obj1) {
26778 ecode2 = SWIG_AsVal_int(obj1, &val2);
26779 if (!SWIG_IsOK(ecode2)) {
26780 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyCommandEvent" "', expected argument " "2"" of type '" "int""'");
26781 }
26782 arg2 = static_cast< int >(val2);
26783 }
26784 {
26785 PyThreadState* __tstate = wxPyBeginAllowThreads();
26786 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
26787 wxPyEndAllowThreads(__tstate);
26788 if (PyErr_Occurred()) SWIG_fail;
26789 }
26790 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_NEW | 0 );
26791 return resultobj;
26792 fail:
26793 return NULL;
26794 }
26795
26796
26797 SWIGINTERN PyObject *_wrap_delete_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26798 PyObject *resultobj = 0;
26799 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26800 void *argp1 = 0 ;
26801 int res1 = 0 ;
26802 PyObject *swig_obj[1] ;
26803
26804 if (!args) SWIG_fail;
26805 swig_obj[0] = args;
26806 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_DISOWN | 0 );
26807 if (!SWIG_IsOK(res1)) {
26808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyCommandEvent" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26809 }
26810 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26811 {
26812 PyThreadState* __tstate = wxPyBeginAllowThreads();
26813 delete arg1;
26814
26815 wxPyEndAllowThreads(__tstate);
26816 if (PyErr_Occurred()) SWIG_fail;
26817 }
26818 resultobj = SWIG_Py_Void();
26819 return resultobj;
26820 fail:
26821 return NULL;
26822 }
26823
26824
26825 SWIGINTERN PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26826 PyObject *resultobj = 0;
26827 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26828 PyObject *arg2 = (PyObject *) 0 ;
26829 void *argp1 = 0 ;
26830 int res1 = 0 ;
26831 PyObject * obj0 = 0 ;
26832 PyObject * obj1 = 0 ;
26833 char * kwnames[] = {
26834 (char *) "self",(char *) "self", NULL
26835 };
26836
26837 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
26838 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
26839 if (!SWIG_IsOK(res1)) {
26840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26841 }
26842 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26843 arg2 = obj1;
26844 {
26845 PyThreadState* __tstate = wxPyBeginAllowThreads();
26846 (arg1)->SetSelf(arg2);
26847 wxPyEndAllowThreads(__tstate);
26848 if (PyErr_Occurred()) SWIG_fail;
26849 }
26850 resultobj = SWIG_Py_Void();
26851 return resultobj;
26852 fail:
26853 return NULL;
26854 }
26855
26856
26857 SWIGINTERN PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26858 PyObject *resultobj = 0;
26859 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26860 PyObject *result = 0 ;
26861 void *argp1 = 0 ;
26862 int res1 = 0 ;
26863 PyObject *swig_obj[1] ;
26864
26865 if (!args) SWIG_fail;
26866 swig_obj[0] = args;
26867 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
26868 if (!SWIG_IsOK(res1)) {
26869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26870 }
26871 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26872 {
26873 PyThreadState* __tstate = wxPyBeginAllowThreads();
26874 result = (PyObject *)(arg1)->GetSelf();
26875 wxPyEndAllowThreads(__tstate);
26876 if (PyErr_Occurred()) SWIG_fail;
26877 }
26878 resultobj = result;
26879 return resultobj;
26880 fail:
26881 return NULL;
26882 }
26883
26884
26885 SWIGINTERN PyObject *PyCommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26886 PyObject *obj;
26887 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26888 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyCommandEvent, SWIG_NewClientData(obj));
26889 return SWIG_Py_Void();
26890 }
26891
26892 SWIGINTERN PyObject *PyCommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26893 return SWIG_Python_InitShadowInstance(args);
26894 }
26895
26896 SWIGINTERN PyObject *_wrap_new_DateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26897 PyObject *resultobj = 0;
26898 wxWindow *arg1 = (wxWindow *) 0 ;
26899 wxDateTime *arg2 = 0 ;
26900 wxEventType arg3 ;
26901 wxDateEvent *result = 0 ;
26902 void *argp1 = 0 ;
26903 int res1 = 0 ;
26904 void *argp2 = 0 ;
26905 int res2 = 0 ;
26906 int val3 ;
26907 int ecode3 = 0 ;
26908 PyObject * obj0 = 0 ;
26909 PyObject * obj1 = 0 ;
26910 PyObject * obj2 = 0 ;
26911 char * kwnames[] = {
26912 (char *) "win",(char *) "dt",(char *) "type", NULL
26913 };
26914
26915 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26916 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26917 if (!SWIG_IsOK(res1)) {
26918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26919 }
26920 arg1 = reinterpret_cast< wxWindow * >(argp1);
26921 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26922 if (!SWIG_IsOK(res2)) {
26923 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26924 }
26925 if (!argp2) {
26926 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26927 }
26928 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26929 ecode3 = SWIG_AsVal_int(obj2, &val3);
26930 if (!SWIG_IsOK(ecode3)) {
26931 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateEvent" "', expected argument " "3"" of type '" "wxEventType""'");
26932 }
26933 arg3 = static_cast< wxEventType >(val3);
26934 {
26935 PyThreadState* __tstate = wxPyBeginAllowThreads();
26936 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
26937 wxPyEndAllowThreads(__tstate);
26938 if (PyErr_Occurred()) SWIG_fail;
26939 }
26940 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateEvent, SWIG_POINTER_NEW | 0 );
26941 return resultobj;
26942 fail:
26943 return NULL;
26944 }
26945
26946
26947 SWIGINTERN PyObject *_wrap_DateEvent_GetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26948 PyObject *resultobj = 0;
26949 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
26950 wxDateTime *result = 0 ;
26951 void *argp1 = 0 ;
26952 int res1 = 0 ;
26953 PyObject *swig_obj[1] ;
26954
26955 if (!args) SWIG_fail;
26956 swig_obj[0] = args;
26957 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
26958 if (!SWIG_IsOK(res1)) {
26959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_GetDate" "', expected argument " "1"" of type '" "wxDateEvent const *""'");
26960 }
26961 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
26962 {
26963 PyThreadState* __tstate = wxPyBeginAllowThreads();
26964 {
26965 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
26966 result = (wxDateTime *) &_result_ref;
26967 }
26968 wxPyEndAllowThreads(__tstate);
26969 if (PyErr_Occurred()) SWIG_fail;
26970 }
26971 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26972 return resultobj;
26973 fail:
26974 return NULL;
26975 }
26976
26977
26978 SWIGINTERN PyObject *_wrap_DateEvent_SetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26979 PyObject *resultobj = 0;
26980 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
26981 wxDateTime *arg2 = 0 ;
26982 void *argp1 = 0 ;
26983 int res1 = 0 ;
26984 void *argp2 = 0 ;
26985 int res2 = 0 ;
26986 PyObject * obj0 = 0 ;
26987 PyObject * obj1 = 0 ;
26988 char * kwnames[] = {
26989 (char *) "self",(char *) "date", NULL
26990 };
26991
26992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) SWIG_fail;
26993 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
26994 if (!SWIG_IsOK(res1)) {
26995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_SetDate" "', expected argument " "1"" of type '" "wxDateEvent *""'");
26996 }
26997 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
26998 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26999 if (!SWIG_IsOK(res2)) {
27000 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27001 }
27002 if (!argp2) {
27003 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27004 }
27005 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27006 {
27007 PyThreadState* __tstate = wxPyBeginAllowThreads();
27008 (arg1)->SetDate((wxDateTime const &)*arg2);
27009 wxPyEndAllowThreads(__tstate);
27010 if (PyErr_Occurred()) SWIG_fail;
27011 }
27012 resultobj = SWIG_Py_Void();
27013 return resultobj;
27014 fail:
27015 return NULL;
27016 }
27017
27018
27019 SWIGINTERN PyObject *DateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27020 PyObject *obj;
27021 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27022 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateEvent, SWIG_NewClientData(obj));
27023 return SWIG_Py_Void();
27024 }
27025
27026 SWIGINTERN PyObject *DateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27027 return SWIG_Python_InitShadowInstance(args);
27028 }
27029
27030 SWIGINTERN PyObject *_wrap_new_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27031 PyObject *resultobj = 0;
27032 wxPyApp *result = 0 ;
27033
27034 if (!SWIG_Python_UnpackTuple(args,"new_PyApp",0,0,0)) SWIG_fail;
27035 {
27036 PyThreadState* __tstate = wxPyBeginAllowThreads();
27037 result = (wxPyApp *)new_wxPyApp();
27038 wxPyEndAllowThreads(__tstate);
27039 if (PyErr_Occurred()) SWIG_fail;
27040 }
27041 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyApp, SWIG_POINTER_NEW | 0 );
27042 return resultobj;
27043 fail:
27044 return NULL;
27045 }
27046
27047
27048 SWIGINTERN PyObject *_wrap_delete_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27049 PyObject *resultobj = 0;
27050 wxPyApp *arg1 = (wxPyApp *) 0 ;
27051 void *argp1 = 0 ;
27052 int res1 = 0 ;
27053 PyObject *swig_obj[1] ;
27054
27055 if (!args) SWIG_fail;
27056 swig_obj[0] = args;
27057 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, SWIG_POINTER_DISOWN | 0 );
27058 if (!SWIG_IsOK(res1)) {
27059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
27060 }
27061 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27062 {
27063 PyThreadState* __tstate = wxPyBeginAllowThreads();
27064 delete arg1;
27065
27066 wxPyEndAllowThreads(__tstate);
27067 if (PyErr_Occurred()) SWIG_fail;
27068 }
27069 resultobj = SWIG_Py_Void();
27070 return resultobj;
27071 fail:
27072 return NULL;
27073 }
27074
27075
27076 SWIGINTERN PyObject *_wrap_PyApp__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27077 PyObject *resultobj = 0;
27078 wxPyApp *arg1 = (wxPyApp *) 0 ;
27079 PyObject *arg2 = (PyObject *) 0 ;
27080 PyObject *arg3 = (PyObject *) 0 ;
27081 bool arg4 ;
27082 void *argp1 = 0 ;
27083 int res1 = 0 ;
27084 bool val4 ;
27085 int ecode4 = 0 ;
27086 PyObject * obj0 = 0 ;
27087 PyObject * obj1 = 0 ;
27088 PyObject * obj2 = 0 ;
27089 PyObject * obj3 = 0 ;
27090 char * kwnames[] = {
27091 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
27092 };
27093
27094 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
27095 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27096 if (!SWIG_IsOK(res1)) {
27097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyApp *""'");
27098 }
27099 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27100 arg2 = obj1;
27101 arg3 = obj2;
27102 ecode4 = SWIG_AsVal_bool(obj3, &val4);
27103 if (!SWIG_IsOK(ecode4)) {
27104 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyApp__setCallbackInfo" "', expected argument " "4"" of type '" "bool""'");
27105 }
27106 arg4 = static_cast< bool >(val4);
27107 {
27108 PyThreadState* __tstate = wxPyBeginAllowThreads();
27109 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
27110 wxPyEndAllowThreads(__tstate);
27111 if (PyErr_Occurred()) SWIG_fail;
27112 }
27113 resultobj = SWIG_Py_Void();
27114 return resultobj;
27115 fail:
27116 return NULL;
27117 }
27118
27119
27120 SWIGINTERN PyObject *_wrap_PyApp_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27121 PyObject *resultobj = 0;
27122 wxPyApp *arg1 = (wxPyApp *) 0 ;
27123 wxString result;
27124 void *argp1 = 0 ;
27125 int res1 = 0 ;
27126 PyObject *swig_obj[1] ;
27127
27128 if (!args) SWIG_fail;
27129 swig_obj[0] = args;
27130 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27131 if (!SWIG_IsOK(res1)) {
27132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAppName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27133 }
27134 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27135 {
27136 PyThreadState* __tstate = wxPyBeginAllowThreads();
27137 result = ((wxPyApp const *)arg1)->GetAppName();
27138 wxPyEndAllowThreads(__tstate);
27139 if (PyErr_Occurred()) SWIG_fail;
27140 }
27141 {
27142 #if wxUSE_UNICODE
27143 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27144 #else
27145 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27146 #endif
27147 }
27148 return resultobj;
27149 fail:
27150 return NULL;
27151 }
27152
27153
27154 SWIGINTERN PyObject *_wrap_PyApp_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27155 PyObject *resultobj = 0;
27156 wxPyApp *arg1 = (wxPyApp *) 0 ;
27157 wxString *arg2 = 0 ;
27158 void *argp1 = 0 ;
27159 int res1 = 0 ;
27160 bool temp2 = false ;
27161 PyObject * obj0 = 0 ;
27162 PyObject * obj1 = 0 ;
27163 char * kwnames[] = {
27164 (char *) "self",(char *) "name", NULL
27165 };
27166
27167 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
27168 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27169 if (!SWIG_IsOK(res1)) {
27170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAppName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27171 }
27172 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27173 {
27174 arg2 = wxString_in_helper(obj1);
27175 if (arg2 == NULL) SWIG_fail;
27176 temp2 = true;
27177 }
27178 {
27179 PyThreadState* __tstate = wxPyBeginAllowThreads();
27180 (arg1)->SetAppName((wxString const &)*arg2);
27181 wxPyEndAllowThreads(__tstate);
27182 if (PyErr_Occurred()) SWIG_fail;
27183 }
27184 resultobj = SWIG_Py_Void();
27185 {
27186 if (temp2)
27187 delete arg2;
27188 }
27189 return resultobj;
27190 fail:
27191 {
27192 if (temp2)
27193 delete arg2;
27194 }
27195 return NULL;
27196 }
27197
27198
27199 SWIGINTERN PyObject *_wrap_PyApp_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27200 PyObject *resultobj = 0;
27201 wxPyApp *arg1 = (wxPyApp *) 0 ;
27202 wxString result;
27203 void *argp1 = 0 ;
27204 int res1 = 0 ;
27205 PyObject *swig_obj[1] ;
27206
27207 if (!args) SWIG_fail;
27208 swig_obj[0] = args;
27209 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27210 if (!SWIG_IsOK(res1)) {
27211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetClassName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27212 }
27213 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27214 {
27215 PyThreadState* __tstate = wxPyBeginAllowThreads();
27216 result = ((wxPyApp const *)arg1)->GetClassName();
27217 wxPyEndAllowThreads(__tstate);
27218 if (PyErr_Occurred()) SWIG_fail;
27219 }
27220 {
27221 #if wxUSE_UNICODE
27222 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27223 #else
27224 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27225 #endif
27226 }
27227 return resultobj;
27228 fail:
27229 return NULL;
27230 }
27231
27232
27233 SWIGINTERN PyObject *_wrap_PyApp_SetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27234 PyObject *resultobj = 0;
27235 wxPyApp *arg1 = (wxPyApp *) 0 ;
27236 wxString *arg2 = 0 ;
27237 void *argp1 = 0 ;
27238 int res1 = 0 ;
27239 bool temp2 = false ;
27240 PyObject * obj0 = 0 ;
27241 PyObject * obj1 = 0 ;
27242 char * kwnames[] = {
27243 (char *) "self",(char *) "name", NULL
27244 };
27245
27246 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) SWIG_fail;
27247 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27248 if (!SWIG_IsOK(res1)) {
27249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetClassName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27250 }
27251 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27252 {
27253 arg2 = wxString_in_helper(obj1);
27254 if (arg2 == NULL) SWIG_fail;
27255 temp2 = true;
27256 }
27257 {
27258 PyThreadState* __tstate = wxPyBeginAllowThreads();
27259 (arg1)->SetClassName((wxString const &)*arg2);
27260 wxPyEndAllowThreads(__tstate);
27261 if (PyErr_Occurred()) SWIG_fail;
27262 }
27263 resultobj = SWIG_Py_Void();
27264 {
27265 if (temp2)
27266 delete arg2;
27267 }
27268 return resultobj;
27269 fail:
27270 {
27271 if (temp2)
27272 delete arg2;
27273 }
27274 return NULL;
27275 }
27276
27277
27278 SWIGINTERN PyObject *_wrap_PyApp_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27279 PyObject *resultobj = 0;
27280 wxPyApp *arg1 = (wxPyApp *) 0 ;
27281 wxString *result = 0 ;
27282 void *argp1 = 0 ;
27283 int res1 = 0 ;
27284 PyObject *swig_obj[1] ;
27285
27286 if (!args) SWIG_fail;
27287 swig_obj[0] = args;
27288 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27289 if (!SWIG_IsOK(res1)) {
27290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetVendorName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27291 }
27292 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27293 {
27294 PyThreadState* __tstate = wxPyBeginAllowThreads();
27295 {
27296 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
27297 result = (wxString *) &_result_ref;
27298 }
27299 wxPyEndAllowThreads(__tstate);
27300 if (PyErr_Occurred()) SWIG_fail;
27301 }
27302 {
27303 #if wxUSE_UNICODE
27304 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
27305 #else
27306 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
27307 #endif
27308 }
27309 return resultobj;
27310 fail:
27311 return NULL;
27312 }
27313
27314
27315 SWIGINTERN PyObject *_wrap_PyApp_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27316 PyObject *resultobj = 0;
27317 wxPyApp *arg1 = (wxPyApp *) 0 ;
27318 wxString *arg2 = 0 ;
27319 void *argp1 = 0 ;
27320 int res1 = 0 ;
27321 bool temp2 = false ;
27322 PyObject * obj0 = 0 ;
27323 PyObject * obj1 = 0 ;
27324 char * kwnames[] = {
27325 (char *) "self",(char *) "name", NULL
27326 };
27327
27328 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
27329 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27330 if (!SWIG_IsOK(res1)) {
27331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetVendorName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27332 }
27333 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27334 {
27335 arg2 = wxString_in_helper(obj1);
27336 if (arg2 == NULL) SWIG_fail;
27337 temp2 = true;
27338 }
27339 {
27340 PyThreadState* __tstate = wxPyBeginAllowThreads();
27341 (arg1)->SetVendorName((wxString const &)*arg2);
27342 wxPyEndAllowThreads(__tstate);
27343 if (PyErr_Occurred()) SWIG_fail;
27344 }
27345 resultobj = SWIG_Py_Void();
27346 {
27347 if (temp2)
27348 delete arg2;
27349 }
27350 return resultobj;
27351 fail:
27352 {
27353 if (temp2)
27354 delete arg2;
27355 }
27356 return NULL;
27357 }
27358
27359
27360 SWIGINTERN PyObject *_wrap_PyApp_GetTraits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27361 PyObject *resultobj = 0;
27362 wxPyApp *arg1 = (wxPyApp *) 0 ;
27363 wxAppTraits *result = 0 ;
27364 void *argp1 = 0 ;
27365 int res1 = 0 ;
27366 PyObject *swig_obj[1] ;
27367
27368 if (!args) SWIG_fail;
27369 swig_obj[0] = args;
27370 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27371 if (!SWIG_IsOK(res1)) {
27372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTraits" "', expected argument " "1"" of type '" "wxPyApp *""'");
27373 }
27374 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27375 {
27376 PyThreadState* __tstate = wxPyBeginAllowThreads();
27377 result = (wxAppTraits *)(arg1)->GetTraits();
27378 wxPyEndAllowThreads(__tstate);
27379 if (PyErr_Occurred()) SWIG_fail;
27380 }
27381 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAppTraits, 0 | 0 );
27382 return resultobj;
27383 fail:
27384 return NULL;
27385 }
27386
27387
27388 SWIGINTERN PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27389 PyObject *resultobj = 0;
27390 wxPyApp *arg1 = (wxPyApp *) 0 ;
27391 void *argp1 = 0 ;
27392 int res1 = 0 ;
27393 PyObject *swig_obj[1] ;
27394
27395 if (!args) SWIG_fail;
27396 swig_obj[0] = args;
27397 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27398 if (!SWIG_IsOK(res1)) {
27399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27400 }
27401 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27402 {
27403 PyThreadState* __tstate = wxPyBeginAllowThreads();
27404 (arg1)->ProcessPendingEvents();
27405 wxPyEndAllowThreads(__tstate);
27406 if (PyErr_Occurred()) SWIG_fail;
27407 }
27408 resultobj = SWIG_Py_Void();
27409 return resultobj;
27410 fail:
27411 return NULL;
27412 }
27413
27414
27415 SWIGINTERN PyObject *_wrap_PyApp_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27416 PyObject *resultobj = 0;
27417 wxPyApp *arg1 = (wxPyApp *) 0 ;
27418 bool arg2 = (bool) false ;
27419 bool result;
27420 void *argp1 = 0 ;
27421 int res1 = 0 ;
27422 bool val2 ;
27423 int ecode2 = 0 ;
27424 PyObject * obj0 = 0 ;
27425 PyObject * obj1 = 0 ;
27426 char * kwnames[] = {
27427 (char *) "self",(char *) "onlyIfNeeded", NULL
27428 };
27429
27430 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) SWIG_fail;
27431 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27432 if (!SWIG_IsOK(res1)) {
27433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Yield" "', expected argument " "1"" of type '" "wxPyApp *""'");
27434 }
27435 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27436 if (obj1) {
27437 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27438 if (!SWIG_IsOK(ecode2)) {
27439 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_Yield" "', expected argument " "2"" of type '" "bool""'");
27440 }
27441 arg2 = static_cast< bool >(val2);
27442 }
27443 {
27444 PyThreadState* __tstate = wxPyBeginAllowThreads();
27445 result = (bool)(arg1)->Yield(arg2);
27446 wxPyEndAllowThreads(__tstate);
27447 if (PyErr_Occurred()) SWIG_fail;
27448 }
27449 {
27450 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27451 }
27452 return resultobj;
27453 fail:
27454 return NULL;
27455 }
27456
27457
27458 SWIGINTERN PyObject *_wrap_PyApp_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27459 PyObject *resultobj = 0;
27460 wxPyApp *arg1 = (wxPyApp *) 0 ;
27461 void *argp1 = 0 ;
27462 int res1 = 0 ;
27463 PyObject *swig_obj[1] ;
27464
27465 if (!args) SWIG_fail;
27466 swig_obj[0] = args;
27467 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27468 if (!SWIG_IsOK(res1)) {
27469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_WakeUpIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27470 }
27471 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27472 {
27473 PyThreadState* __tstate = wxPyBeginAllowThreads();
27474 (arg1)->WakeUpIdle();
27475 wxPyEndAllowThreads(__tstate);
27476 if (PyErr_Occurred()) SWIG_fail;
27477 }
27478 resultobj = SWIG_Py_Void();
27479 return resultobj;
27480 fail:
27481 return NULL;
27482 }
27483
27484
27485 SWIGINTERN PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27486 PyObject *resultobj = 0;
27487 bool result;
27488
27489 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsMainLoopRunning",0,0,0)) SWIG_fail;
27490 {
27491 PyThreadState* __tstate = wxPyBeginAllowThreads();
27492 result = (bool)wxPyApp::IsMainLoopRunning();
27493 wxPyEndAllowThreads(__tstate);
27494 if (PyErr_Occurred()) SWIG_fail;
27495 }
27496 {
27497 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27498 }
27499 return resultobj;
27500 fail:
27501 return NULL;
27502 }
27503
27504
27505 SWIGINTERN PyObject *_wrap_PyApp_MainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27506 PyObject *resultobj = 0;
27507 wxPyApp *arg1 = (wxPyApp *) 0 ;
27508 int result;
27509 void *argp1 = 0 ;
27510 int res1 = 0 ;
27511 PyObject *swig_obj[1] ;
27512
27513 if (!args) SWIG_fail;
27514 swig_obj[0] = args;
27515 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27516 if (!SWIG_IsOK(res1)) {
27517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_MainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27518 }
27519 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27520 {
27521 PyThreadState* __tstate = wxPyBeginAllowThreads();
27522 result = (int)(arg1)->MainLoop();
27523 wxPyEndAllowThreads(__tstate);
27524 if (PyErr_Occurred()) SWIG_fail;
27525 }
27526 resultobj = SWIG_From_int(static_cast< int >(result));
27527 return resultobj;
27528 fail:
27529 return NULL;
27530 }
27531
27532
27533 SWIGINTERN PyObject *_wrap_PyApp_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27534 PyObject *resultobj = 0;
27535 wxPyApp *arg1 = (wxPyApp *) 0 ;
27536 void *argp1 = 0 ;
27537 int res1 = 0 ;
27538 PyObject *swig_obj[1] ;
27539
27540 if (!args) SWIG_fail;
27541 swig_obj[0] = args;
27542 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27543 if (!SWIG_IsOK(res1)) {
27544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Exit" "', expected argument " "1"" of type '" "wxPyApp *""'");
27545 }
27546 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27547 {
27548 PyThreadState* __tstate = wxPyBeginAllowThreads();
27549 (arg1)->Exit();
27550 wxPyEndAllowThreads(__tstate);
27551 if (PyErr_Occurred()) SWIG_fail;
27552 }
27553 resultobj = SWIG_Py_Void();
27554 return resultobj;
27555 fail:
27556 return NULL;
27557 }
27558
27559
27560 SWIGINTERN PyObject *_wrap_PyApp_ExitMainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27561 PyObject *resultobj = 0;
27562 wxPyApp *arg1 = (wxPyApp *) 0 ;
27563 void *argp1 = 0 ;
27564 int res1 = 0 ;
27565 PyObject *swig_obj[1] ;
27566
27567 if (!args) SWIG_fail;
27568 swig_obj[0] = args;
27569 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27570 if (!SWIG_IsOK(res1)) {
27571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ExitMainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27572 }
27573 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27574 {
27575 PyThreadState* __tstate = wxPyBeginAllowThreads();
27576 (arg1)->ExitMainLoop();
27577 wxPyEndAllowThreads(__tstate);
27578 if (PyErr_Occurred()) SWIG_fail;
27579 }
27580 resultobj = SWIG_Py_Void();
27581 return resultobj;
27582 fail:
27583 return NULL;
27584 }
27585
27586
27587 SWIGINTERN PyObject *_wrap_PyApp_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27588 PyObject *resultobj = 0;
27589 wxPyApp *arg1 = (wxPyApp *) 0 ;
27590 bool result;
27591 void *argp1 = 0 ;
27592 int res1 = 0 ;
27593 PyObject *swig_obj[1] ;
27594
27595 if (!args) SWIG_fail;
27596 swig_obj[0] = args;
27597 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27598 if (!SWIG_IsOK(res1)) {
27599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Pending" "', expected argument " "1"" of type '" "wxPyApp *""'");
27600 }
27601 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27602 {
27603 PyThreadState* __tstate = wxPyBeginAllowThreads();
27604 result = (bool)(arg1)->Pending();
27605 wxPyEndAllowThreads(__tstate);
27606 if (PyErr_Occurred()) SWIG_fail;
27607 }
27608 {
27609 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27610 }
27611 return resultobj;
27612 fail:
27613 return NULL;
27614 }
27615
27616
27617 SWIGINTERN PyObject *_wrap_PyApp_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27618 PyObject *resultobj = 0;
27619 wxPyApp *arg1 = (wxPyApp *) 0 ;
27620 bool result;
27621 void *argp1 = 0 ;
27622 int res1 = 0 ;
27623 PyObject *swig_obj[1] ;
27624
27625 if (!args) SWIG_fail;
27626 swig_obj[0] = args;
27627 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27628 if (!SWIG_IsOK(res1)) {
27629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Dispatch" "', expected argument " "1"" of type '" "wxPyApp *""'");
27630 }
27631 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27632 {
27633 PyThreadState* __tstate = wxPyBeginAllowThreads();
27634 result = (bool)(arg1)->Dispatch();
27635 wxPyEndAllowThreads(__tstate);
27636 if (PyErr_Occurred()) SWIG_fail;
27637 }
27638 {
27639 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27640 }
27641 return resultobj;
27642 fail:
27643 return NULL;
27644 }
27645
27646
27647 SWIGINTERN PyObject *_wrap_PyApp_ProcessIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27648 PyObject *resultobj = 0;
27649 wxPyApp *arg1 = (wxPyApp *) 0 ;
27650 bool result;
27651 void *argp1 = 0 ;
27652 int res1 = 0 ;
27653 PyObject *swig_obj[1] ;
27654
27655 if (!args) SWIG_fail;
27656 swig_obj[0] = args;
27657 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27658 if (!SWIG_IsOK(res1)) {
27659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27660 }
27661 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27662 {
27663 PyThreadState* __tstate = wxPyBeginAllowThreads();
27664 result = (bool)(arg1)->ProcessIdle();
27665 wxPyEndAllowThreads(__tstate);
27666 if (PyErr_Occurred()) SWIG_fail;
27667 }
27668 {
27669 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27670 }
27671 return resultobj;
27672 fail:
27673 return NULL;
27674 }
27675
27676
27677 SWIGINTERN PyObject *_wrap_PyApp_SendIdleEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27678 PyObject *resultobj = 0;
27679 wxPyApp *arg1 = (wxPyApp *) 0 ;
27680 wxWindow *arg2 = (wxWindow *) 0 ;
27681 wxIdleEvent *arg3 = 0 ;
27682 bool result;
27683 void *argp1 = 0 ;
27684 int res1 = 0 ;
27685 void *argp2 = 0 ;
27686 int res2 = 0 ;
27687 void *argp3 = 0 ;
27688 int res3 = 0 ;
27689 PyObject * obj0 = 0 ;
27690 PyObject * obj1 = 0 ;
27691 PyObject * obj2 = 0 ;
27692 char * kwnames[] = {
27693 (char *) "self",(char *) "win",(char *) "event", NULL
27694 };
27695
27696 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27697 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27698 if (!SWIG_IsOK(res1)) {
27699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SendIdleEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27700 }
27701 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27702 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27703 if (!SWIG_IsOK(res2)) {
27704 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SendIdleEvents" "', expected argument " "2"" of type '" "wxWindow *""'");
27705 }
27706 arg2 = reinterpret_cast< wxWindow * >(argp2);
27707 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIdleEvent, 0 );
27708 if (!SWIG_IsOK(res3)) {
27709 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27710 }
27711 if (!argp3) {
27712 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27713 }
27714 arg3 = reinterpret_cast< wxIdleEvent * >(argp3);
27715 {
27716 PyThreadState* __tstate = wxPyBeginAllowThreads();
27717 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
27718 wxPyEndAllowThreads(__tstate);
27719 if (PyErr_Occurred()) SWIG_fail;
27720 }
27721 {
27722 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27723 }
27724 return resultobj;
27725 fail:
27726 return NULL;
27727 }
27728
27729
27730 SWIGINTERN PyObject *_wrap_PyApp_IsActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27731 PyObject *resultobj = 0;
27732 wxPyApp *arg1 = (wxPyApp *) 0 ;
27733 bool result;
27734 void *argp1 = 0 ;
27735 int res1 = 0 ;
27736 PyObject *swig_obj[1] ;
27737
27738 if (!args) SWIG_fail;
27739 swig_obj[0] = args;
27740 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27741 if (!SWIG_IsOK(res1)) {
27742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_IsActive" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27743 }
27744 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27745 {
27746 PyThreadState* __tstate = wxPyBeginAllowThreads();
27747 result = (bool)((wxPyApp const *)arg1)->IsActive();
27748 wxPyEndAllowThreads(__tstate);
27749 if (PyErr_Occurred()) SWIG_fail;
27750 }
27751 {
27752 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27753 }
27754 return resultobj;
27755 fail:
27756 return NULL;
27757 }
27758
27759
27760 SWIGINTERN PyObject *_wrap_PyApp_SetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27761 PyObject *resultobj = 0;
27762 wxPyApp *arg1 = (wxPyApp *) 0 ;
27763 wxWindow *arg2 = (wxWindow *) 0 ;
27764 void *argp1 = 0 ;
27765 int res1 = 0 ;
27766 void *argp2 = 0 ;
27767 int res2 = 0 ;
27768 PyObject * obj0 = 0 ;
27769 PyObject * obj1 = 0 ;
27770 char * kwnames[] = {
27771 (char *) "self",(char *) "win", NULL
27772 };
27773
27774 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) SWIG_fail;
27775 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27776 if (!SWIG_IsOK(res1)) {
27777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetTopWindow" "', expected argument " "1"" of type '" "wxPyApp *""'");
27778 }
27779 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27780 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27781 if (!SWIG_IsOK(res2)) {
27782 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SetTopWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
27783 }
27784 arg2 = reinterpret_cast< wxWindow * >(argp2);
27785 {
27786 PyThreadState* __tstate = wxPyBeginAllowThreads();
27787 (arg1)->SetTopWindow(arg2);
27788 wxPyEndAllowThreads(__tstate);
27789 if (PyErr_Occurred()) SWIG_fail;
27790 }
27791 resultobj = SWIG_Py_Void();
27792 return resultobj;
27793 fail:
27794 return NULL;
27795 }
27796
27797
27798 SWIGINTERN PyObject *_wrap_PyApp_GetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27799 PyObject *resultobj = 0;
27800 wxPyApp *arg1 = (wxPyApp *) 0 ;
27801 wxWindow *result = 0 ;
27802 void *argp1 = 0 ;
27803 int res1 = 0 ;
27804 PyObject *swig_obj[1] ;
27805
27806 if (!args) SWIG_fail;
27807 swig_obj[0] = args;
27808 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27809 if (!SWIG_IsOK(res1)) {
27810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTopWindow" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27811 }
27812 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27813 {
27814 PyThreadState* __tstate = wxPyBeginAllowThreads();
27815 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
27816 wxPyEndAllowThreads(__tstate);
27817 if (PyErr_Occurred()) SWIG_fail;
27818 }
27819 {
27820 resultobj = wxPyMake_wxObject(result, (bool)0);
27821 }
27822 return resultobj;
27823 fail:
27824 return NULL;
27825 }
27826
27827
27828 SWIGINTERN PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27829 PyObject *resultobj = 0;
27830 wxPyApp *arg1 = (wxPyApp *) 0 ;
27831 bool arg2 ;
27832 void *argp1 = 0 ;
27833 int res1 = 0 ;
27834 bool val2 ;
27835 int ecode2 = 0 ;
27836 PyObject * obj0 = 0 ;
27837 PyObject * obj1 = 0 ;
27838 char * kwnames[] = {
27839 (char *) "self",(char *) "flag", NULL
27840 };
27841
27842 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) SWIG_fail;
27843 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27844 if (!SWIG_IsOK(res1)) {
27845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp *""'");
27846 }
27847 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27848 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27849 if (!SWIG_IsOK(ecode2)) {
27850 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "2"" of type '" "bool""'");
27851 }
27852 arg2 = static_cast< bool >(val2);
27853 {
27854 PyThreadState* __tstate = wxPyBeginAllowThreads();
27855 (arg1)->SetExitOnFrameDelete(arg2);
27856 wxPyEndAllowThreads(__tstate);
27857 if (PyErr_Occurred()) SWIG_fail;
27858 }
27859 resultobj = SWIG_Py_Void();
27860 return resultobj;
27861 fail:
27862 return NULL;
27863 }
27864
27865
27866 SWIGINTERN PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27867 PyObject *resultobj = 0;
27868 wxPyApp *arg1 = (wxPyApp *) 0 ;
27869 bool result;
27870 void *argp1 = 0 ;
27871 int res1 = 0 ;
27872 PyObject *swig_obj[1] ;
27873
27874 if (!args) SWIG_fail;
27875 swig_obj[0] = args;
27876 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27877 if (!SWIG_IsOK(res1)) {
27878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27879 }
27880 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27881 {
27882 PyThreadState* __tstate = wxPyBeginAllowThreads();
27883 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
27884 wxPyEndAllowThreads(__tstate);
27885 if (PyErr_Occurred()) SWIG_fail;
27886 }
27887 {
27888 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27889 }
27890 return resultobj;
27891 fail:
27892 return NULL;
27893 }
27894
27895
27896 SWIGINTERN PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27897 PyObject *resultobj = 0;
27898 wxPyApp *arg1 = (wxPyApp *) 0 ;
27899 bool arg2 ;
27900 void *argp1 = 0 ;
27901 int res1 = 0 ;
27902 bool val2 ;
27903 int ecode2 = 0 ;
27904 PyObject * obj0 = 0 ;
27905 PyObject * obj1 = 0 ;
27906 char * kwnames[] = {
27907 (char *) "self",(char *) "flag", NULL
27908 };
27909
27910 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) SWIG_fail;
27911 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27912 if (!SWIG_IsOK(res1)) {
27913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp *""'");
27914 }
27915 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27916 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27917 if (!SWIG_IsOK(ecode2)) {
27918 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "2"" of type '" "bool""'");
27919 }
27920 arg2 = static_cast< bool >(val2);
27921 {
27922 PyThreadState* __tstate = wxPyBeginAllowThreads();
27923 (arg1)->SetUseBestVisual(arg2);
27924 wxPyEndAllowThreads(__tstate);
27925 if (PyErr_Occurred()) SWIG_fail;
27926 }
27927 resultobj = SWIG_Py_Void();
27928 return resultobj;
27929 fail:
27930 return NULL;
27931 }
27932
27933
27934 SWIGINTERN PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27935 PyObject *resultobj = 0;
27936 wxPyApp *arg1 = (wxPyApp *) 0 ;
27937 bool result;
27938 void *argp1 = 0 ;
27939 int res1 = 0 ;
27940 PyObject *swig_obj[1] ;
27941
27942 if (!args) SWIG_fail;
27943 swig_obj[0] = args;
27944 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27945 if (!SWIG_IsOK(res1)) {
27946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27947 }
27948 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27949 {
27950 PyThreadState* __tstate = wxPyBeginAllowThreads();
27951 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
27952 wxPyEndAllowThreads(__tstate);
27953 if (PyErr_Occurred()) SWIG_fail;
27954 }
27955 {
27956 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27957 }
27958 return resultobj;
27959 fail:
27960 return NULL;
27961 }
27962
27963
27964 SWIGINTERN PyObject *_wrap_PyApp_SetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27965 PyObject *resultobj = 0;
27966 wxPyApp *arg1 = (wxPyApp *) 0 ;
27967 int arg2 ;
27968 void *argp1 = 0 ;
27969 int res1 = 0 ;
27970 int val2 ;
27971 int ecode2 = 0 ;
27972 PyObject * obj0 = 0 ;
27973 PyObject * obj1 = 0 ;
27974 char * kwnames[] = {
27975 (char *) "self",(char *) "mode", NULL
27976 };
27977
27978 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) SWIG_fail;
27979 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27980 if (!SWIG_IsOK(res1)) {
27981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetPrintMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
27982 }
27983 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27984 ecode2 = SWIG_AsVal_int(obj1, &val2);
27985 if (!SWIG_IsOK(ecode2)) {
27986 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetPrintMode" "', expected argument " "2"" of type '" "int""'");
27987 }
27988 arg2 = static_cast< int >(val2);
27989 {
27990 PyThreadState* __tstate = wxPyBeginAllowThreads();
27991 (arg1)->SetPrintMode(arg2);
27992 wxPyEndAllowThreads(__tstate);
27993 if (PyErr_Occurred()) SWIG_fail;
27994 }
27995 resultobj = SWIG_Py_Void();
27996 return resultobj;
27997 fail:
27998 return NULL;
27999 }
28000
28001
28002 SWIGINTERN PyObject *_wrap_PyApp_GetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28003 PyObject *resultobj = 0;
28004 wxPyApp *arg1 = (wxPyApp *) 0 ;
28005 int result;
28006 void *argp1 = 0 ;
28007 int res1 = 0 ;
28008 PyObject *swig_obj[1] ;
28009
28010 if (!args) SWIG_fail;
28011 swig_obj[0] = args;
28012 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28013 if (!SWIG_IsOK(res1)) {
28014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetPrintMode" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28015 }
28016 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28017 {
28018 PyThreadState* __tstate = wxPyBeginAllowThreads();
28019 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
28020 wxPyEndAllowThreads(__tstate);
28021 if (PyErr_Occurred()) SWIG_fail;
28022 }
28023 resultobj = SWIG_From_int(static_cast< int >(result));
28024 return resultobj;
28025 fail:
28026 return NULL;
28027 }
28028
28029
28030 SWIGINTERN PyObject *_wrap_PyApp_SetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28031 PyObject *resultobj = 0;
28032 wxPyApp *arg1 = (wxPyApp *) 0 ;
28033 int arg2 ;
28034 void *argp1 = 0 ;
28035 int res1 = 0 ;
28036 int val2 ;
28037 int ecode2 = 0 ;
28038 PyObject * obj0 = 0 ;
28039 PyObject * obj1 = 0 ;
28040 char * kwnames[] = {
28041 (char *) "self",(char *) "mode", NULL
28042 };
28043
28044 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) SWIG_fail;
28045 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28046 if (!SWIG_IsOK(res1)) {
28047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
28048 }
28049 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28050 ecode2 = SWIG_AsVal_int(obj1, &val2);
28051 if (!SWIG_IsOK(ecode2)) {
28052 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetAssertMode" "', expected argument " "2"" of type '" "int""'");
28053 }
28054 arg2 = static_cast< int >(val2);
28055 {
28056 PyThreadState* __tstate = wxPyBeginAllowThreads();
28057 (arg1)->SetAssertMode(arg2);
28058 wxPyEndAllowThreads(__tstate);
28059 if (PyErr_Occurred()) SWIG_fail;
28060 }
28061 resultobj = SWIG_Py_Void();
28062 return resultobj;
28063 fail:
28064 return NULL;
28065 }
28066
28067
28068 SWIGINTERN PyObject *_wrap_PyApp_GetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28069 PyObject *resultobj = 0;
28070 wxPyApp *arg1 = (wxPyApp *) 0 ;
28071 int result;
28072 void *argp1 = 0 ;
28073 int res1 = 0 ;
28074 PyObject *swig_obj[1] ;
28075
28076 if (!args) SWIG_fail;
28077 swig_obj[0] = args;
28078 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28079 if (!SWIG_IsOK(res1)) {
28080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
28081 }
28082 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28083 {
28084 PyThreadState* __tstate = wxPyBeginAllowThreads();
28085 result = (int)(arg1)->GetAssertMode();
28086 wxPyEndAllowThreads(__tstate);
28087 if (PyErr_Occurred()) SWIG_fail;
28088 }
28089 resultobj = SWIG_From_int(static_cast< int >(result));
28090 return resultobj;
28091 fail:
28092 return NULL;
28093 }
28094
28095
28096 SWIGINTERN PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28097 PyObject *resultobj = 0;
28098 bool result;
28099
28100 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacSupportPCMenuShortcuts",0,0,0)) SWIG_fail;
28101 {
28102 PyThreadState* __tstate = wxPyBeginAllowThreads();
28103 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
28104 wxPyEndAllowThreads(__tstate);
28105 if (PyErr_Occurred()) SWIG_fail;
28106 }
28107 {
28108 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28109 }
28110 return resultobj;
28111 fail:
28112 return NULL;
28113 }
28114
28115
28116 SWIGINTERN PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28117 PyObject *resultobj = 0;
28118 long result;
28119
28120 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacAboutMenuItemId",0,0,0)) SWIG_fail;
28121 {
28122 PyThreadState* __tstate = wxPyBeginAllowThreads();
28123 result = (long)wxPyApp::GetMacAboutMenuItemId();
28124 wxPyEndAllowThreads(__tstate);
28125 if (PyErr_Occurred()) SWIG_fail;
28126 }
28127 resultobj = SWIG_From_long(static_cast< long >(result));
28128 return resultobj;
28129 fail:
28130 return NULL;
28131 }
28132
28133
28134 SWIGINTERN PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28135 PyObject *resultobj = 0;
28136 long result;
28137
28138 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacPreferencesMenuItemId",0,0,0)) SWIG_fail;
28139 {
28140 PyThreadState* __tstate = wxPyBeginAllowThreads();
28141 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
28142 wxPyEndAllowThreads(__tstate);
28143 if (PyErr_Occurred()) SWIG_fail;
28144 }
28145 resultobj = SWIG_From_long(static_cast< long >(result));
28146 return resultobj;
28147 fail:
28148 return NULL;
28149 }
28150
28151
28152 SWIGINTERN PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28153 PyObject *resultobj = 0;
28154 long result;
28155
28156 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacExitMenuItemId",0,0,0)) SWIG_fail;
28157 {
28158 PyThreadState* __tstate = wxPyBeginAllowThreads();
28159 result = (long)wxPyApp::GetMacExitMenuItemId();
28160 wxPyEndAllowThreads(__tstate);
28161 if (PyErr_Occurred()) SWIG_fail;
28162 }
28163 resultobj = SWIG_From_long(static_cast< long >(result));
28164 return resultobj;
28165 fail:
28166 return NULL;
28167 }
28168
28169
28170 SWIGINTERN PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28171 PyObject *resultobj = 0;
28172 wxString result;
28173
28174 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacHelpMenuTitleName",0,0,0)) SWIG_fail;
28175 {
28176 PyThreadState* __tstate = wxPyBeginAllowThreads();
28177 result = wxPyApp::GetMacHelpMenuTitleName();
28178 wxPyEndAllowThreads(__tstate);
28179 if (PyErr_Occurred()) SWIG_fail;
28180 }
28181 {
28182 #if wxUSE_UNICODE
28183 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28184 #else
28185 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28186 #endif
28187 }
28188 return resultobj;
28189 fail:
28190 return NULL;
28191 }
28192
28193
28194 SWIGINTERN PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28195 PyObject *resultobj = 0;
28196 bool arg1 ;
28197 bool val1 ;
28198 int ecode1 = 0 ;
28199 PyObject * obj0 = 0 ;
28200 char * kwnames[] = {
28201 (char *) "val", NULL
28202 };
28203
28204 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) SWIG_fail;
28205 ecode1 = SWIG_AsVal_bool(obj0, &val1);
28206 if (!SWIG_IsOK(ecode1)) {
28207 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacSupportPCMenuShortcuts" "', expected argument " "1"" of type '" "bool""'");
28208 }
28209 arg1 = static_cast< bool >(val1);
28210 {
28211 PyThreadState* __tstate = wxPyBeginAllowThreads();
28212 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
28213 wxPyEndAllowThreads(__tstate);
28214 if (PyErr_Occurred()) SWIG_fail;
28215 }
28216 resultobj = SWIG_Py_Void();
28217 return resultobj;
28218 fail:
28219 return NULL;
28220 }
28221
28222
28223 SWIGINTERN PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28224 PyObject *resultobj = 0;
28225 long arg1 ;
28226 long val1 ;
28227 int ecode1 = 0 ;
28228 PyObject * obj0 = 0 ;
28229 char * kwnames[] = {
28230 (char *) "val", NULL
28231 };
28232
28233 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) SWIG_fail;
28234 ecode1 = SWIG_AsVal_long(obj0, &val1);
28235 if (!SWIG_IsOK(ecode1)) {
28236 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacAboutMenuItemId" "', expected argument " "1"" of type '" "long""'");
28237 }
28238 arg1 = static_cast< long >(val1);
28239 {
28240 PyThreadState* __tstate = wxPyBeginAllowThreads();
28241 wxPyApp::SetMacAboutMenuItemId(arg1);
28242 wxPyEndAllowThreads(__tstate);
28243 if (PyErr_Occurred()) SWIG_fail;
28244 }
28245 resultobj = SWIG_Py_Void();
28246 return resultobj;
28247 fail:
28248 return NULL;
28249 }
28250
28251
28252 SWIGINTERN PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28253 PyObject *resultobj = 0;
28254 long arg1 ;
28255 long val1 ;
28256 int ecode1 = 0 ;
28257 PyObject * obj0 = 0 ;
28258 char * kwnames[] = {
28259 (char *) "val", NULL
28260 };
28261
28262 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) SWIG_fail;
28263 ecode1 = SWIG_AsVal_long(obj0, &val1);
28264 if (!SWIG_IsOK(ecode1)) {
28265 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacPreferencesMenuItemId" "', expected argument " "1"" of type '" "long""'");
28266 }
28267 arg1 = static_cast< long >(val1);
28268 {
28269 PyThreadState* __tstate = wxPyBeginAllowThreads();
28270 wxPyApp::SetMacPreferencesMenuItemId(arg1);
28271 wxPyEndAllowThreads(__tstate);
28272 if (PyErr_Occurred()) SWIG_fail;
28273 }
28274 resultobj = SWIG_Py_Void();
28275 return resultobj;
28276 fail:
28277 return NULL;
28278 }
28279
28280
28281 SWIGINTERN PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28282 PyObject *resultobj = 0;
28283 long arg1 ;
28284 long val1 ;
28285 int ecode1 = 0 ;
28286 PyObject * obj0 = 0 ;
28287 char * kwnames[] = {
28288 (char *) "val", NULL
28289 };
28290
28291 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) SWIG_fail;
28292 ecode1 = SWIG_AsVal_long(obj0, &val1);
28293 if (!SWIG_IsOK(ecode1)) {
28294 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacExitMenuItemId" "', expected argument " "1"" of type '" "long""'");
28295 }
28296 arg1 = static_cast< long >(val1);
28297 {
28298 PyThreadState* __tstate = wxPyBeginAllowThreads();
28299 wxPyApp::SetMacExitMenuItemId(arg1);
28300 wxPyEndAllowThreads(__tstate);
28301 if (PyErr_Occurred()) SWIG_fail;
28302 }
28303 resultobj = SWIG_Py_Void();
28304 return resultobj;
28305 fail:
28306 return NULL;
28307 }
28308
28309
28310 SWIGINTERN PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28311 PyObject *resultobj = 0;
28312 wxString *arg1 = 0 ;
28313 bool temp1 = false ;
28314 PyObject * obj0 = 0 ;
28315 char * kwnames[] = {
28316 (char *) "val", NULL
28317 };
28318
28319 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) SWIG_fail;
28320 {
28321 arg1 = wxString_in_helper(obj0);
28322 if (arg1 == NULL) SWIG_fail;
28323 temp1 = true;
28324 }
28325 {
28326 PyThreadState* __tstate = wxPyBeginAllowThreads();
28327 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
28328 wxPyEndAllowThreads(__tstate);
28329 if (PyErr_Occurred()) SWIG_fail;
28330 }
28331 resultobj = SWIG_Py_Void();
28332 {
28333 if (temp1)
28334 delete arg1;
28335 }
28336 return resultobj;
28337 fail:
28338 {
28339 if (temp1)
28340 delete arg1;
28341 }
28342 return NULL;
28343 }
28344
28345
28346 SWIGINTERN PyObject *_wrap_PyApp__BootstrapApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28347 PyObject *resultobj = 0;
28348 wxPyApp *arg1 = (wxPyApp *) 0 ;
28349 void *argp1 = 0 ;
28350 int res1 = 0 ;
28351 PyObject *swig_obj[1] ;
28352
28353 if (!args) SWIG_fail;
28354 swig_obj[0] = args;
28355 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28356 if (!SWIG_IsOK(res1)) {
28357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__BootstrapApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
28358 }
28359 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28360 {
28361 PyThreadState* __tstate = wxPyBeginAllowThreads();
28362 (arg1)->_BootstrapApp();
28363 wxPyEndAllowThreads(__tstate);
28364 if (PyErr_Occurred()) SWIG_fail;
28365 }
28366 resultobj = SWIG_Py_Void();
28367 return resultobj;
28368 fail:
28369 return NULL;
28370 }
28371
28372
28373 SWIGINTERN PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28374 PyObject *resultobj = 0;
28375 int result;
28376
28377 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetComCtl32Version",0,0,0)) SWIG_fail;
28378 {
28379 PyThreadState* __tstate = wxPyBeginAllowThreads();
28380 result = (int)wxPyApp::GetComCtl32Version();
28381 wxPyEndAllowThreads(__tstate);
28382 if (PyErr_Occurred()) SWIG_fail;
28383 }
28384 resultobj = SWIG_From_int(static_cast< int >(result));
28385 return resultobj;
28386 fail:
28387 return NULL;
28388 }
28389
28390
28391 SWIGINTERN PyObject *PyApp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28392 PyObject *obj;
28393 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28394 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyApp, SWIG_NewClientData(obj));
28395 return SWIG_Py_Void();
28396 }
28397
28398 SWIGINTERN PyObject *PyApp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28399 return SWIG_Python_InitShadowInstance(args);
28400 }
28401
28402 SWIGINTERN PyObject *_wrap_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28403 PyObject *resultobj = 0;
28404
28405 if (!SWIG_Python_UnpackTuple(args,"Exit",0,0,0)) SWIG_fail;
28406 {
28407 PyThreadState* __tstate = wxPyBeginAllowThreads();
28408 wxExit();
28409 wxPyEndAllowThreads(__tstate);
28410 if (PyErr_Occurred()) SWIG_fail;
28411 }
28412 resultobj = SWIG_Py_Void();
28413 return resultobj;
28414 fail:
28415 return NULL;
28416 }
28417
28418
28419 SWIGINTERN PyObject *_wrap_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28420 PyObject *resultobj = 0;
28421 bool result;
28422
28423 if (!SWIG_Python_UnpackTuple(args,"Yield",0,0,0)) SWIG_fail;
28424 {
28425 PyThreadState* __tstate = wxPyBeginAllowThreads();
28426 result = (bool)wxYield();
28427 wxPyEndAllowThreads(__tstate);
28428 if (PyErr_Occurred()) SWIG_fail;
28429 }
28430 {
28431 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28432 }
28433 return resultobj;
28434 fail:
28435 return NULL;
28436 }
28437
28438
28439 SWIGINTERN PyObject *_wrap_YieldIfNeeded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28440 PyObject *resultobj = 0;
28441 bool result;
28442
28443 if (!SWIG_Python_UnpackTuple(args,"YieldIfNeeded",0,0,0)) SWIG_fail;
28444 {
28445 PyThreadState* __tstate = wxPyBeginAllowThreads();
28446 result = (bool)wxYieldIfNeeded();
28447 wxPyEndAllowThreads(__tstate);
28448 if (PyErr_Occurred()) SWIG_fail;
28449 }
28450 {
28451 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28452 }
28453 return resultobj;
28454 fail:
28455 return NULL;
28456 }
28457
28458
28459 SWIGINTERN PyObject *_wrap_SafeYield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28460 PyObject *resultobj = 0;
28461 wxWindow *arg1 = (wxWindow *) NULL ;
28462 bool arg2 = (bool) false ;
28463 bool result;
28464 void *argp1 = 0 ;
28465 int res1 = 0 ;
28466 bool val2 ;
28467 int ecode2 = 0 ;
28468 PyObject * obj0 = 0 ;
28469 PyObject * obj1 = 0 ;
28470 char * kwnames[] = {
28471 (char *) "win",(char *) "onlyIfNeeded", NULL
28472 };
28473
28474 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) SWIG_fail;
28475 if (obj0) {
28476 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
28477 if (!SWIG_IsOK(res1)) {
28478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SafeYield" "', expected argument " "1"" of type '" "wxWindow *""'");
28479 }
28480 arg1 = reinterpret_cast< wxWindow * >(argp1);
28481 }
28482 if (obj1) {
28483 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28484 if (!SWIG_IsOK(ecode2)) {
28485 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SafeYield" "', expected argument " "2"" of type '" "bool""'");
28486 }
28487 arg2 = static_cast< bool >(val2);
28488 }
28489 {
28490 PyThreadState* __tstate = wxPyBeginAllowThreads();
28491 result = (bool)wxSafeYield(arg1,arg2);
28492 wxPyEndAllowThreads(__tstate);
28493 if (PyErr_Occurred()) SWIG_fail;
28494 }
28495 {
28496 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28497 }
28498 return resultobj;
28499 fail:
28500 return NULL;
28501 }
28502
28503
28504 SWIGINTERN PyObject *_wrap_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28505 PyObject *resultobj = 0;
28506
28507 if (!SWIG_Python_UnpackTuple(args,"WakeUpIdle",0,0,0)) SWIG_fail;
28508 {
28509 PyThreadState* __tstate = wxPyBeginAllowThreads();
28510 wxWakeUpIdle();
28511 wxPyEndAllowThreads(__tstate);
28512 if (PyErr_Occurred()) SWIG_fail;
28513 }
28514 resultobj = SWIG_Py_Void();
28515 return resultobj;
28516 fail:
28517 return NULL;
28518 }
28519
28520
28521 SWIGINTERN PyObject *_wrap_PostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28522 PyObject *resultobj = 0;
28523 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
28524 wxEvent *arg2 = 0 ;
28525 void *argp1 = 0 ;
28526 int res1 = 0 ;
28527 void *argp2 = 0 ;
28528 int res2 = 0 ;
28529 PyObject * obj0 = 0 ;
28530 PyObject * obj1 = 0 ;
28531 char * kwnames[] = {
28532 (char *) "dest",(char *) "event", NULL
28533 };
28534
28535 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) SWIG_fail;
28536 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
28537 if (!SWIG_IsOK(res1)) {
28538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
28539 }
28540 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
28541 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
28542 if (!SWIG_IsOK(res2)) {
28543 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28544 }
28545 if (!argp2) {
28546 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28547 }
28548 arg2 = reinterpret_cast< wxEvent * >(argp2);
28549 {
28550 PyThreadState* __tstate = wxPyBeginAllowThreads();
28551 wxPostEvent(arg1,*arg2);
28552 wxPyEndAllowThreads(__tstate);
28553 if (PyErr_Occurred()) SWIG_fail;
28554 }
28555 resultobj = SWIG_Py_Void();
28556 return resultobj;
28557 fail:
28558 return NULL;
28559 }
28560
28561
28562 SWIGINTERN PyObject *_wrap_App_CleanUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28563 PyObject *resultobj = 0;
28564
28565 if (!SWIG_Python_UnpackTuple(args,"App_CleanUp",0,0,0)) SWIG_fail;
28566 {
28567 PyThreadState* __tstate = wxPyBeginAllowThreads();
28568 wxApp_CleanUp();
28569 wxPyEndAllowThreads(__tstate);
28570 if (PyErr_Occurred()) SWIG_fail;
28571 }
28572 resultobj = SWIG_Py_Void();
28573 return resultobj;
28574 fail:
28575 return NULL;
28576 }
28577
28578
28579 SWIGINTERN PyObject *_wrap_GetApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28580 PyObject *resultobj = 0;
28581 wxPyApp *result = 0 ;
28582
28583 if (!SWIG_Python_UnpackTuple(args,"GetApp",0,0,0)) SWIG_fail;
28584 {
28585 PyThreadState* __tstate = wxPyBeginAllowThreads();
28586 result = (wxPyApp *)wxPyGetApp();
28587 wxPyEndAllowThreads(__tstate);
28588 if (PyErr_Occurred()) SWIG_fail;
28589 }
28590 {
28591 resultobj = wxPyMake_wxObject(result, 0);
28592 }
28593 return resultobj;
28594 fail:
28595 return NULL;
28596 }
28597
28598
28599 SWIGINTERN PyObject *_wrap_SetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28600 PyObject *resultobj = 0;
28601 char *arg1 = (char *) 0 ;
28602 int res1 ;
28603 char *buf1 = 0 ;
28604 int alloc1 = 0 ;
28605 PyObject * obj0 = 0 ;
28606 char * kwnames[] = {
28607 (char *) "encoding", NULL
28608 };
28609
28610 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) SWIG_fail;
28611 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
28612 if (!SWIG_IsOK(res1)) {
28613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetDefaultPyEncoding" "', expected argument " "1"" of type '" "char const *""'");
28614 }
28615 arg1 = buf1;
28616 {
28617 PyThreadState* __tstate = wxPyBeginAllowThreads();
28618 wxSetDefaultPyEncoding((char const *)arg1);
28619 wxPyEndAllowThreads(__tstate);
28620 if (PyErr_Occurred()) SWIG_fail;
28621 }
28622 resultobj = SWIG_Py_Void();
28623 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28624 return resultobj;
28625 fail:
28626 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28627 return NULL;
28628 }
28629
28630
28631 SWIGINTERN PyObject *_wrap_GetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28632 PyObject *resultobj = 0;
28633 char *result = 0 ;
28634
28635 if (!SWIG_Python_UnpackTuple(args,"GetDefaultPyEncoding",0,0,0)) SWIG_fail;
28636 {
28637 PyThreadState* __tstate = wxPyBeginAllowThreads();
28638 result = (char *)wxGetDefaultPyEncoding();
28639 wxPyEndAllowThreads(__tstate);
28640 if (PyErr_Occurred()) SWIG_fail;
28641 }
28642 resultobj = SWIG_FromCharPtr(result);
28643 return resultobj;
28644 fail:
28645 return NULL;
28646 }
28647
28648
28649 SWIGINTERN PyObject *_wrap_new_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28650 PyObject *resultobj = 0;
28651 wxEventLoop *result = 0 ;
28652
28653 if (!SWIG_Python_UnpackTuple(args,"new_EventLoop",0,0,0)) SWIG_fail;
28654 {
28655 PyThreadState* __tstate = wxPyBeginAllowThreads();
28656 result = (wxEventLoop *)new wxEventLoop();
28657 wxPyEndAllowThreads(__tstate);
28658 if (PyErr_Occurred()) SWIG_fail;
28659 }
28660 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, SWIG_POINTER_NEW | 0 );
28661 return resultobj;
28662 fail:
28663 return NULL;
28664 }
28665
28666
28667 SWIGINTERN PyObject *_wrap_delete_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28668 PyObject *resultobj = 0;
28669 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28670 void *argp1 = 0 ;
28671 int res1 = 0 ;
28672 PyObject *swig_obj[1] ;
28673
28674 if (!args) SWIG_fail;
28675 swig_obj[0] = args;
28676 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, SWIG_POINTER_DISOWN | 0 );
28677 if (!SWIG_IsOK(res1)) {
28678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoop" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28679 }
28680 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28681 {
28682 PyThreadState* __tstate = wxPyBeginAllowThreads();
28683 delete arg1;
28684
28685 wxPyEndAllowThreads(__tstate);
28686 if (PyErr_Occurred()) SWIG_fail;
28687 }
28688 resultobj = SWIG_Py_Void();
28689 return resultobj;
28690 fail:
28691 return NULL;
28692 }
28693
28694
28695 SWIGINTERN PyObject *_wrap_EventLoop_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28696 PyObject *resultobj = 0;
28697 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28698 int result;
28699 void *argp1 = 0 ;
28700 int res1 = 0 ;
28701 PyObject *swig_obj[1] ;
28702
28703 if (!args) SWIG_fail;
28704 swig_obj[0] = args;
28705 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28706 if (!SWIG_IsOK(res1)) {
28707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Run" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28708 }
28709 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28710 {
28711 PyThreadState* __tstate = wxPyBeginAllowThreads();
28712 result = (int)(arg1)->Run();
28713 wxPyEndAllowThreads(__tstate);
28714 if (PyErr_Occurred()) SWIG_fail;
28715 }
28716 resultobj = SWIG_From_int(static_cast< int >(result));
28717 return resultobj;
28718 fail:
28719 return NULL;
28720 }
28721
28722
28723 SWIGINTERN PyObject *_wrap_EventLoop_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28724 PyObject *resultobj = 0;
28725 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28726 int arg2 = (int) 0 ;
28727 void *argp1 = 0 ;
28728 int res1 = 0 ;
28729 int val2 ;
28730 int ecode2 = 0 ;
28731 PyObject * obj0 = 0 ;
28732 PyObject * obj1 = 0 ;
28733 char * kwnames[] = {
28734 (char *) "self",(char *) "rc", NULL
28735 };
28736
28737 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) SWIG_fail;
28738 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28739 if (!SWIG_IsOK(res1)) {
28740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Exit" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28741 }
28742 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28743 if (obj1) {
28744 ecode2 = SWIG_AsVal_int(obj1, &val2);
28745 if (!SWIG_IsOK(ecode2)) {
28746 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventLoop_Exit" "', expected argument " "2"" of type '" "int""'");
28747 }
28748 arg2 = static_cast< int >(val2);
28749 }
28750 {
28751 PyThreadState* __tstate = wxPyBeginAllowThreads();
28752 (arg1)->Exit(arg2);
28753 wxPyEndAllowThreads(__tstate);
28754 if (PyErr_Occurred()) SWIG_fail;
28755 }
28756 resultobj = SWIG_Py_Void();
28757 return resultobj;
28758 fail:
28759 return NULL;
28760 }
28761
28762
28763 SWIGINTERN PyObject *_wrap_EventLoop_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28764 PyObject *resultobj = 0;
28765 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28766 bool result;
28767 void *argp1 = 0 ;
28768 int res1 = 0 ;
28769 PyObject *swig_obj[1] ;
28770
28771 if (!args) SWIG_fail;
28772 swig_obj[0] = args;
28773 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28774 if (!SWIG_IsOK(res1)) {
28775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Pending" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
28776 }
28777 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28778 {
28779 PyThreadState* __tstate = wxPyBeginAllowThreads();
28780 result = (bool)((wxEventLoop const *)arg1)->Pending();
28781 wxPyEndAllowThreads(__tstate);
28782 if (PyErr_Occurred()) SWIG_fail;
28783 }
28784 {
28785 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28786 }
28787 return resultobj;
28788 fail:
28789 return NULL;
28790 }
28791
28792
28793 SWIGINTERN PyObject *_wrap_EventLoop_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28794 PyObject *resultobj = 0;
28795 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28796 bool result;
28797 void *argp1 = 0 ;
28798 int res1 = 0 ;
28799 PyObject *swig_obj[1] ;
28800
28801 if (!args) SWIG_fail;
28802 swig_obj[0] = args;
28803 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28804 if (!SWIG_IsOK(res1)) {
28805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Dispatch" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28806 }
28807 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28808 {
28809 PyThreadState* __tstate = wxPyBeginAllowThreads();
28810 result = (bool)(arg1)->Dispatch();
28811 wxPyEndAllowThreads(__tstate);
28812 if (PyErr_Occurred()) SWIG_fail;
28813 }
28814 {
28815 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28816 }
28817 return resultobj;
28818 fail:
28819 return NULL;
28820 }
28821
28822
28823 SWIGINTERN PyObject *_wrap_EventLoop_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28824 PyObject *resultobj = 0;
28825 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28826 bool result;
28827 void *argp1 = 0 ;
28828 int res1 = 0 ;
28829 PyObject *swig_obj[1] ;
28830
28831 if (!args) SWIG_fail;
28832 swig_obj[0] = args;
28833 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28834 if (!SWIG_IsOK(res1)) {
28835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_IsRunning" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
28836 }
28837 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28838 {
28839 PyThreadState* __tstate = wxPyBeginAllowThreads();
28840 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
28841 wxPyEndAllowThreads(__tstate);
28842 if (PyErr_Occurred()) SWIG_fail;
28843 }
28844 {
28845 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28846 }
28847 return resultobj;
28848 fail:
28849 return NULL;
28850 }
28851
28852
28853 SWIGINTERN PyObject *_wrap_EventLoop_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28854 PyObject *resultobj = 0;
28855 wxEventLoop *result = 0 ;
28856
28857 if (!SWIG_Python_UnpackTuple(args,"EventLoop_GetActive",0,0,0)) SWIG_fail;
28858 {
28859 PyThreadState* __tstate = wxPyBeginAllowThreads();
28860 result = (wxEventLoop *)wxEventLoop::GetActive();
28861 wxPyEndAllowThreads(__tstate);
28862 if (PyErr_Occurred()) SWIG_fail;
28863 }
28864 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, 0 | 0 );
28865 return resultobj;
28866 fail:
28867 return NULL;
28868 }
28869
28870
28871 SWIGINTERN PyObject *_wrap_EventLoop_SetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28872 PyObject *resultobj = 0;
28873 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28874 void *argp1 = 0 ;
28875 int res1 = 0 ;
28876 PyObject * obj0 = 0 ;
28877 char * kwnames[] = {
28878 (char *) "loop", NULL
28879 };
28880
28881 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) SWIG_fail;
28882 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28883 if (!SWIG_IsOK(res1)) {
28884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_SetActive" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28885 }
28886 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28887 {
28888 PyThreadState* __tstate = wxPyBeginAllowThreads();
28889 wxEventLoop::SetActive(arg1);
28890 wxPyEndAllowThreads(__tstate);
28891 if (PyErr_Occurred()) SWIG_fail;
28892 }
28893 resultobj = SWIG_Py_Void();
28894 return resultobj;
28895 fail:
28896 return NULL;
28897 }
28898
28899
28900 SWIGINTERN PyObject *EventLoop_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28901 PyObject *obj;
28902 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28903 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoop, SWIG_NewClientData(obj));
28904 return SWIG_Py_Void();
28905 }
28906
28907 SWIGINTERN PyObject *EventLoop_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28908 return SWIG_Python_InitShadowInstance(args);
28909 }
28910
28911 SWIGINTERN PyObject *_wrap_new_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28912 PyObject *resultobj = 0;
28913 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28914 wxEventLoopActivator *result = 0 ;
28915 void *argp1 = 0 ;
28916 int res1 = 0 ;
28917 PyObject * obj0 = 0 ;
28918 char * kwnames[] = {
28919 (char *) "evtLoop", NULL
28920 };
28921
28922 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_EventLoopActivator",kwnames,&obj0)) SWIG_fail;
28923 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28924 if (!SWIG_IsOK(res1)) {
28925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28926 }
28927 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28928 {
28929 PyThreadState* __tstate = wxPyBeginAllowThreads();
28930 result = (wxEventLoopActivator *)new wxEventLoopActivator(arg1);
28931 wxPyEndAllowThreads(__tstate);
28932 if (PyErr_Occurred()) SWIG_fail;
28933 }
28934 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_NEW | 0 );
28935 return resultobj;
28936 fail:
28937 return NULL;
28938 }
28939
28940
28941 SWIGINTERN PyObject *_wrap_delete_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28942 PyObject *resultobj = 0;
28943 wxEventLoopActivator *arg1 = (wxEventLoopActivator *) 0 ;
28944 void *argp1 = 0 ;
28945 int res1 = 0 ;
28946 PyObject *swig_obj[1] ;
28947
28948 if (!args) SWIG_fail;
28949 swig_obj[0] = args;
28950 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_DISOWN | 0 );
28951 if (!SWIG_IsOK(res1)) {
28952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoopActivator *""'");
28953 }
28954 arg1 = reinterpret_cast< wxEventLoopActivator * >(argp1);
28955 {
28956 PyThreadState* __tstate = wxPyBeginAllowThreads();
28957 delete arg1;
28958
28959 wxPyEndAllowThreads(__tstate);
28960 if (PyErr_Occurred()) SWIG_fail;
28961 }
28962 resultobj = SWIG_Py_Void();
28963 return resultobj;
28964 fail:
28965 return NULL;
28966 }
28967
28968
28969 SWIGINTERN PyObject *EventLoopActivator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28970 PyObject *obj;
28971 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28972 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoopActivator, SWIG_NewClientData(obj));
28973 return SWIG_Py_Void();
28974 }
28975
28976 SWIGINTERN PyObject *EventLoopActivator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28977 return SWIG_Python_InitShadowInstance(args);
28978 }
28979
28980 SWIGINTERN PyObject *_wrap_new_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28981 PyObject *resultobj = 0;
28982 int arg1 = (int) 0 ;
28983 int arg2 = (int) 0 ;
28984 int arg3 = (int) 0 ;
28985 wxAcceleratorEntry *result = 0 ;
28986 int val1 ;
28987 int ecode1 = 0 ;
28988 int val2 ;
28989 int ecode2 = 0 ;
28990 int val3 ;
28991 int ecode3 = 0 ;
28992 PyObject * obj0 = 0 ;
28993 PyObject * obj1 = 0 ;
28994 PyObject * obj2 = 0 ;
28995 char * kwnames[] = {
28996 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
28997 };
28998
28999 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
29000 if (obj0) {
29001 ecode1 = SWIG_AsVal_int(obj0, &val1);
29002 if (!SWIG_IsOK(ecode1)) {
29003 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AcceleratorEntry" "', expected argument " "1"" of type '" "int""'");
29004 }
29005 arg1 = static_cast< int >(val1);
29006 }
29007 if (obj1) {
29008 ecode2 = SWIG_AsVal_int(obj1, &val2);
29009 if (!SWIG_IsOK(ecode2)) {
29010 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AcceleratorEntry" "', expected argument " "2"" of type '" "int""'");
29011 }
29012 arg2 = static_cast< int >(val2);
29013 }
29014 if (obj2) {
29015 ecode3 = SWIG_AsVal_int(obj2, &val3);
29016 if (!SWIG_IsOK(ecode3)) {
29017 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AcceleratorEntry" "', expected argument " "3"" of type '" "int""'");
29018 }
29019 arg3 = static_cast< int >(val3);
29020 }
29021 {
29022 PyThreadState* __tstate = wxPyBeginAllowThreads();
29023 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
29024 wxPyEndAllowThreads(__tstate);
29025 if (PyErr_Occurred()) SWIG_fail;
29026 }
29027 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_NEW | 0 );
29028 return resultobj;
29029 fail:
29030 return NULL;
29031 }
29032
29033
29034 SWIGINTERN PyObject *_wrap_delete_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29035 PyObject *resultobj = 0;
29036 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29037 void *argp1 = 0 ;
29038 int res1 = 0 ;
29039 PyObject *swig_obj[1] ;
29040
29041 if (!args) SWIG_fail;
29042 swig_obj[0] = args;
29043 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_DISOWN | 0 );
29044 if (!SWIG_IsOK(res1)) {
29045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorEntry" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29046 }
29047 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29048 {
29049 PyThreadState* __tstate = wxPyBeginAllowThreads();
29050 delete arg1;
29051
29052 wxPyEndAllowThreads(__tstate);
29053 if (PyErr_Occurred()) SWIG_fail;
29054 }
29055 resultobj = SWIG_Py_Void();
29056 return resultobj;
29057 fail:
29058 return NULL;
29059 }
29060
29061
29062 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29063 PyObject *resultobj = 0;
29064 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29065 int arg2 ;
29066 int arg3 ;
29067 int arg4 ;
29068 void *argp1 = 0 ;
29069 int res1 = 0 ;
29070 int val2 ;
29071 int ecode2 = 0 ;
29072 int val3 ;
29073 int ecode3 = 0 ;
29074 int val4 ;
29075 int ecode4 = 0 ;
29076 PyObject * obj0 = 0 ;
29077 PyObject * obj1 = 0 ;
29078 PyObject * obj2 = 0 ;
29079 PyObject * obj3 = 0 ;
29080 char * kwnames[] = {
29081 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
29082 };
29083
29084 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
29085 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29086 if (!SWIG_IsOK(res1)) {
29087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_Set" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29088 }
29089 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29090 ecode2 = SWIG_AsVal_int(obj1, &val2);
29091 if (!SWIG_IsOK(ecode2)) {
29092 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AcceleratorEntry_Set" "', expected argument " "2"" of type '" "int""'");
29093 }
29094 arg2 = static_cast< int >(val2);
29095 ecode3 = SWIG_AsVal_int(obj2, &val3);
29096 if (!SWIG_IsOK(ecode3)) {
29097 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AcceleratorEntry_Set" "', expected argument " "3"" of type '" "int""'");
29098 }
29099 arg3 = static_cast< int >(val3);
29100 ecode4 = SWIG_AsVal_int(obj3, &val4);
29101 if (!SWIG_IsOK(ecode4)) {
29102 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AcceleratorEntry_Set" "', expected argument " "4"" of type '" "int""'");
29103 }
29104 arg4 = static_cast< int >(val4);
29105 {
29106 PyThreadState* __tstate = wxPyBeginAllowThreads();
29107 (arg1)->Set(arg2,arg3,arg4);
29108 wxPyEndAllowThreads(__tstate);
29109 if (PyErr_Occurred()) SWIG_fail;
29110 }
29111 resultobj = SWIG_Py_Void();
29112 return resultobj;
29113 fail:
29114 return NULL;
29115 }
29116
29117
29118 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29119 PyObject *resultobj = 0;
29120 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29121 int result;
29122 void *argp1 = 0 ;
29123 int res1 = 0 ;
29124 PyObject *swig_obj[1] ;
29125
29126 if (!args) SWIG_fail;
29127 swig_obj[0] = args;
29128 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29129 if (!SWIG_IsOK(res1)) {
29130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetFlags" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29131 }
29132 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29133 {
29134 PyThreadState* __tstate = wxPyBeginAllowThreads();
29135 result = (int)(arg1)->GetFlags();
29136 wxPyEndAllowThreads(__tstate);
29137 if (PyErr_Occurred()) SWIG_fail;
29138 }
29139 resultobj = SWIG_From_int(static_cast< int >(result));
29140 return resultobj;
29141 fail:
29142 return NULL;
29143 }
29144
29145
29146 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29147 PyObject *resultobj = 0;
29148 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29149 int result;
29150 void *argp1 = 0 ;
29151 int res1 = 0 ;
29152 PyObject *swig_obj[1] ;
29153
29154 if (!args) SWIG_fail;
29155 swig_obj[0] = args;
29156 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29157 if (!SWIG_IsOK(res1)) {
29158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetKeyCode" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29159 }
29160 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29161 {
29162 PyThreadState* __tstate = wxPyBeginAllowThreads();
29163 result = (int)(arg1)->GetKeyCode();
29164 wxPyEndAllowThreads(__tstate);
29165 if (PyErr_Occurred()) SWIG_fail;
29166 }
29167 resultobj = SWIG_From_int(static_cast< int >(result));
29168 return resultobj;
29169 fail:
29170 return NULL;
29171 }
29172
29173
29174 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29175 PyObject *resultobj = 0;
29176 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29177 int result;
29178 void *argp1 = 0 ;
29179 int res1 = 0 ;
29180 PyObject *swig_obj[1] ;
29181
29182 if (!args) SWIG_fail;
29183 swig_obj[0] = args;
29184 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29185 if (!SWIG_IsOK(res1)) {
29186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetCommand" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29187 }
29188 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29189 {
29190 PyThreadState* __tstate = wxPyBeginAllowThreads();
29191 result = (int)(arg1)->GetCommand();
29192 wxPyEndAllowThreads(__tstate);
29193 if (PyErr_Occurred()) SWIG_fail;
29194 }
29195 resultobj = SWIG_From_int(static_cast< int >(result));
29196 return resultobj;
29197 fail:
29198 return NULL;
29199 }
29200
29201
29202 SWIGINTERN PyObject *AcceleratorEntry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29203 PyObject *obj;
29204 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29205 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorEntry, SWIG_NewClientData(obj));
29206 return SWIG_Py_Void();
29207 }
29208
29209 SWIGINTERN PyObject *AcceleratorEntry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29210 return SWIG_Python_InitShadowInstance(args);
29211 }
29212
29213 SWIGINTERN PyObject *_wrap_new_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29214 PyObject *resultobj = 0;
29215 int arg1 ;
29216 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
29217 wxAcceleratorTable *result = 0 ;
29218 PyObject * obj0 = 0 ;
29219 char * kwnames[] = {
29220 (char *) "n", NULL
29221 };
29222
29223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) SWIG_fail;
29224 {
29225 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
29226 if (arg2) arg1 = PyList_Size(obj0);
29227 else arg1 = 0;
29228 }
29229 {
29230 PyThreadState* __tstate = wxPyBeginAllowThreads();
29231 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
29232 wxPyEndAllowThreads(__tstate);
29233 if (PyErr_Occurred()) SWIG_fail;
29234 }
29235 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_NEW | 0 );
29236 return resultobj;
29237 fail:
29238 return NULL;
29239 }
29240
29241
29242 SWIGINTERN PyObject *_wrap_delete_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29243 PyObject *resultobj = 0;
29244 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
29245 void *argp1 = 0 ;
29246 int res1 = 0 ;
29247 PyObject *swig_obj[1] ;
29248
29249 if (!args) SWIG_fail;
29250 swig_obj[0] = args;
29251 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_DISOWN | 0 );
29252 if (!SWIG_IsOK(res1)) {
29253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorTable" "', expected argument " "1"" of type '" "wxAcceleratorTable *""'");
29254 }
29255 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
29256 {
29257 PyThreadState* __tstate = wxPyBeginAllowThreads();
29258 delete arg1;
29259
29260 wxPyEndAllowThreads(__tstate);
29261 if (PyErr_Occurred()) SWIG_fail;
29262 }
29263 resultobj = SWIG_Py_Void();
29264 return resultobj;
29265 fail:
29266 return NULL;
29267 }
29268
29269
29270 SWIGINTERN PyObject *_wrap_AcceleratorTable_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29271 PyObject *resultobj = 0;
29272 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
29273 bool result;
29274 void *argp1 = 0 ;
29275 int res1 = 0 ;
29276 PyObject *swig_obj[1] ;
29277
29278 if (!args) SWIG_fail;
29279 swig_obj[0] = args;
29280 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
29281 if (!SWIG_IsOK(res1)) {
29282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorTable_Ok" "', expected argument " "1"" of type '" "wxAcceleratorTable const *""'");
29283 }
29284 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
29285 {
29286 PyThreadState* __tstate = wxPyBeginAllowThreads();
29287 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
29288 wxPyEndAllowThreads(__tstate);
29289 if (PyErr_Occurred()) SWIG_fail;
29290 }
29291 {
29292 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29293 }
29294 return resultobj;
29295 fail:
29296 return NULL;
29297 }
29298
29299
29300 SWIGINTERN PyObject *AcceleratorTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29301 PyObject *obj;
29302 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29303 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorTable, SWIG_NewClientData(obj));
29304 return SWIG_Py_Void();
29305 }
29306
29307 SWIGINTERN PyObject *AcceleratorTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29308 return SWIG_Python_InitShadowInstance(args);
29309 }
29310
29311 SWIGINTERN int NullAcceleratorTable_set(PyObject *) {
29312 SWIG_Error(SWIG_AttributeError,"Variable NullAcceleratorTable is read-only.");
29313 return 1;
29314 }
29315
29316
29317 SWIGINTERN PyObject *NullAcceleratorTable_get(void) {
29318 PyObject *pyobj = 0;
29319
29320 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0 );
29321 return pyobj;
29322 }
29323
29324
29325 SWIGINTERN PyObject *_wrap_GetAccelFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29326 PyObject *resultobj = 0;
29327 wxString *arg1 = 0 ;
29328 wxAcceleratorEntry *result = 0 ;
29329 bool temp1 = false ;
29330 PyObject * obj0 = 0 ;
29331 char * kwnames[] = {
29332 (char *) "label", NULL
29333 };
29334
29335 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) SWIG_fail;
29336 {
29337 arg1 = wxString_in_helper(obj0);
29338 if (arg1 == NULL) SWIG_fail;
29339 temp1 = true;
29340 }
29341 {
29342 PyThreadState* __tstate = wxPyBeginAllowThreads();
29343 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
29344 wxPyEndAllowThreads(__tstate);
29345 if (PyErr_Occurred()) SWIG_fail;
29346 }
29347 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29348 {
29349 if (temp1)
29350 delete arg1;
29351 }
29352 return resultobj;
29353 fail:
29354 {
29355 if (temp1)
29356 delete arg1;
29357 }
29358 return NULL;
29359 }
29360
29361
29362 SWIGINTERN int PanelNameStr_set(PyObject *) {
29363 SWIG_Error(SWIG_AttributeError,"Variable PanelNameStr is read-only.");
29364 return 1;
29365 }
29366
29367
29368 SWIGINTERN PyObject *PanelNameStr_get(void) {
29369 PyObject *pyobj = 0;
29370
29371 {
29372 #if wxUSE_UNICODE
29373 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29374 #else
29375 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29376 #endif
29377 }
29378 return pyobj;
29379 }
29380
29381
29382 SWIGINTERN PyObject *_wrap_new_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29383 PyObject *resultobj = 0;
29384 wxVisualAttributes *result = 0 ;
29385
29386 if (!SWIG_Python_UnpackTuple(args,"new_VisualAttributes",0,0,0)) SWIG_fail;
29387 {
29388 PyThreadState* __tstate = wxPyBeginAllowThreads();
29389 result = (wxVisualAttributes *)new_wxVisualAttributes();
29390 wxPyEndAllowThreads(__tstate);
29391 if (PyErr_Occurred()) SWIG_fail;
29392 }
29393 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_NEW | 0 );
29394 return resultobj;
29395 fail:
29396 return NULL;
29397 }
29398
29399
29400 SWIGINTERN PyObject *_wrap_delete_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29401 PyObject *resultobj = 0;
29402 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29403 void *argp1 = 0 ;
29404 int res1 = 0 ;
29405 PyObject *swig_obj[1] ;
29406
29407 if (!args) SWIG_fail;
29408 swig_obj[0] = args;
29409 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_DISOWN | 0 );
29410 if (!SWIG_IsOK(res1)) {
29411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VisualAttributes" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29412 }
29413 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29414 {
29415 PyThreadState* __tstate = wxPyBeginAllowThreads();
29416 delete_wxVisualAttributes(arg1);
29417
29418 wxPyEndAllowThreads(__tstate);
29419 if (PyErr_Occurred()) SWIG_fail;
29420 }
29421 resultobj = SWIG_Py_Void();
29422 return resultobj;
29423 fail:
29424 return NULL;
29425 }
29426
29427
29428 SWIGINTERN PyObject *_wrap_VisualAttributes_font_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29429 PyObject *resultobj = 0;
29430 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29431 wxFont *arg2 = (wxFont *) 0 ;
29432 void *argp1 = 0 ;
29433 int res1 = 0 ;
29434 void *argp2 = 0 ;
29435 int res2 = 0 ;
29436 PyObject *swig_obj[2] ;
29437
29438 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_font_set",2,2,swig_obj)) SWIG_fail;
29439 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29440 if (!SWIG_IsOK(res1)) {
29441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29442 }
29443 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29444 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
29445 if (!SWIG_IsOK(res2)) {
29446 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_font_set" "', expected argument " "2"" of type '" "wxFont *""'");
29447 }
29448 arg2 = reinterpret_cast< wxFont * >(argp2);
29449 if (arg1) (arg1)->font = *arg2;
29450
29451 resultobj = SWIG_Py_Void();
29452 return resultobj;
29453 fail:
29454 return NULL;
29455 }
29456
29457
29458 SWIGINTERN PyObject *_wrap_VisualAttributes_font_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29459 PyObject *resultobj = 0;
29460 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29461 wxFont *result = 0 ;
29462 void *argp1 = 0 ;
29463 int res1 = 0 ;
29464 PyObject *swig_obj[1] ;
29465
29466 if (!args) SWIG_fail;
29467 swig_obj[0] = args;
29468 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29469 if (!SWIG_IsOK(res1)) {
29470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29471 }
29472 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29473 result = (wxFont *)& ((arg1)->font);
29474 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, 0 | 0 );
29475 return resultobj;
29476 fail:
29477 return NULL;
29478 }
29479
29480
29481 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29482 PyObject *resultobj = 0;
29483 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29484 wxColour *arg2 = (wxColour *) 0 ;
29485 void *argp1 = 0 ;
29486 int res1 = 0 ;
29487 void *argp2 = 0 ;
29488 int res2 = 0 ;
29489 PyObject *swig_obj[2] ;
29490
29491 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colFg_set",2,2,swig_obj)) SWIG_fail;
29492 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29493 if (!SWIG_IsOK(res1)) {
29494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29495 }
29496 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29497 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29498 if (!SWIG_IsOK(res2)) {
29499 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colFg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29500 }
29501 arg2 = reinterpret_cast< wxColour * >(argp2);
29502 if (arg1) (arg1)->colFg = *arg2;
29503
29504 resultobj = SWIG_Py_Void();
29505 return resultobj;
29506 fail:
29507 return NULL;
29508 }
29509
29510
29511 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29512 PyObject *resultobj = 0;
29513 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29514 wxColour *result = 0 ;
29515 void *argp1 = 0 ;
29516 int res1 = 0 ;
29517 PyObject *swig_obj[1] ;
29518
29519 if (!args) SWIG_fail;
29520 swig_obj[0] = args;
29521 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29522 if (!SWIG_IsOK(res1)) {
29523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29524 }
29525 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29526 result = (wxColour *)& ((arg1)->colFg);
29527 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29528 return resultobj;
29529 fail:
29530 return NULL;
29531 }
29532
29533
29534 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29535 PyObject *resultobj = 0;
29536 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29537 wxColour *arg2 = (wxColour *) 0 ;
29538 void *argp1 = 0 ;
29539 int res1 = 0 ;
29540 void *argp2 = 0 ;
29541 int res2 = 0 ;
29542 PyObject *swig_obj[2] ;
29543
29544 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colBg_set",2,2,swig_obj)) SWIG_fail;
29545 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29546 if (!SWIG_IsOK(res1)) {
29547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29548 }
29549 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29550 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29551 if (!SWIG_IsOK(res2)) {
29552 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colBg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29553 }
29554 arg2 = reinterpret_cast< wxColour * >(argp2);
29555 if (arg1) (arg1)->colBg = *arg2;
29556
29557 resultobj = SWIG_Py_Void();
29558 return resultobj;
29559 fail:
29560 return NULL;
29561 }
29562
29563
29564 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29565 PyObject *resultobj = 0;
29566 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29567 wxColour *result = 0 ;
29568 void *argp1 = 0 ;
29569 int res1 = 0 ;
29570 PyObject *swig_obj[1] ;
29571
29572 if (!args) SWIG_fail;
29573 swig_obj[0] = args;
29574 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29575 if (!SWIG_IsOK(res1)) {
29576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29577 }
29578 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29579 result = (wxColour *)& ((arg1)->colBg);
29580 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29581 return resultobj;
29582 fail:
29583 return NULL;
29584 }
29585
29586
29587 SWIGINTERN PyObject *VisualAttributes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29588 PyObject *obj;
29589 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29590 SWIG_TypeNewClientData(SWIGTYPE_p_wxVisualAttributes, SWIG_NewClientData(obj));
29591 return SWIG_Py_Void();
29592 }
29593
29594 SWIGINTERN PyObject *VisualAttributes_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29595 return SWIG_Python_InitShadowInstance(args);
29596 }
29597
29598 SWIGINTERN PyObject *_wrap_new_Window(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29599 PyObject *resultobj = 0;
29600 wxWindow *arg1 = (wxWindow *) 0 ;
29601 int arg2 = (int) (int)-1 ;
29602 wxPoint const &arg3_defvalue = wxDefaultPosition ;
29603 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
29604 wxSize const &arg4_defvalue = wxDefaultSize ;
29605 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
29606 long arg5 = (long) 0 ;
29607 wxString const &arg6_defvalue = wxPyPanelNameStr ;
29608 wxString *arg6 = (wxString *) &arg6_defvalue ;
29609 wxWindow *result = 0 ;
29610 void *argp1 = 0 ;
29611 int res1 = 0 ;
29612 int val2 ;
29613 int ecode2 = 0 ;
29614 wxPoint temp3 ;
29615 wxSize temp4 ;
29616 long val5 ;
29617 int ecode5 = 0 ;
29618 bool temp6 = false ;
29619 PyObject * obj0 = 0 ;
29620 PyObject * obj1 = 0 ;
29621 PyObject * obj2 = 0 ;
29622 PyObject * obj3 = 0 ;
29623 PyObject * obj4 = 0 ;
29624 PyObject * obj5 = 0 ;
29625 char * kwnames[] = {
29626 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
29627 };
29628
29629 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
29630 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29631 if (!SWIG_IsOK(res1)) {
29632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Window" "', expected argument " "1"" of type '" "wxWindow *""'");
29633 }
29634 arg1 = reinterpret_cast< wxWindow * >(argp1);
29635 if (obj1) {
29636 ecode2 = SWIG_AsVal_int(obj1, &val2);
29637 if (!SWIG_IsOK(ecode2)) {
29638 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Window" "', expected argument " "2"" of type '" "int""'");
29639 }
29640 arg2 = static_cast< int >(val2);
29641 }
29642 if (obj2) {
29643 {
29644 arg3 = &temp3;
29645 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
29646 }
29647 }
29648 if (obj3) {
29649 {
29650 arg4 = &temp4;
29651 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
29652 }
29653 }
29654 if (obj4) {
29655 ecode5 = SWIG_AsVal_long(obj4, &val5);
29656 if (!SWIG_IsOK(ecode5)) {
29657 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Window" "', expected argument " "5"" of type '" "long""'");
29658 }
29659 arg5 = static_cast< long >(val5);
29660 }
29661 if (obj5) {
29662 {
29663 arg6 = wxString_in_helper(obj5);
29664 if (arg6 == NULL) SWIG_fail;
29665 temp6 = true;
29666 }
29667 }
29668 {
29669 if (!wxPyCheckForApp()) SWIG_fail;
29670 PyThreadState* __tstate = wxPyBeginAllowThreads();
29671 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
29672 wxPyEndAllowThreads(__tstate);
29673 if (PyErr_Occurred()) SWIG_fail;
29674 }
29675 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_NEW | 0 );
29676 {
29677 if (temp6)
29678 delete arg6;
29679 }
29680 return resultobj;
29681 fail:
29682 {
29683 if (temp6)
29684 delete arg6;
29685 }
29686 return NULL;
29687 }
29688
29689
29690 SWIGINTERN PyObject *_wrap_new_PreWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29691 PyObject *resultobj = 0;
29692 wxWindow *result = 0 ;
29693
29694 if (!SWIG_Python_UnpackTuple(args,"new_PreWindow",0,0,0)) SWIG_fail;
29695 {
29696 if (!wxPyCheckForApp()) SWIG_fail;
29697 PyThreadState* __tstate = wxPyBeginAllowThreads();
29698 result = (wxWindow *)new wxWindow();
29699 wxPyEndAllowThreads(__tstate);
29700 if (PyErr_Occurred()) SWIG_fail;
29701 }
29702 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_OWN | 0 );
29703 return resultobj;
29704 fail:
29705 return NULL;
29706 }
29707
29708
29709 SWIGINTERN PyObject *_wrap_Window_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29710 PyObject *resultobj = 0;
29711 wxWindow *arg1 = (wxWindow *) 0 ;
29712 wxWindow *arg2 = (wxWindow *) 0 ;
29713 int arg3 = (int) (int)-1 ;
29714 wxPoint const &arg4_defvalue = wxDefaultPosition ;
29715 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
29716 wxSize const &arg5_defvalue = wxDefaultSize ;
29717 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
29718 long arg6 = (long) 0 ;
29719 wxString const &arg7_defvalue = wxPyPanelNameStr ;
29720 wxString *arg7 = (wxString *) &arg7_defvalue ;
29721 bool result;
29722 void *argp1 = 0 ;
29723 int res1 = 0 ;
29724 void *argp2 = 0 ;
29725 int res2 = 0 ;
29726 int val3 ;
29727 int ecode3 = 0 ;
29728 wxPoint temp4 ;
29729 wxSize temp5 ;
29730 long val6 ;
29731 int ecode6 = 0 ;
29732 bool temp7 = false ;
29733 PyObject * obj0 = 0 ;
29734 PyObject * obj1 = 0 ;
29735 PyObject * obj2 = 0 ;
29736 PyObject * obj3 = 0 ;
29737 PyObject * obj4 = 0 ;
29738 PyObject * obj5 = 0 ;
29739 PyObject * obj6 = 0 ;
29740 char * kwnames[] = {
29741 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
29742 };
29743
29744 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
29745 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29746 if (!SWIG_IsOK(res1)) {
29747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Create" "', expected argument " "1"" of type '" "wxWindow *""'");
29748 }
29749 arg1 = reinterpret_cast< wxWindow * >(argp1);
29750 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
29751 if (!SWIG_IsOK(res2)) {
29752 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
29753 }
29754 arg2 = reinterpret_cast< wxWindow * >(argp2);
29755 if (obj2) {
29756 ecode3 = SWIG_AsVal_int(obj2, &val3);
29757 if (!SWIG_IsOK(ecode3)) {
29758 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Create" "', expected argument " "3"" of type '" "int""'");
29759 }
29760 arg3 = static_cast< int >(val3);
29761 }
29762 if (obj3) {
29763 {
29764 arg4 = &temp4;
29765 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
29766 }
29767 }
29768 if (obj4) {
29769 {
29770 arg5 = &temp5;
29771 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
29772 }
29773 }
29774 if (obj5) {
29775 ecode6 = SWIG_AsVal_long(obj5, &val6);
29776 if (!SWIG_IsOK(ecode6)) {
29777 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_Create" "', expected argument " "6"" of type '" "long""'");
29778 }
29779 arg6 = static_cast< long >(val6);
29780 }
29781 if (obj6) {
29782 {
29783 arg7 = wxString_in_helper(obj6);
29784 if (arg7 == NULL) SWIG_fail;
29785 temp7 = true;
29786 }
29787 }
29788 {
29789 PyThreadState* __tstate = wxPyBeginAllowThreads();
29790 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
29791 wxPyEndAllowThreads(__tstate);
29792 if (PyErr_Occurred()) SWIG_fail;
29793 }
29794 {
29795 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29796 }
29797 {
29798 if (temp7)
29799 delete arg7;
29800 }
29801 return resultobj;
29802 fail:
29803 {
29804 if (temp7)
29805 delete arg7;
29806 }
29807 return NULL;
29808 }
29809
29810
29811 SWIGINTERN PyObject *_wrap_Window_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29812 PyObject *resultobj = 0;
29813 wxWindow *arg1 = (wxWindow *) 0 ;
29814 bool arg2 = (bool) false ;
29815 bool result;
29816 void *argp1 = 0 ;
29817 int res1 = 0 ;
29818 bool val2 ;
29819 int ecode2 = 0 ;
29820 PyObject * obj0 = 0 ;
29821 PyObject * obj1 = 0 ;
29822 char * kwnames[] = {
29823 (char *) "self",(char *) "force", NULL
29824 };
29825
29826 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) SWIG_fail;
29827 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29828 if (!SWIG_IsOK(res1)) {
29829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Close" "', expected argument " "1"" of type '" "wxWindow *""'");
29830 }
29831 arg1 = reinterpret_cast< wxWindow * >(argp1);
29832 if (obj1) {
29833 ecode2 = SWIG_AsVal_bool(obj1, &val2);
29834 if (!SWIG_IsOK(ecode2)) {
29835 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Close" "', expected argument " "2"" of type '" "bool""'");
29836 }
29837 arg2 = static_cast< bool >(val2);
29838 }
29839 {
29840 PyThreadState* __tstate = wxPyBeginAllowThreads();
29841 result = (bool)(arg1)->Close(arg2);
29842 wxPyEndAllowThreads(__tstate);
29843 if (PyErr_Occurred()) SWIG_fail;
29844 }
29845 {
29846 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29847 }
29848 return resultobj;
29849 fail:
29850 return NULL;
29851 }
29852
29853
29854 SWIGINTERN PyObject *_wrap_Window_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29855 PyObject *resultobj = 0;
29856 wxWindow *arg1 = (wxWindow *) 0 ;
29857 bool result;
29858 void *argp1 = 0 ;
29859 int res1 = 0 ;
29860 PyObject *swig_obj[1] ;
29861
29862 if (!args) SWIG_fail;
29863 swig_obj[0] = args;
29864 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29865 if (!SWIG_IsOK(res1)) {
29866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Destroy" "', expected argument " "1"" of type '" "wxWindow *""'");
29867 }
29868 arg1 = reinterpret_cast< wxWindow * >(argp1);
29869 {
29870 PyThreadState* __tstate = wxPyBeginAllowThreads();
29871 result = (bool)(arg1)->Destroy();
29872 wxPyEndAllowThreads(__tstate);
29873 if (PyErr_Occurred()) SWIG_fail;
29874 }
29875 {
29876 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29877 }
29878 return resultobj;
29879 fail:
29880 return NULL;
29881 }
29882
29883
29884 SWIGINTERN PyObject *_wrap_Window_DestroyChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29885 PyObject *resultobj = 0;
29886 wxWindow *arg1 = (wxWindow *) 0 ;
29887 bool result;
29888 void *argp1 = 0 ;
29889 int res1 = 0 ;
29890 PyObject *swig_obj[1] ;
29891
29892 if (!args) SWIG_fail;
29893 swig_obj[0] = args;
29894 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29895 if (!SWIG_IsOK(res1)) {
29896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DestroyChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
29897 }
29898 arg1 = reinterpret_cast< wxWindow * >(argp1);
29899 {
29900 PyThreadState* __tstate = wxPyBeginAllowThreads();
29901 result = (bool)(arg1)->DestroyChildren();
29902 wxPyEndAllowThreads(__tstate);
29903 if (PyErr_Occurred()) SWIG_fail;
29904 }
29905 {
29906 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29907 }
29908 return resultobj;
29909 fail:
29910 return NULL;
29911 }
29912
29913
29914 SWIGINTERN PyObject *_wrap_Window_IsBeingDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29915 PyObject *resultobj = 0;
29916 wxWindow *arg1 = (wxWindow *) 0 ;
29917 bool result;
29918 void *argp1 = 0 ;
29919 int res1 = 0 ;
29920 PyObject *swig_obj[1] ;
29921
29922 if (!args) SWIG_fail;
29923 swig_obj[0] = args;
29924 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29925 if (!SWIG_IsOK(res1)) {
29926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsBeingDeleted" "', expected argument " "1"" of type '" "wxWindow const *""'");
29927 }
29928 arg1 = reinterpret_cast< wxWindow * >(argp1);
29929 {
29930 PyThreadState* __tstate = wxPyBeginAllowThreads();
29931 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
29932 wxPyEndAllowThreads(__tstate);
29933 if (PyErr_Occurred()) SWIG_fail;
29934 }
29935 {
29936 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29937 }
29938 return resultobj;
29939 fail:
29940 return NULL;
29941 }
29942
29943
29944 SWIGINTERN PyObject *_wrap_Window_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29945 PyObject *resultobj = 0;
29946 wxWindow *arg1 = (wxWindow *) 0 ;
29947 wxString *arg2 = 0 ;
29948 void *argp1 = 0 ;
29949 int res1 = 0 ;
29950 bool temp2 = false ;
29951 PyObject * obj0 = 0 ;
29952 PyObject * obj1 = 0 ;
29953 char * kwnames[] = {
29954 (char *) "self",(char *) "label", NULL
29955 };
29956
29957 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
29958 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29959 if (!SWIG_IsOK(res1)) {
29960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLabel" "', expected argument " "1"" of type '" "wxWindow *""'");
29961 }
29962 arg1 = reinterpret_cast< wxWindow * >(argp1);
29963 {
29964 arg2 = wxString_in_helper(obj1);
29965 if (arg2 == NULL) SWIG_fail;
29966 temp2 = true;
29967 }
29968 {
29969 PyThreadState* __tstate = wxPyBeginAllowThreads();
29970 (arg1)->SetLabel((wxString const &)*arg2);
29971 wxPyEndAllowThreads(__tstate);
29972 if (PyErr_Occurred()) SWIG_fail;
29973 }
29974 resultobj = SWIG_Py_Void();
29975 {
29976 if (temp2)
29977 delete arg2;
29978 }
29979 return resultobj;
29980 fail:
29981 {
29982 if (temp2)
29983 delete arg2;
29984 }
29985 return NULL;
29986 }
29987
29988
29989 SWIGINTERN PyObject *_wrap_Window_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29990 PyObject *resultobj = 0;
29991 wxWindow *arg1 = (wxWindow *) 0 ;
29992 wxString result;
29993 void *argp1 = 0 ;
29994 int res1 = 0 ;
29995 PyObject *swig_obj[1] ;
29996
29997 if (!args) SWIG_fail;
29998 swig_obj[0] = args;
29999 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30000 if (!SWIG_IsOK(res1)) {
30001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLabel" "', expected argument " "1"" of type '" "wxWindow const *""'");
30002 }
30003 arg1 = reinterpret_cast< wxWindow * >(argp1);
30004 {
30005 PyThreadState* __tstate = wxPyBeginAllowThreads();
30006 result = ((wxWindow const *)arg1)->GetLabel();
30007 wxPyEndAllowThreads(__tstate);
30008 if (PyErr_Occurred()) SWIG_fail;
30009 }
30010 {
30011 #if wxUSE_UNICODE
30012 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30013 #else
30014 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30015 #endif
30016 }
30017 return resultobj;
30018 fail:
30019 return NULL;
30020 }
30021
30022
30023 SWIGINTERN PyObject *_wrap_Window_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30024 PyObject *resultobj = 0;
30025 wxWindow *arg1 = (wxWindow *) 0 ;
30026 wxString *arg2 = 0 ;
30027 void *argp1 = 0 ;
30028 int res1 = 0 ;
30029 bool temp2 = false ;
30030 PyObject * obj0 = 0 ;
30031 PyObject * obj1 = 0 ;
30032 char * kwnames[] = {
30033 (char *) "self",(char *) "name", NULL
30034 };
30035
30036 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
30037 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30038 if (!SWIG_IsOK(res1)) {
30039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetName" "', expected argument " "1"" of type '" "wxWindow *""'");
30040 }
30041 arg1 = reinterpret_cast< wxWindow * >(argp1);
30042 {
30043 arg2 = wxString_in_helper(obj1);
30044 if (arg2 == NULL) SWIG_fail;
30045 temp2 = true;
30046 }
30047 {
30048 PyThreadState* __tstate = wxPyBeginAllowThreads();
30049 (arg1)->SetName((wxString const &)*arg2);
30050 wxPyEndAllowThreads(__tstate);
30051 if (PyErr_Occurred()) SWIG_fail;
30052 }
30053 resultobj = SWIG_Py_Void();
30054 {
30055 if (temp2)
30056 delete arg2;
30057 }
30058 return resultobj;
30059 fail:
30060 {
30061 if (temp2)
30062 delete arg2;
30063 }
30064 return NULL;
30065 }
30066
30067
30068 SWIGINTERN PyObject *_wrap_Window_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30069 PyObject *resultobj = 0;
30070 wxWindow *arg1 = (wxWindow *) 0 ;
30071 wxString result;
30072 void *argp1 = 0 ;
30073 int res1 = 0 ;
30074 PyObject *swig_obj[1] ;
30075
30076 if (!args) SWIG_fail;
30077 swig_obj[0] = args;
30078 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30079 if (!SWIG_IsOK(res1)) {
30080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetName" "', expected argument " "1"" of type '" "wxWindow const *""'");
30081 }
30082 arg1 = reinterpret_cast< wxWindow * >(argp1);
30083 {
30084 PyThreadState* __tstate = wxPyBeginAllowThreads();
30085 result = ((wxWindow const *)arg1)->GetName();
30086 wxPyEndAllowThreads(__tstate);
30087 if (PyErr_Occurred()) SWIG_fail;
30088 }
30089 {
30090 #if wxUSE_UNICODE
30091 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30092 #else
30093 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30094 #endif
30095 }
30096 return resultobj;
30097 fail:
30098 return NULL;
30099 }
30100
30101
30102 SWIGINTERN PyObject *_wrap_Window_SetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30103 PyObject *resultobj = 0;
30104 wxWindow *arg1 = (wxWindow *) 0 ;
30105 wxWindowVariant arg2 ;
30106 void *argp1 = 0 ;
30107 int res1 = 0 ;
30108 int val2 ;
30109 int ecode2 = 0 ;
30110 PyObject * obj0 = 0 ;
30111 PyObject * obj1 = 0 ;
30112 char * kwnames[] = {
30113 (char *) "self",(char *) "variant", NULL
30114 };
30115
30116 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) SWIG_fail;
30117 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30118 if (!SWIG_IsOK(res1)) {
30119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowVariant" "', expected argument " "1"" of type '" "wxWindow *""'");
30120 }
30121 arg1 = reinterpret_cast< wxWindow * >(argp1);
30122 ecode2 = SWIG_AsVal_int(obj1, &val2);
30123 if (!SWIG_IsOK(ecode2)) {
30124 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowVariant" "', expected argument " "2"" of type '" "wxWindowVariant""'");
30125 }
30126 arg2 = static_cast< wxWindowVariant >(val2);
30127 {
30128 PyThreadState* __tstate = wxPyBeginAllowThreads();
30129 (arg1)->SetWindowVariant(arg2);
30130 wxPyEndAllowThreads(__tstate);
30131 if (PyErr_Occurred()) SWIG_fail;
30132 }
30133 resultobj = SWIG_Py_Void();
30134 return resultobj;
30135 fail:
30136 return NULL;
30137 }
30138
30139
30140 SWIGINTERN PyObject *_wrap_Window_GetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30141 PyObject *resultobj = 0;
30142 wxWindow *arg1 = (wxWindow *) 0 ;
30143 wxWindowVariant result;
30144 void *argp1 = 0 ;
30145 int res1 = 0 ;
30146 PyObject *swig_obj[1] ;
30147
30148 if (!args) SWIG_fail;
30149 swig_obj[0] = args;
30150 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30151 if (!SWIG_IsOK(res1)) {
30152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowVariant" "', expected argument " "1"" of type '" "wxWindow const *""'");
30153 }
30154 arg1 = reinterpret_cast< wxWindow * >(argp1);
30155 {
30156 PyThreadState* __tstate = wxPyBeginAllowThreads();
30157 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
30158 wxPyEndAllowThreads(__tstate);
30159 if (PyErr_Occurred()) SWIG_fail;
30160 }
30161 resultobj = SWIG_From_int(static_cast< int >(result));
30162 return resultobj;
30163 fail:
30164 return NULL;
30165 }
30166
30167
30168 SWIGINTERN PyObject *_wrap_Window_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30169 PyObject *resultobj = 0;
30170 wxWindow *arg1 = (wxWindow *) 0 ;
30171 int arg2 ;
30172 void *argp1 = 0 ;
30173 int res1 = 0 ;
30174 int val2 ;
30175 int ecode2 = 0 ;
30176 PyObject * obj0 = 0 ;
30177 PyObject * obj1 = 0 ;
30178 char * kwnames[] = {
30179 (char *) "self",(char *) "winid", NULL
30180 };
30181
30182 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
30183 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30184 if (!SWIG_IsOK(res1)) {
30185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetId" "', expected argument " "1"" of type '" "wxWindow *""'");
30186 }
30187 arg1 = reinterpret_cast< wxWindow * >(argp1);
30188 ecode2 = SWIG_AsVal_int(obj1, &val2);
30189 if (!SWIG_IsOK(ecode2)) {
30190 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetId" "', expected argument " "2"" of type '" "int""'");
30191 }
30192 arg2 = static_cast< int >(val2);
30193 {
30194 PyThreadState* __tstate = wxPyBeginAllowThreads();
30195 (arg1)->SetId(arg2);
30196 wxPyEndAllowThreads(__tstate);
30197 if (PyErr_Occurred()) SWIG_fail;
30198 }
30199 resultobj = SWIG_Py_Void();
30200 return resultobj;
30201 fail:
30202 return NULL;
30203 }
30204
30205
30206 SWIGINTERN PyObject *_wrap_Window_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30207 PyObject *resultobj = 0;
30208 wxWindow *arg1 = (wxWindow *) 0 ;
30209 int result;
30210 void *argp1 = 0 ;
30211 int res1 = 0 ;
30212 PyObject *swig_obj[1] ;
30213
30214 if (!args) SWIG_fail;
30215 swig_obj[0] = args;
30216 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30217 if (!SWIG_IsOK(res1)) {
30218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetId" "', expected argument " "1"" of type '" "wxWindow const *""'");
30219 }
30220 arg1 = reinterpret_cast< wxWindow * >(argp1);
30221 {
30222 PyThreadState* __tstate = wxPyBeginAllowThreads();
30223 result = (int)((wxWindow const *)arg1)->GetId();
30224 wxPyEndAllowThreads(__tstate);
30225 if (PyErr_Occurred()) SWIG_fail;
30226 }
30227 resultobj = SWIG_From_int(static_cast< int >(result));
30228 return resultobj;
30229 fail:
30230 return NULL;
30231 }
30232
30233
30234 SWIGINTERN PyObject *_wrap_Window_NewControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30235 PyObject *resultobj = 0;
30236 int result;
30237
30238 if (!SWIG_Python_UnpackTuple(args,"Window_NewControlId",0,0,0)) SWIG_fail;
30239 {
30240 PyThreadState* __tstate = wxPyBeginAllowThreads();
30241 result = (int)wxWindow::NewControlId();
30242 wxPyEndAllowThreads(__tstate);
30243 if (PyErr_Occurred()) SWIG_fail;
30244 }
30245 resultobj = SWIG_From_int(static_cast< int >(result));
30246 return resultobj;
30247 fail:
30248 return NULL;
30249 }
30250
30251
30252 SWIGINTERN PyObject *_wrap_Window_NextControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30253 PyObject *resultobj = 0;
30254 int arg1 ;
30255 int result;
30256 int val1 ;
30257 int ecode1 = 0 ;
30258 PyObject * obj0 = 0 ;
30259 char * kwnames[] = {
30260 (char *) "winid", NULL
30261 };
30262
30263 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) SWIG_fail;
30264 ecode1 = SWIG_AsVal_int(obj0, &val1);
30265 if (!SWIG_IsOK(ecode1)) {
30266 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_NextControlId" "', expected argument " "1"" of type '" "int""'");
30267 }
30268 arg1 = static_cast< int >(val1);
30269 {
30270 PyThreadState* __tstate = wxPyBeginAllowThreads();
30271 result = (int)wxWindow::NextControlId(arg1);
30272 wxPyEndAllowThreads(__tstate);
30273 if (PyErr_Occurred()) SWIG_fail;
30274 }
30275 resultobj = SWIG_From_int(static_cast< int >(result));
30276 return resultobj;
30277 fail:
30278 return NULL;
30279 }
30280
30281
30282 SWIGINTERN PyObject *_wrap_Window_PrevControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30283 PyObject *resultobj = 0;
30284 int arg1 ;
30285 int result;
30286 int val1 ;
30287 int ecode1 = 0 ;
30288 PyObject * obj0 = 0 ;
30289 char * kwnames[] = {
30290 (char *) "winid", NULL
30291 };
30292
30293 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) SWIG_fail;
30294 ecode1 = SWIG_AsVal_int(obj0, &val1);
30295 if (!SWIG_IsOK(ecode1)) {
30296 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_PrevControlId" "', expected argument " "1"" of type '" "int""'");
30297 }
30298 arg1 = static_cast< int >(val1);
30299 {
30300 PyThreadState* __tstate = wxPyBeginAllowThreads();
30301 result = (int)wxWindow::PrevControlId(arg1);
30302 wxPyEndAllowThreads(__tstate);
30303 if (PyErr_Occurred()) SWIG_fail;
30304 }
30305 resultobj = SWIG_From_int(static_cast< int >(result));
30306 return resultobj;
30307 fail:
30308 return NULL;
30309 }
30310
30311
30312 SWIGINTERN PyObject *_wrap_Window_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30313 PyObject *resultobj = 0;
30314 wxWindow *arg1 = (wxWindow *) 0 ;
30315 wxSize *arg2 = 0 ;
30316 void *argp1 = 0 ;
30317 int res1 = 0 ;
30318 wxSize temp2 ;
30319 PyObject * obj0 = 0 ;
30320 PyObject * obj1 = 0 ;
30321 char * kwnames[] = {
30322 (char *) "self",(char *) "size", NULL
30323 };
30324
30325 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
30326 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30327 if (!SWIG_IsOK(res1)) {
30328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30329 }
30330 arg1 = reinterpret_cast< wxWindow * >(argp1);
30331 {
30332 arg2 = &temp2;
30333 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30334 }
30335 {
30336 PyThreadState* __tstate = wxPyBeginAllowThreads();
30337 (arg1)->SetSize((wxSize const &)*arg2);
30338 wxPyEndAllowThreads(__tstate);
30339 if (PyErr_Occurred()) SWIG_fail;
30340 }
30341 resultobj = SWIG_Py_Void();
30342 return resultobj;
30343 fail:
30344 return NULL;
30345 }
30346
30347
30348 SWIGINTERN PyObject *_wrap_Window_SetDimensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30349 PyObject *resultobj = 0;
30350 wxWindow *arg1 = (wxWindow *) 0 ;
30351 int arg2 ;
30352 int arg3 ;
30353 int arg4 ;
30354 int arg5 ;
30355 int arg6 = (int) wxSIZE_AUTO ;
30356 void *argp1 = 0 ;
30357 int res1 = 0 ;
30358 int val2 ;
30359 int ecode2 = 0 ;
30360 int val3 ;
30361 int ecode3 = 0 ;
30362 int val4 ;
30363 int ecode4 = 0 ;
30364 int val5 ;
30365 int ecode5 = 0 ;
30366 int val6 ;
30367 int ecode6 = 0 ;
30368 PyObject * obj0 = 0 ;
30369 PyObject * obj1 = 0 ;
30370 PyObject * obj2 = 0 ;
30371 PyObject * obj3 = 0 ;
30372 PyObject * obj4 = 0 ;
30373 PyObject * obj5 = 0 ;
30374 char * kwnames[] = {
30375 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
30376 };
30377
30378 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
30379 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30380 if (!SWIG_IsOK(res1)) {
30381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDimensions" "', expected argument " "1"" of type '" "wxWindow *""'");
30382 }
30383 arg1 = reinterpret_cast< wxWindow * >(argp1);
30384 ecode2 = SWIG_AsVal_int(obj1, &val2);
30385 if (!SWIG_IsOK(ecode2)) {
30386 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDimensions" "', expected argument " "2"" of type '" "int""'");
30387 }
30388 arg2 = static_cast< int >(val2);
30389 ecode3 = SWIG_AsVal_int(obj2, &val3);
30390 if (!SWIG_IsOK(ecode3)) {
30391 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetDimensions" "', expected argument " "3"" of type '" "int""'");
30392 }
30393 arg3 = static_cast< int >(val3);
30394 ecode4 = SWIG_AsVal_int(obj3, &val4);
30395 if (!SWIG_IsOK(ecode4)) {
30396 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetDimensions" "', expected argument " "4"" of type '" "int""'");
30397 }
30398 arg4 = static_cast< int >(val4);
30399 ecode5 = SWIG_AsVal_int(obj4, &val5);
30400 if (!SWIG_IsOK(ecode5)) {
30401 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetDimensions" "', expected argument " "5"" of type '" "int""'");
30402 }
30403 arg5 = static_cast< int >(val5);
30404 if (obj5) {
30405 ecode6 = SWIG_AsVal_int(obj5, &val6);
30406 if (!SWIG_IsOK(ecode6)) {
30407 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetDimensions" "', expected argument " "6"" of type '" "int""'");
30408 }
30409 arg6 = static_cast< int >(val6);
30410 }
30411 {
30412 PyThreadState* __tstate = wxPyBeginAllowThreads();
30413 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
30414 wxPyEndAllowThreads(__tstate);
30415 if (PyErr_Occurred()) SWIG_fail;
30416 }
30417 resultobj = SWIG_Py_Void();
30418 return resultobj;
30419 fail:
30420 return NULL;
30421 }
30422
30423
30424 SWIGINTERN PyObject *_wrap_Window_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30425 PyObject *resultobj = 0;
30426 wxWindow *arg1 = (wxWindow *) 0 ;
30427 wxRect *arg2 = 0 ;
30428 int arg3 = (int) wxSIZE_AUTO ;
30429 void *argp1 = 0 ;
30430 int res1 = 0 ;
30431 wxRect temp2 ;
30432 int val3 ;
30433 int ecode3 = 0 ;
30434 PyObject * obj0 = 0 ;
30435 PyObject * obj1 = 0 ;
30436 PyObject * obj2 = 0 ;
30437 char * kwnames[] = {
30438 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
30439 };
30440
30441 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30442 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30443 if (!SWIG_IsOK(res1)) {
30444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetRect" "', expected argument " "1"" of type '" "wxWindow *""'");
30445 }
30446 arg1 = reinterpret_cast< wxWindow * >(argp1);
30447 {
30448 arg2 = &temp2;
30449 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30450 }
30451 if (obj2) {
30452 ecode3 = SWIG_AsVal_int(obj2, &val3);
30453 if (!SWIG_IsOK(ecode3)) {
30454 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetRect" "', expected argument " "3"" of type '" "int""'");
30455 }
30456 arg3 = static_cast< int >(val3);
30457 }
30458 {
30459 PyThreadState* __tstate = wxPyBeginAllowThreads();
30460 (arg1)->SetSize((wxRect const &)*arg2,arg3);
30461 wxPyEndAllowThreads(__tstate);
30462 if (PyErr_Occurred()) SWIG_fail;
30463 }
30464 resultobj = SWIG_Py_Void();
30465 return resultobj;
30466 fail:
30467 return NULL;
30468 }
30469
30470
30471 SWIGINTERN PyObject *_wrap_Window_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30472 PyObject *resultobj = 0;
30473 wxWindow *arg1 = (wxWindow *) 0 ;
30474 int arg2 ;
30475 int arg3 ;
30476 void *argp1 = 0 ;
30477 int res1 = 0 ;
30478 int val2 ;
30479 int ecode2 = 0 ;
30480 int val3 ;
30481 int ecode3 = 0 ;
30482 PyObject * obj0 = 0 ;
30483 PyObject * obj1 = 0 ;
30484 PyObject * obj2 = 0 ;
30485 char * kwnames[] = {
30486 (char *) "self",(char *) "width",(char *) "height", NULL
30487 };
30488
30489 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30490 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30491 if (!SWIG_IsOK(res1)) {
30492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
30493 }
30494 arg1 = reinterpret_cast< wxWindow * >(argp1);
30495 ecode2 = SWIG_AsVal_int(obj1, &val2);
30496 if (!SWIG_IsOK(ecode2)) {
30497 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
30498 }
30499 arg2 = static_cast< int >(val2);
30500 ecode3 = SWIG_AsVal_int(obj2, &val3);
30501 if (!SWIG_IsOK(ecode3)) {
30502 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
30503 }
30504 arg3 = static_cast< int >(val3);
30505 {
30506 PyThreadState* __tstate = wxPyBeginAllowThreads();
30507 (arg1)->SetSize(arg2,arg3);
30508 wxPyEndAllowThreads(__tstate);
30509 if (PyErr_Occurred()) SWIG_fail;
30510 }
30511 resultobj = SWIG_Py_Void();
30512 return resultobj;
30513 fail:
30514 return NULL;
30515 }
30516
30517
30518 SWIGINTERN PyObject *_wrap_Window_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30519 PyObject *resultobj = 0;
30520 wxWindow *arg1 = (wxWindow *) 0 ;
30521 wxPoint *arg2 = 0 ;
30522 int arg3 = (int) wxSIZE_USE_EXISTING ;
30523 void *argp1 = 0 ;
30524 int res1 = 0 ;
30525 wxPoint temp2 ;
30526 int val3 ;
30527 int ecode3 = 0 ;
30528 PyObject * obj0 = 0 ;
30529 PyObject * obj1 = 0 ;
30530 PyObject * obj2 = 0 ;
30531 char * kwnames[] = {
30532 (char *) "self",(char *) "pt",(char *) "flags", NULL
30533 };
30534
30535 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30536 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30537 if (!SWIG_IsOK(res1)) {
30538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Move" "', expected argument " "1"" of type '" "wxWindow *""'");
30539 }
30540 arg1 = reinterpret_cast< wxWindow * >(argp1);
30541 {
30542 arg2 = &temp2;
30543 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30544 }
30545 if (obj2) {
30546 ecode3 = SWIG_AsVal_int(obj2, &val3);
30547 if (!SWIG_IsOK(ecode3)) {
30548 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Move" "', expected argument " "3"" of type '" "int""'");
30549 }
30550 arg3 = static_cast< int >(val3);
30551 }
30552 {
30553 PyThreadState* __tstate = wxPyBeginAllowThreads();
30554 (arg1)->Move((wxPoint const &)*arg2,arg3);
30555 wxPyEndAllowThreads(__tstate);
30556 if (PyErr_Occurred()) SWIG_fail;
30557 }
30558 resultobj = SWIG_Py_Void();
30559 return resultobj;
30560 fail:
30561 return NULL;
30562 }
30563
30564
30565 SWIGINTERN PyObject *_wrap_Window_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30566 PyObject *resultobj = 0;
30567 wxWindow *arg1 = (wxWindow *) 0 ;
30568 int arg2 ;
30569 int arg3 ;
30570 int arg4 = (int) wxSIZE_USE_EXISTING ;
30571 void *argp1 = 0 ;
30572 int res1 = 0 ;
30573 int val2 ;
30574 int ecode2 = 0 ;
30575 int val3 ;
30576 int ecode3 = 0 ;
30577 int val4 ;
30578 int ecode4 = 0 ;
30579 PyObject * obj0 = 0 ;
30580 PyObject * obj1 = 0 ;
30581 PyObject * obj2 = 0 ;
30582 PyObject * obj3 = 0 ;
30583 char * kwnames[] = {
30584 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
30585 };
30586
30587 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30588 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30589 if (!SWIG_IsOK(res1)) {
30590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveXY" "', expected argument " "1"" of type '" "wxWindow *""'");
30591 }
30592 arg1 = reinterpret_cast< wxWindow * >(argp1);
30593 ecode2 = SWIG_AsVal_int(obj1, &val2);
30594 if (!SWIG_IsOK(ecode2)) {
30595 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MoveXY" "', expected argument " "2"" of type '" "int""'");
30596 }
30597 arg2 = static_cast< int >(val2);
30598 ecode3 = SWIG_AsVal_int(obj2, &val3);
30599 if (!SWIG_IsOK(ecode3)) {
30600 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_MoveXY" "', expected argument " "3"" of type '" "int""'");
30601 }
30602 arg3 = static_cast< int >(val3);
30603 if (obj3) {
30604 ecode4 = SWIG_AsVal_int(obj3, &val4);
30605 if (!SWIG_IsOK(ecode4)) {
30606 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_MoveXY" "', expected argument " "4"" of type '" "int""'");
30607 }
30608 arg4 = static_cast< int >(val4);
30609 }
30610 {
30611 PyThreadState* __tstate = wxPyBeginAllowThreads();
30612 (arg1)->Move(arg2,arg3,arg4);
30613 wxPyEndAllowThreads(__tstate);
30614 if (PyErr_Occurred()) SWIG_fail;
30615 }
30616 resultobj = SWIG_Py_Void();
30617 return resultobj;
30618 fail:
30619 return NULL;
30620 }
30621
30622
30623 SWIGINTERN PyObject *_wrap_Window_SetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30624 PyObject *resultobj = 0;
30625 wxWindow *arg1 = (wxWindow *) 0 ;
30626 wxSize const &arg2_defvalue = wxDefaultSize ;
30627 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
30628 void *argp1 = 0 ;
30629 int res1 = 0 ;
30630 wxSize temp2 ;
30631 PyObject * obj0 = 0 ;
30632 PyObject * obj1 = 0 ;
30633 char * kwnames[] = {
30634 (char *) "self",(char *) "size", NULL
30635 };
30636
30637 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) SWIG_fail;
30638 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30639 if (!SWIG_IsOK(res1)) {
30640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30641 }
30642 arg1 = reinterpret_cast< wxWindow * >(argp1);
30643 if (obj1) {
30644 {
30645 arg2 = &temp2;
30646 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30647 }
30648 }
30649 {
30650 PyThreadState* __tstate = wxPyBeginAllowThreads();
30651 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
30652 wxPyEndAllowThreads(__tstate);
30653 if (PyErr_Occurred()) SWIG_fail;
30654 }
30655 resultobj = SWIG_Py_Void();
30656 return resultobj;
30657 fail:
30658 return NULL;
30659 }
30660
30661
30662 SWIGINTERN PyObject *_wrap_Window_Raise(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30663 PyObject *resultobj = 0;
30664 wxWindow *arg1 = (wxWindow *) 0 ;
30665 void *argp1 = 0 ;
30666 int res1 = 0 ;
30667 PyObject *swig_obj[1] ;
30668
30669 if (!args) SWIG_fail;
30670 swig_obj[0] = args;
30671 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30672 if (!SWIG_IsOK(res1)) {
30673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Raise" "', expected argument " "1"" of type '" "wxWindow *""'");
30674 }
30675 arg1 = reinterpret_cast< wxWindow * >(argp1);
30676 {
30677 PyThreadState* __tstate = wxPyBeginAllowThreads();
30678 (arg1)->Raise();
30679 wxPyEndAllowThreads(__tstate);
30680 if (PyErr_Occurred()) SWIG_fail;
30681 }
30682 resultobj = SWIG_Py_Void();
30683 return resultobj;
30684 fail:
30685 return NULL;
30686 }
30687
30688
30689 SWIGINTERN PyObject *_wrap_Window_Lower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30690 PyObject *resultobj = 0;
30691 wxWindow *arg1 = (wxWindow *) 0 ;
30692 void *argp1 = 0 ;
30693 int res1 = 0 ;
30694 PyObject *swig_obj[1] ;
30695
30696 if (!args) SWIG_fail;
30697 swig_obj[0] = args;
30698 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30699 if (!SWIG_IsOK(res1)) {
30700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Lower" "', expected argument " "1"" of type '" "wxWindow *""'");
30701 }
30702 arg1 = reinterpret_cast< wxWindow * >(argp1);
30703 {
30704 PyThreadState* __tstate = wxPyBeginAllowThreads();
30705 (arg1)->Lower();
30706 wxPyEndAllowThreads(__tstate);
30707 if (PyErr_Occurred()) SWIG_fail;
30708 }
30709 resultobj = SWIG_Py_Void();
30710 return resultobj;
30711 fail:
30712 return NULL;
30713 }
30714
30715
30716 SWIGINTERN PyObject *_wrap_Window_SetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30717 PyObject *resultobj = 0;
30718 wxWindow *arg1 = (wxWindow *) 0 ;
30719 wxSize *arg2 = 0 ;
30720 void *argp1 = 0 ;
30721 int res1 = 0 ;
30722 wxSize temp2 ;
30723 PyObject * obj0 = 0 ;
30724 PyObject * obj1 = 0 ;
30725 char * kwnames[] = {
30726 (char *) "self",(char *) "size", NULL
30727 };
30728
30729 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) SWIG_fail;
30730 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30731 if (!SWIG_IsOK(res1)) {
30732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30733 }
30734 arg1 = reinterpret_cast< wxWindow * >(argp1);
30735 {
30736 arg2 = &temp2;
30737 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30738 }
30739 {
30740 PyThreadState* __tstate = wxPyBeginAllowThreads();
30741 (arg1)->SetClientSize((wxSize const &)*arg2);
30742 wxPyEndAllowThreads(__tstate);
30743 if (PyErr_Occurred()) SWIG_fail;
30744 }
30745 resultobj = SWIG_Py_Void();
30746 return resultobj;
30747 fail:
30748 return NULL;
30749 }
30750
30751
30752 SWIGINTERN PyObject *_wrap_Window_SetClientSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30753 PyObject *resultobj = 0;
30754 wxWindow *arg1 = (wxWindow *) 0 ;
30755 int arg2 ;
30756 int arg3 ;
30757 void *argp1 = 0 ;
30758 int res1 = 0 ;
30759 int val2 ;
30760 int ecode2 = 0 ;
30761 int val3 ;
30762 int ecode3 = 0 ;
30763 PyObject * obj0 = 0 ;
30764 PyObject * obj1 = 0 ;
30765 PyObject * obj2 = 0 ;
30766 char * kwnames[] = {
30767 (char *) "self",(char *) "width",(char *) "height", NULL
30768 };
30769
30770 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30771 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30772 if (!SWIG_IsOK(res1)) {
30773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
30774 }
30775 arg1 = reinterpret_cast< wxWindow * >(argp1);
30776 ecode2 = SWIG_AsVal_int(obj1, &val2);
30777 if (!SWIG_IsOK(ecode2)) {
30778 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetClientSizeWH" "', expected argument " "2"" of type '" "int""'");
30779 }
30780 arg2 = static_cast< int >(val2);
30781 ecode3 = SWIG_AsVal_int(obj2, &val3);
30782 if (!SWIG_IsOK(ecode3)) {
30783 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetClientSizeWH" "', expected argument " "3"" of type '" "int""'");
30784 }
30785 arg3 = static_cast< int >(val3);
30786 {
30787 PyThreadState* __tstate = wxPyBeginAllowThreads();
30788 (arg1)->SetClientSize(arg2,arg3);
30789 wxPyEndAllowThreads(__tstate);
30790 if (PyErr_Occurred()) SWIG_fail;
30791 }
30792 resultobj = SWIG_Py_Void();
30793 return resultobj;
30794 fail:
30795 return NULL;
30796 }
30797
30798
30799 SWIGINTERN PyObject *_wrap_Window_SetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30800 PyObject *resultobj = 0;
30801 wxWindow *arg1 = (wxWindow *) 0 ;
30802 wxRect *arg2 = 0 ;
30803 void *argp1 = 0 ;
30804 int res1 = 0 ;
30805 wxRect temp2 ;
30806 PyObject * obj0 = 0 ;
30807 PyObject * obj1 = 0 ;
30808 char * kwnames[] = {
30809 (char *) "self",(char *) "rect", NULL
30810 };
30811
30812 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) SWIG_fail;
30813 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30814 if (!SWIG_IsOK(res1)) {
30815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientRect" "', expected argument " "1"" of type '" "wxWindow *""'");
30816 }
30817 arg1 = reinterpret_cast< wxWindow * >(argp1);
30818 {
30819 arg2 = &temp2;
30820 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30821 }
30822 {
30823 PyThreadState* __tstate = wxPyBeginAllowThreads();
30824 (arg1)->SetClientSize((wxRect const &)*arg2);
30825 wxPyEndAllowThreads(__tstate);
30826 if (PyErr_Occurred()) SWIG_fail;
30827 }
30828 resultobj = SWIG_Py_Void();
30829 return resultobj;
30830 fail:
30831 return NULL;
30832 }
30833
30834
30835 SWIGINTERN PyObject *_wrap_Window_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30836 PyObject *resultobj = 0;
30837 wxWindow *arg1 = (wxWindow *) 0 ;
30838 wxPoint result;
30839 void *argp1 = 0 ;
30840 int res1 = 0 ;
30841 PyObject *swig_obj[1] ;
30842
30843 if (!args) SWIG_fail;
30844 swig_obj[0] = args;
30845 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30846 if (!SWIG_IsOK(res1)) {
30847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
30848 }
30849 arg1 = reinterpret_cast< wxWindow * >(argp1);
30850 {
30851 PyThreadState* __tstate = wxPyBeginAllowThreads();
30852 result = ((wxWindow const *)arg1)->GetPosition();
30853 wxPyEndAllowThreads(__tstate);
30854 if (PyErr_Occurred()) SWIG_fail;
30855 }
30856 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
30857 return resultobj;
30858 fail:
30859 return NULL;
30860 }
30861
30862
30863 SWIGINTERN PyObject *_wrap_Window_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30864 PyObject *resultobj = 0;
30865 wxWindow *arg1 = (wxWindow *) 0 ;
30866 int *arg2 = (int *) 0 ;
30867 int *arg3 = (int *) 0 ;
30868 void *argp1 = 0 ;
30869 int res1 = 0 ;
30870 int temp2 ;
30871 int res2 = SWIG_TMPOBJ ;
30872 int temp3 ;
30873 int res3 = SWIG_TMPOBJ ;
30874 PyObject *swig_obj[1] ;
30875
30876 arg2 = &temp2;
30877 arg3 = &temp3;
30878 if (!args) SWIG_fail;
30879 swig_obj[0] = args;
30880 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30881 if (!SWIG_IsOK(res1)) {
30882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30883 }
30884 arg1 = reinterpret_cast< wxWindow * >(argp1);
30885 {
30886 PyThreadState* __tstate = wxPyBeginAllowThreads();
30887 ((wxWindow const *)arg1)->GetPosition(arg2,arg3);
30888 wxPyEndAllowThreads(__tstate);
30889 if (PyErr_Occurred()) SWIG_fail;
30890 }
30891 resultobj = SWIG_Py_Void();
30892 if (SWIG_IsTmpObj(res2)) {
30893 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30894 } else {
30895 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30896 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30897 }
30898 if (SWIG_IsTmpObj(res3)) {
30899 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30900 } else {
30901 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30902 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30903 }
30904 return resultobj;
30905 fail:
30906 return NULL;
30907 }
30908
30909
30910 SWIGINTERN PyObject *_wrap_Window_GetScreenPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30911 PyObject *resultobj = 0;
30912 wxWindow *arg1 = (wxWindow *) 0 ;
30913 wxPoint result;
30914 void *argp1 = 0 ;
30915 int res1 = 0 ;
30916 PyObject *swig_obj[1] ;
30917
30918 if (!args) SWIG_fail;
30919 swig_obj[0] = args;
30920 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30921 if (!SWIG_IsOK(res1)) {
30922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
30923 }
30924 arg1 = reinterpret_cast< wxWindow * >(argp1);
30925 {
30926 PyThreadState* __tstate = wxPyBeginAllowThreads();
30927 result = ((wxWindow const *)arg1)->GetScreenPosition();
30928 wxPyEndAllowThreads(__tstate);
30929 if (PyErr_Occurred()) SWIG_fail;
30930 }
30931 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
30932 return resultobj;
30933 fail:
30934 return NULL;
30935 }
30936
30937
30938 SWIGINTERN PyObject *_wrap_Window_GetScreenPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30939 PyObject *resultobj = 0;
30940 wxWindow *arg1 = (wxWindow *) 0 ;
30941 int *arg2 = (int *) 0 ;
30942 int *arg3 = (int *) 0 ;
30943 void *argp1 = 0 ;
30944 int res1 = 0 ;
30945 int temp2 ;
30946 int res2 = SWIG_TMPOBJ ;
30947 int temp3 ;
30948 int res3 = SWIG_TMPOBJ ;
30949 PyObject *swig_obj[1] ;
30950
30951 arg2 = &temp2;
30952 arg3 = &temp3;
30953 if (!args) SWIG_fail;
30954 swig_obj[0] = args;
30955 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30956 if (!SWIG_IsOK(res1)) {
30957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30958 }
30959 arg1 = reinterpret_cast< wxWindow * >(argp1);
30960 {
30961 PyThreadState* __tstate = wxPyBeginAllowThreads();
30962 ((wxWindow const *)arg1)->GetScreenPosition(arg2,arg3);
30963 wxPyEndAllowThreads(__tstate);
30964 if (PyErr_Occurred()) SWIG_fail;
30965 }
30966 resultobj = SWIG_Py_Void();
30967 if (SWIG_IsTmpObj(res2)) {
30968 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30969 } else {
30970 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30971 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30972 }
30973 if (SWIG_IsTmpObj(res3)) {
30974 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30975 } else {
30976 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30977 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30978 }
30979 return resultobj;
30980 fail:
30981 return NULL;
30982 }
30983
30984
30985 SWIGINTERN PyObject *_wrap_Window_GetScreenRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30986 PyObject *resultobj = 0;
30987 wxWindow *arg1 = (wxWindow *) 0 ;
30988 wxRect result;
30989 void *argp1 = 0 ;
30990 int res1 = 0 ;
30991 PyObject *swig_obj[1] ;
30992
30993 if (!args) SWIG_fail;
30994 swig_obj[0] = args;
30995 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30996 if (!SWIG_IsOK(res1)) {
30997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
30998 }
30999 arg1 = reinterpret_cast< wxWindow * >(argp1);
31000 {
31001 PyThreadState* __tstate = wxPyBeginAllowThreads();
31002 result = ((wxWindow const *)arg1)->GetScreenRect();
31003 wxPyEndAllowThreads(__tstate);
31004 if (PyErr_Occurred()) SWIG_fail;
31005 }
31006 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
31007 return resultobj;
31008 fail:
31009 return NULL;
31010 }
31011
31012
31013 SWIGINTERN PyObject *_wrap_Window_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31014 PyObject *resultobj = 0;
31015 wxWindow *arg1 = (wxWindow *) 0 ;
31016 wxSize result;
31017 void *argp1 = 0 ;
31018 int res1 = 0 ;
31019 PyObject *swig_obj[1] ;
31020
31021 if (!args) SWIG_fail;
31022 swig_obj[0] = args;
31023 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31024 if (!SWIG_IsOK(res1)) {
31025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31026 }
31027 arg1 = reinterpret_cast< wxWindow * >(argp1);
31028 {
31029 PyThreadState* __tstate = wxPyBeginAllowThreads();
31030 result = ((wxWindow const *)arg1)->GetSize();
31031 wxPyEndAllowThreads(__tstate);
31032 if (PyErr_Occurred()) SWIG_fail;
31033 }
31034 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31035 return resultobj;
31036 fail:
31037 return NULL;
31038 }
31039
31040
31041 SWIGINTERN PyObject *_wrap_Window_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31042 PyObject *resultobj = 0;
31043 wxWindow *arg1 = (wxWindow *) 0 ;
31044 int *arg2 = (int *) 0 ;
31045 int *arg3 = (int *) 0 ;
31046 void *argp1 = 0 ;
31047 int res1 = 0 ;
31048 int temp2 ;
31049 int res2 = SWIG_TMPOBJ ;
31050 int temp3 ;
31051 int res3 = SWIG_TMPOBJ ;
31052 PyObject *swig_obj[1] ;
31053
31054 arg2 = &temp2;
31055 arg3 = &temp3;
31056 if (!args) SWIG_fail;
31057 swig_obj[0] = args;
31058 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31059 if (!SWIG_IsOK(res1)) {
31060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31061 }
31062 arg1 = reinterpret_cast< wxWindow * >(argp1);
31063 {
31064 PyThreadState* __tstate = wxPyBeginAllowThreads();
31065 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
31066 wxPyEndAllowThreads(__tstate);
31067 if (PyErr_Occurred()) SWIG_fail;
31068 }
31069 resultobj = SWIG_Py_Void();
31070 if (SWIG_IsTmpObj(res2)) {
31071 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31072 } else {
31073 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31074 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31075 }
31076 if (SWIG_IsTmpObj(res3)) {
31077 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31078 } else {
31079 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31080 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31081 }
31082 return resultobj;
31083 fail:
31084 return NULL;
31085 }
31086
31087
31088 SWIGINTERN PyObject *_wrap_Window_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31089 PyObject *resultobj = 0;
31090 wxWindow *arg1 = (wxWindow *) 0 ;
31091 wxRect result;
31092 void *argp1 = 0 ;
31093 int res1 = 0 ;
31094 PyObject *swig_obj[1] ;
31095
31096 if (!args) SWIG_fail;
31097 swig_obj[0] = args;
31098 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31099 if (!SWIG_IsOK(res1)) {
31100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
31101 }
31102 arg1 = reinterpret_cast< wxWindow * >(argp1);
31103 {
31104 PyThreadState* __tstate = wxPyBeginAllowThreads();
31105 result = ((wxWindow const *)arg1)->GetRect();
31106 wxPyEndAllowThreads(__tstate);
31107 if (PyErr_Occurred()) SWIG_fail;
31108 }
31109 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
31110 return resultobj;
31111 fail:
31112 return NULL;
31113 }
31114
31115
31116 SWIGINTERN PyObject *_wrap_Window_GetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31117 PyObject *resultobj = 0;
31118 wxWindow *arg1 = (wxWindow *) 0 ;
31119 wxSize result;
31120 void *argp1 = 0 ;
31121 int res1 = 0 ;
31122 PyObject *swig_obj[1] ;
31123
31124 if (!args) SWIG_fail;
31125 swig_obj[0] = args;
31126 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31127 if (!SWIG_IsOK(res1)) {
31128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31129 }
31130 arg1 = reinterpret_cast< wxWindow * >(argp1);
31131 {
31132 PyThreadState* __tstate = wxPyBeginAllowThreads();
31133 result = ((wxWindow const *)arg1)->GetClientSize();
31134 wxPyEndAllowThreads(__tstate);
31135 if (PyErr_Occurred()) SWIG_fail;
31136 }
31137 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31138 return resultobj;
31139 fail:
31140 return NULL;
31141 }
31142
31143
31144 SWIGINTERN PyObject *_wrap_Window_GetClientSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31145 PyObject *resultobj = 0;
31146 wxWindow *arg1 = (wxWindow *) 0 ;
31147 int *arg2 = (int *) 0 ;
31148 int *arg3 = (int *) 0 ;
31149 void *argp1 = 0 ;
31150 int res1 = 0 ;
31151 int temp2 ;
31152 int res2 = SWIG_TMPOBJ ;
31153 int temp3 ;
31154 int res3 = SWIG_TMPOBJ ;
31155 PyObject *swig_obj[1] ;
31156
31157 arg2 = &temp2;
31158 arg3 = &temp3;
31159 if (!args) SWIG_fail;
31160 swig_obj[0] = args;
31161 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31162 if (!SWIG_IsOK(res1)) {
31163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31164 }
31165 arg1 = reinterpret_cast< wxWindow * >(argp1);
31166 {
31167 PyThreadState* __tstate = wxPyBeginAllowThreads();
31168 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
31169 wxPyEndAllowThreads(__tstate);
31170 if (PyErr_Occurred()) SWIG_fail;
31171 }
31172 resultobj = SWIG_Py_Void();
31173 if (SWIG_IsTmpObj(res2)) {
31174 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31175 } else {
31176 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31177 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31178 }
31179 if (SWIG_IsTmpObj(res3)) {
31180 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31181 } else {
31182 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31183 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31184 }
31185 return resultobj;
31186 fail:
31187 return NULL;
31188 }
31189
31190
31191 SWIGINTERN PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31192 PyObject *resultobj = 0;
31193 wxWindow *arg1 = (wxWindow *) 0 ;
31194 wxPoint result;
31195 void *argp1 = 0 ;
31196 int res1 = 0 ;
31197 PyObject *swig_obj[1] ;
31198
31199 if (!args) SWIG_fail;
31200 swig_obj[0] = args;
31201 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31202 if (!SWIG_IsOK(res1)) {
31203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientAreaOrigin" "', expected argument " "1"" of type '" "wxWindow const *""'");
31204 }
31205 arg1 = reinterpret_cast< wxWindow * >(argp1);
31206 {
31207 PyThreadState* __tstate = wxPyBeginAllowThreads();
31208 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
31209 wxPyEndAllowThreads(__tstate);
31210 if (PyErr_Occurred()) SWIG_fail;
31211 }
31212 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
31213 return resultobj;
31214 fail:
31215 return NULL;
31216 }
31217
31218
31219 SWIGINTERN PyObject *_wrap_Window_GetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31220 PyObject *resultobj = 0;
31221 wxWindow *arg1 = (wxWindow *) 0 ;
31222 wxRect result;
31223 void *argp1 = 0 ;
31224 int res1 = 0 ;
31225 PyObject *swig_obj[1] ;
31226
31227 if (!args) SWIG_fail;
31228 swig_obj[0] = args;
31229 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31230 if (!SWIG_IsOK(res1)) {
31231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
31232 }
31233 arg1 = reinterpret_cast< wxWindow * >(argp1);
31234 {
31235 PyThreadState* __tstate = wxPyBeginAllowThreads();
31236 result = ((wxWindow const *)arg1)->GetClientRect();
31237 wxPyEndAllowThreads(__tstate);
31238 if (PyErr_Occurred()) SWIG_fail;
31239 }
31240 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
31241 return resultobj;
31242 fail:
31243 return NULL;
31244 }
31245
31246
31247 SWIGINTERN PyObject *_wrap_Window_GetBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31248 PyObject *resultobj = 0;
31249 wxWindow *arg1 = (wxWindow *) 0 ;
31250 wxSize result;
31251 void *argp1 = 0 ;
31252 int res1 = 0 ;
31253 PyObject *swig_obj[1] ;
31254
31255 if (!args) SWIG_fail;
31256 swig_obj[0] = args;
31257 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31258 if (!SWIG_IsOK(res1)) {
31259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31260 }
31261 arg1 = reinterpret_cast< wxWindow * >(argp1);
31262 {
31263 PyThreadState* __tstate = wxPyBeginAllowThreads();
31264 result = ((wxWindow const *)arg1)->GetBestSize();
31265 wxPyEndAllowThreads(__tstate);
31266 if (PyErr_Occurred()) SWIG_fail;
31267 }
31268 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31269 return resultobj;
31270 fail:
31271 return NULL;
31272 }
31273
31274
31275 SWIGINTERN PyObject *_wrap_Window_GetBestSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31276 PyObject *resultobj = 0;
31277 wxWindow *arg1 = (wxWindow *) 0 ;
31278 int *arg2 = (int *) 0 ;
31279 int *arg3 = (int *) 0 ;
31280 void *argp1 = 0 ;
31281 int res1 = 0 ;
31282 int temp2 ;
31283 int res2 = SWIG_TMPOBJ ;
31284 int temp3 ;
31285 int res3 = SWIG_TMPOBJ ;
31286 PyObject *swig_obj[1] ;
31287
31288 arg2 = &temp2;
31289 arg3 = &temp3;
31290 if (!args) SWIG_fail;
31291 swig_obj[0] = args;
31292 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31293 if (!SWIG_IsOK(res1)) {
31294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31295 }
31296 arg1 = reinterpret_cast< wxWindow * >(argp1);
31297 {
31298 PyThreadState* __tstate = wxPyBeginAllowThreads();
31299 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
31300 wxPyEndAllowThreads(__tstate);
31301 if (PyErr_Occurred()) SWIG_fail;
31302 }
31303 resultobj = SWIG_Py_Void();
31304 if (SWIG_IsTmpObj(res2)) {
31305 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31306 } else {
31307 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31308 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31309 }
31310 if (SWIG_IsTmpObj(res3)) {
31311 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31312 } else {
31313 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31314 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31315 }
31316 return resultobj;
31317 fail:
31318 return NULL;
31319 }
31320
31321
31322 SWIGINTERN PyObject *_wrap_Window_InvalidateBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31323 PyObject *resultobj = 0;
31324 wxWindow *arg1 = (wxWindow *) 0 ;
31325 void *argp1 = 0 ;
31326 int res1 = 0 ;
31327 PyObject *swig_obj[1] ;
31328
31329 if (!args) SWIG_fail;
31330 swig_obj[0] = args;
31331 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31332 if (!SWIG_IsOK(res1)) {
31333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InvalidateBestSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31334 }
31335 arg1 = reinterpret_cast< wxWindow * >(argp1);
31336 {
31337 PyThreadState* __tstate = wxPyBeginAllowThreads();
31338 (arg1)->InvalidateBestSize();
31339 wxPyEndAllowThreads(__tstate);
31340 if (PyErr_Occurred()) SWIG_fail;
31341 }
31342 resultobj = SWIG_Py_Void();
31343 return resultobj;
31344 fail:
31345 return NULL;
31346 }
31347
31348
31349 SWIGINTERN PyObject *_wrap_Window_CacheBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31350 PyObject *resultobj = 0;
31351 wxWindow *arg1 = (wxWindow *) 0 ;
31352 wxSize *arg2 = 0 ;
31353 void *argp1 = 0 ;
31354 int res1 = 0 ;
31355 wxSize temp2 ;
31356 PyObject * obj0 = 0 ;
31357 PyObject * obj1 = 0 ;
31358 char * kwnames[] = {
31359 (char *) "self",(char *) "size", NULL
31360 };
31361
31362 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) SWIG_fail;
31363 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31364 if (!SWIG_IsOK(res1)) {
31365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CacheBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31366 }
31367 arg1 = reinterpret_cast< wxWindow * >(argp1);
31368 {
31369 arg2 = &temp2;
31370 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31371 }
31372 {
31373 PyThreadState* __tstate = wxPyBeginAllowThreads();
31374 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
31375 wxPyEndAllowThreads(__tstate);
31376 if (PyErr_Occurred()) SWIG_fail;
31377 }
31378 resultobj = SWIG_Py_Void();
31379 return resultobj;
31380 fail:
31381 return NULL;
31382 }
31383
31384
31385 SWIGINTERN PyObject *_wrap_Window_GetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31386 PyObject *resultobj = 0;
31387 wxWindow *arg1 = (wxWindow *) 0 ;
31388 wxSize result;
31389 void *argp1 = 0 ;
31390 int res1 = 0 ;
31391 PyObject *swig_obj[1] ;
31392
31393 if (!args) SWIG_fail;
31394 swig_obj[0] = args;
31395 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31396 if (!SWIG_IsOK(res1)) {
31397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31398 }
31399 arg1 = reinterpret_cast< wxWindow * >(argp1);
31400 {
31401 PyThreadState* __tstate = wxPyBeginAllowThreads();
31402 result = ((wxWindow const *)arg1)->GetBestFittingSize();
31403 wxPyEndAllowThreads(__tstate);
31404 if (PyErr_Occurred()) SWIG_fail;
31405 }
31406 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31407 return resultobj;
31408 fail:
31409 return NULL;
31410 }
31411
31412
31413 SWIGINTERN PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31414 PyObject *resultobj = 0;
31415 wxWindow *arg1 = (wxWindow *) 0 ;
31416 wxSize result;
31417 void *argp1 = 0 ;
31418 int res1 = 0 ;
31419 PyObject *swig_obj[1] ;
31420
31421 if (!args) SWIG_fail;
31422 swig_obj[0] = args;
31423 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31424 if (!SWIG_IsOK(res1)) {
31425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAdjustedBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31426 }
31427 arg1 = reinterpret_cast< wxWindow * >(argp1);
31428 {
31429 PyThreadState* __tstate = wxPyBeginAllowThreads();
31430 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
31431 wxPyEndAllowThreads(__tstate);
31432 if (PyErr_Occurred()) SWIG_fail;
31433 }
31434 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31435 return resultobj;
31436 fail:
31437 return NULL;
31438 }
31439
31440
31441 SWIGINTERN PyObject *_wrap_Window_Center(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31442 PyObject *resultobj = 0;
31443 wxWindow *arg1 = (wxWindow *) 0 ;
31444 int arg2 = (int) wxBOTH ;
31445 void *argp1 = 0 ;
31446 int res1 = 0 ;
31447 int val2 ;
31448 int ecode2 = 0 ;
31449 PyObject * obj0 = 0 ;
31450 PyObject * obj1 = 0 ;
31451 char * kwnames[] = {
31452 (char *) "self",(char *) "direction", NULL
31453 };
31454
31455 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) 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_Center" "', expected argument " "1"" of type '" "wxWindow *""'");
31459 }
31460 arg1 = reinterpret_cast< wxWindow * >(argp1);
31461 if (obj1) {
31462 ecode2 = SWIG_AsVal_int(obj1, &val2);
31463 if (!SWIG_IsOK(ecode2)) {
31464 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Center" "', expected argument " "2"" of type '" "int""'");
31465 }
31466 arg2 = static_cast< int >(val2);
31467 }
31468 {
31469 PyThreadState* __tstate = wxPyBeginAllowThreads();
31470 (arg1)->Center(arg2);
31471 wxPyEndAllowThreads(__tstate);
31472 if (PyErr_Occurred()) SWIG_fail;
31473 }
31474 resultobj = SWIG_Py_Void();
31475 return resultobj;
31476 fail:
31477 return NULL;
31478 }
31479
31480
31481 SWIGINTERN PyObject *_wrap_Window_CenterOnParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31482 PyObject *resultobj = 0;
31483 wxWindow *arg1 = (wxWindow *) 0 ;
31484 int arg2 = (int) wxBOTH ;
31485 void *argp1 = 0 ;
31486 int res1 = 0 ;
31487 int val2 ;
31488 int ecode2 = 0 ;
31489 PyObject * obj0 = 0 ;
31490 PyObject * obj1 = 0 ;
31491 char * kwnames[] = {
31492 (char *) "self",(char *) "dir", NULL
31493 };
31494
31495 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) SWIG_fail;
31496 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31497 if (!SWIG_IsOK(res1)) {
31498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CenterOnParent" "', expected argument " "1"" of type '" "wxWindow *""'");
31499 }
31500 arg1 = reinterpret_cast< wxWindow * >(argp1);
31501 if (obj1) {
31502 ecode2 = SWIG_AsVal_int(obj1, &val2);
31503 if (!SWIG_IsOK(ecode2)) {
31504 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_CenterOnParent" "', expected argument " "2"" of type '" "int""'");
31505 }
31506 arg2 = static_cast< int >(val2);
31507 }
31508 {
31509 PyThreadState* __tstate = wxPyBeginAllowThreads();
31510 (arg1)->CenterOnParent(arg2);
31511 wxPyEndAllowThreads(__tstate);
31512 if (PyErr_Occurred()) SWIG_fail;
31513 }
31514 resultobj = SWIG_Py_Void();
31515 return resultobj;
31516 fail:
31517 return NULL;
31518 }
31519
31520
31521 SWIGINTERN PyObject *_wrap_Window_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31522 PyObject *resultobj = 0;
31523 wxWindow *arg1 = (wxWindow *) 0 ;
31524 void *argp1 = 0 ;
31525 int res1 = 0 ;
31526 PyObject *swig_obj[1] ;
31527
31528 if (!args) SWIG_fail;
31529 swig_obj[0] = args;
31530 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31531 if (!SWIG_IsOK(res1)) {
31532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Fit" "', expected argument " "1"" of type '" "wxWindow *""'");
31533 }
31534 arg1 = reinterpret_cast< wxWindow * >(argp1);
31535 {
31536 PyThreadState* __tstate = wxPyBeginAllowThreads();
31537 (arg1)->Fit();
31538 wxPyEndAllowThreads(__tstate);
31539 if (PyErr_Occurred()) SWIG_fail;
31540 }
31541 resultobj = SWIG_Py_Void();
31542 return resultobj;
31543 fail:
31544 return NULL;
31545 }
31546
31547
31548 SWIGINTERN PyObject *_wrap_Window_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31549 PyObject *resultobj = 0;
31550 wxWindow *arg1 = (wxWindow *) 0 ;
31551 void *argp1 = 0 ;
31552 int res1 = 0 ;
31553 PyObject *swig_obj[1] ;
31554
31555 if (!args) SWIG_fail;
31556 swig_obj[0] = args;
31557 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31558 if (!SWIG_IsOK(res1)) {
31559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FitInside" "', expected argument " "1"" of type '" "wxWindow *""'");
31560 }
31561 arg1 = reinterpret_cast< wxWindow * >(argp1);
31562 {
31563 PyThreadState* __tstate = wxPyBeginAllowThreads();
31564 (arg1)->FitInside();
31565 wxPyEndAllowThreads(__tstate);
31566 if (PyErr_Occurred()) SWIG_fail;
31567 }
31568 resultobj = SWIG_Py_Void();
31569 return resultobj;
31570 fail:
31571 return NULL;
31572 }
31573
31574
31575 SWIGINTERN PyObject *_wrap_Window_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31576 PyObject *resultobj = 0;
31577 wxWindow *arg1 = (wxWindow *) 0 ;
31578 int arg2 ;
31579 int arg3 ;
31580 int arg4 = (int) -1 ;
31581 int arg5 = (int) -1 ;
31582 int arg6 = (int) -1 ;
31583 int arg7 = (int) -1 ;
31584 void *argp1 = 0 ;
31585 int res1 = 0 ;
31586 int val2 ;
31587 int ecode2 = 0 ;
31588 int val3 ;
31589 int ecode3 = 0 ;
31590 int val4 ;
31591 int ecode4 = 0 ;
31592 int val5 ;
31593 int ecode5 = 0 ;
31594 int val6 ;
31595 int ecode6 = 0 ;
31596 int val7 ;
31597 int ecode7 = 0 ;
31598 PyObject * obj0 = 0 ;
31599 PyObject * obj1 = 0 ;
31600 PyObject * obj2 = 0 ;
31601 PyObject * obj3 = 0 ;
31602 PyObject * obj4 = 0 ;
31603 PyObject * obj5 = 0 ;
31604 PyObject * obj6 = 0 ;
31605 char * kwnames[] = {
31606 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
31607 };
31608
31609 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
31610 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31611 if (!SWIG_IsOK(res1)) {
31612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
31613 }
31614 arg1 = reinterpret_cast< wxWindow * >(argp1);
31615 ecode2 = SWIG_AsVal_int(obj1, &val2);
31616 if (!SWIG_IsOK(ecode2)) {
31617 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeHints" "', expected argument " "2"" of type '" "int""'");
31618 }
31619 arg2 = static_cast< int >(val2);
31620 ecode3 = SWIG_AsVal_int(obj2, &val3);
31621 if (!SWIG_IsOK(ecode3)) {
31622 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeHints" "', expected argument " "3"" of type '" "int""'");
31623 }
31624 arg3 = static_cast< int >(val3);
31625 if (obj3) {
31626 ecode4 = SWIG_AsVal_int(obj3, &val4);
31627 if (!SWIG_IsOK(ecode4)) {
31628 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetSizeHints" "', expected argument " "4"" of type '" "int""'");
31629 }
31630 arg4 = static_cast< int >(val4);
31631 }
31632 if (obj4) {
31633 ecode5 = SWIG_AsVal_int(obj4, &val5);
31634 if (!SWIG_IsOK(ecode5)) {
31635 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetSizeHints" "', expected argument " "5"" of type '" "int""'");
31636 }
31637 arg5 = static_cast< int >(val5);
31638 }
31639 if (obj5) {
31640 ecode6 = SWIG_AsVal_int(obj5, &val6);
31641 if (!SWIG_IsOK(ecode6)) {
31642 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetSizeHints" "', expected argument " "6"" of type '" "int""'");
31643 }
31644 arg6 = static_cast< int >(val6);
31645 }
31646 if (obj6) {
31647 ecode7 = SWIG_AsVal_int(obj6, &val7);
31648 if (!SWIG_IsOK(ecode7)) {
31649 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Window_SetSizeHints" "', expected argument " "7"" of type '" "int""'");
31650 }
31651 arg7 = static_cast< int >(val7);
31652 }
31653 {
31654 PyThreadState* __tstate = wxPyBeginAllowThreads();
31655 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
31656 wxPyEndAllowThreads(__tstate);
31657 if (PyErr_Occurred()) SWIG_fail;
31658 }
31659 resultobj = SWIG_Py_Void();
31660 return resultobj;
31661 fail:
31662 return NULL;
31663 }
31664
31665
31666 SWIGINTERN PyObject *_wrap_Window_SetSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31667 PyObject *resultobj = 0;
31668 wxWindow *arg1 = (wxWindow *) 0 ;
31669 wxSize *arg2 = 0 ;
31670 wxSize const &arg3_defvalue = wxDefaultSize ;
31671 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
31672 wxSize const &arg4_defvalue = wxDefaultSize ;
31673 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
31674 void *argp1 = 0 ;
31675 int res1 = 0 ;
31676 wxSize temp2 ;
31677 wxSize temp3 ;
31678 wxSize temp4 ;
31679 PyObject * obj0 = 0 ;
31680 PyObject * obj1 = 0 ;
31681 PyObject * obj2 = 0 ;
31682 PyObject * obj3 = 0 ;
31683 char * kwnames[] = {
31684 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
31685 };
31686
31687 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
31688 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31689 if (!SWIG_IsOK(res1)) {
31690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
31691 }
31692 arg1 = reinterpret_cast< wxWindow * >(argp1);
31693 {
31694 arg2 = &temp2;
31695 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31696 }
31697 if (obj2) {
31698 {
31699 arg3 = &temp3;
31700 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
31701 }
31702 }
31703 if (obj3) {
31704 {
31705 arg4 = &temp4;
31706 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
31707 }
31708 }
31709 {
31710 PyThreadState* __tstate = wxPyBeginAllowThreads();
31711 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
31712 wxPyEndAllowThreads(__tstate);
31713 if (PyErr_Occurred()) SWIG_fail;
31714 }
31715 resultobj = SWIG_Py_Void();
31716 return resultobj;
31717 fail:
31718 return NULL;
31719 }
31720
31721
31722 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31723 PyObject *resultobj = 0;
31724 wxWindow *arg1 = (wxWindow *) 0 ;
31725 int arg2 ;
31726 int arg3 ;
31727 int arg4 = (int) -1 ;
31728 int arg5 = (int) -1 ;
31729 void *argp1 = 0 ;
31730 int res1 = 0 ;
31731 int val2 ;
31732 int ecode2 = 0 ;
31733 int val3 ;
31734 int ecode3 = 0 ;
31735 int val4 ;
31736 int ecode4 = 0 ;
31737 int val5 ;
31738 int ecode5 = 0 ;
31739 PyObject * obj0 = 0 ;
31740 PyObject * obj1 = 0 ;
31741 PyObject * obj2 = 0 ;
31742 PyObject * obj3 = 0 ;
31743 PyObject * obj4 = 0 ;
31744 char * kwnames[] = {
31745 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
31746 };
31747
31748 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
31749 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31750 if (!SWIG_IsOK(res1)) {
31751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
31752 }
31753 arg1 = reinterpret_cast< wxWindow * >(argp1);
31754 ecode2 = SWIG_AsVal_int(obj1, &val2);
31755 if (!SWIG_IsOK(ecode2)) {
31756 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "2"" of type '" "int""'");
31757 }
31758 arg2 = static_cast< int >(val2);
31759 ecode3 = SWIG_AsVal_int(obj2, &val3);
31760 if (!SWIG_IsOK(ecode3)) {
31761 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "3"" of type '" "int""'");
31762 }
31763 arg3 = static_cast< int >(val3);
31764 if (obj3) {
31765 ecode4 = SWIG_AsVal_int(obj3, &val4);
31766 if (!SWIG_IsOK(ecode4)) {
31767 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "4"" of type '" "int""'");
31768 }
31769 arg4 = static_cast< int >(val4);
31770 }
31771 if (obj4) {
31772 ecode5 = SWIG_AsVal_int(obj4, &val5);
31773 if (!SWIG_IsOK(ecode5)) {
31774 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "5"" of type '" "int""'");
31775 }
31776 arg5 = static_cast< int >(val5);
31777 }
31778 {
31779 PyThreadState* __tstate = wxPyBeginAllowThreads();
31780 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
31781 wxPyEndAllowThreads(__tstate);
31782 if (PyErr_Occurred()) SWIG_fail;
31783 }
31784 resultobj = SWIG_Py_Void();
31785 return resultobj;
31786 fail:
31787 return NULL;
31788 }
31789
31790
31791 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31792 PyObject *resultobj = 0;
31793 wxWindow *arg1 = (wxWindow *) 0 ;
31794 wxSize *arg2 = 0 ;
31795 wxSize const &arg3_defvalue = wxDefaultSize ;
31796 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
31797 void *argp1 = 0 ;
31798 int res1 = 0 ;
31799 wxSize temp2 ;
31800 wxSize temp3 ;
31801 PyObject * obj0 = 0 ;
31802 PyObject * obj1 = 0 ;
31803 PyObject * obj2 = 0 ;
31804 char * kwnames[] = {
31805 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
31806 };
31807
31808 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31809 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31810 if (!SWIG_IsOK(res1)) {
31811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
31812 }
31813 arg1 = reinterpret_cast< wxWindow * >(argp1);
31814 {
31815 arg2 = &temp2;
31816 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31817 }
31818 if (obj2) {
31819 {
31820 arg3 = &temp3;
31821 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
31822 }
31823 }
31824 {
31825 PyThreadState* __tstate = wxPyBeginAllowThreads();
31826 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
31827 wxPyEndAllowThreads(__tstate);
31828 if (PyErr_Occurred()) SWIG_fail;
31829 }
31830 resultobj = SWIG_Py_Void();
31831 return resultobj;
31832 fail:
31833 return NULL;
31834 }
31835
31836
31837 SWIGINTERN PyObject *_wrap_Window_GetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31838 PyObject *resultobj = 0;
31839 wxWindow *arg1 = (wxWindow *) 0 ;
31840 wxSize result;
31841 void *argp1 = 0 ;
31842 int res1 = 0 ;
31843 PyObject *swig_obj[1] ;
31844
31845 if (!args) SWIG_fail;
31846 swig_obj[0] = args;
31847 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31848 if (!SWIG_IsOK(res1)) {
31849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31850 }
31851 arg1 = reinterpret_cast< wxWindow * >(argp1);
31852 {
31853 PyThreadState* __tstate = wxPyBeginAllowThreads();
31854 result = ((wxWindow const *)arg1)->GetMaxSize();
31855 wxPyEndAllowThreads(__tstate);
31856 if (PyErr_Occurred()) SWIG_fail;
31857 }
31858 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31859 return resultobj;
31860 fail:
31861 return NULL;
31862 }
31863
31864
31865 SWIGINTERN PyObject *_wrap_Window_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31866 PyObject *resultobj = 0;
31867 wxWindow *arg1 = (wxWindow *) 0 ;
31868 wxSize result;
31869 void *argp1 = 0 ;
31870 int res1 = 0 ;
31871 PyObject *swig_obj[1] ;
31872
31873 if (!args) SWIG_fail;
31874 swig_obj[0] = args;
31875 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31876 if (!SWIG_IsOK(res1)) {
31877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31878 }
31879 arg1 = reinterpret_cast< wxWindow * >(argp1);
31880 {
31881 PyThreadState* __tstate = wxPyBeginAllowThreads();
31882 result = ((wxWindow const *)arg1)->GetMinSize();
31883 wxPyEndAllowThreads(__tstate);
31884 if (PyErr_Occurred()) SWIG_fail;
31885 }
31886 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31887 return resultobj;
31888 fail:
31889 return NULL;
31890 }
31891
31892
31893 SWIGINTERN PyObject *_wrap_Window_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31894 PyObject *resultobj = 0;
31895 wxWindow *arg1 = (wxWindow *) 0 ;
31896 wxSize *arg2 = 0 ;
31897 void *argp1 = 0 ;
31898 int res1 = 0 ;
31899 wxSize temp2 ;
31900 PyObject * obj0 = 0 ;
31901 PyObject * obj1 = 0 ;
31902 char * kwnames[] = {
31903 (char *) "self",(char *) "minSize", NULL
31904 };
31905
31906 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
31907 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31908 if (!SWIG_IsOK(res1)) {
31909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMinSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31910 }
31911 arg1 = reinterpret_cast< wxWindow * >(argp1);
31912 {
31913 arg2 = &temp2;
31914 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31915 }
31916 {
31917 PyThreadState* __tstate = wxPyBeginAllowThreads();
31918 (arg1)->SetMinSize((wxSize const &)*arg2);
31919 wxPyEndAllowThreads(__tstate);
31920 if (PyErr_Occurred()) SWIG_fail;
31921 }
31922 resultobj = SWIG_Py_Void();
31923 return resultobj;
31924 fail:
31925 return NULL;
31926 }
31927
31928
31929 SWIGINTERN PyObject *_wrap_Window_SetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31930 PyObject *resultobj = 0;
31931 wxWindow *arg1 = (wxWindow *) 0 ;
31932 wxSize *arg2 = 0 ;
31933 void *argp1 = 0 ;
31934 int res1 = 0 ;
31935 wxSize temp2 ;
31936 PyObject * obj0 = 0 ;
31937 PyObject * obj1 = 0 ;
31938 char * kwnames[] = {
31939 (char *) "self",(char *) "maxSize", NULL
31940 };
31941
31942 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) SWIG_fail;
31943 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31944 if (!SWIG_IsOK(res1)) {
31945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMaxSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31946 }
31947 arg1 = reinterpret_cast< wxWindow * >(argp1);
31948 {
31949 arg2 = &temp2;
31950 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31951 }
31952 {
31953 PyThreadState* __tstate = wxPyBeginAllowThreads();
31954 (arg1)->SetMaxSize((wxSize const &)*arg2);
31955 wxPyEndAllowThreads(__tstate);
31956 if (PyErr_Occurred()) SWIG_fail;
31957 }
31958 resultobj = SWIG_Py_Void();
31959 return resultobj;
31960 fail:
31961 return NULL;
31962 }
31963
31964
31965 SWIGINTERN PyObject *_wrap_Window_GetMinWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31966 PyObject *resultobj = 0;
31967 wxWindow *arg1 = (wxWindow *) 0 ;
31968 int result;
31969 void *argp1 = 0 ;
31970 int res1 = 0 ;
31971 PyObject *swig_obj[1] ;
31972
31973 if (!args) SWIG_fail;
31974 swig_obj[0] = args;
31975 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31976 if (!SWIG_IsOK(res1)) {
31977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
31978 }
31979 arg1 = reinterpret_cast< wxWindow * >(argp1);
31980 {
31981 PyThreadState* __tstate = wxPyBeginAllowThreads();
31982 result = (int)((wxWindow const *)arg1)->GetMinWidth();
31983 wxPyEndAllowThreads(__tstate);
31984 if (PyErr_Occurred()) SWIG_fail;
31985 }
31986 resultobj = SWIG_From_int(static_cast< int >(result));
31987 return resultobj;
31988 fail:
31989 return NULL;
31990 }
31991
31992
31993 SWIGINTERN PyObject *_wrap_Window_GetMinHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31994 PyObject *resultobj = 0;
31995 wxWindow *arg1 = (wxWindow *) 0 ;
31996 int result;
31997 void *argp1 = 0 ;
31998 int res1 = 0 ;
31999 PyObject *swig_obj[1] ;
32000
32001 if (!args) SWIG_fail;
32002 swig_obj[0] = args;
32003 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32004 if (!SWIG_IsOK(res1)) {
32005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
32006 }
32007 arg1 = reinterpret_cast< wxWindow * >(argp1);
32008 {
32009 PyThreadState* __tstate = wxPyBeginAllowThreads();
32010 result = (int)((wxWindow const *)arg1)->GetMinHeight();
32011 wxPyEndAllowThreads(__tstate);
32012 if (PyErr_Occurred()) SWIG_fail;
32013 }
32014 resultobj = SWIG_From_int(static_cast< int >(result));
32015 return resultobj;
32016 fail:
32017 return NULL;
32018 }
32019
32020
32021 SWIGINTERN PyObject *_wrap_Window_GetMaxWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32022 PyObject *resultobj = 0;
32023 wxWindow *arg1 = (wxWindow *) 0 ;
32024 int result;
32025 void *argp1 = 0 ;
32026 int res1 = 0 ;
32027 PyObject *swig_obj[1] ;
32028
32029 if (!args) SWIG_fail;
32030 swig_obj[0] = args;
32031 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32032 if (!SWIG_IsOK(res1)) {
32033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
32034 }
32035 arg1 = reinterpret_cast< wxWindow * >(argp1);
32036 {
32037 PyThreadState* __tstate = wxPyBeginAllowThreads();
32038 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
32039 wxPyEndAllowThreads(__tstate);
32040 if (PyErr_Occurred()) SWIG_fail;
32041 }
32042 resultobj = SWIG_From_int(static_cast< int >(result));
32043 return resultobj;
32044 fail:
32045 return NULL;
32046 }
32047
32048
32049 SWIGINTERN PyObject *_wrap_Window_GetMaxHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32050 PyObject *resultobj = 0;
32051 wxWindow *arg1 = (wxWindow *) 0 ;
32052 int result;
32053 void *argp1 = 0 ;
32054 int res1 = 0 ;
32055 PyObject *swig_obj[1] ;
32056
32057 if (!args) SWIG_fail;
32058 swig_obj[0] = args;
32059 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32060 if (!SWIG_IsOK(res1)) {
32061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
32062 }
32063 arg1 = reinterpret_cast< wxWindow * >(argp1);
32064 {
32065 PyThreadState* __tstate = wxPyBeginAllowThreads();
32066 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
32067 wxPyEndAllowThreads(__tstate);
32068 if (PyErr_Occurred()) SWIG_fail;
32069 }
32070 resultobj = SWIG_From_int(static_cast< int >(result));
32071 return resultobj;
32072 fail:
32073 return NULL;
32074 }
32075
32076
32077 SWIGINTERN PyObject *_wrap_Window_SetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32078 PyObject *resultobj = 0;
32079 wxWindow *arg1 = (wxWindow *) 0 ;
32080 wxSize *arg2 = 0 ;
32081 void *argp1 = 0 ;
32082 int res1 = 0 ;
32083 wxSize temp2 ;
32084 PyObject * obj0 = 0 ;
32085 PyObject * obj1 = 0 ;
32086 char * kwnames[] = {
32087 (char *) "self",(char *) "size", NULL
32088 };
32089
32090 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) SWIG_fail;
32091 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32092 if (!SWIG_IsOK(res1)) {
32093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSize" "', expected argument " "1"" of type '" "wxWindow *""'");
32094 }
32095 arg1 = reinterpret_cast< wxWindow * >(argp1);
32096 {
32097 arg2 = &temp2;
32098 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32099 }
32100 {
32101 PyThreadState* __tstate = wxPyBeginAllowThreads();
32102 (arg1)->SetVirtualSize((wxSize const &)*arg2);
32103 wxPyEndAllowThreads(__tstate);
32104 if (PyErr_Occurred()) SWIG_fail;
32105 }
32106 resultobj = SWIG_Py_Void();
32107 return resultobj;
32108 fail:
32109 return NULL;
32110 }
32111
32112
32113 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32114 PyObject *resultobj = 0;
32115 wxWindow *arg1 = (wxWindow *) 0 ;
32116 int arg2 ;
32117 int arg3 ;
32118 void *argp1 = 0 ;
32119 int res1 = 0 ;
32120 int val2 ;
32121 int ecode2 = 0 ;
32122 int val3 ;
32123 int ecode3 = 0 ;
32124 PyObject * obj0 = 0 ;
32125 PyObject * obj1 = 0 ;
32126 PyObject * obj2 = 0 ;
32127 char * kwnames[] = {
32128 (char *) "self",(char *) "w",(char *) "h", NULL
32129 };
32130
32131 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32132 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32133 if (!SWIG_IsOK(res1)) {
32134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
32135 }
32136 arg1 = reinterpret_cast< wxWindow * >(argp1);
32137 ecode2 = SWIG_AsVal_int(obj1, &val2);
32138 if (!SWIG_IsOK(ecode2)) {
32139 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "2"" of type '" "int""'");
32140 }
32141 arg2 = static_cast< int >(val2);
32142 ecode3 = SWIG_AsVal_int(obj2, &val3);
32143 if (!SWIG_IsOK(ecode3)) {
32144 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "3"" of type '" "int""'");
32145 }
32146 arg3 = static_cast< int >(val3);
32147 {
32148 PyThreadState* __tstate = wxPyBeginAllowThreads();
32149 (arg1)->SetVirtualSize(arg2,arg3);
32150 wxPyEndAllowThreads(__tstate);
32151 if (PyErr_Occurred()) SWIG_fail;
32152 }
32153 resultobj = SWIG_Py_Void();
32154 return resultobj;
32155 fail:
32156 return NULL;
32157 }
32158
32159
32160 SWIGINTERN PyObject *_wrap_Window_GetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32161 PyObject *resultobj = 0;
32162 wxWindow *arg1 = (wxWindow *) 0 ;
32163 wxSize result;
32164 void *argp1 = 0 ;
32165 int res1 = 0 ;
32166 PyObject *swig_obj[1] ;
32167
32168 if (!args) SWIG_fail;
32169 swig_obj[0] = args;
32170 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32171 if (!SWIG_IsOK(res1)) {
32172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32173 }
32174 arg1 = reinterpret_cast< wxWindow * >(argp1);
32175 {
32176 PyThreadState* __tstate = wxPyBeginAllowThreads();
32177 result = ((wxWindow const *)arg1)->GetVirtualSize();
32178 wxPyEndAllowThreads(__tstate);
32179 if (PyErr_Occurred()) SWIG_fail;
32180 }
32181 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32182 return resultobj;
32183 fail:
32184 return NULL;
32185 }
32186
32187
32188 SWIGINTERN PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32189 PyObject *resultobj = 0;
32190 wxWindow *arg1 = (wxWindow *) 0 ;
32191 int *arg2 = (int *) 0 ;
32192 int *arg3 = (int *) 0 ;
32193 void *argp1 = 0 ;
32194 int res1 = 0 ;
32195 int temp2 ;
32196 int res2 = SWIG_TMPOBJ ;
32197 int temp3 ;
32198 int res3 = SWIG_TMPOBJ ;
32199 PyObject *swig_obj[1] ;
32200
32201 arg2 = &temp2;
32202 arg3 = &temp3;
32203 if (!args) SWIG_fail;
32204 swig_obj[0] = args;
32205 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32206 if (!SWIG_IsOK(res1)) {
32207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
32208 }
32209 arg1 = reinterpret_cast< wxWindow * >(argp1);
32210 {
32211 PyThreadState* __tstate = wxPyBeginAllowThreads();
32212 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
32213 wxPyEndAllowThreads(__tstate);
32214 if (PyErr_Occurred()) SWIG_fail;
32215 }
32216 resultobj = SWIG_Py_Void();
32217 if (SWIG_IsTmpObj(res2)) {
32218 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
32219 } else {
32220 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32221 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
32222 }
32223 if (SWIG_IsTmpObj(res3)) {
32224 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
32225 } else {
32226 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32227 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
32228 }
32229 return resultobj;
32230 fail:
32231 return NULL;
32232 }
32233
32234
32235 SWIGINTERN PyObject *_wrap_Window_GetBestVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32236 PyObject *resultobj = 0;
32237 wxWindow *arg1 = (wxWindow *) 0 ;
32238 wxSize result;
32239 void *argp1 = 0 ;
32240 int res1 = 0 ;
32241 PyObject *swig_obj[1] ;
32242
32243 if (!args) SWIG_fail;
32244 swig_obj[0] = args;
32245 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32246 if (!SWIG_IsOK(res1)) {
32247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32248 }
32249 arg1 = reinterpret_cast< wxWindow * >(argp1);
32250 {
32251 PyThreadState* __tstate = wxPyBeginAllowThreads();
32252 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
32253 wxPyEndAllowThreads(__tstate);
32254 if (PyErr_Occurred()) SWIG_fail;
32255 }
32256 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32257 return resultobj;
32258 fail:
32259 return NULL;
32260 }
32261
32262
32263 SWIGINTERN PyObject *_wrap_Window_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32264 PyObject *resultobj = 0;
32265 wxWindow *arg1 = (wxWindow *) 0 ;
32266 bool arg2 = (bool) true ;
32267 bool result;
32268 void *argp1 = 0 ;
32269 int res1 = 0 ;
32270 bool val2 ;
32271 int ecode2 = 0 ;
32272 PyObject * obj0 = 0 ;
32273 PyObject * obj1 = 0 ;
32274 char * kwnames[] = {
32275 (char *) "self",(char *) "show", NULL
32276 };
32277
32278 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) SWIG_fail;
32279 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32280 if (!SWIG_IsOK(res1)) {
32281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Show" "', expected argument " "1"" of type '" "wxWindow *""'");
32282 }
32283 arg1 = reinterpret_cast< wxWindow * >(argp1);
32284 if (obj1) {
32285 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32286 if (!SWIG_IsOK(ecode2)) {
32287 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Show" "', expected argument " "2"" of type '" "bool""'");
32288 }
32289 arg2 = static_cast< bool >(val2);
32290 }
32291 {
32292 PyThreadState* __tstate = wxPyBeginAllowThreads();
32293 result = (bool)(arg1)->Show(arg2);
32294 wxPyEndAllowThreads(__tstate);
32295 if (PyErr_Occurred()) SWIG_fail;
32296 }
32297 {
32298 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32299 }
32300 return resultobj;
32301 fail:
32302 return NULL;
32303 }
32304
32305
32306 SWIGINTERN PyObject *_wrap_Window_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32307 PyObject *resultobj = 0;
32308 wxWindow *arg1 = (wxWindow *) 0 ;
32309 bool result;
32310 void *argp1 = 0 ;
32311 int res1 = 0 ;
32312 PyObject *swig_obj[1] ;
32313
32314 if (!args) SWIG_fail;
32315 swig_obj[0] = args;
32316 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32317 if (!SWIG_IsOK(res1)) {
32318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Hide" "', expected argument " "1"" of type '" "wxWindow *""'");
32319 }
32320 arg1 = reinterpret_cast< wxWindow * >(argp1);
32321 {
32322 PyThreadState* __tstate = wxPyBeginAllowThreads();
32323 result = (bool)(arg1)->Hide();
32324 wxPyEndAllowThreads(__tstate);
32325 if (PyErr_Occurred()) SWIG_fail;
32326 }
32327 {
32328 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32329 }
32330 return resultobj;
32331 fail:
32332 return NULL;
32333 }
32334
32335
32336 SWIGINTERN PyObject *_wrap_Window_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32337 PyObject *resultobj = 0;
32338 wxWindow *arg1 = (wxWindow *) 0 ;
32339 bool arg2 = (bool) true ;
32340 bool result;
32341 void *argp1 = 0 ;
32342 int res1 = 0 ;
32343 bool val2 ;
32344 int ecode2 = 0 ;
32345 PyObject * obj0 = 0 ;
32346 PyObject * obj1 = 0 ;
32347 char * kwnames[] = {
32348 (char *) "self",(char *) "enable", NULL
32349 };
32350
32351 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
32352 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32353 if (!SWIG_IsOK(res1)) {
32354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Enable" "', expected argument " "1"" of type '" "wxWindow *""'");
32355 }
32356 arg1 = reinterpret_cast< wxWindow * >(argp1);
32357 if (obj1) {
32358 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32359 if (!SWIG_IsOK(ecode2)) {
32360 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Enable" "', expected argument " "2"" of type '" "bool""'");
32361 }
32362 arg2 = static_cast< bool >(val2);
32363 }
32364 {
32365 PyThreadState* __tstate = wxPyBeginAllowThreads();
32366 result = (bool)(arg1)->Enable(arg2);
32367 wxPyEndAllowThreads(__tstate);
32368 if (PyErr_Occurred()) SWIG_fail;
32369 }
32370 {
32371 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32372 }
32373 return resultobj;
32374 fail:
32375 return NULL;
32376 }
32377
32378
32379 SWIGINTERN PyObject *_wrap_Window_Disable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32380 PyObject *resultobj = 0;
32381 wxWindow *arg1 = (wxWindow *) 0 ;
32382 bool result;
32383 void *argp1 = 0 ;
32384 int res1 = 0 ;
32385 PyObject *swig_obj[1] ;
32386
32387 if (!args) SWIG_fail;
32388 swig_obj[0] = args;
32389 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32390 if (!SWIG_IsOK(res1)) {
32391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Disable" "', expected argument " "1"" of type '" "wxWindow *""'");
32392 }
32393 arg1 = reinterpret_cast< wxWindow * >(argp1);
32394 {
32395 PyThreadState* __tstate = wxPyBeginAllowThreads();
32396 result = (bool)(arg1)->Disable();
32397 wxPyEndAllowThreads(__tstate);
32398 if (PyErr_Occurred()) SWIG_fail;
32399 }
32400 {
32401 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32402 }
32403 return resultobj;
32404 fail:
32405 return NULL;
32406 }
32407
32408
32409 SWIGINTERN PyObject *_wrap_Window_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32410 PyObject *resultobj = 0;
32411 wxWindow *arg1 = (wxWindow *) 0 ;
32412 bool result;
32413 void *argp1 = 0 ;
32414 int res1 = 0 ;
32415 PyObject *swig_obj[1] ;
32416
32417 if (!args) SWIG_fail;
32418 swig_obj[0] = args;
32419 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32420 if (!SWIG_IsOK(res1)) {
32421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShown" "', expected argument " "1"" of type '" "wxWindow const *""'");
32422 }
32423 arg1 = reinterpret_cast< wxWindow * >(argp1);
32424 {
32425 PyThreadState* __tstate = wxPyBeginAllowThreads();
32426 result = (bool)((wxWindow const *)arg1)->IsShown();
32427 wxPyEndAllowThreads(__tstate);
32428 if (PyErr_Occurred()) SWIG_fail;
32429 }
32430 {
32431 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32432 }
32433 return resultobj;
32434 fail:
32435 return NULL;
32436 }
32437
32438
32439 SWIGINTERN PyObject *_wrap_Window_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32440 PyObject *resultobj = 0;
32441 wxWindow *arg1 = (wxWindow *) 0 ;
32442 bool result;
32443 void *argp1 = 0 ;
32444 int res1 = 0 ;
32445 PyObject *swig_obj[1] ;
32446
32447 if (!args) SWIG_fail;
32448 swig_obj[0] = args;
32449 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32450 if (!SWIG_IsOK(res1)) {
32451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
32452 }
32453 arg1 = reinterpret_cast< wxWindow * >(argp1);
32454 {
32455 PyThreadState* __tstate = wxPyBeginAllowThreads();
32456 result = (bool)((wxWindow const *)arg1)->IsEnabled();
32457 wxPyEndAllowThreads(__tstate);
32458 if (PyErr_Occurred()) SWIG_fail;
32459 }
32460 {
32461 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32462 }
32463 return resultobj;
32464 fail:
32465 return NULL;
32466 }
32467
32468
32469 SWIGINTERN PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32470 PyObject *resultobj = 0;
32471 wxWindow *arg1 = (wxWindow *) 0 ;
32472 long arg2 ;
32473 void *argp1 = 0 ;
32474 int res1 = 0 ;
32475 long val2 ;
32476 int ecode2 = 0 ;
32477 PyObject * obj0 = 0 ;
32478 PyObject * obj1 = 0 ;
32479 char * kwnames[] = {
32480 (char *) "self",(char *) "style", NULL
32481 };
32482
32483 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) SWIG_fail;
32484 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32485 if (!SWIG_IsOK(res1)) {
32486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow *""'");
32487 }
32488 arg1 = reinterpret_cast< wxWindow * >(argp1);
32489 ecode2 = SWIG_AsVal_long(obj1, &val2);
32490 if (!SWIG_IsOK(ecode2)) {
32491 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "2"" of type '" "long""'");
32492 }
32493 arg2 = static_cast< long >(val2);
32494 {
32495 PyThreadState* __tstate = wxPyBeginAllowThreads();
32496 (arg1)->SetWindowStyleFlag(arg2);
32497 wxPyEndAllowThreads(__tstate);
32498 if (PyErr_Occurred()) SWIG_fail;
32499 }
32500 resultobj = SWIG_Py_Void();
32501 return resultobj;
32502 fail:
32503 return NULL;
32504 }
32505
32506
32507 SWIGINTERN PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32508 PyObject *resultobj = 0;
32509 wxWindow *arg1 = (wxWindow *) 0 ;
32510 long result;
32511 void *argp1 = 0 ;
32512 int res1 = 0 ;
32513 PyObject *swig_obj[1] ;
32514
32515 if (!args) SWIG_fail;
32516 swig_obj[0] = args;
32517 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32518 if (!SWIG_IsOK(res1)) {
32519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
32520 }
32521 arg1 = reinterpret_cast< wxWindow * >(argp1);
32522 {
32523 PyThreadState* __tstate = wxPyBeginAllowThreads();
32524 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
32525 wxPyEndAllowThreads(__tstate);
32526 if (PyErr_Occurred()) SWIG_fail;
32527 }
32528 resultobj = SWIG_From_long(static_cast< long >(result));
32529 return resultobj;
32530 fail:
32531 return NULL;
32532 }
32533
32534
32535 SWIGINTERN PyObject *_wrap_Window_HasFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32536 PyObject *resultobj = 0;
32537 wxWindow *arg1 = (wxWindow *) 0 ;
32538 int arg2 ;
32539 bool result;
32540 void *argp1 = 0 ;
32541 int res1 = 0 ;
32542 int val2 ;
32543 int ecode2 = 0 ;
32544 PyObject * obj0 = 0 ;
32545 PyObject * obj1 = 0 ;
32546 char * kwnames[] = {
32547 (char *) "self",(char *) "flag", NULL
32548 };
32549
32550 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) SWIG_fail;
32551 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32552 if (!SWIG_IsOK(res1)) {
32553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
32554 }
32555 arg1 = reinterpret_cast< wxWindow * >(argp1);
32556 ecode2 = SWIG_AsVal_int(obj1, &val2);
32557 if (!SWIG_IsOK(ecode2)) {
32558 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasFlag" "', expected argument " "2"" of type '" "int""'");
32559 }
32560 arg2 = static_cast< int >(val2);
32561 {
32562 PyThreadState* __tstate = wxPyBeginAllowThreads();
32563 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
32564 wxPyEndAllowThreads(__tstate);
32565 if (PyErr_Occurred()) SWIG_fail;
32566 }
32567 {
32568 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32569 }
32570 return resultobj;
32571 fail:
32572 return NULL;
32573 }
32574
32575
32576 SWIGINTERN PyObject *_wrap_Window_IsRetained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32577 PyObject *resultobj = 0;
32578 wxWindow *arg1 = (wxWindow *) 0 ;
32579 bool result;
32580 void *argp1 = 0 ;
32581 int res1 = 0 ;
32582 PyObject *swig_obj[1] ;
32583
32584 if (!args) SWIG_fail;
32585 swig_obj[0] = args;
32586 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32587 if (!SWIG_IsOK(res1)) {
32588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsRetained" "', expected argument " "1"" of type '" "wxWindow const *""'");
32589 }
32590 arg1 = reinterpret_cast< wxWindow * >(argp1);
32591 {
32592 PyThreadState* __tstate = wxPyBeginAllowThreads();
32593 result = (bool)((wxWindow const *)arg1)->IsRetained();
32594 wxPyEndAllowThreads(__tstate);
32595 if (PyErr_Occurred()) SWIG_fail;
32596 }
32597 {
32598 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32599 }
32600 return resultobj;
32601 fail:
32602 return NULL;
32603 }
32604
32605
32606 SWIGINTERN PyObject *_wrap_Window_SetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32607 PyObject *resultobj = 0;
32608 wxWindow *arg1 = (wxWindow *) 0 ;
32609 long arg2 ;
32610 void *argp1 = 0 ;
32611 int res1 = 0 ;
32612 long val2 ;
32613 int ecode2 = 0 ;
32614 PyObject * obj0 = 0 ;
32615 PyObject * obj1 = 0 ;
32616 char * kwnames[] = {
32617 (char *) "self",(char *) "exStyle", NULL
32618 };
32619
32620 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) SWIG_fail;
32621 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32622 if (!SWIG_IsOK(res1)) {
32623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetExtraStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
32624 }
32625 arg1 = reinterpret_cast< wxWindow * >(argp1);
32626 ecode2 = SWIG_AsVal_long(obj1, &val2);
32627 if (!SWIG_IsOK(ecode2)) {
32628 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetExtraStyle" "', expected argument " "2"" of type '" "long""'");
32629 }
32630 arg2 = static_cast< long >(val2);
32631 {
32632 PyThreadState* __tstate = wxPyBeginAllowThreads();
32633 (arg1)->SetExtraStyle(arg2);
32634 wxPyEndAllowThreads(__tstate);
32635 if (PyErr_Occurred()) SWIG_fail;
32636 }
32637 resultobj = SWIG_Py_Void();
32638 return resultobj;
32639 fail:
32640 return NULL;
32641 }
32642
32643
32644 SWIGINTERN PyObject *_wrap_Window_GetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32645 PyObject *resultobj = 0;
32646 wxWindow *arg1 = (wxWindow *) 0 ;
32647 long result;
32648 void *argp1 = 0 ;
32649 int res1 = 0 ;
32650 PyObject *swig_obj[1] ;
32651
32652 if (!args) SWIG_fail;
32653 swig_obj[0] = args;
32654 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32655 if (!SWIG_IsOK(res1)) {
32656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetExtraStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
32657 }
32658 arg1 = reinterpret_cast< wxWindow * >(argp1);
32659 {
32660 PyThreadState* __tstate = wxPyBeginAllowThreads();
32661 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
32662 wxPyEndAllowThreads(__tstate);
32663 if (PyErr_Occurred()) SWIG_fail;
32664 }
32665 resultobj = SWIG_From_long(static_cast< long >(result));
32666 return resultobj;
32667 fail:
32668 return NULL;
32669 }
32670
32671
32672 SWIGINTERN PyObject *_wrap_Window_MakeModal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32673 PyObject *resultobj = 0;
32674 wxWindow *arg1 = (wxWindow *) 0 ;
32675 bool arg2 = (bool) true ;
32676 void *argp1 = 0 ;
32677 int res1 = 0 ;
32678 bool val2 ;
32679 int ecode2 = 0 ;
32680 PyObject * obj0 = 0 ;
32681 PyObject * obj1 = 0 ;
32682 char * kwnames[] = {
32683 (char *) "self",(char *) "modal", NULL
32684 };
32685
32686 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) SWIG_fail;
32687 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32688 if (!SWIG_IsOK(res1)) {
32689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MakeModal" "', expected argument " "1"" of type '" "wxWindow *""'");
32690 }
32691 arg1 = reinterpret_cast< wxWindow * >(argp1);
32692 if (obj1) {
32693 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32694 if (!SWIG_IsOK(ecode2)) {
32695 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MakeModal" "', expected argument " "2"" of type '" "bool""'");
32696 }
32697 arg2 = static_cast< bool >(val2);
32698 }
32699 {
32700 PyThreadState* __tstate = wxPyBeginAllowThreads();
32701 (arg1)->MakeModal(arg2);
32702 wxPyEndAllowThreads(__tstate);
32703 if (PyErr_Occurred()) SWIG_fail;
32704 }
32705 resultobj = SWIG_Py_Void();
32706 return resultobj;
32707 fail:
32708 return NULL;
32709 }
32710
32711
32712 SWIGINTERN PyObject *_wrap_Window_SetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32713 PyObject *resultobj = 0;
32714 wxWindow *arg1 = (wxWindow *) 0 ;
32715 bool arg2 ;
32716 void *argp1 = 0 ;
32717 int res1 = 0 ;
32718 bool val2 ;
32719 int ecode2 = 0 ;
32720 PyObject * obj0 = 0 ;
32721 PyObject * obj1 = 0 ;
32722 char * kwnames[] = {
32723 (char *) "self",(char *) "enableTheme", NULL
32724 };
32725
32726 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
32727 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32728 if (!SWIG_IsOK(res1)) {
32729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow *""'");
32730 }
32731 arg1 = reinterpret_cast< wxWindow * >(argp1);
32732 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32733 if (!SWIG_IsOK(ecode2)) {
32734 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetThemeEnabled" "', expected argument " "2"" of type '" "bool""'");
32735 }
32736 arg2 = static_cast< bool >(val2);
32737 {
32738 PyThreadState* __tstate = wxPyBeginAllowThreads();
32739 (arg1)->SetThemeEnabled(arg2);
32740 wxPyEndAllowThreads(__tstate);
32741 if (PyErr_Occurred()) SWIG_fail;
32742 }
32743 resultobj = SWIG_Py_Void();
32744 return resultobj;
32745 fail:
32746 return NULL;
32747 }
32748
32749
32750 SWIGINTERN PyObject *_wrap_Window_GetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32751 PyObject *resultobj = 0;
32752 wxWindow *arg1 = (wxWindow *) 0 ;
32753 bool result;
32754 void *argp1 = 0 ;
32755 int res1 = 0 ;
32756 PyObject *swig_obj[1] ;
32757
32758 if (!args) SWIG_fail;
32759 swig_obj[0] = args;
32760 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32761 if (!SWIG_IsOK(res1)) {
32762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
32763 }
32764 arg1 = reinterpret_cast< wxWindow * >(argp1);
32765 {
32766 PyThreadState* __tstate = wxPyBeginAllowThreads();
32767 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
32768 wxPyEndAllowThreads(__tstate);
32769 if (PyErr_Occurred()) SWIG_fail;
32770 }
32771 {
32772 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32773 }
32774 return resultobj;
32775 fail:
32776 return NULL;
32777 }
32778
32779
32780 SWIGINTERN PyObject *_wrap_Window_SetFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32781 PyObject *resultobj = 0;
32782 wxWindow *arg1 = (wxWindow *) 0 ;
32783 void *argp1 = 0 ;
32784 int res1 = 0 ;
32785 PyObject *swig_obj[1] ;
32786
32787 if (!args) SWIG_fail;
32788 swig_obj[0] = args;
32789 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32790 if (!SWIG_IsOK(res1)) {
32791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocus" "', expected argument " "1"" of type '" "wxWindow *""'");
32792 }
32793 arg1 = reinterpret_cast< wxWindow * >(argp1);
32794 {
32795 PyThreadState* __tstate = wxPyBeginAllowThreads();
32796 (arg1)->SetFocus();
32797 wxPyEndAllowThreads(__tstate);
32798 if (PyErr_Occurred()) SWIG_fail;
32799 }
32800 resultobj = SWIG_Py_Void();
32801 return resultobj;
32802 fail:
32803 return NULL;
32804 }
32805
32806
32807 SWIGINTERN PyObject *_wrap_Window_SetFocusFromKbd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32808 PyObject *resultobj = 0;
32809 wxWindow *arg1 = (wxWindow *) 0 ;
32810 void *argp1 = 0 ;
32811 int res1 = 0 ;
32812 PyObject *swig_obj[1] ;
32813
32814 if (!args) SWIG_fail;
32815 swig_obj[0] = args;
32816 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32817 if (!SWIG_IsOK(res1)) {
32818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocusFromKbd" "', expected argument " "1"" of type '" "wxWindow *""'");
32819 }
32820 arg1 = reinterpret_cast< wxWindow * >(argp1);
32821 {
32822 PyThreadState* __tstate = wxPyBeginAllowThreads();
32823 (arg1)->SetFocusFromKbd();
32824 wxPyEndAllowThreads(__tstate);
32825 if (PyErr_Occurred()) SWIG_fail;
32826 }
32827 resultobj = SWIG_Py_Void();
32828 return resultobj;
32829 fail:
32830 return NULL;
32831 }
32832
32833
32834 SWIGINTERN PyObject *_wrap_Window_FindFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32835 PyObject *resultobj = 0;
32836 wxWindow *result = 0 ;
32837
32838 if (!SWIG_Python_UnpackTuple(args,"Window_FindFocus",0,0,0)) SWIG_fail;
32839 {
32840 if (!wxPyCheckForApp()) SWIG_fail;
32841 PyThreadState* __tstate = wxPyBeginAllowThreads();
32842 result = (wxWindow *)wxWindow::FindFocus();
32843 wxPyEndAllowThreads(__tstate);
32844 if (PyErr_Occurred()) SWIG_fail;
32845 }
32846 {
32847 resultobj = wxPyMake_wxObject(result, 0);
32848 }
32849 return resultobj;
32850 fail:
32851 return NULL;
32852 }
32853
32854
32855 SWIGINTERN PyObject *_wrap_Window_AcceptsFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32856 PyObject *resultobj = 0;
32857 wxWindow *arg1 = (wxWindow *) 0 ;
32858 bool result;
32859 void *argp1 = 0 ;
32860 int res1 = 0 ;
32861 PyObject *swig_obj[1] ;
32862
32863 if (!args) SWIG_fail;
32864 swig_obj[0] = args;
32865 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32866 if (!SWIG_IsOK(res1)) {
32867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
32868 }
32869 arg1 = reinterpret_cast< wxWindow * >(argp1);
32870 {
32871 PyThreadState* __tstate = wxPyBeginAllowThreads();
32872 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
32873 wxPyEndAllowThreads(__tstate);
32874 if (PyErr_Occurred()) SWIG_fail;
32875 }
32876 {
32877 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32878 }
32879 return resultobj;
32880 fail:
32881 return NULL;
32882 }
32883
32884
32885 SWIGINTERN PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32886 PyObject *resultobj = 0;
32887 wxWindow *arg1 = (wxWindow *) 0 ;
32888 bool result;
32889 void *argp1 = 0 ;
32890 int res1 = 0 ;
32891 PyObject *swig_obj[1] ;
32892
32893 if (!args) SWIG_fail;
32894 swig_obj[0] = args;
32895 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32896 if (!SWIG_IsOK(res1)) {
32897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
32898 }
32899 arg1 = reinterpret_cast< wxWindow * >(argp1);
32900 {
32901 PyThreadState* __tstate = wxPyBeginAllowThreads();
32902 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
32903 wxPyEndAllowThreads(__tstate);
32904 if (PyErr_Occurred()) SWIG_fail;
32905 }
32906 {
32907 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32908 }
32909 return resultobj;
32910 fail:
32911 return NULL;
32912 }
32913
32914
32915 SWIGINTERN PyObject *_wrap_Window_Navigate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32916 PyObject *resultobj = 0;
32917 wxWindow *arg1 = (wxWindow *) 0 ;
32918 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
32919 bool result;
32920 void *argp1 = 0 ;
32921 int res1 = 0 ;
32922 int val2 ;
32923 int ecode2 = 0 ;
32924 PyObject * obj0 = 0 ;
32925 PyObject * obj1 = 0 ;
32926 char * kwnames[] = {
32927 (char *) "self",(char *) "flags", NULL
32928 };
32929
32930 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) SWIG_fail;
32931 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32932 if (!SWIG_IsOK(res1)) {
32933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Navigate" "', expected argument " "1"" of type '" "wxWindow *""'");
32934 }
32935 arg1 = reinterpret_cast< wxWindow * >(argp1);
32936 if (obj1) {
32937 ecode2 = SWIG_AsVal_int(obj1, &val2);
32938 if (!SWIG_IsOK(ecode2)) {
32939 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Navigate" "', expected argument " "2"" of type '" "int""'");
32940 }
32941 arg2 = static_cast< int >(val2);
32942 }
32943 {
32944 PyThreadState* __tstate = wxPyBeginAllowThreads();
32945 result = (bool)(arg1)->Navigate(arg2);
32946 wxPyEndAllowThreads(__tstate);
32947 if (PyErr_Occurred()) SWIG_fail;
32948 }
32949 {
32950 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32951 }
32952 return resultobj;
32953 fail:
32954 return NULL;
32955 }
32956
32957
32958 SWIGINTERN PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32959 PyObject *resultobj = 0;
32960 wxWindow *arg1 = (wxWindow *) 0 ;
32961 wxWindow *arg2 = (wxWindow *) 0 ;
32962 void *argp1 = 0 ;
32963 int res1 = 0 ;
32964 void *argp2 = 0 ;
32965 int res2 = 0 ;
32966 PyObject * obj0 = 0 ;
32967 PyObject * obj1 = 0 ;
32968 char * kwnames[] = {
32969 (char *) "self",(char *) "win", NULL
32970 };
32971
32972 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
32973 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32974 if (!SWIG_IsOK(res1)) {
32975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
32976 }
32977 arg1 = reinterpret_cast< wxWindow * >(argp1);
32978 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32979 if (!SWIG_IsOK(res2)) {
32980 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
32981 }
32982 arg2 = reinterpret_cast< wxWindow * >(argp2);
32983 {
32984 PyThreadState* __tstate = wxPyBeginAllowThreads();
32985 (arg1)->MoveAfterInTabOrder(arg2);
32986 wxPyEndAllowThreads(__tstate);
32987 if (PyErr_Occurred()) SWIG_fail;
32988 }
32989 resultobj = SWIG_Py_Void();
32990 return resultobj;
32991 fail:
32992 return NULL;
32993 }
32994
32995
32996 SWIGINTERN PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32997 PyObject *resultobj = 0;
32998 wxWindow *arg1 = (wxWindow *) 0 ;
32999 wxWindow *arg2 = (wxWindow *) 0 ;
33000 void *argp1 = 0 ;
33001 int res1 = 0 ;
33002 void *argp2 = 0 ;
33003 int res2 = 0 ;
33004 PyObject * obj0 = 0 ;
33005 PyObject * obj1 = 0 ;
33006 char * kwnames[] = {
33007 (char *) "self",(char *) "win", NULL
33008 };
33009
33010 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
33011 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33012 if (!SWIG_IsOK(res1)) {
33013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
33014 }
33015 arg1 = reinterpret_cast< wxWindow * >(argp1);
33016 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33017 if (!SWIG_IsOK(res2)) {
33018 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
33019 }
33020 arg2 = reinterpret_cast< wxWindow * >(argp2);
33021 {
33022 PyThreadState* __tstate = wxPyBeginAllowThreads();
33023 (arg1)->MoveBeforeInTabOrder(arg2);
33024 wxPyEndAllowThreads(__tstate);
33025 if (PyErr_Occurred()) SWIG_fail;
33026 }
33027 resultobj = SWIG_Py_Void();
33028 return resultobj;
33029 fail:
33030 return NULL;
33031 }
33032
33033
33034 SWIGINTERN PyObject *_wrap_Window_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33035 PyObject *resultobj = 0;
33036 wxWindow *arg1 = (wxWindow *) 0 ;
33037 PyObject *result = 0 ;
33038 void *argp1 = 0 ;
33039 int res1 = 0 ;
33040 PyObject *swig_obj[1] ;
33041
33042 if (!args) SWIG_fail;
33043 swig_obj[0] = args;
33044 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33045 if (!SWIG_IsOK(res1)) {
33046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
33047 }
33048 arg1 = reinterpret_cast< wxWindow * >(argp1);
33049 {
33050 PyThreadState* __tstate = wxPyBeginAllowThreads();
33051 result = (PyObject *)wxWindow_GetChildren(arg1);
33052 wxPyEndAllowThreads(__tstate);
33053 if (PyErr_Occurred()) SWIG_fail;
33054 }
33055 resultobj = result;
33056 return resultobj;
33057 fail:
33058 return NULL;
33059 }
33060
33061
33062 SWIGINTERN PyObject *_wrap_Window_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33063 PyObject *resultobj = 0;
33064 wxWindow *arg1 = (wxWindow *) 0 ;
33065 wxWindow *result = 0 ;
33066 void *argp1 = 0 ;
33067 int res1 = 0 ;
33068 PyObject *swig_obj[1] ;
33069
33070 if (!args) SWIG_fail;
33071 swig_obj[0] = args;
33072 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33073 if (!SWIG_IsOK(res1)) {
33074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
33075 }
33076 arg1 = reinterpret_cast< wxWindow * >(argp1);
33077 {
33078 PyThreadState* __tstate = wxPyBeginAllowThreads();
33079 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
33080 wxPyEndAllowThreads(__tstate);
33081 if (PyErr_Occurred()) SWIG_fail;
33082 }
33083 {
33084 resultobj = wxPyMake_wxObject(result, 0);
33085 }
33086 return resultobj;
33087 fail:
33088 return NULL;
33089 }
33090
33091
33092 SWIGINTERN PyObject *_wrap_Window_GetGrandParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33093 PyObject *resultobj = 0;
33094 wxWindow *arg1 = (wxWindow *) 0 ;
33095 wxWindow *result = 0 ;
33096 void *argp1 = 0 ;
33097 int res1 = 0 ;
33098 PyObject *swig_obj[1] ;
33099
33100 if (!args) SWIG_fail;
33101 swig_obj[0] = args;
33102 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33103 if (!SWIG_IsOK(res1)) {
33104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetGrandParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
33105 }
33106 arg1 = reinterpret_cast< wxWindow * >(argp1);
33107 {
33108 PyThreadState* __tstate = wxPyBeginAllowThreads();
33109 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
33110 wxPyEndAllowThreads(__tstate);
33111 if (PyErr_Occurred()) SWIG_fail;
33112 }
33113 {
33114 resultobj = wxPyMake_wxObject(result, 0);
33115 }
33116 return resultobj;
33117 fail:
33118 return NULL;
33119 }
33120
33121
33122 SWIGINTERN PyObject *_wrap_Window_IsTopLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33123 PyObject *resultobj = 0;
33124 wxWindow *arg1 = (wxWindow *) 0 ;
33125 bool result;
33126 void *argp1 = 0 ;
33127 int res1 = 0 ;
33128 PyObject *swig_obj[1] ;
33129
33130 if (!args) SWIG_fail;
33131 swig_obj[0] = args;
33132 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33133 if (!SWIG_IsOK(res1)) {
33134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsTopLevel" "', expected argument " "1"" of type '" "wxWindow const *""'");
33135 }
33136 arg1 = reinterpret_cast< wxWindow * >(argp1);
33137 {
33138 PyThreadState* __tstate = wxPyBeginAllowThreads();
33139 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
33140 wxPyEndAllowThreads(__tstate);
33141 if (PyErr_Occurred()) SWIG_fail;
33142 }
33143 {
33144 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33145 }
33146 return resultobj;
33147 fail:
33148 return NULL;
33149 }
33150
33151
33152 SWIGINTERN PyObject *_wrap_Window_Reparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33153 PyObject *resultobj = 0;
33154 wxWindow *arg1 = (wxWindow *) 0 ;
33155 wxWindow *arg2 = (wxWindow *) 0 ;
33156 bool result;
33157 void *argp1 = 0 ;
33158 int res1 = 0 ;
33159 void *argp2 = 0 ;
33160 int res2 = 0 ;
33161 PyObject * obj0 = 0 ;
33162 PyObject * obj1 = 0 ;
33163 char * kwnames[] = {
33164 (char *) "self",(char *) "newParent", NULL
33165 };
33166
33167 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) SWIG_fail;
33168 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33169 if (!SWIG_IsOK(res1)) {
33170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Reparent" "', expected argument " "1"" of type '" "wxWindow *""'");
33171 }
33172 arg1 = reinterpret_cast< wxWindow * >(argp1);
33173 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33174 if (!SWIG_IsOK(res2)) {
33175 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Reparent" "', expected argument " "2"" of type '" "wxWindow *""'");
33176 }
33177 arg2 = reinterpret_cast< wxWindow * >(argp2);
33178 {
33179 PyThreadState* __tstate = wxPyBeginAllowThreads();
33180 result = (bool)(arg1)->Reparent(arg2);
33181 wxPyEndAllowThreads(__tstate);
33182 if (PyErr_Occurred()) SWIG_fail;
33183 }
33184 {
33185 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33186 }
33187 return resultobj;
33188 fail:
33189 return NULL;
33190 }
33191
33192
33193 SWIGINTERN PyObject *_wrap_Window_AddChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33194 PyObject *resultobj = 0;
33195 wxWindow *arg1 = (wxWindow *) 0 ;
33196 wxWindow *arg2 = (wxWindow *) 0 ;
33197 void *argp1 = 0 ;
33198 int res1 = 0 ;
33199 void *argp2 = 0 ;
33200 int res2 = 0 ;
33201 PyObject * obj0 = 0 ;
33202 PyObject * obj1 = 0 ;
33203 char * kwnames[] = {
33204 (char *) "self",(char *) "child", NULL
33205 };
33206
33207 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) SWIG_fail;
33208 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33209 if (!SWIG_IsOK(res1)) {
33210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AddChild" "', expected argument " "1"" of type '" "wxWindow *""'");
33211 }
33212 arg1 = reinterpret_cast< wxWindow * >(argp1);
33213 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33214 if (!SWIG_IsOK(res2)) {
33215 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_AddChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33216 }
33217 arg2 = reinterpret_cast< wxWindow * >(argp2);
33218 {
33219 PyThreadState* __tstate = wxPyBeginAllowThreads();
33220 (arg1)->AddChild(arg2);
33221 wxPyEndAllowThreads(__tstate);
33222 if (PyErr_Occurred()) SWIG_fail;
33223 }
33224 resultobj = SWIG_Py_Void();
33225 return resultobj;
33226 fail:
33227 return NULL;
33228 }
33229
33230
33231 SWIGINTERN PyObject *_wrap_Window_RemoveChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33232 PyObject *resultobj = 0;
33233 wxWindow *arg1 = (wxWindow *) 0 ;
33234 wxWindow *arg2 = (wxWindow *) 0 ;
33235 void *argp1 = 0 ;
33236 int res1 = 0 ;
33237 void *argp2 = 0 ;
33238 int res2 = 0 ;
33239 PyObject * obj0 = 0 ;
33240 PyObject * obj1 = 0 ;
33241 char * kwnames[] = {
33242 (char *) "self",(char *) "child", NULL
33243 };
33244
33245 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) SWIG_fail;
33246 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33247 if (!SWIG_IsOK(res1)) {
33248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveChild" "', expected argument " "1"" of type '" "wxWindow *""'");
33249 }
33250 arg1 = reinterpret_cast< wxWindow * >(argp1);
33251 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33252 if (!SWIG_IsOK(res2)) {
33253 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33254 }
33255 arg2 = reinterpret_cast< wxWindow * >(argp2);
33256 {
33257 PyThreadState* __tstate = wxPyBeginAllowThreads();
33258 (arg1)->RemoveChild(arg2);
33259 wxPyEndAllowThreads(__tstate);
33260 if (PyErr_Occurred()) SWIG_fail;
33261 }
33262 resultobj = SWIG_Py_Void();
33263 return resultobj;
33264 fail:
33265 return NULL;
33266 }
33267
33268
33269 SWIGINTERN PyObject *_wrap_Window_SetDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33270 PyObject *resultobj = 0;
33271 wxWindow *arg1 = (wxWindow *) 0 ;
33272 bool arg2 ;
33273 void *argp1 = 0 ;
33274 int res1 = 0 ;
33275 bool val2 ;
33276 int ecode2 = 0 ;
33277 PyObject * obj0 = 0 ;
33278 PyObject * obj1 = 0 ;
33279 char * kwnames[] = {
33280 (char *) "self",(char *) "on", NULL
33281 };
33282
33283 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDoubleBuffered",kwnames,&obj0,&obj1)) SWIG_fail;
33284 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33285 if (!SWIG_IsOK(res1)) {
33286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow *""'");
33287 }
33288 arg1 = reinterpret_cast< wxWindow * >(argp1);
33289 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33290 if (!SWIG_IsOK(ecode2)) {
33291 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDoubleBuffered" "', expected argument " "2"" of type '" "bool""'");
33292 }
33293 arg2 = static_cast< bool >(val2);
33294 {
33295 PyThreadState* __tstate = wxPyBeginAllowThreads();
33296 wxWindow_SetDoubleBuffered(arg1,arg2);
33297 wxPyEndAllowThreads(__tstate);
33298 if (PyErr_Occurred()) SWIG_fail;
33299 }
33300 resultobj = SWIG_Py_Void();
33301 return resultobj;
33302 fail:
33303 return NULL;
33304 }
33305
33306
33307 SWIGINTERN PyObject *_wrap_Window_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33308 PyObject *resultobj = 0;
33309 wxWindow *arg1 = (wxWindow *) 0 ;
33310 long arg2 ;
33311 wxWindow *result = 0 ;
33312 void *argp1 = 0 ;
33313 int res1 = 0 ;
33314 long val2 ;
33315 int ecode2 = 0 ;
33316 PyObject * obj0 = 0 ;
33317 PyObject * obj1 = 0 ;
33318 char * kwnames[] = {
33319 (char *) "self",(char *) "winid", NULL
33320 };
33321
33322 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
33323 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33324 if (!SWIG_IsOK(res1)) {
33325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowById" "', expected argument " "1"" of type '" "wxWindow *""'");
33326 }
33327 arg1 = reinterpret_cast< wxWindow * >(argp1);
33328 ecode2 = SWIG_AsVal_long(obj1, &val2);
33329 if (!SWIG_IsOK(ecode2)) {
33330 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FindWindowById" "', expected argument " "2"" of type '" "long""'");
33331 }
33332 arg2 = static_cast< long >(val2);
33333 {
33334 PyThreadState* __tstate = wxPyBeginAllowThreads();
33335 result = (wxWindow *)(arg1)->FindWindow(arg2);
33336 wxPyEndAllowThreads(__tstate);
33337 if (PyErr_Occurred()) SWIG_fail;
33338 }
33339 {
33340 resultobj = wxPyMake_wxObject(result, 0);
33341 }
33342 return resultobj;
33343 fail:
33344 return NULL;
33345 }
33346
33347
33348 SWIGINTERN PyObject *_wrap_Window_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33349 PyObject *resultobj = 0;
33350 wxWindow *arg1 = (wxWindow *) 0 ;
33351 wxString *arg2 = 0 ;
33352 wxWindow *result = 0 ;
33353 void *argp1 = 0 ;
33354 int res1 = 0 ;
33355 bool temp2 = false ;
33356 PyObject * obj0 = 0 ;
33357 PyObject * obj1 = 0 ;
33358 char * kwnames[] = {
33359 (char *) "self",(char *) "name", NULL
33360 };
33361
33362 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
33363 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33364 if (!SWIG_IsOK(res1)) {
33365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowByName" "', expected argument " "1"" of type '" "wxWindow *""'");
33366 }
33367 arg1 = reinterpret_cast< wxWindow * >(argp1);
33368 {
33369 arg2 = wxString_in_helper(obj1);
33370 if (arg2 == NULL) SWIG_fail;
33371 temp2 = true;
33372 }
33373 {
33374 PyThreadState* __tstate = wxPyBeginAllowThreads();
33375 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
33376 wxPyEndAllowThreads(__tstate);
33377 if (PyErr_Occurred()) SWIG_fail;
33378 }
33379 {
33380 resultobj = wxPyMake_wxObject(result, 0);
33381 }
33382 {
33383 if (temp2)
33384 delete arg2;
33385 }
33386 return resultobj;
33387 fail:
33388 {
33389 if (temp2)
33390 delete arg2;
33391 }
33392 return NULL;
33393 }
33394
33395
33396 SWIGINTERN PyObject *_wrap_Window_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33397 PyObject *resultobj = 0;
33398 wxWindow *arg1 = (wxWindow *) 0 ;
33399 wxEvtHandler *result = 0 ;
33400 void *argp1 = 0 ;
33401 int res1 = 0 ;
33402 PyObject *swig_obj[1] ;
33403
33404 if (!args) SWIG_fail;
33405 swig_obj[0] = args;
33406 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33407 if (!SWIG_IsOK(res1)) {
33408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEventHandler" "', expected argument " "1"" of type '" "wxWindow const *""'");
33409 }
33410 arg1 = reinterpret_cast< wxWindow * >(argp1);
33411 {
33412 PyThreadState* __tstate = wxPyBeginAllowThreads();
33413 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
33414 wxPyEndAllowThreads(__tstate);
33415 if (PyErr_Occurred()) SWIG_fail;
33416 }
33417 {
33418 resultobj = wxPyMake_wxObject(result, 0);
33419 }
33420 return resultobj;
33421 fail:
33422 return NULL;
33423 }
33424
33425
33426 SWIGINTERN PyObject *_wrap_Window_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33427 PyObject *resultobj = 0;
33428 wxWindow *arg1 = (wxWindow *) 0 ;
33429 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33430 void *argp1 = 0 ;
33431 int res1 = 0 ;
33432 void *argp2 = 0 ;
33433 int res2 = 0 ;
33434 PyObject * obj0 = 0 ;
33435 PyObject * obj1 = 0 ;
33436 char * kwnames[] = {
33437 (char *) "self",(char *) "handler", NULL
33438 };
33439
33440 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33441 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33442 if (!SWIG_IsOK(res1)) {
33443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33444 }
33445 arg1 = reinterpret_cast< wxWindow * >(argp1);
33446 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33447 if (!SWIG_IsOK(res2)) {
33448 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33449 }
33450 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33451 {
33452 PyThreadState* __tstate = wxPyBeginAllowThreads();
33453 (arg1)->SetEventHandler(arg2);
33454 wxPyEndAllowThreads(__tstate);
33455 if (PyErr_Occurred()) SWIG_fail;
33456 }
33457 resultobj = SWIG_Py_Void();
33458 return resultobj;
33459 fail:
33460 return NULL;
33461 }
33462
33463
33464 SWIGINTERN PyObject *_wrap_Window_PushEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33465 PyObject *resultobj = 0;
33466 wxWindow *arg1 = (wxWindow *) 0 ;
33467 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33468 void *argp1 = 0 ;
33469 int res1 = 0 ;
33470 void *argp2 = 0 ;
33471 int res2 = 0 ;
33472 PyObject * obj0 = 0 ;
33473 PyObject * obj1 = 0 ;
33474 char * kwnames[] = {
33475 (char *) "self",(char *) "handler", NULL
33476 };
33477
33478 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33479 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33480 if (!SWIG_IsOK(res1)) {
33481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PushEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33482 }
33483 arg1 = reinterpret_cast< wxWindow * >(argp1);
33484 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33485 if (!SWIG_IsOK(res2)) {
33486 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PushEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33487 }
33488 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33489 {
33490 PyThreadState* __tstate = wxPyBeginAllowThreads();
33491 (arg1)->PushEventHandler(arg2);
33492 wxPyEndAllowThreads(__tstate);
33493 if (PyErr_Occurred()) SWIG_fail;
33494 }
33495 resultobj = SWIG_Py_Void();
33496 return resultobj;
33497 fail:
33498 return NULL;
33499 }
33500
33501
33502 SWIGINTERN PyObject *_wrap_Window_PopEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33503 PyObject *resultobj = 0;
33504 wxWindow *arg1 = (wxWindow *) 0 ;
33505 bool arg2 = (bool) false ;
33506 wxEvtHandler *result = 0 ;
33507 void *argp1 = 0 ;
33508 int res1 = 0 ;
33509 bool val2 ;
33510 int ecode2 = 0 ;
33511 PyObject * obj0 = 0 ;
33512 PyObject * obj1 = 0 ;
33513 char * kwnames[] = {
33514 (char *) "self",(char *) "deleteHandler", NULL
33515 };
33516
33517 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33518 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33519 if (!SWIG_IsOK(res1)) {
33520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33521 }
33522 arg1 = reinterpret_cast< wxWindow * >(argp1);
33523 if (obj1) {
33524 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33525 if (!SWIG_IsOK(ecode2)) {
33526 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_PopEventHandler" "', expected argument " "2"" of type '" "bool""'");
33527 }
33528 arg2 = static_cast< bool >(val2);
33529 }
33530 {
33531 PyThreadState* __tstate = wxPyBeginAllowThreads();
33532 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
33533 wxPyEndAllowThreads(__tstate);
33534 if (PyErr_Occurred()) SWIG_fail;
33535 }
33536 {
33537 resultobj = wxPyMake_wxObject(result, 0);
33538 }
33539 return resultobj;
33540 fail:
33541 return NULL;
33542 }
33543
33544
33545 SWIGINTERN PyObject *_wrap_Window_RemoveEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33546 PyObject *resultobj = 0;
33547 wxWindow *arg1 = (wxWindow *) 0 ;
33548 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33549 bool result;
33550 void *argp1 = 0 ;
33551 int res1 = 0 ;
33552 void *argp2 = 0 ;
33553 int res2 = 0 ;
33554 PyObject * obj0 = 0 ;
33555 PyObject * obj1 = 0 ;
33556 char * kwnames[] = {
33557 (char *) "self",(char *) "handler", NULL
33558 };
33559
33560 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33561 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33562 if (!SWIG_IsOK(res1)) {
33563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33564 }
33565 arg1 = reinterpret_cast< wxWindow * >(argp1);
33566 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33567 if (!SWIG_IsOK(res2)) {
33568 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33569 }
33570 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33571 {
33572 PyThreadState* __tstate = wxPyBeginAllowThreads();
33573 result = (bool)(arg1)->RemoveEventHandler(arg2);
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_SetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33587 PyObject *resultobj = 0;
33588 wxWindow *arg1 = (wxWindow *) 0 ;
33589 wxValidator *arg2 = 0 ;
33590 void *argp1 = 0 ;
33591 int res1 = 0 ;
33592 void *argp2 = 0 ;
33593 int res2 = 0 ;
33594 PyObject * obj0 = 0 ;
33595 PyObject * obj1 = 0 ;
33596 char * kwnames[] = {
33597 (char *) "self",(char *) "validator", NULL
33598 };
33599
33600 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) SWIG_fail;
33601 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33602 if (!SWIG_IsOK(res1)) {
33603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
33604 }
33605 arg1 = reinterpret_cast< wxWindow * >(argp1);
33606 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxValidator, 0 | 0);
33607 if (!SWIG_IsOK(res2)) {
33608 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
33609 }
33610 if (!argp2) {
33611 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
33612 }
33613 arg2 = reinterpret_cast< wxValidator * >(argp2);
33614 {
33615 PyThreadState* __tstate = wxPyBeginAllowThreads();
33616 (arg1)->SetValidator((wxValidator const &)*arg2);
33617 wxPyEndAllowThreads(__tstate);
33618 if (PyErr_Occurred()) SWIG_fail;
33619 }
33620 resultobj = SWIG_Py_Void();
33621 return resultobj;
33622 fail:
33623 return NULL;
33624 }
33625
33626
33627 SWIGINTERN PyObject *_wrap_Window_GetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33628 PyObject *resultobj = 0;
33629 wxWindow *arg1 = (wxWindow *) 0 ;
33630 wxValidator *result = 0 ;
33631 void *argp1 = 0 ;
33632 int res1 = 0 ;
33633 PyObject *swig_obj[1] ;
33634
33635 if (!args) SWIG_fail;
33636 swig_obj[0] = args;
33637 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33638 if (!SWIG_IsOK(res1)) {
33639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
33640 }
33641 arg1 = reinterpret_cast< wxWindow * >(argp1);
33642 {
33643 PyThreadState* __tstate = wxPyBeginAllowThreads();
33644 result = (wxValidator *)(arg1)->GetValidator();
33645 wxPyEndAllowThreads(__tstate);
33646 if (PyErr_Occurred()) SWIG_fail;
33647 }
33648 {
33649 resultobj = wxPyMake_wxObject(result, (bool)0);
33650 }
33651 return resultobj;
33652 fail:
33653 return NULL;
33654 }
33655
33656
33657 SWIGINTERN PyObject *_wrap_Window_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33658 PyObject *resultobj = 0;
33659 wxWindow *arg1 = (wxWindow *) 0 ;
33660 bool result;
33661 void *argp1 = 0 ;
33662 int res1 = 0 ;
33663 PyObject *swig_obj[1] ;
33664
33665 if (!args) SWIG_fail;
33666 swig_obj[0] = args;
33667 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33668 if (!SWIG_IsOK(res1)) {
33669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Validate" "', expected argument " "1"" of type '" "wxWindow *""'");
33670 }
33671 arg1 = reinterpret_cast< wxWindow * >(argp1);
33672 {
33673 PyThreadState* __tstate = wxPyBeginAllowThreads();
33674 result = (bool)(arg1)->Validate();
33675 wxPyEndAllowThreads(__tstate);
33676 if (PyErr_Occurred()) SWIG_fail;
33677 }
33678 {
33679 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33680 }
33681 return resultobj;
33682 fail:
33683 return NULL;
33684 }
33685
33686
33687 SWIGINTERN PyObject *_wrap_Window_TransferDataToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33688 PyObject *resultobj = 0;
33689 wxWindow *arg1 = (wxWindow *) 0 ;
33690 bool result;
33691 void *argp1 = 0 ;
33692 int res1 = 0 ;
33693 PyObject *swig_obj[1] ;
33694
33695 if (!args) SWIG_fail;
33696 swig_obj[0] = args;
33697 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33698 if (!SWIG_IsOK(res1)) {
33699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataToWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
33700 }
33701 arg1 = reinterpret_cast< wxWindow * >(argp1);
33702 {
33703 PyThreadState* __tstate = wxPyBeginAllowThreads();
33704 result = (bool)(arg1)->TransferDataToWindow();
33705 wxPyEndAllowThreads(__tstate);
33706 if (PyErr_Occurred()) SWIG_fail;
33707 }
33708 {
33709 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33710 }
33711 return resultobj;
33712 fail:
33713 return NULL;
33714 }
33715
33716
33717 SWIGINTERN PyObject *_wrap_Window_TransferDataFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33718 PyObject *resultobj = 0;
33719 wxWindow *arg1 = (wxWindow *) 0 ;
33720 bool result;
33721 void *argp1 = 0 ;
33722 int res1 = 0 ;
33723 PyObject *swig_obj[1] ;
33724
33725 if (!args) SWIG_fail;
33726 swig_obj[0] = args;
33727 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33728 if (!SWIG_IsOK(res1)) {
33729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
33730 }
33731 arg1 = reinterpret_cast< wxWindow * >(argp1);
33732 {
33733 PyThreadState* __tstate = wxPyBeginAllowThreads();
33734 result = (bool)(arg1)->TransferDataFromWindow();
33735 wxPyEndAllowThreads(__tstate);
33736 if (PyErr_Occurred()) SWIG_fail;
33737 }
33738 {
33739 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33740 }
33741 return resultobj;
33742 fail:
33743 return NULL;
33744 }
33745
33746
33747 SWIGINTERN PyObject *_wrap_Window_InitDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33748 PyObject *resultobj = 0;
33749 wxWindow *arg1 = (wxWindow *) 0 ;
33750 void *argp1 = 0 ;
33751 int res1 = 0 ;
33752 PyObject *swig_obj[1] ;
33753
33754 if (!args) SWIG_fail;
33755 swig_obj[0] = args;
33756 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33757 if (!SWIG_IsOK(res1)) {
33758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InitDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
33759 }
33760 arg1 = reinterpret_cast< wxWindow * >(argp1);
33761 {
33762 PyThreadState* __tstate = wxPyBeginAllowThreads();
33763 (arg1)->InitDialog();
33764 wxPyEndAllowThreads(__tstate);
33765 if (PyErr_Occurred()) SWIG_fail;
33766 }
33767 resultobj = SWIG_Py_Void();
33768 return resultobj;
33769 fail:
33770 return NULL;
33771 }
33772
33773
33774 SWIGINTERN PyObject *_wrap_Window_SetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33775 PyObject *resultobj = 0;
33776 wxWindow *arg1 = (wxWindow *) 0 ;
33777 wxAcceleratorTable *arg2 = 0 ;
33778 void *argp1 = 0 ;
33779 int res1 = 0 ;
33780 void *argp2 = 0 ;
33781 int res2 = 0 ;
33782 PyObject * obj0 = 0 ;
33783 PyObject * obj1 = 0 ;
33784 char * kwnames[] = {
33785 (char *) "self",(char *) "accel", NULL
33786 };
33787
33788 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) SWIG_fail;
33789 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33790 if (!SWIG_IsOK(res1)) {
33791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
33792 }
33793 arg1 = reinterpret_cast< wxWindow * >(argp1);
33794 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAcceleratorTable, 0 | 0);
33795 if (!SWIG_IsOK(res2)) {
33796 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
33797 }
33798 if (!argp2) {
33799 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
33800 }
33801 arg2 = reinterpret_cast< wxAcceleratorTable * >(argp2);
33802 {
33803 PyThreadState* __tstate = wxPyBeginAllowThreads();
33804 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
33805 wxPyEndAllowThreads(__tstate);
33806 if (PyErr_Occurred()) SWIG_fail;
33807 }
33808 resultobj = SWIG_Py_Void();
33809 return resultobj;
33810 fail:
33811 return NULL;
33812 }
33813
33814
33815 SWIGINTERN PyObject *_wrap_Window_GetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33816 PyObject *resultobj = 0;
33817 wxWindow *arg1 = (wxWindow *) 0 ;
33818 wxAcceleratorTable *result = 0 ;
33819 void *argp1 = 0 ;
33820 int res1 = 0 ;
33821 PyObject *swig_obj[1] ;
33822
33823 if (!args) SWIG_fail;
33824 swig_obj[0] = args;
33825 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33826 if (!SWIG_IsOK(res1)) {
33827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
33828 }
33829 arg1 = reinterpret_cast< wxWindow * >(argp1);
33830 {
33831 PyThreadState* __tstate = wxPyBeginAllowThreads();
33832 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
33833 wxPyEndAllowThreads(__tstate);
33834 if (PyErr_Occurred()) SWIG_fail;
33835 }
33836 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
33837 return resultobj;
33838 fail:
33839 return NULL;
33840 }
33841
33842
33843 SWIGINTERN PyObject *_wrap_Window_RegisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33844 PyObject *resultobj = 0;
33845 wxWindow *arg1 = (wxWindow *) 0 ;
33846 int arg2 ;
33847 int arg3 ;
33848 int arg4 ;
33849 bool result;
33850 void *argp1 = 0 ;
33851 int res1 = 0 ;
33852 int val2 ;
33853 int ecode2 = 0 ;
33854 int val3 ;
33855 int ecode3 = 0 ;
33856 int val4 ;
33857 int ecode4 = 0 ;
33858 PyObject * obj0 = 0 ;
33859 PyObject * obj1 = 0 ;
33860 PyObject * obj2 = 0 ;
33861 PyObject * obj3 = 0 ;
33862 char * kwnames[] = {
33863 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
33864 };
33865
33866 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33867 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33868 if (!SWIG_IsOK(res1)) {
33869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RegisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
33870 }
33871 arg1 = reinterpret_cast< wxWindow * >(argp1);
33872 ecode2 = SWIG_AsVal_int(obj1, &val2);
33873 if (!SWIG_IsOK(ecode2)) {
33874 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_RegisterHotKey" "', expected argument " "2"" of type '" "int""'");
33875 }
33876 arg2 = static_cast< int >(val2);
33877 ecode3 = SWIG_AsVal_int(obj2, &val3);
33878 if (!SWIG_IsOK(ecode3)) {
33879 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RegisterHotKey" "', expected argument " "3"" of type '" "int""'");
33880 }
33881 arg3 = static_cast< int >(val3);
33882 ecode4 = SWIG_AsVal_int(obj3, &val4);
33883 if (!SWIG_IsOK(ecode4)) {
33884 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_RegisterHotKey" "', expected argument " "4"" of type '" "int""'");
33885 }
33886 arg4 = static_cast< int >(val4);
33887 {
33888 PyThreadState* __tstate = wxPyBeginAllowThreads();
33889 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
33890 wxPyEndAllowThreads(__tstate);
33891 if (PyErr_Occurred()) SWIG_fail;
33892 }
33893 {
33894 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33895 }
33896 return resultobj;
33897 fail:
33898 return NULL;
33899 }
33900
33901
33902 SWIGINTERN PyObject *_wrap_Window_UnregisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33903 PyObject *resultobj = 0;
33904 wxWindow *arg1 = (wxWindow *) 0 ;
33905 int arg2 ;
33906 bool result;
33907 void *argp1 = 0 ;
33908 int res1 = 0 ;
33909 int val2 ;
33910 int ecode2 = 0 ;
33911 PyObject * obj0 = 0 ;
33912 PyObject * obj1 = 0 ;
33913 char * kwnames[] = {
33914 (char *) "self",(char *) "hotkeyId", NULL
33915 };
33916
33917 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) SWIG_fail;
33918 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33919 if (!SWIG_IsOK(res1)) {
33920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UnregisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
33921 }
33922 arg1 = reinterpret_cast< wxWindow * >(argp1);
33923 ecode2 = SWIG_AsVal_int(obj1, &val2);
33924 if (!SWIG_IsOK(ecode2)) {
33925 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UnregisterHotKey" "', expected argument " "2"" of type '" "int""'");
33926 }
33927 arg2 = static_cast< int >(val2);
33928 {
33929 PyThreadState* __tstate = wxPyBeginAllowThreads();
33930 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
33931 wxPyEndAllowThreads(__tstate);
33932 if (PyErr_Occurred()) SWIG_fail;
33933 }
33934 {
33935 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33936 }
33937 return resultobj;
33938 fail:
33939 return NULL;
33940 }
33941
33942
33943 SWIGINTERN PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33944 PyObject *resultobj = 0;
33945 wxWindow *arg1 = (wxWindow *) 0 ;
33946 wxPoint *arg2 = 0 ;
33947 wxPoint result;
33948 void *argp1 = 0 ;
33949 int res1 = 0 ;
33950 wxPoint temp2 ;
33951 PyObject * obj0 = 0 ;
33952 PyObject * obj1 = 0 ;
33953 char * kwnames[] = {
33954 (char *) "self",(char *) "pt", NULL
33955 };
33956
33957 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
33958 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33959 if (!SWIG_IsOK(res1)) {
33960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogPointToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
33961 }
33962 arg1 = reinterpret_cast< wxWindow * >(argp1);
33963 {
33964 arg2 = &temp2;
33965 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
33966 }
33967 {
33968 PyThreadState* __tstate = wxPyBeginAllowThreads();
33969 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
33970 wxPyEndAllowThreads(__tstate);
33971 if (PyErr_Occurred()) SWIG_fail;
33972 }
33973 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
33974 return resultobj;
33975 fail:
33976 return NULL;
33977 }
33978
33979
33980 SWIGINTERN PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33981 PyObject *resultobj = 0;
33982 wxWindow *arg1 = (wxWindow *) 0 ;
33983 wxSize *arg2 = 0 ;
33984 wxSize result;
33985 void *argp1 = 0 ;
33986 int res1 = 0 ;
33987 wxSize temp2 ;
33988 PyObject * obj0 = 0 ;
33989 PyObject * obj1 = 0 ;
33990 char * kwnames[] = {
33991 (char *) "self",(char *) "sz", NULL
33992 };
33993
33994 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
33995 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33996 if (!SWIG_IsOK(res1)) {
33997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogSizeToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
33998 }
33999 arg1 = reinterpret_cast< wxWindow * >(argp1);
34000 {
34001 arg2 = &temp2;
34002 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34003 }
34004 {
34005 PyThreadState* __tstate = wxPyBeginAllowThreads();
34006 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
34007 wxPyEndAllowThreads(__tstate);
34008 if (PyErr_Occurred()) SWIG_fail;
34009 }
34010 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34011 return resultobj;
34012 fail:
34013 return NULL;
34014 }
34015
34016
34017 SWIGINTERN PyObject *_wrap_Window_DLG_PNT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34018 PyObject *resultobj = 0;
34019 wxWindow *arg1 = (wxWindow *) 0 ;
34020 wxPoint *arg2 = 0 ;
34021 wxPoint result;
34022 void *argp1 = 0 ;
34023 int res1 = 0 ;
34024 wxPoint temp2 ;
34025 PyObject * obj0 = 0 ;
34026 PyObject * obj1 = 0 ;
34027 char * kwnames[] = {
34028 (char *) "self",(char *) "pt", NULL
34029 };
34030
34031 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) SWIG_fail;
34032 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34033 if (!SWIG_IsOK(res1)) {
34034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_PNT" "', expected argument " "1"" of type '" "wxWindow *""'");
34035 }
34036 arg1 = reinterpret_cast< wxWindow * >(argp1);
34037 {
34038 arg2 = &temp2;
34039 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34040 }
34041 {
34042 PyThreadState* __tstate = wxPyBeginAllowThreads();
34043 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
34044 wxPyEndAllowThreads(__tstate);
34045 if (PyErr_Occurred()) SWIG_fail;
34046 }
34047 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34048 return resultobj;
34049 fail:
34050 return NULL;
34051 }
34052
34053
34054 SWIGINTERN PyObject *_wrap_Window_DLG_SZE(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34055 PyObject *resultobj = 0;
34056 wxWindow *arg1 = (wxWindow *) 0 ;
34057 wxSize *arg2 = 0 ;
34058 wxSize result;
34059 void *argp1 = 0 ;
34060 int res1 = 0 ;
34061 wxSize temp2 ;
34062 PyObject * obj0 = 0 ;
34063 PyObject * obj1 = 0 ;
34064 char * kwnames[] = {
34065 (char *) "self",(char *) "sz", NULL
34066 };
34067
34068 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) SWIG_fail;
34069 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34070 if (!SWIG_IsOK(res1)) {
34071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_SZE" "', expected argument " "1"" of type '" "wxWindow *""'");
34072 }
34073 arg1 = reinterpret_cast< wxWindow * >(argp1);
34074 {
34075 arg2 = &temp2;
34076 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34077 }
34078 {
34079 PyThreadState* __tstate = wxPyBeginAllowThreads();
34080 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
34081 wxPyEndAllowThreads(__tstate);
34082 if (PyErr_Occurred()) SWIG_fail;
34083 }
34084 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34085 return resultobj;
34086 fail:
34087 return NULL;
34088 }
34089
34090
34091 SWIGINTERN PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34092 PyObject *resultobj = 0;
34093 wxWindow *arg1 = (wxWindow *) 0 ;
34094 wxPoint *arg2 = 0 ;
34095 wxPoint result;
34096 void *argp1 = 0 ;
34097 int res1 = 0 ;
34098 wxPoint temp2 ;
34099 PyObject * obj0 = 0 ;
34100 PyObject * obj1 = 0 ;
34101 char * kwnames[] = {
34102 (char *) "self",(char *) "pt", NULL
34103 };
34104
34105 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
34106 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34107 if (!SWIG_IsOK(res1)) {
34108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelPointToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
34109 }
34110 arg1 = reinterpret_cast< wxWindow * >(argp1);
34111 {
34112 arg2 = &temp2;
34113 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34114 }
34115 {
34116 PyThreadState* __tstate = wxPyBeginAllowThreads();
34117 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
34118 wxPyEndAllowThreads(__tstate);
34119 if (PyErr_Occurred()) SWIG_fail;
34120 }
34121 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34122 return resultobj;
34123 fail:
34124 return NULL;
34125 }
34126
34127
34128 SWIGINTERN PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34129 PyObject *resultobj = 0;
34130 wxWindow *arg1 = (wxWindow *) 0 ;
34131 wxSize *arg2 = 0 ;
34132 wxSize result;
34133 void *argp1 = 0 ;
34134 int res1 = 0 ;
34135 wxSize temp2 ;
34136 PyObject * obj0 = 0 ;
34137 PyObject * obj1 = 0 ;
34138 char * kwnames[] = {
34139 (char *) "self",(char *) "sz", NULL
34140 };
34141
34142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
34143 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34144 if (!SWIG_IsOK(res1)) {
34145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelSizeToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
34146 }
34147 arg1 = reinterpret_cast< wxWindow * >(argp1);
34148 {
34149 arg2 = &temp2;
34150 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34151 }
34152 {
34153 PyThreadState* __tstate = wxPyBeginAllowThreads();
34154 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
34155 wxPyEndAllowThreads(__tstate);
34156 if (PyErr_Occurred()) SWIG_fail;
34157 }
34158 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34159 return resultobj;
34160 fail:
34161 return NULL;
34162 }
34163
34164
34165 SWIGINTERN PyObject *_wrap_Window_WarpPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34166 PyObject *resultobj = 0;
34167 wxWindow *arg1 = (wxWindow *) 0 ;
34168 int arg2 ;
34169 int arg3 ;
34170 void *argp1 = 0 ;
34171 int res1 = 0 ;
34172 int val2 ;
34173 int ecode2 = 0 ;
34174 int val3 ;
34175 int ecode3 = 0 ;
34176 PyObject * obj0 = 0 ;
34177 PyObject * obj1 = 0 ;
34178 PyObject * obj2 = 0 ;
34179 char * kwnames[] = {
34180 (char *) "self",(char *) "x",(char *) "y", NULL
34181 };
34182
34183 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34184 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34185 if (!SWIG_IsOK(res1)) {
34186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_WarpPointer" "', expected argument " "1"" of type '" "wxWindow *""'");
34187 }
34188 arg1 = reinterpret_cast< wxWindow * >(argp1);
34189 ecode2 = SWIG_AsVal_int(obj1, &val2);
34190 if (!SWIG_IsOK(ecode2)) {
34191 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_WarpPointer" "', expected argument " "2"" of type '" "int""'");
34192 }
34193 arg2 = static_cast< int >(val2);
34194 ecode3 = SWIG_AsVal_int(obj2, &val3);
34195 if (!SWIG_IsOK(ecode3)) {
34196 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_WarpPointer" "', expected argument " "3"" of type '" "int""'");
34197 }
34198 arg3 = static_cast< int >(val3);
34199 {
34200 PyThreadState* __tstate = wxPyBeginAllowThreads();
34201 (arg1)->WarpPointer(arg2,arg3);
34202 wxPyEndAllowThreads(__tstate);
34203 if (PyErr_Occurred()) SWIG_fail;
34204 }
34205 resultobj = SWIG_Py_Void();
34206 return resultobj;
34207 fail:
34208 return NULL;
34209 }
34210
34211
34212 SWIGINTERN PyObject *_wrap_Window_CaptureMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34213 PyObject *resultobj = 0;
34214 wxWindow *arg1 = (wxWindow *) 0 ;
34215 void *argp1 = 0 ;
34216 int res1 = 0 ;
34217 PyObject *swig_obj[1] ;
34218
34219 if (!args) SWIG_fail;
34220 swig_obj[0] = args;
34221 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34222 if (!SWIG_IsOK(res1)) {
34223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CaptureMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
34224 }
34225 arg1 = reinterpret_cast< wxWindow * >(argp1);
34226 {
34227 PyThreadState* __tstate = wxPyBeginAllowThreads();
34228 (arg1)->CaptureMouse();
34229 wxPyEndAllowThreads(__tstate);
34230 if (PyErr_Occurred()) SWIG_fail;
34231 }
34232 resultobj = SWIG_Py_Void();
34233 return resultobj;
34234 fail:
34235 return NULL;
34236 }
34237
34238
34239 SWIGINTERN PyObject *_wrap_Window_ReleaseMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34240 PyObject *resultobj = 0;
34241 wxWindow *arg1 = (wxWindow *) 0 ;
34242 void *argp1 = 0 ;
34243 int res1 = 0 ;
34244 PyObject *swig_obj[1] ;
34245
34246 if (!args) SWIG_fail;
34247 swig_obj[0] = args;
34248 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34249 if (!SWIG_IsOK(res1)) {
34250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ReleaseMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
34251 }
34252 arg1 = reinterpret_cast< wxWindow * >(argp1);
34253 {
34254 PyThreadState* __tstate = wxPyBeginAllowThreads();
34255 (arg1)->ReleaseMouse();
34256 wxPyEndAllowThreads(__tstate);
34257 if (PyErr_Occurred()) SWIG_fail;
34258 }
34259 resultobj = SWIG_Py_Void();
34260 return resultobj;
34261 fail:
34262 return NULL;
34263 }
34264
34265
34266 SWIGINTERN PyObject *_wrap_Window_GetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34267 PyObject *resultobj = 0;
34268 wxWindow *result = 0 ;
34269
34270 if (!SWIG_Python_UnpackTuple(args,"Window_GetCapture",0,0,0)) SWIG_fail;
34271 {
34272 if (!wxPyCheckForApp()) SWIG_fail;
34273 PyThreadState* __tstate = wxPyBeginAllowThreads();
34274 result = (wxWindow *)wxWindow::GetCapture();
34275 wxPyEndAllowThreads(__tstate);
34276 if (PyErr_Occurred()) SWIG_fail;
34277 }
34278 {
34279 resultobj = wxPyMake_wxObject(result, 0);
34280 }
34281 return resultobj;
34282 fail:
34283 return NULL;
34284 }
34285
34286
34287 SWIGINTERN PyObject *_wrap_Window_HasCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34288 PyObject *resultobj = 0;
34289 wxWindow *arg1 = (wxWindow *) 0 ;
34290 bool result;
34291 void *argp1 = 0 ;
34292 int res1 = 0 ;
34293 PyObject *swig_obj[1] ;
34294
34295 if (!args) SWIG_fail;
34296 swig_obj[0] = args;
34297 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34298 if (!SWIG_IsOK(res1)) {
34299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasCapture" "', expected argument " "1"" of type '" "wxWindow const *""'");
34300 }
34301 arg1 = reinterpret_cast< wxWindow * >(argp1);
34302 {
34303 PyThreadState* __tstate = wxPyBeginAllowThreads();
34304 result = (bool)((wxWindow const *)arg1)->HasCapture();
34305 wxPyEndAllowThreads(__tstate);
34306 if (PyErr_Occurred()) SWIG_fail;
34307 }
34308 {
34309 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34310 }
34311 return resultobj;
34312 fail:
34313 return NULL;
34314 }
34315
34316
34317 SWIGINTERN PyObject *_wrap_Window_Refresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34318 PyObject *resultobj = 0;
34319 wxWindow *arg1 = (wxWindow *) 0 ;
34320 bool arg2 = (bool) true ;
34321 wxRect *arg3 = (wxRect *) NULL ;
34322 void *argp1 = 0 ;
34323 int res1 = 0 ;
34324 bool val2 ;
34325 int ecode2 = 0 ;
34326 void *argp3 = 0 ;
34327 int res3 = 0 ;
34328 PyObject * obj0 = 0 ;
34329 PyObject * obj1 = 0 ;
34330 PyObject * obj2 = 0 ;
34331 char * kwnames[] = {
34332 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
34333 };
34334
34335 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34336 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34337 if (!SWIG_IsOK(res1)) {
34338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Refresh" "', expected argument " "1"" of type '" "wxWindow *""'");
34339 }
34340 arg1 = reinterpret_cast< wxWindow * >(argp1);
34341 if (obj1) {
34342 ecode2 = SWIG_AsVal_bool(obj1, &val2);
34343 if (!SWIG_IsOK(ecode2)) {
34344 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Refresh" "', expected argument " "2"" of type '" "bool""'");
34345 }
34346 arg2 = static_cast< bool >(val2);
34347 }
34348 if (obj2) {
34349 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxRect, 0 | 0 );
34350 if (!SWIG_IsOK(res3)) {
34351 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_Refresh" "', expected argument " "3"" of type '" "wxRect const *""'");
34352 }
34353 arg3 = reinterpret_cast< wxRect * >(argp3);
34354 }
34355 {
34356 PyThreadState* __tstate = wxPyBeginAllowThreads();
34357 (arg1)->Refresh(arg2,(wxRect const *)arg3);
34358 wxPyEndAllowThreads(__tstate);
34359 if (PyErr_Occurred()) SWIG_fail;
34360 }
34361 resultobj = SWIG_Py_Void();
34362 return resultobj;
34363 fail:
34364 return NULL;
34365 }
34366
34367
34368 SWIGINTERN PyObject *_wrap_Window_RefreshRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34369 PyObject *resultobj = 0;
34370 wxWindow *arg1 = (wxWindow *) 0 ;
34371 wxRect *arg2 = 0 ;
34372 bool arg3 = (bool) true ;
34373 void *argp1 = 0 ;
34374 int res1 = 0 ;
34375 wxRect temp2 ;
34376 bool val3 ;
34377 int ecode3 = 0 ;
34378 PyObject * obj0 = 0 ;
34379 PyObject * obj1 = 0 ;
34380 PyObject * obj2 = 0 ;
34381 char * kwnames[] = {
34382 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
34383 };
34384
34385 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34386 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34387 if (!SWIG_IsOK(res1)) {
34388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RefreshRect" "', expected argument " "1"" of type '" "wxWindow *""'");
34389 }
34390 arg1 = reinterpret_cast< wxWindow * >(argp1);
34391 {
34392 arg2 = &temp2;
34393 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34394 }
34395 if (obj2) {
34396 ecode3 = SWIG_AsVal_bool(obj2, &val3);
34397 if (!SWIG_IsOK(ecode3)) {
34398 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RefreshRect" "', expected argument " "3"" of type '" "bool""'");
34399 }
34400 arg3 = static_cast< bool >(val3);
34401 }
34402 {
34403 PyThreadState* __tstate = wxPyBeginAllowThreads();
34404 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
34405 wxPyEndAllowThreads(__tstate);
34406 if (PyErr_Occurred()) SWIG_fail;
34407 }
34408 resultobj = SWIG_Py_Void();
34409 return resultobj;
34410 fail:
34411 return NULL;
34412 }
34413
34414
34415 SWIGINTERN PyObject *_wrap_Window_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34416 PyObject *resultobj = 0;
34417 wxWindow *arg1 = (wxWindow *) 0 ;
34418 void *argp1 = 0 ;
34419 int res1 = 0 ;
34420 PyObject *swig_obj[1] ;
34421
34422 if (!args) SWIG_fail;
34423 swig_obj[0] = args;
34424 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34425 if (!SWIG_IsOK(res1)) {
34426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Update" "', expected argument " "1"" of type '" "wxWindow *""'");
34427 }
34428 arg1 = reinterpret_cast< wxWindow * >(argp1);
34429 {
34430 PyThreadState* __tstate = wxPyBeginAllowThreads();
34431 (arg1)->Update();
34432 wxPyEndAllowThreads(__tstate);
34433 if (PyErr_Occurred()) SWIG_fail;
34434 }
34435 resultobj = SWIG_Py_Void();
34436 return resultobj;
34437 fail:
34438 return NULL;
34439 }
34440
34441
34442 SWIGINTERN PyObject *_wrap_Window_ClearBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34443 PyObject *resultobj = 0;
34444 wxWindow *arg1 = (wxWindow *) 0 ;
34445 void *argp1 = 0 ;
34446 int res1 = 0 ;
34447 PyObject *swig_obj[1] ;
34448
34449 if (!args) SWIG_fail;
34450 swig_obj[0] = args;
34451 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34452 if (!SWIG_IsOK(res1)) {
34453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClearBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
34454 }
34455 arg1 = reinterpret_cast< wxWindow * >(argp1);
34456 {
34457 PyThreadState* __tstate = wxPyBeginAllowThreads();
34458 (arg1)->ClearBackground();
34459 wxPyEndAllowThreads(__tstate);
34460 if (PyErr_Occurred()) SWIG_fail;
34461 }
34462 resultobj = SWIG_Py_Void();
34463 return resultobj;
34464 fail:
34465 return NULL;
34466 }
34467
34468
34469 SWIGINTERN PyObject *_wrap_Window_Freeze(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34470 PyObject *resultobj = 0;
34471 wxWindow *arg1 = (wxWindow *) 0 ;
34472 void *argp1 = 0 ;
34473 int res1 = 0 ;
34474 PyObject *swig_obj[1] ;
34475
34476 if (!args) SWIG_fail;
34477 swig_obj[0] = args;
34478 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34479 if (!SWIG_IsOK(res1)) {
34480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Freeze" "', expected argument " "1"" of type '" "wxWindow *""'");
34481 }
34482 arg1 = reinterpret_cast< wxWindow * >(argp1);
34483 {
34484 PyThreadState* __tstate = wxPyBeginAllowThreads();
34485 (arg1)->Freeze();
34486 wxPyEndAllowThreads(__tstate);
34487 if (PyErr_Occurred()) SWIG_fail;
34488 }
34489 resultobj = SWIG_Py_Void();
34490 return resultobj;
34491 fail:
34492 return NULL;
34493 }
34494
34495
34496 SWIGINTERN PyObject *_wrap_Window_Thaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34497 PyObject *resultobj = 0;
34498 wxWindow *arg1 = (wxWindow *) 0 ;
34499 void *argp1 = 0 ;
34500 int res1 = 0 ;
34501 PyObject *swig_obj[1] ;
34502
34503 if (!args) SWIG_fail;
34504 swig_obj[0] = args;
34505 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34506 if (!SWIG_IsOK(res1)) {
34507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Thaw" "', expected argument " "1"" of type '" "wxWindow *""'");
34508 }
34509 arg1 = reinterpret_cast< wxWindow * >(argp1);
34510 {
34511 PyThreadState* __tstate = wxPyBeginAllowThreads();
34512 (arg1)->Thaw();
34513 wxPyEndAllowThreads(__tstate);
34514 if (PyErr_Occurred()) SWIG_fail;
34515 }
34516 resultobj = SWIG_Py_Void();
34517 return resultobj;
34518 fail:
34519 return NULL;
34520 }
34521
34522
34523 SWIGINTERN PyObject *_wrap_Window_PrepareDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34524 PyObject *resultobj = 0;
34525 wxWindow *arg1 = (wxWindow *) 0 ;
34526 wxDC *arg2 = 0 ;
34527 void *argp1 = 0 ;
34528 int res1 = 0 ;
34529 void *argp2 = 0 ;
34530 int res2 = 0 ;
34531 PyObject * obj0 = 0 ;
34532 PyObject * obj1 = 0 ;
34533 char * kwnames[] = {
34534 (char *) "self",(char *) "dc", NULL
34535 };
34536
34537 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) SWIG_fail;
34538 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34539 if (!SWIG_IsOK(res1)) {
34540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PrepareDC" "', expected argument " "1"" of type '" "wxWindow *""'");
34541 }
34542 arg1 = reinterpret_cast< wxWindow * >(argp1);
34543 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
34544 if (!SWIG_IsOK(res2)) {
34545 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
34546 }
34547 if (!argp2) {
34548 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
34549 }
34550 arg2 = reinterpret_cast< wxDC * >(argp2);
34551 {
34552 PyThreadState* __tstate = wxPyBeginAllowThreads();
34553 (arg1)->PrepareDC(*arg2);
34554 wxPyEndAllowThreads(__tstate);
34555 if (PyErr_Occurred()) SWIG_fail;
34556 }
34557 resultobj = SWIG_Py_Void();
34558 return resultobj;
34559 fail:
34560 return NULL;
34561 }
34562
34563
34564 SWIGINTERN PyObject *_wrap_Window_GetUpdateRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34565 PyObject *resultobj = 0;
34566 wxWindow *arg1 = (wxWindow *) 0 ;
34567 wxRegion *result = 0 ;
34568 void *argp1 = 0 ;
34569 int res1 = 0 ;
34570 PyObject *swig_obj[1] ;
34571
34572 if (!args) SWIG_fail;
34573 swig_obj[0] = args;
34574 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34575 if (!SWIG_IsOK(res1)) {
34576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateRegion" "', expected argument " "1"" of type '" "wxWindow *""'");
34577 }
34578 arg1 = reinterpret_cast< wxWindow * >(argp1);
34579 {
34580 PyThreadState* __tstate = wxPyBeginAllowThreads();
34581 {
34582 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
34583 result = (wxRegion *) &_result_ref;
34584 }
34585 wxPyEndAllowThreads(__tstate);
34586 if (PyErr_Occurred()) SWIG_fail;
34587 }
34588 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, 0 | 0 );
34589 return resultobj;
34590 fail:
34591 return NULL;
34592 }
34593
34594
34595 SWIGINTERN PyObject *_wrap_Window_GetUpdateClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34596 PyObject *resultobj = 0;
34597 wxWindow *arg1 = (wxWindow *) 0 ;
34598 wxRect result;
34599 void *argp1 = 0 ;
34600 int res1 = 0 ;
34601 PyObject *swig_obj[1] ;
34602
34603 if (!args) SWIG_fail;
34604 swig_obj[0] = args;
34605 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34606 if (!SWIG_IsOK(res1)) {
34607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34608 }
34609 arg1 = reinterpret_cast< wxWindow * >(argp1);
34610 {
34611 PyThreadState* __tstate = wxPyBeginAllowThreads();
34612 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
34613 wxPyEndAllowThreads(__tstate);
34614 if (PyErr_Occurred()) SWIG_fail;
34615 }
34616 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34617 return resultobj;
34618 fail:
34619 return NULL;
34620 }
34621
34622
34623 SWIGINTERN PyObject *_wrap_Window_IsExposed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34624 PyObject *resultobj = 0;
34625 wxWindow *arg1 = (wxWindow *) 0 ;
34626 int arg2 ;
34627 int arg3 ;
34628 int arg4 = (int) 1 ;
34629 int arg5 = (int) 1 ;
34630 bool result;
34631 void *argp1 = 0 ;
34632 int res1 = 0 ;
34633 int val2 ;
34634 int ecode2 = 0 ;
34635 int val3 ;
34636 int ecode3 = 0 ;
34637 int val4 ;
34638 int ecode4 = 0 ;
34639 int val5 ;
34640 int ecode5 = 0 ;
34641 PyObject * obj0 = 0 ;
34642 PyObject * obj1 = 0 ;
34643 PyObject * obj2 = 0 ;
34644 PyObject * obj3 = 0 ;
34645 PyObject * obj4 = 0 ;
34646 char * kwnames[] = {
34647 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
34648 };
34649
34650 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
34651 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34652 if (!SWIG_IsOK(res1)) {
34653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposed" "', expected argument " "1"" of type '" "wxWindow const *""'");
34654 }
34655 arg1 = reinterpret_cast< wxWindow * >(argp1);
34656 ecode2 = SWIG_AsVal_int(obj1, &val2);
34657 if (!SWIG_IsOK(ecode2)) {
34658 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_IsExposed" "', expected argument " "2"" of type '" "int""'");
34659 }
34660 arg2 = static_cast< int >(val2);
34661 ecode3 = SWIG_AsVal_int(obj2, &val3);
34662 if (!SWIG_IsOK(ecode3)) {
34663 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_IsExposed" "', expected argument " "3"" of type '" "int""'");
34664 }
34665 arg3 = static_cast< int >(val3);
34666 if (obj3) {
34667 ecode4 = SWIG_AsVal_int(obj3, &val4);
34668 if (!SWIG_IsOK(ecode4)) {
34669 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_IsExposed" "', expected argument " "4"" of type '" "int""'");
34670 }
34671 arg4 = static_cast< int >(val4);
34672 }
34673 if (obj4) {
34674 ecode5 = SWIG_AsVal_int(obj4, &val5);
34675 if (!SWIG_IsOK(ecode5)) {
34676 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_IsExposed" "', expected argument " "5"" of type '" "int""'");
34677 }
34678 arg5 = static_cast< int >(val5);
34679 }
34680 {
34681 PyThreadState* __tstate = wxPyBeginAllowThreads();
34682 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
34683 wxPyEndAllowThreads(__tstate);
34684 if (PyErr_Occurred()) SWIG_fail;
34685 }
34686 {
34687 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34688 }
34689 return resultobj;
34690 fail:
34691 return NULL;
34692 }
34693
34694
34695 SWIGINTERN PyObject *_wrap_Window_IsExposedPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34696 PyObject *resultobj = 0;
34697 wxWindow *arg1 = (wxWindow *) 0 ;
34698 wxPoint *arg2 = 0 ;
34699 bool result;
34700 void *argp1 = 0 ;
34701 int res1 = 0 ;
34702 wxPoint temp2 ;
34703 PyObject * obj0 = 0 ;
34704 PyObject * obj1 = 0 ;
34705 char * kwnames[] = {
34706 (char *) "self",(char *) "pt", NULL
34707 };
34708
34709 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) SWIG_fail;
34710 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34711 if (!SWIG_IsOK(res1)) {
34712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
34713 }
34714 arg1 = reinterpret_cast< wxWindow * >(argp1);
34715 {
34716 arg2 = &temp2;
34717 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34718 }
34719 {
34720 PyThreadState* __tstate = wxPyBeginAllowThreads();
34721 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
34722 wxPyEndAllowThreads(__tstate);
34723 if (PyErr_Occurred()) SWIG_fail;
34724 }
34725 {
34726 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34727 }
34728 return resultobj;
34729 fail:
34730 return NULL;
34731 }
34732
34733
34734 SWIGINTERN PyObject *_wrap_Window_IsExposedRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34735 PyObject *resultobj = 0;
34736 wxWindow *arg1 = (wxWindow *) 0 ;
34737 wxRect *arg2 = 0 ;
34738 bool result;
34739 void *argp1 = 0 ;
34740 int res1 = 0 ;
34741 wxRect temp2 ;
34742 PyObject * obj0 = 0 ;
34743 PyObject * obj1 = 0 ;
34744 char * kwnames[] = {
34745 (char *) "self",(char *) "rect", NULL
34746 };
34747
34748 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) SWIG_fail;
34749 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34750 if (!SWIG_IsOK(res1)) {
34751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34752 }
34753 arg1 = reinterpret_cast< wxWindow * >(argp1);
34754 {
34755 arg2 = &temp2;
34756 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34757 }
34758 {
34759 PyThreadState* __tstate = wxPyBeginAllowThreads();
34760 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
34761 wxPyEndAllowThreads(__tstate);
34762 if (PyErr_Occurred()) SWIG_fail;
34763 }
34764 {
34765 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34766 }
34767 return resultobj;
34768 fail:
34769 return NULL;
34770 }
34771
34772
34773 SWIGINTERN PyObject *_wrap_Window_GetDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34774 PyObject *resultobj = 0;
34775 wxWindow *arg1 = (wxWindow *) 0 ;
34776 SwigValueWrapper<wxVisualAttributes > result;
34777 void *argp1 = 0 ;
34778 int res1 = 0 ;
34779 PyObject *swig_obj[1] ;
34780
34781 if (!args) SWIG_fail;
34782 swig_obj[0] = args;
34783 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34784 if (!SWIG_IsOK(res1)) {
34785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultAttributes" "', expected argument " "1"" of type '" "wxWindow const *""'");
34786 }
34787 arg1 = reinterpret_cast< wxWindow * >(argp1);
34788 {
34789 PyThreadState* __tstate = wxPyBeginAllowThreads();
34790 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
34791 wxPyEndAllowThreads(__tstate);
34792 if (PyErr_Occurred()) SWIG_fail;
34793 }
34794 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
34795 return resultobj;
34796 fail:
34797 return NULL;
34798 }
34799
34800
34801 SWIGINTERN PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34802 PyObject *resultobj = 0;
34803 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
34804 SwigValueWrapper<wxVisualAttributes > result;
34805 int val1 ;
34806 int ecode1 = 0 ;
34807 PyObject * obj0 = 0 ;
34808 char * kwnames[] = {
34809 (char *) "variant", NULL
34810 };
34811
34812 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
34813 if (obj0) {
34814 ecode1 = SWIG_AsVal_int(obj0, &val1);
34815 if (!SWIG_IsOK(ecode1)) {
34816 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
34817 }
34818 arg1 = static_cast< wxWindowVariant >(val1);
34819 }
34820 {
34821 if (!wxPyCheckForApp()) SWIG_fail;
34822 PyThreadState* __tstate = wxPyBeginAllowThreads();
34823 result = wxWindow::GetClassDefaultAttributes(arg1);
34824 wxPyEndAllowThreads(__tstate);
34825 if (PyErr_Occurred()) SWIG_fail;
34826 }
34827 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
34828 return resultobj;
34829 fail:
34830 return NULL;
34831 }
34832
34833
34834 SWIGINTERN PyObject *_wrap_Window_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34835 PyObject *resultobj = 0;
34836 wxWindow *arg1 = (wxWindow *) 0 ;
34837 wxColour *arg2 = 0 ;
34838 bool result;
34839 void *argp1 = 0 ;
34840 int res1 = 0 ;
34841 wxColour temp2 ;
34842 PyObject * obj0 = 0 ;
34843 PyObject * obj1 = 0 ;
34844 char * kwnames[] = {
34845 (char *) "self",(char *) "colour", NULL
34846 };
34847
34848 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34849 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34850 if (!SWIG_IsOK(res1)) {
34851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34852 }
34853 arg1 = reinterpret_cast< wxWindow * >(argp1);
34854 {
34855 arg2 = &temp2;
34856 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34857 }
34858 {
34859 PyThreadState* __tstate = wxPyBeginAllowThreads();
34860 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
34861 wxPyEndAllowThreads(__tstate);
34862 if (PyErr_Occurred()) SWIG_fail;
34863 }
34864 {
34865 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34866 }
34867 return resultobj;
34868 fail:
34869 return NULL;
34870 }
34871
34872
34873 SWIGINTERN PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34874 PyObject *resultobj = 0;
34875 wxWindow *arg1 = (wxWindow *) 0 ;
34876 wxColour *arg2 = 0 ;
34877 void *argp1 = 0 ;
34878 int res1 = 0 ;
34879 wxColour temp2 ;
34880 PyObject * obj0 = 0 ;
34881 PyObject * obj1 = 0 ;
34882 char * kwnames[] = {
34883 (char *) "self",(char *) "colour", NULL
34884 };
34885
34886 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34887 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34888 if (!SWIG_IsOK(res1)) {
34889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34890 }
34891 arg1 = reinterpret_cast< wxWindow * >(argp1);
34892 {
34893 arg2 = &temp2;
34894 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34895 }
34896 {
34897 PyThreadState* __tstate = wxPyBeginAllowThreads();
34898 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
34899 wxPyEndAllowThreads(__tstate);
34900 if (PyErr_Occurred()) SWIG_fail;
34901 }
34902 resultobj = SWIG_Py_Void();
34903 return resultobj;
34904 fail:
34905 return NULL;
34906 }
34907
34908
34909 SWIGINTERN PyObject *_wrap_Window_SetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34910 PyObject *resultobj = 0;
34911 wxWindow *arg1 = (wxWindow *) 0 ;
34912 wxColour *arg2 = 0 ;
34913 bool result;
34914 void *argp1 = 0 ;
34915 int res1 = 0 ;
34916 wxColour temp2 ;
34917 PyObject * obj0 = 0 ;
34918 PyObject * obj1 = 0 ;
34919 char * kwnames[] = {
34920 (char *) "self",(char *) "colour", NULL
34921 };
34922
34923 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34924 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34925 if (!SWIG_IsOK(res1)) {
34926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34927 }
34928 arg1 = reinterpret_cast< wxWindow * >(argp1);
34929 {
34930 arg2 = &temp2;
34931 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34932 }
34933 {
34934 PyThreadState* __tstate = wxPyBeginAllowThreads();
34935 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
34936 wxPyEndAllowThreads(__tstate);
34937 if (PyErr_Occurred()) SWIG_fail;
34938 }
34939 {
34940 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34941 }
34942 return resultobj;
34943 fail:
34944 return NULL;
34945 }
34946
34947
34948 SWIGINTERN PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34949 PyObject *resultobj = 0;
34950 wxWindow *arg1 = (wxWindow *) 0 ;
34951 wxColour *arg2 = 0 ;
34952 void *argp1 = 0 ;
34953 int res1 = 0 ;
34954 wxColour temp2 ;
34955 PyObject * obj0 = 0 ;
34956 PyObject * obj1 = 0 ;
34957 char * kwnames[] = {
34958 (char *) "self",(char *) "colour", NULL
34959 };
34960
34961 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34962 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34963 if (!SWIG_IsOK(res1)) {
34964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34965 }
34966 arg1 = reinterpret_cast< wxWindow * >(argp1);
34967 {
34968 arg2 = &temp2;
34969 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34970 }
34971 {
34972 PyThreadState* __tstate = wxPyBeginAllowThreads();
34973 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
34974 wxPyEndAllowThreads(__tstate);
34975 if (PyErr_Occurred()) SWIG_fail;
34976 }
34977 resultobj = SWIG_Py_Void();
34978 return resultobj;
34979 fail:
34980 return NULL;
34981 }
34982
34983
34984 SWIGINTERN PyObject *_wrap_Window_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34985 PyObject *resultobj = 0;
34986 wxWindow *arg1 = (wxWindow *) 0 ;
34987 wxColour result;
34988 void *argp1 = 0 ;
34989 int res1 = 0 ;
34990 PyObject *swig_obj[1] ;
34991
34992 if (!args) SWIG_fail;
34993 swig_obj[0] = args;
34994 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34995 if (!SWIG_IsOK(res1)) {
34996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
34997 }
34998 arg1 = reinterpret_cast< wxWindow * >(argp1);
34999 {
35000 PyThreadState* __tstate = wxPyBeginAllowThreads();
35001 result = ((wxWindow const *)arg1)->GetBackgroundColour();
35002 wxPyEndAllowThreads(__tstate);
35003 if (PyErr_Occurred()) SWIG_fail;
35004 }
35005 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
35006 return resultobj;
35007 fail:
35008 return NULL;
35009 }
35010
35011
35012 SWIGINTERN PyObject *_wrap_Window_GetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35013 PyObject *resultobj = 0;
35014 wxWindow *arg1 = (wxWindow *) 0 ;
35015 wxColour result;
35016 void *argp1 = 0 ;
35017 int res1 = 0 ;
35018 PyObject *swig_obj[1] ;
35019
35020 if (!args) SWIG_fail;
35021 swig_obj[0] = args;
35022 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35023 if (!SWIG_IsOK(res1)) {
35024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetForegroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
35025 }
35026 arg1 = reinterpret_cast< wxWindow * >(argp1);
35027 {
35028 PyThreadState* __tstate = wxPyBeginAllowThreads();
35029 result = ((wxWindow const *)arg1)->GetForegroundColour();
35030 wxPyEndAllowThreads(__tstate);
35031 if (PyErr_Occurred()) SWIG_fail;
35032 }
35033 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
35034 return resultobj;
35035 fail:
35036 return NULL;
35037 }
35038
35039
35040 SWIGINTERN PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35041 PyObject *resultobj = 0;
35042 wxWindow *arg1 = (wxWindow *) 0 ;
35043 bool result;
35044 void *argp1 = 0 ;
35045 int res1 = 0 ;
35046 PyObject *swig_obj[1] ;
35047
35048 if (!args) SWIG_fail;
35049 swig_obj[0] = args;
35050 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35051 if (!SWIG_IsOK(res1)) {
35052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritsBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
35053 }
35054 arg1 = reinterpret_cast< wxWindow * >(argp1);
35055 {
35056 PyThreadState* __tstate = wxPyBeginAllowThreads();
35057 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
35058 wxPyEndAllowThreads(__tstate);
35059 if (PyErr_Occurred()) SWIG_fail;
35060 }
35061 {
35062 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35063 }
35064 return resultobj;
35065 fail:
35066 return NULL;
35067 }
35068
35069
35070 SWIGINTERN PyObject *_wrap_Window_UseBgCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35071 PyObject *resultobj = 0;
35072 wxWindow *arg1 = (wxWindow *) 0 ;
35073 bool result;
35074 void *argp1 = 0 ;
35075 int res1 = 0 ;
35076 PyObject *swig_obj[1] ;
35077
35078 if (!args) SWIG_fail;
35079 swig_obj[0] = args;
35080 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35081 if (!SWIG_IsOK(res1)) {
35082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UseBgCol" "', expected argument " "1"" of type '" "wxWindow const *""'");
35083 }
35084 arg1 = reinterpret_cast< wxWindow * >(argp1);
35085 {
35086 PyThreadState* __tstate = wxPyBeginAllowThreads();
35087 result = (bool)((wxWindow const *)arg1)->UseBgCol();
35088 wxPyEndAllowThreads(__tstate);
35089 if (PyErr_Occurred()) SWIG_fail;
35090 }
35091 {
35092 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35093 }
35094 return resultobj;
35095 fail:
35096 return NULL;
35097 }
35098
35099
35100 SWIGINTERN PyObject *_wrap_Window_SetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35101 PyObject *resultobj = 0;
35102 wxWindow *arg1 = (wxWindow *) 0 ;
35103 wxBackgroundStyle arg2 ;
35104 bool result;
35105 void *argp1 = 0 ;
35106 int res1 = 0 ;
35107 int val2 ;
35108 int ecode2 = 0 ;
35109 PyObject * obj0 = 0 ;
35110 PyObject * obj1 = 0 ;
35111 char * kwnames[] = {
35112 (char *) "self",(char *) "style", NULL
35113 };
35114
35115 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) SWIG_fail;
35116 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35117 if (!SWIG_IsOK(res1)) {
35118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
35119 }
35120 arg1 = reinterpret_cast< wxWindow * >(argp1);
35121 ecode2 = SWIG_AsVal_int(obj1, &val2);
35122 if (!SWIG_IsOK(ecode2)) {
35123 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetBackgroundStyle" "', expected argument " "2"" of type '" "wxBackgroundStyle""'");
35124 }
35125 arg2 = static_cast< wxBackgroundStyle >(val2);
35126 {
35127 PyThreadState* __tstate = wxPyBeginAllowThreads();
35128 result = (bool)(arg1)->SetBackgroundStyle(arg2);
35129 wxPyEndAllowThreads(__tstate);
35130 if (PyErr_Occurred()) SWIG_fail;
35131 }
35132 {
35133 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35134 }
35135 return resultobj;
35136 fail:
35137 return NULL;
35138 }
35139
35140
35141 SWIGINTERN PyObject *_wrap_Window_GetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35142 PyObject *resultobj = 0;
35143 wxWindow *arg1 = (wxWindow *) 0 ;
35144 wxBackgroundStyle result;
35145 void *argp1 = 0 ;
35146 int res1 = 0 ;
35147 PyObject *swig_obj[1] ;
35148
35149 if (!args) SWIG_fail;
35150 swig_obj[0] = args;
35151 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35152 if (!SWIG_IsOK(res1)) {
35153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
35154 }
35155 arg1 = reinterpret_cast< wxWindow * >(argp1);
35156 {
35157 PyThreadState* __tstate = wxPyBeginAllowThreads();
35158 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
35159 wxPyEndAllowThreads(__tstate);
35160 if (PyErr_Occurred()) SWIG_fail;
35161 }
35162 resultobj = SWIG_From_int(static_cast< int >(result));
35163 return resultobj;
35164 fail:
35165 return NULL;
35166 }
35167
35168
35169 SWIGINTERN PyObject *_wrap_Window_HasTransparentBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35170 PyObject *resultobj = 0;
35171 wxWindow *arg1 = (wxWindow *) 0 ;
35172 bool result;
35173 void *argp1 = 0 ;
35174 int res1 = 0 ;
35175 PyObject *swig_obj[1] ;
35176
35177 if (!args) SWIG_fail;
35178 swig_obj[0] = args;
35179 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35180 if (!SWIG_IsOK(res1)) {
35181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasTransparentBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
35182 }
35183 arg1 = reinterpret_cast< wxWindow * >(argp1);
35184 {
35185 PyThreadState* __tstate = wxPyBeginAllowThreads();
35186 result = (bool)(arg1)->HasTransparentBackground();
35187 wxPyEndAllowThreads(__tstate);
35188 if (PyErr_Occurred()) SWIG_fail;
35189 }
35190 {
35191 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35192 }
35193 return resultobj;
35194 fail:
35195 return NULL;
35196 }
35197
35198
35199 SWIGINTERN PyObject *_wrap_Window_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35200 PyObject *resultobj = 0;
35201 wxWindow *arg1 = (wxWindow *) 0 ;
35202 wxCursor *arg2 = 0 ;
35203 bool result;
35204 void *argp1 = 0 ;
35205 int res1 = 0 ;
35206 void *argp2 = 0 ;
35207 int res2 = 0 ;
35208 PyObject * obj0 = 0 ;
35209 PyObject * obj1 = 0 ;
35210 char * kwnames[] = {
35211 (char *) "self",(char *) "cursor", NULL
35212 };
35213
35214 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
35215 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35216 if (!SWIG_IsOK(res1)) {
35217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
35218 }
35219 arg1 = reinterpret_cast< wxWindow * >(argp1);
35220 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
35221 if (!SWIG_IsOK(res2)) {
35222 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
35223 }
35224 if (!argp2) {
35225 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
35226 }
35227 arg2 = reinterpret_cast< wxCursor * >(argp2);
35228 {
35229 PyThreadState* __tstate = wxPyBeginAllowThreads();
35230 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
35231 wxPyEndAllowThreads(__tstate);
35232 if (PyErr_Occurred()) SWIG_fail;
35233 }
35234 {
35235 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35236 }
35237 return resultobj;
35238 fail:
35239 return NULL;
35240 }
35241
35242
35243 SWIGINTERN PyObject *_wrap_Window_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35244 PyObject *resultobj = 0;
35245 wxWindow *arg1 = (wxWindow *) 0 ;
35246 wxCursor result;
35247 void *argp1 = 0 ;
35248 int res1 = 0 ;
35249 PyObject *swig_obj[1] ;
35250
35251 if (!args) SWIG_fail;
35252 swig_obj[0] = args;
35253 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35254 if (!SWIG_IsOK(res1)) {
35255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
35256 }
35257 arg1 = reinterpret_cast< wxWindow * >(argp1);
35258 {
35259 PyThreadState* __tstate = wxPyBeginAllowThreads();
35260 result = (arg1)->GetCursor();
35261 wxPyEndAllowThreads(__tstate);
35262 if (PyErr_Occurred()) SWIG_fail;
35263 }
35264 resultobj = SWIG_NewPointerObj((new wxCursor(static_cast< const wxCursor& >(result))), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );
35265 return resultobj;
35266 fail:
35267 return NULL;
35268 }
35269
35270
35271 SWIGINTERN PyObject *_wrap_Window_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35272 PyObject *resultobj = 0;
35273 wxWindow *arg1 = (wxWindow *) 0 ;
35274 wxFont *arg2 = 0 ;
35275 bool result;
35276 void *argp1 = 0 ;
35277 int res1 = 0 ;
35278 void *argp2 = 0 ;
35279 int res2 = 0 ;
35280 PyObject * obj0 = 0 ;
35281 PyObject * obj1 = 0 ;
35282 char * kwnames[] = {
35283 (char *) "self",(char *) "font", NULL
35284 };
35285
35286 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
35287 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35288 if (!SWIG_IsOK(res1)) {
35289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35290 }
35291 arg1 = reinterpret_cast< wxWindow * >(argp1);
35292 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
35293 if (!SWIG_IsOK(res2)) {
35294 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35295 }
35296 if (!argp2) {
35297 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35298 }
35299 arg2 = reinterpret_cast< wxFont * >(argp2);
35300 {
35301 PyThreadState* __tstate = wxPyBeginAllowThreads();
35302 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
35303 wxPyEndAllowThreads(__tstate);
35304 if (PyErr_Occurred()) SWIG_fail;
35305 }
35306 {
35307 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35308 }
35309 return resultobj;
35310 fail:
35311 return NULL;
35312 }
35313
35314
35315 SWIGINTERN PyObject *_wrap_Window_SetOwnFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35316 PyObject *resultobj = 0;
35317 wxWindow *arg1 = (wxWindow *) 0 ;
35318 wxFont *arg2 = 0 ;
35319 void *argp1 = 0 ;
35320 int res1 = 0 ;
35321 void *argp2 = 0 ;
35322 int res2 = 0 ;
35323 PyObject * obj0 = 0 ;
35324 PyObject * obj1 = 0 ;
35325 char * kwnames[] = {
35326 (char *) "self",(char *) "font", NULL
35327 };
35328
35329 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) SWIG_fail;
35330 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35331 if (!SWIG_IsOK(res1)) {
35332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35333 }
35334 arg1 = reinterpret_cast< wxWindow * >(argp1);
35335 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
35336 if (!SWIG_IsOK(res2)) {
35337 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35338 }
35339 if (!argp2) {
35340 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35341 }
35342 arg2 = reinterpret_cast< wxFont * >(argp2);
35343 {
35344 PyThreadState* __tstate = wxPyBeginAllowThreads();
35345 (arg1)->SetOwnFont((wxFont const &)*arg2);
35346 wxPyEndAllowThreads(__tstate);
35347 if (PyErr_Occurred()) SWIG_fail;
35348 }
35349 resultobj = SWIG_Py_Void();
35350 return resultobj;
35351 fail:
35352 return NULL;
35353 }
35354
35355
35356 SWIGINTERN PyObject *_wrap_Window_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35357 PyObject *resultobj = 0;
35358 wxWindow *arg1 = (wxWindow *) 0 ;
35359 wxFont result;
35360 void *argp1 = 0 ;
35361 int res1 = 0 ;
35362 PyObject *swig_obj[1] ;
35363
35364 if (!args) SWIG_fail;
35365 swig_obj[0] = args;
35366 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35367 if (!SWIG_IsOK(res1)) {
35368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35369 }
35370 arg1 = reinterpret_cast< wxWindow * >(argp1);
35371 {
35372 PyThreadState* __tstate = wxPyBeginAllowThreads();
35373 result = (arg1)->GetFont();
35374 wxPyEndAllowThreads(__tstate);
35375 if (PyErr_Occurred()) SWIG_fail;
35376 }
35377 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
35378 return resultobj;
35379 fail:
35380 return NULL;
35381 }
35382
35383
35384 SWIGINTERN PyObject *_wrap_Window_SetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35385 PyObject *resultobj = 0;
35386 wxWindow *arg1 = (wxWindow *) 0 ;
35387 wxCaret *arg2 = (wxCaret *) 0 ;
35388 void *argp1 = 0 ;
35389 int res1 = 0 ;
35390 int res2 = 0 ;
35391 PyObject * obj0 = 0 ;
35392 PyObject * obj1 = 0 ;
35393 char * kwnames[] = {
35394 (char *) "self",(char *) "caret", NULL
35395 };
35396
35397 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) SWIG_fail;
35398 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35399 if (!SWIG_IsOK(res1)) {
35400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCaret" "', expected argument " "1"" of type '" "wxWindow *""'");
35401 }
35402 arg1 = reinterpret_cast< wxWindow * >(argp1);
35403 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
35404 if (!SWIG_IsOK(res2)) {
35405 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCaret" "', expected argument " "2"" of type '" "wxCaret *""'");
35406 }
35407 {
35408 PyThreadState* __tstate = wxPyBeginAllowThreads();
35409 (arg1)->SetCaret(arg2);
35410 wxPyEndAllowThreads(__tstate);
35411 if (PyErr_Occurred()) SWIG_fail;
35412 }
35413 resultobj = SWIG_Py_Void();
35414 return resultobj;
35415 fail:
35416 return NULL;
35417 }
35418
35419
35420 SWIGINTERN PyObject *_wrap_Window_GetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35421 PyObject *resultobj = 0;
35422 wxWindow *arg1 = (wxWindow *) 0 ;
35423 wxCaret *result = 0 ;
35424 void *argp1 = 0 ;
35425 int res1 = 0 ;
35426 PyObject *swig_obj[1] ;
35427
35428 if (!args) SWIG_fail;
35429 swig_obj[0] = args;
35430 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35431 if (!SWIG_IsOK(res1)) {
35432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCaret" "', expected argument " "1"" of type '" "wxWindow const *""'");
35433 }
35434 arg1 = reinterpret_cast< wxWindow * >(argp1);
35435 {
35436 PyThreadState* __tstate = wxPyBeginAllowThreads();
35437 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
35438 wxPyEndAllowThreads(__tstate);
35439 if (PyErr_Occurred()) SWIG_fail;
35440 }
35441 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, 0 | 0 );
35442 return resultobj;
35443 fail:
35444 return NULL;
35445 }
35446
35447
35448 SWIGINTERN PyObject *_wrap_Window_GetCharHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35449 PyObject *resultobj = 0;
35450 wxWindow *arg1 = (wxWindow *) 0 ;
35451 int result;
35452 void *argp1 = 0 ;
35453 int res1 = 0 ;
35454 PyObject *swig_obj[1] ;
35455
35456 if (!args) SWIG_fail;
35457 swig_obj[0] = args;
35458 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35459 if (!SWIG_IsOK(res1)) {
35460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
35461 }
35462 arg1 = reinterpret_cast< wxWindow * >(argp1);
35463 {
35464 PyThreadState* __tstate = wxPyBeginAllowThreads();
35465 result = (int)((wxWindow const *)arg1)->GetCharHeight();
35466 wxPyEndAllowThreads(__tstate);
35467 if (PyErr_Occurred()) SWIG_fail;
35468 }
35469 resultobj = SWIG_From_int(static_cast< int >(result));
35470 return resultobj;
35471 fail:
35472 return NULL;
35473 }
35474
35475
35476 SWIGINTERN PyObject *_wrap_Window_GetCharWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35477 PyObject *resultobj = 0;
35478 wxWindow *arg1 = (wxWindow *) 0 ;
35479 int result;
35480 void *argp1 = 0 ;
35481 int res1 = 0 ;
35482 PyObject *swig_obj[1] ;
35483
35484 if (!args) SWIG_fail;
35485 swig_obj[0] = args;
35486 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35487 if (!SWIG_IsOK(res1)) {
35488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
35489 }
35490 arg1 = reinterpret_cast< wxWindow * >(argp1);
35491 {
35492 PyThreadState* __tstate = wxPyBeginAllowThreads();
35493 result = (int)((wxWindow const *)arg1)->GetCharWidth();
35494 wxPyEndAllowThreads(__tstate);
35495 if (PyErr_Occurred()) SWIG_fail;
35496 }
35497 resultobj = SWIG_From_int(static_cast< int >(result));
35498 return resultobj;
35499 fail:
35500 return NULL;
35501 }
35502
35503
35504 SWIGINTERN PyObject *_wrap_Window_GetTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35505 PyObject *resultobj = 0;
35506 wxWindow *arg1 = (wxWindow *) 0 ;
35507 wxString *arg2 = 0 ;
35508 int *arg3 = (int *) 0 ;
35509 int *arg4 = (int *) 0 ;
35510 void *argp1 = 0 ;
35511 int res1 = 0 ;
35512 bool temp2 = false ;
35513 int temp3 ;
35514 int res3 = SWIG_TMPOBJ ;
35515 int temp4 ;
35516 int res4 = SWIG_TMPOBJ ;
35517 PyObject * obj0 = 0 ;
35518 PyObject * obj1 = 0 ;
35519 char * kwnames[] = {
35520 (char *) "self",(char *) "string", NULL
35521 };
35522
35523 arg3 = &temp3;
35524 arg4 = &temp4;
35525 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) SWIG_fail;
35526 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35527 if (!SWIG_IsOK(res1)) {
35528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
35529 }
35530 arg1 = reinterpret_cast< wxWindow * >(argp1);
35531 {
35532 arg2 = wxString_in_helper(obj1);
35533 if (arg2 == NULL) SWIG_fail;
35534 temp2 = true;
35535 }
35536 {
35537 PyThreadState* __tstate = wxPyBeginAllowThreads();
35538 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
35539 wxPyEndAllowThreads(__tstate);
35540 if (PyErr_Occurred()) SWIG_fail;
35541 }
35542 resultobj = SWIG_Py_Void();
35543 if (SWIG_IsTmpObj(res3)) {
35544 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35545 } else {
35546 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35547 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35548 }
35549 if (SWIG_IsTmpObj(res4)) {
35550 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
35551 } else {
35552 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35553 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
35554 }
35555 {
35556 if (temp2)
35557 delete arg2;
35558 }
35559 return resultobj;
35560 fail:
35561 {
35562 if (temp2)
35563 delete arg2;
35564 }
35565 return NULL;
35566 }
35567
35568
35569 SWIGINTERN PyObject *_wrap_Window_GetFullTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35570 PyObject *resultobj = 0;
35571 wxWindow *arg1 = (wxWindow *) 0 ;
35572 wxString *arg2 = 0 ;
35573 int *arg3 = (int *) 0 ;
35574 int *arg4 = (int *) 0 ;
35575 int *arg5 = (int *) 0 ;
35576 int *arg6 = (int *) 0 ;
35577 wxFont *arg7 = (wxFont *) NULL ;
35578 void *argp1 = 0 ;
35579 int res1 = 0 ;
35580 bool temp2 = false ;
35581 int temp3 ;
35582 int res3 = SWIG_TMPOBJ ;
35583 int temp4 ;
35584 int res4 = SWIG_TMPOBJ ;
35585 int temp5 ;
35586 int res5 = SWIG_TMPOBJ ;
35587 int temp6 ;
35588 int res6 = SWIG_TMPOBJ ;
35589 void *argp7 = 0 ;
35590 int res7 = 0 ;
35591 PyObject * obj0 = 0 ;
35592 PyObject * obj1 = 0 ;
35593 PyObject * obj2 = 0 ;
35594 char * kwnames[] = {
35595 (char *) "self",(char *) "string",(char *) "font", NULL
35596 };
35597
35598 arg3 = &temp3;
35599 arg4 = &temp4;
35600 arg5 = &temp5;
35601 arg6 = &temp6;
35602 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35603 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35604 if (!SWIG_IsOK(res1)) {
35605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFullTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
35606 }
35607 arg1 = reinterpret_cast< wxWindow * >(argp1);
35608 {
35609 arg2 = wxString_in_helper(obj1);
35610 if (arg2 == NULL) SWIG_fail;
35611 temp2 = true;
35612 }
35613 if (obj2) {
35614 res7 = SWIG_ConvertPtr(obj2, &argp7,SWIGTYPE_p_wxFont, 0 | 0 );
35615 if (!SWIG_IsOK(res7)) {
35616 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Window_GetFullTextExtent" "', expected argument " "7"" of type '" "wxFont const *""'");
35617 }
35618 arg7 = reinterpret_cast< wxFont * >(argp7);
35619 }
35620 {
35621 PyThreadState* __tstate = wxPyBeginAllowThreads();
35622 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
35623 wxPyEndAllowThreads(__tstate);
35624 if (PyErr_Occurred()) SWIG_fail;
35625 }
35626 resultobj = SWIG_Py_Void();
35627 if (SWIG_IsTmpObj(res3)) {
35628 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35629 } else {
35630 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35631 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35632 }
35633 if (SWIG_IsTmpObj(res4)) {
35634 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
35635 } else {
35636 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35637 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
35638 }
35639 if (SWIG_IsTmpObj(res5)) {
35640 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
35641 } else {
35642 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35643 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
35644 }
35645 if (SWIG_IsTmpObj(res6)) {
35646 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
35647 } else {
35648 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35649 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
35650 }
35651 {
35652 if (temp2)
35653 delete arg2;
35654 }
35655 return resultobj;
35656 fail:
35657 {
35658 if (temp2)
35659 delete arg2;
35660 }
35661 return NULL;
35662 }
35663
35664
35665 SWIGINTERN PyObject *_wrap_Window_ClientToScreenXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35666 PyObject *resultobj = 0;
35667 wxWindow *arg1 = (wxWindow *) 0 ;
35668 int *arg2 = (int *) 0 ;
35669 int *arg3 = (int *) 0 ;
35670 void *argp1 = 0 ;
35671 int res1 = 0 ;
35672 int temp2 ;
35673 int res2 = 0 ;
35674 int temp3 ;
35675 int res3 = 0 ;
35676 PyObject * obj0 = 0 ;
35677 PyObject * obj1 = 0 ;
35678 PyObject * obj2 = 0 ;
35679 char * kwnames[] = {
35680 (char *) "self",(char *) "x",(char *) "y", NULL
35681 };
35682
35683 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35684 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35685 if (!SWIG_IsOK(res1)) {
35686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreenXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35687 }
35688 arg1 = reinterpret_cast< wxWindow * >(argp1);
35689 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
35690 int val;
35691 int ecode = SWIG_AsVal_int(obj1, &val);
35692 if (!SWIG_IsOK(ecode)) {
35693 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "2"" of type '" "int""'");
35694 }
35695 temp2 = static_cast< int >(val);
35696 arg2 = &temp2;
35697 res2 = SWIG_AddTmpMask(ecode);
35698 }
35699 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
35700 int val;
35701 int ecode = SWIG_AsVal_int(obj2, &val);
35702 if (!SWIG_IsOK(ecode)) {
35703 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "3"" of type '" "int""'");
35704 }
35705 temp3 = static_cast< int >(val);
35706 arg3 = &temp3;
35707 res3 = SWIG_AddTmpMask(ecode);
35708 }
35709 {
35710 PyThreadState* __tstate = wxPyBeginAllowThreads();
35711 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
35712 wxPyEndAllowThreads(__tstate);
35713 if (PyErr_Occurred()) SWIG_fail;
35714 }
35715 resultobj = SWIG_Py_Void();
35716 if (SWIG_IsTmpObj(res2)) {
35717 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35718 } else {
35719 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35720 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35721 }
35722 if (SWIG_IsTmpObj(res3)) {
35723 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35724 } else {
35725 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35726 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35727 }
35728 return resultobj;
35729 fail:
35730 return NULL;
35731 }
35732
35733
35734 SWIGINTERN PyObject *_wrap_Window_ScreenToClientXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35735 PyObject *resultobj = 0;
35736 wxWindow *arg1 = (wxWindow *) 0 ;
35737 int *arg2 = (int *) 0 ;
35738 int *arg3 = (int *) 0 ;
35739 void *argp1 = 0 ;
35740 int res1 = 0 ;
35741 int temp2 ;
35742 int res2 = 0 ;
35743 int temp3 ;
35744 int res3 = 0 ;
35745 PyObject * obj0 = 0 ;
35746 PyObject * obj1 = 0 ;
35747 PyObject * obj2 = 0 ;
35748 char * kwnames[] = {
35749 (char *) "self",(char *) "x",(char *) "y", NULL
35750 };
35751
35752 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35753 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35754 if (!SWIG_IsOK(res1)) {
35755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClientXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35756 }
35757 arg1 = reinterpret_cast< wxWindow * >(argp1);
35758 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
35759 int val;
35760 int ecode = SWIG_AsVal_int(obj1, &val);
35761 if (!SWIG_IsOK(ecode)) {
35762 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "2"" of type '" "int""'");
35763 }
35764 temp2 = static_cast< int >(val);
35765 arg2 = &temp2;
35766 res2 = SWIG_AddTmpMask(ecode);
35767 }
35768 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
35769 int val;
35770 int ecode = SWIG_AsVal_int(obj2, &val);
35771 if (!SWIG_IsOK(ecode)) {
35772 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "3"" of type '" "int""'");
35773 }
35774 temp3 = static_cast< int >(val);
35775 arg3 = &temp3;
35776 res3 = SWIG_AddTmpMask(ecode);
35777 }
35778 {
35779 PyThreadState* __tstate = wxPyBeginAllowThreads();
35780 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
35781 wxPyEndAllowThreads(__tstate);
35782 if (PyErr_Occurred()) SWIG_fail;
35783 }
35784 resultobj = SWIG_Py_Void();
35785 if (SWIG_IsTmpObj(res2)) {
35786 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35787 } else {
35788 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35789 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35790 }
35791 if (SWIG_IsTmpObj(res3)) {
35792 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35793 } else {
35794 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35795 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35796 }
35797 return resultobj;
35798 fail:
35799 return NULL;
35800 }
35801
35802
35803 SWIGINTERN PyObject *_wrap_Window_ClientToScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35804 PyObject *resultobj = 0;
35805 wxWindow *arg1 = (wxWindow *) 0 ;
35806 wxPoint *arg2 = 0 ;
35807 wxPoint result;
35808 void *argp1 = 0 ;
35809 int res1 = 0 ;
35810 wxPoint temp2 ;
35811 PyObject * obj0 = 0 ;
35812 PyObject * obj1 = 0 ;
35813 char * kwnames[] = {
35814 (char *) "self",(char *) "pt", NULL
35815 };
35816
35817 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) SWIG_fail;
35818 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35819 if (!SWIG_IsOK(res1)) {
35820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
35821 }
35822 arg1 = reinterpret_cast< wxWindow * >(argp1);
35823 {
35824 arg2 = &temp2;
35825 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35826 }
35827 {
35828 PyThreadState* __tstate = wxPyBeginAllowThreads();
35829 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
35830 wxPyEndAllowThreads(__tstate);
35831 if (PyErr_Occurred()) SWIG_fail;
35832 }
35833 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35834 return resultobj;
35835 fail:
35836 return NULL;
35837 }
35838
35839
35840 SWIGINTERN PyObject *_wrap_Window_ScreenToClient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35841 PyObject *resultobj = 0;
35842 wxWindow *arg1 = (wxWindow *) 0 ;
35843 wxPoint *arg2 = 0 ;
35844 wxPoint result;
35845 void *argp1 = 0 ;
35846 int res1 = 0 ;
35847 wxPoint temp2 ;
35848 PyObject * obj0 = 0 ;
35849 PyObject * obj1 = 0 ;
35850 char * kwnames[] = {
35851 (char *) "self",(char *) "pt", NULL
35852 };
35853
35854 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) SWIG_fail;
35855 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35856 if (!SWIG_IsOK(res1)) {
35857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClient" "', expected argument " "1"" of type '" "wxWindow const *""'");
35858 }
35859 arg1 = reinterpret_cast< wxWindow * >(argp1);
35860 {
35861 arg2 = &temp2;
35862 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35863 }
35864 {
35865 PyThreadState* __tstate = wxPyBeginAllowThreads();
35866 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
35867 wxPyEndAllowThreads(__tstate);
35868 if (PyErr_Occurred()) SWIG_fail;
35869 }
35870 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35871 return resultobj;
35872 fail:
35873 return NULL;
35874 }
35875
35876
35877 SWIGINTERN PyObject *_wrap_Window_HitTestXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35878 PyObject *resultobj = 0;
35879 wxWindow *arg1 = (wxWindow *) 0 ;
35880 int arg2 ;
35881 int arg3 ;
35882 wxHitTest result;
35883 void *argp1 = 0 ;
35884 int res1 = 0 ;
35885 int val2 ;
35886 int ecode2 = 0 ;
35887 int val3 ;
35888 int ecode3 = 0 ;
35889 PyObject * obj0 = 0 ;
35890 PyObject * obj1 = 0 ;
35891 PyObject * obj2 = 0 ;
35892 char * kwnames[] = {
35893 (char *) "self",(char *) "x",(char *) "y", NULL
35894 };
35895
35896 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35897 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35898 if (!SWIG_IsOK(res1)) {
35899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTestXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35900 }
35901 arg1 = reinterpret_cast< wxWindow * >(argp1);
35902 ecode2 = SWIG_AsVal_int(obj1, &val2);
35903 if (!SWIG_IsOK(ecode2)) {
35904 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HitTestXY" "', expected argument " "2"" of type '" "int""'");
35905 }
35906 arg2 = static_cast< int >(val2);
35907 ecode3 = SWIG_AsVal_int(obj2, &val3);
35908 if (!SWIG_IsOK(ecode3)) {
35909 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_HitTestXY" "', expected argument " "3"" of type '" "int""'");
35910 }
35911 arg3 = static_cast< int >(val3);
35912 {
35913 PyThreadState* __tstate = wxPyBeginAllowThreads();
35914 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
35915 wxPyEndAllowThreads(__tstate);
35916 if (PyErr_Occurred()) SWIG_fail;
35917 }
35918 resultobj = SWIG_From_int(static_cast< int >(result));
35919 return resultobj;
35920 fail:
35921 return NULL;
35922 }
35923
35924
35925 SWIGINTERN PyObject *_wrap_Window_HitTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35926 PyObject *resultobj = 0;
35927 wxWindow *arg1 = (wxWindow *) 0 ;
35928 wxPoint *arg2 = 0 ;
35929 wxHitTest result;
35930 void *argp1 = 0 ;
35931 int res1 = 0 ;
35932 wxPoint temp2 ;
35933 PyObject * obj0 = 0 ;
35934 PyObject * obj1 = 0 ;
35935 char * kwnames[] = {
35936 (char *) "self",(char *) "pt", NULL
35937 };
35938
35939 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) SWIG_fail;
35940 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35941 if (!SWIG_IsOK(res1)) {
35942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTest" "', expected argument " "1"" of type '" "wxWindow const *""'");
35943 }
35944 arg1 = reinterpret_cast< wxWindow * >(argp1);
35945 {
35946 arg2 = &temp2;
35947 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35948 }
35949 {
35950 PyThreadState* __tstate = wxPyBeginAllowThreads();
35951 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
35952 wxPyEndAllowThreads(__tstate);
35953 if (PyErr_Occurred()) SWIG_fail;
35954 }
35955 resultobj = SWIG_From_int(static_cast< int >(result));
35956 return resultobj;
35957 fail:
35958 return NULL;
35959 }
35960
35961
35962 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
35963 PyObject *resultobj = 0;
35964 wxWindow *arg1 = (wxWindow *) 0 ;
35965 long arg2 ;
35966 wxBorder result;
35967 void *argp1 = 0 ;
35968 int res1 = 0 ;
35969 long val2 ;
35970 int ecode2 = 0 ;
35971
35972 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
35973 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35974 if (!SWIG_IsOK(res1)) {
35975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
35976 }
35977 arg1 = reinterpret_cast< wxWindow * >(argp1);
35978 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
35979 if (!SWIG_IsOK(ecode2)) {
35980 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetBorder" "', expected argument " "2"" of type '" "long""'");
35981 }
35982 arg2 = static_cast< long >(val2);
35983 {
35984 PyThreadState* __tstate = wxPyBeginAllowThreads();
35985 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
35986 wxPyEndAllowThreads(__tstate);
35987 if (PyErr_Occurred()) SWIG_fail;
35988 }
35989 resultobj = SWIG_From_int(static_cast< int >(result));
35990 return resultobj;
35991 fail:
35992 return NULL;
35993 }
35994
35995
35996 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
35997 PyObject *resultobj = 0;
35998 wxWindow *arg1 = (wxWindow *) 0 ;
35999 wxBorder result;
36000 void *argp1 = 0 ;
36001 int res1 = 0 ;
36002
36003 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
36004 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36005 if (!SWIG_IsOK(res1)) {
36006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
36007 }
36008 arg1 = reinterpret_cast< wxWindow * >(argp1);
36009 {
36010 PyThreadState* __tstate = wxPyBeginAllowThreads();
36011 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
36012 wxPyEndAllowThreads(__tstate);
36013 if (PyErr_Occurred()) SWIG_fail;
36014 }
36015 resultobj = SWIG_From_int(static_cast< int >(result));
36016 return resultobj;
36017 fail:
36018 return NULL;
36019 }
36020
36021
36022 SWIGINTERN PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
36023 int argc;
36024 PyObject *argv[3];
36025
36026 if (!(argc = SWIG_Python_UnpackTuple(args,"Window_GetBorder",0,2,argv))) SWIG_fail;
36027 --argc;
36028 if (argc == 1) {
36029 return _wrap_Window_GetBorder__SWIG_1(self, argc, argv);
36030 }
36031 if (argc == 2) {
36032 return _wrap_Window_GetBorder__SWIG_0(self, argc, argv);
36033 }
36034
36035 fail:
36036 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
36037 return NULL;
36038 }
36039
36040
36041 SWIGINTERN PyObject *_wrap_Window_UpdateWindowUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36042 PyObject *resultobj = 0;
36043 wxWindow *arg1 = (wxWindow *) 0 ;
36044 long arg2 = (long) wxUPDATE_UI_NONE ;
36045 void *argp1 = 0 ;
36046 int res1 = 0 ;
36047 long val2 ;
36048 int ecode2 = 0 ;
36049 PyObject * obj0 = 0 ;
36050 PyObject * obj1 = 0 ;
36051 char * kwnames[] = {
36052 (char *) "self",(char *) "flags", NULL
36053 };
36054
36055 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) SWIG_fail;
36056 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36057 if (!SWIG_IsOK(res1)) {
36058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UpdateWindowUI" "', expected argument " "1"" of type '" "wxWindow *""'");
36059 }
36060 arg1 = reinterpret_cast< wxWindow * >(argp1);
36061 if (obj1) {
36062 ecode2 = SWIG_AsVal_long(obj1, &val2);
36063 if (!SWIG_IsOK(ecode2)) {
36064 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UpdateWindowUI" "', expected argument " "2"" of type '" "long""'");
36065 }
36066 arg2 = static_cast< long >(val2);
36067 }
36068 {
36069 PyThreadState* __tstate = wxPyBeginAllowThreads();
36070 (arg1)->UpdateWindowUI(arg2);
36071 wxPyEndAllowThreads(__tstate);
36072 if (PyErr_Occurred()) SWIG_fail;
36073 }
36074 resultobj = SWIG_Py_Void();
36075 return resultobj;
36076 fail:
36077 return NULL;
36078 }
36079
36080
36081 SWIGINTERN PyObject *_wrap_Window_PopupMenuXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36082 PyObject *resultobj = 0;
36083 wxWindow *arg1 = (wxWindow *) 0 ;
36084 wxMenu *arg2 = (wxMenu *) 0 ;
36085 int arg3 = (int) -1 ;
36086 int arg4 = (int) -1 ;
36087 bool result;
36088 void *argp1 = 0 ;
36089 int res1 = 0 ;
36090 void *argp2 = 0 ;
36091 int res2 = 0 ;
36092 int val3 ;
36093 int ecode3 = 0 ;
36094 int val4 ;
36095 int ecode4 = 0 ;
36096 PyObject * obj0 = 0 ;
36097 PyObject * obj1 = 0 ;
36098 PyObject * obj2 = 0 ;
36099 PyObject * obj3 = 0 ;
36100 char * kwnames[] = {
36101 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
36102 };
36103
36104 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36105 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36106 if (!SWIG_IsOK(res1)) {
36107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenuXY" "', expected argument " "1"" of type '" "wxWindow *""'");
36108 }
36109 arg1 = reinterpret_cast< wxWindow * >(argp1);
36110 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
36111 if (!SWIG_IsOK(res2)) {
36112 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenuXY" "', expected argument " "2"" of type '" "wxMenu *""'");
36113 }
36114 arg2 = reinterpret_cast< wxMenu * >(argp2);
36115 if (obj2) {
36116 ecode3 = SWIG_AsVal_int(obj2, &val3);
36117 if (!SWIG_IsOK(ecode3)) {
36118 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_PopupMenuXY" "', expected argument " "3"" of type '" "int""'");
36119 }
36120 arg3 = static_cast< int >(val3);
36121 }
36122 if (obj3) {
36123 ecode4 = SWIG_AsVal_int(obj3, &val4);
36124 if (!SWIG_IsOK(ecode4)) {
36125 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_PopupMenuXY" "', expected argument " "4"" of type '" "int""'");
36126 }
36127 arg4 = static_cast< int >(val4);
36128 }
36129 {
36130 PyThreadState* __tstate = wxPyBeginAllowThreads();
36131 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
36132 wxPyEndAllowThreads(__tstate);
36133 if (PyErr_Occurred()) SWIG_fail;
36134 }
36135 {
36136 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36137 }
36138 return resultobj;
36139 fail:
36140 return NULL;
36141 }
36142
36143
36144 SWIGINTERN PyObject *_wrap_Window_PopupMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36145 PyObject *resultobj = 0;
36146 wxWindow *arg1 = (wxWindow *) 0 ;
36147 wxMenu *arg2 = (wxMenu *) 0 ;
36148 wxPoint const &arg3_defvalue = wxDefaultPosition ;
36149 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
36150 bool result;
36151 void *argp1 = 0 ;
36152 int res1 = 0 ;
36153 void *argp2 = 0 ;
36154 int res2 = 0 ;
36155 wxPoint temp3 ;
36156 PyObject * obj0 = 0 ;
36157 PyObject * obj1 = 0 ;
36158 PyObject * obj2 = 0 ;
36159 char * kwnames[] = {
36160 (char *) "self",(char *) "menu",(char *) "pos", NULL
36161 };
36162
36163 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36164 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36165 if (!SWIG_IsOK(res1)) {
36166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenu" "', expected argument " "1"" of type '" "wxWindow *""'");
36167 }
36168 arg1 = reinterpret_cast< wxWindow * >(argp1);
36169 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
36170 if (!SWIG_IsOK(res2)) {
36171 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
36172 }
36173 arg2 = reinterpret_cast< wxMenu * >(argp2);
36174 if (obj2) {
36175 {
36176 arg3 = &temp3;
36177 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
36178 }
36179 }
36180 {
36181 PyThreadState* __tstate = wxPyBeginAllowThreads();
36182 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
36183 wxPyEndAllowThreads(__tstate);
36184 if (PyErr_Occurred()) SWIG_fail;
36185 }
36186 {
36187 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36188 }
36189 return resultobj;
36190 fail:
36191 return NULL;
36192 }
36193
36194
36195 SWIGINTERN PyObject *_wrap_Window_HasMultiplePages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36196 PyObject *resultobj = 0;
36197 wxWindow *arg1 = (wxWindow *) 0 ;
36198 bool result;
36199 void *argp1 = 0 ;
36200 int res1 = 0 ;
36201 PyObject *swig_obj[1] ;
36202
36203 if (!args) SWIG_fail;
36204 swig_obj[0] = args;
36205 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36206 if (!SWIG_IsOK(res1)) {
36207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasMultiplePages" "', expected argument " "1"" of type '" "wxWindow const *""'");
36208 }
36209 arg1 = reinterpret_cast< wxWindow * >(argp1);
36210 {
36211 PyThreadState* __tstate = wxPyBeginAllowThreads();
36212 result = (bool)((wxWindow const *)arg1)->HasMultiplePages();
36213 wxPyEndAllowThreads(__tstate);
36214 if (PyErr_Occurred()) SWIG_fail;
36215 }
36216 {
36217 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36218 }
36219 return resultobj;
36220 fail:
36221 return NULL;
36222 }
36223
36224
36225 SWIGINTERN PyObject *_wrap_Window_GetHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36226 PyObject *resultobj = 0;
36227 wxWindow *arg1 = (wxWindow *) 0 ;
36228 long result;
36229 void *argp1 = 0 ;
36230 int res1 = 0 ;
36231 PyObject *swig_obj[1] ;
36232
36233 if (!args) SWIG_fail;
36234 swig_obj[0] = args;
36235 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36236 if (!SWIG_IsOK(res1)) {
36237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36238 }
36239 arg1 = reinterpret_cast< wxWindow * >(argp1);
36240 {
36241 PyThreadState* __tstate = wxPyBeginAllowThreads();
36242 result = (long)wxWindow_GetHandle(arg1);
36243 wxPyEndAllowThreads(__tstate);
36244 if (PyErr_Occurred()) SWIG_fail;
36245 }
36246 resultobj = SWIG_From_long(static_cast< long >(result));
36247 return resultobj;
36248 fail:
36249 return NULL;
36250 }
36251
36252
36253 SWIGINTERN PyObject *_wrap_Window_AssociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36254 PyObject *resultobj = 0;
36255 wxWindow *arg1 = (wxWindow *) 0 ;
36256 long arg2 ;
36257 void *argp1 = 0 ;
36258 int res1 = 0 ;
36259 long val2 ;
36260 int ecode2 = 0 ;
36261 PyObject * obj0 = 0 ;
36262 PyObject * obj1 = 0 ;
36263 char * kwnames[] = {
36264 (char *) "self",(char *) "handle", NULL
36265 };
36266
36267 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) SWIG_fail;
36268 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36269 if (!SWIG_IsOK(res1)) {
36270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AssociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36271 }
36272 arg1 = reinterpret_cast< wxWindow * >(argp1);
36273 ecode2 = SWIG_AsVal_long(obj1, &val2);
36274 if (!SWIG_IsOK(ecode2)) {
36275 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AssociateHandle" "', expected argument " "2"" of type '" "long""'");
36276 }
36277 arg2 = static_cast< long >(val2);
36278 {
36279 PyThreadState* __tstate = wxPyBeginAllowThreads();
36280 wxWindow_AssociateHandle(arg1,arg2);
36281 wxPyEndAllowThreads(__tstate);
36282 if (PyErr_Occurred()) SWIG_fail;
36283 }
36284 resultobj = SWIG_Py_Void();
36285 return resultobj;
36286 fail:
36287 return NULL;
36288 }
36289
36290
36291 SWIGINTERN PyObject *_wrap_Window_DissociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36292 PyObject *resultobj = 0;
36293 wxWindow *arg1 = (wxWindow *) 0 ;
36294 void *argp1 = 0 ;
36295 int res1 = 0 ;
36296 PyObject *swig_obj[1] ;
36297
36298 if (!args) SWIG_fail;
36299 swig_obj[0] = args;
36300 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36301 if (!SWIG_IsOK(res1)) {
36302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DissociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36303 }
36304 arg1 = reinterpret_cast< wxWindow * >(argp1);
36305 {
36306 PyThreadState* __tstate = wxPyBeginAllowThreads();
36307 (arg1)->DissociateHandle();
36308 wxPyEndAllowThreads(__tstate);
36309 if (PyErr_Occurred()) SWIG_fail;
36310 }
36311 resultobj = SWIG_Py_Void();
36312 return resultobj;
36313 fail:
36314 return NULL;
36315 }
36316
36317
36318 SWIGINTERN PyObject *_wrap_Window_OnPaint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36319 PyObject *resultobj = 0;
36320 wxWindow *arg1 = (wxWindow *) 0 ;
36321 wxPaintEvent *arg2 = 0 ;
36322 void *argp1 = 0 ;
36323 int res1 = 0 ;
36324 void *argp2 = 0 ;
36325 int res2 = 0 ;
36326 PyObject * obj0 = 0 ;
36327 PyObject * obj1 = 0 ;
36328 char * kwnames[] = {
36329 (char *) "self",(char *) "event", NULL
36330 };
36331
36332 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_OnPaint",kwnames,&obj0,&obj1)) SWIG_fail;
36333 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36334 if (!SWIG_IsOK(res1)) {
36335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_OnPaint" "', expected argument " "1"" of type '" "wxWindow *""'");
36336 }
36337 arg1 = reinterpret_cast< wxWindow * >(argp1);
36338 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPaintEvent, 0 );
36339 if (!SWIG_IsOK(res2)) {
36340 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_OnPaint" "', expected argument " "2"" of type '" "wxPaintEvent &""'");
36341 }
36342 if (!argp2) {
36343 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_OnPaint" "', expected argument " "2"" of type '" "wxPaintEvent &""'");
36344 }
36345 arg2 = reinterpret_cast< wxPaintEvent * >(argp2);
36346 {
36347 PyThreadState* __tstate = wxPyBeginAllowThreads();
36348 (arg1)->OnPaint(*arg2);
36349 wxPyEndAllowThreads(__tstate);
36350 if (PyErr_Occurred()) SWIG_fail;
36351 }
36352 resultobj = SWIG_Py_Void();
36353 return resultobj;
36354 fail:
36355 return NULL;
36356 }
36357
36358
36359 SWIGINTERN PyObject *_wrap_Window_HasScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36360 PyObject *resultobj = 0;
36361 wxWindow *arg1 = (wxWindow *) 0 ;
36362 int arg2 ;
36363 bool result;
36364 void *argp1 = 0 ;
36365 int res1 = 0 ;
36366 int val2 ;
36367 int ecode2 = 0 ;
36368 PyObject * obj0 = 0 ;
36369 PyObject * obj1 = 0 ;
36370 char * kwnames[] = {
36371 (char *) "self",(char *) "orient", NULL
36372 };
36373
36374 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) SWIG_fail;
36375 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36376 if (!SWIG_IsOK(res1)) {
36377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasScrollbar" "', expected argument " "1"" of type '" "wxWindow const *""'");
36378 }
36379 arg1 = reinterpret_cast< wxWindow * >(argp1);
36380 ecode2 = SWIG_AsVal_int(obj1, &val2);
36381 if (!SWIG_IsOK(ecode2)) {
36382 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasScrollbar" "', expected argument " "2"" of type '" "int""'");
36383 }
36384 arg2 = static_cast< int >(val2);
36385 {
36386 PyThreadState* __tstate = wxPyBeginAllowThreads();
36387 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
36388 wxPyEndAllowThreads(__tstate);
36389 if (PyErr_Occurred()) SWIG_fail;
36390 }
36391 {
36392 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36393 }
36394 return resultobj;
36395 fail:
36396 return NULL;
36397 }
36398
36399
36400 SWIGINTERN PyObject *_wrap_Window_SetScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36401 PyObject *resultobj = 0;
36402 wxWindow *arg1 = (wxWindow *) 0 ;
36403 int arg2 ;
36404 int arg3 ;
36405 int arg4 ;
36406 int arg5 ;
36407 bool arg6 = (bool) true ;
36408 void *argp1 = 0 ;
36409 int res1 = 0 ;
36410 int val2 ;
36411 int ecode2 = 0 ;
36412 int val3 ;
36413 int ecode3 = 0 ;
36414 int val4 ;
36415 int ecode4 = 0 ;
36416 int val5 ;
36417 int ecode5 = 0 ;
36418 bool val6 ;
36419 int ecode6 = 0 ;
36420 PyObject * obj0 = 0 ;
36421 PyObject * obj1 = 0 ;
36422 PyObject * obj2 = 0 ;
36423 PyObject * obj3 = 0 ;
36424 PyObject * obj4 = 0 ;
36425 PyObject * obj5 = 0 ;
36426 char * kwnames[] = {
36427 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
36428 };
36429
36430 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
36431 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36432 if (!SWIG_IsOK(res1)) {
36433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollbar" "', expected argument " "1"" of type '" "wxWindow *""'");
36434 }
36435 arg1 = reinterpret_cast< wxWindow * >(argp1);
36436 ecode2 = SWIG_AsVal_int(obj1, &val2);
36437 if (!SWIG_IsOK(ecode2)) {
36438 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollbar" "', expected argument " "2"" of type '" "int""'");
36439 }
36440 arg2 = static_cast< int >(val2);
36441 ecode3 = SWIG_AsVal_int(obj2, &val3);
36442 if (!SWIG_IsOK(ecode3)) {
36443 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollbar" "', expected argument " "3"" of type '" "int""'");
36444 }
36445 arg3 = static_cast< int >(val3);
36446 ecode4 = SWIG_AsVal_int(obj3, &val4);
36447 if (!SWIG_IsOK(ecode4)) {
36448 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollbar" "', expected argument " "4"" of type '" "int""'");
36449 }
36450 arg4 = static_cast< int >(val4);
36451 ecode5 = SWIG_AsVal_int(obj4, &val5);
36452 if (!SWIG_IsOK(ecode5)) {
36453 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetScrollbar" "', expected argument " "5"" of type '" "int""'");
36454 }
36455 arg5 = static_cast< int >(val5);
36456 if (obj5) {
36457 ecode6 = SWIG_AsVal_bool(obj5, &val6);
36458 if (!SWIG_IsOK(ecode6)) {
36459 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetScrollbar" "', expected argument " "6"" of type '" "bool""'");
36460 }
36461 arg6 = static_cast< bool >(val6);
36462 }
36463 {
36464 PyThreadState* __tstate = wxPyBeginAllowThreads();
36465 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
36466 wxPyEndAllowThreads(__tstate);
36467 if (PyErr_Occurred()) SWIG_fail;
36468 }
36469 resultobj = SWIG_Py_Void();
36470 return resultobj;
36471 fail:
36472 return NULL;
36473 }
36474
36475
36476 SWIGINTERN PyObject *_wrap_Window_SetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36477 PyObject *resultobj = 0;
36478 wxWindow *arg1 = (wxWindow *) 0 ;
36479 int arg2 ;
36480 int arg3 ;
36481 bool arg4 = (bool) true ;
36482 void *argp1 = 0 ;
36483 int res1 = 0 ;
36484 int val2 ;
36485 int ecode2 = 0 ;
36486 int val3 ;
36487 int ecode3 = 0 ;
36488 bool val4 ;
36489 int ecode4 = 0 ;
36490 PyObject * obj0 = 0 ;
36491 PyObject * obj1 = 0 ;
36492 PyObject * obj2 = 0 ;
36493 PyObject * obj3 = 0 ;
36494 char * kwnames[] = {
36495 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
36496 };
36497
36498 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36499 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36500 if (!SWIG_IsOK(res1)) {
36501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollPos" "', expected argument " "1"" of type '" "wxWindow *""'");
36502 }
36503 arg1 = reinterpret_cast< wxWindow * >(argp1);
36504 ecode2 = SWIG_AsVal_int(obj1, &val2);
36505 if (!SWIG_IsOK(ecode2)) {
36506 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollPos" "', expected argument " "2"" of type '" "int""'");
36507 }
36508 arg2 = static_cast< int >(val2);
36509 ecode3 = SWIG_AsVal_int(obj2, &val3);
36510 if (!SWIG_IsOK(ecode3)) {
36511 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollPos" "', expected argument " "3"" of type '" "int""'");
36512 }
36513 arg3 = static_cast< int >(val3);
36514 if (obj3) {
36515 ecode4 = SWIG_AsVal_bool(obj3, &val4);
36516 if (!SWIG_IsOK(ecode4)) {
36517 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollPos" "', expected argument " "4"" of type '" "bool""'");
36518 }
36519 arg4 = static_cast< bool >(val4);
36520 }
36521 {
36522 PyThreadState* __tstate = wxPyBeginAllowThreads();
36523 (arg1)->SetScrollPos(arg2,arg3,arg4);
36524 wxPyEndAllowThreads(__tstate);
36525 if (PyErr_Occurred()) SWIG_fail;
36526 }
36527 resultobj = SWIG_Py_Void();
36528 return resultobj;
36529 fail:
36530 return NULL;
36531 }
36532
36533
36534 SWIGINTERN PyObject *_wrap_Window_GetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36535 PyObject *resultobj = 0;
36536 wxWindow *arg1 = (wxWindow *) 0 ;
36537 int arg2 ;
36538 int result;
36539 void *argp1 = 0 ;
36540 int res1 = 0 ;
36541 int val2 ;
36542 int ecode2 = 0 ;
36543 PyObject * obj0 = 0 ;
36544 PyObject * obj1 = 0 ;
36545 char * kwnames[] = {
36546 (char *) "self",(char *) "orientation", NULL
36547 };
36548
36549 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) SWIG_fail;
36550 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36551 if (!SWIG_IsOK(res1)) {
36552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollPos" "', expected argument " "1"" of type '" "wxWindow const *""'");
36553 }
36554 arg1 = reinterpret_cast< wxWindow * >(argp1);
36555 ecode2 = SWIG_AsVal_int(obj1, &val2);
36556 if (!SWIG_IsOK(ecode2)) {
36557 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollPos" "', expected argument " "2"" of type '" "int""'");
36558 }
36559 arg2 = static_cast< int >(val2);
36560 {
36561 PyThreadState* __tstate = wxPyBeginAllowThreads();
36562 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
36563 wxPyEndAllowThreads(__tstate);
36564 if (PyErr_Occurred()) SWIG_fail;
36565 }
36566 resultobj = SWIG_From_int(static_cast< int >(result));
36567 return resultobj;
36568 fail:
36569 return NULL;
36570 }
36571
36572
36573 SWIGINTERN PyObject *_wrap_Window_GetScrollThumb(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36574 PyObject *resultobj = 0;
36575 wxWindow *arg1 = (wxWindow *) 0 ;
36576 int arg2 ;
36577 int result;
36578 void *argp1 = 0 ;
36579 int res1 = 0 ;
36580 int val2 ;
36581 int ecode2 = 0 ;
36582 PyObject * obj0 = 0 ;
36583 PyObject * obj1 = 0 ;
36584 char * kwnames[] = {
36585 (char *) "self",(char *) "orientation", NULL
36586 };
36587
36588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) SWIG_fail;
36589 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36590 if (!SWIG_IsOK(res1)) {
36591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollThumb" "', expected argument " "1"" of type '" "wxWindow const *""'");
36592 }
36593 arg1 = reinterpret_cast< wxWindow * >(argp1);
36594 ecode2 = SWIG_AsVal_int(obj1, &val2);
36595 if (!SWIG_IsOK(ecode2)) {
36596 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollThumb" "', expected argument " "2"" of type '" "int""'");
36597 }
36598 arg2 = static_cast< int >(val2);
36599 {
36600 PyThreadState* __tstate = wxPyBeginAllowThreads();
36601 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
36602 wxPyEndAllowThreads(__tstate);
36603 if (PyErr_Occurred()) SWIG_fail;
36604 }
36605 resultobj = SWIG_From_int(static_cast< int >(result));
36606 return resultobj;
36607 fail:
36608 return NULL;
36609 }
36610
36611
36612 SWIGINTERN PyObject *_wrap_Window_GetScrollRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36613 PyObject *resultobj = 0;
36614 wxWindow *arg1 = (wxWindow *) 0 ;
36615 int arg2 ;
36616 int result;
36617 void *argp1 = 0 ;
36618 int res1 = 0 ;
36619 int val2 ;
36620 int ecode2 = 0 ;
36621 PyObject * obj0 = 0 ;
36622 PyObject * obj1 = 0 ;
36623 char * kwnames[] = {
36624 (char *) "self",(char *) "orientation", NULL
36625 };
36626
36627 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) SWIG_fail;
36628 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36629 if (!SWIG_IsOK(res1)) {
36630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollRange" "', expected argument " "1"" of type '" "wxWindow const *""'");
36631 }
36632 arg1 = reinterpret_cast< wxWindow * >(argp1);
36633 ecode2 = SWIG_AsVal_int(obj1, &val2);
36634 if (!SWIG_IsOK(ecode2)) {
36635 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollRange" "', expected argument " "2"" of type '" "int""'");
36636 }
36637 arg2 = static_cast< int >(val2);
36638 {
36639 PyThreadState* __tstate = wxPyBeginAllowThreads();
36640 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
36641 wxPyEndAllowThreads(__tstate);
36642 if (PyErr_Occurred()) SWIG_fail;
36643 }
36644 resultobj = SWIG_From_int(static_cast< int >(result));
36645 return resultobj;
36646 fail:
36647 return NULL;
36648 }
36649
36650
36651 SWIGINTERN PyObject *_wrap_Window_ScrollWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36652 PyObject *resultobj = 0;
36653 wxWindow *arg1 = (wxWindow *) 0 ;
36654 int arg2 ;
36655 int arg3 ;
36656 wxRect *arg4 = (wxRect *) NULL ;
36657 void *argp1 = 0 ;
36658 int res1 = 0 ;
36659 int val2 ;
36660 int ecode2 = 0 ;
36661 int val3 ;
36662 int ecode3 = 0 ;
36663 void *argp4 = 0 ;
36664 int res4 = 0 ;
36665 PyObject * obj0 = 0 ;
36666 PyObject * obj1 = 0 ;
36667 PyObject * obj2 = 0 ;
36668 PyObject * obj3 = 0 ;
36669 char * kwnames[] = {
36670 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
36671 };
36672
36673 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36674 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36675 if (!SWIG_IsOK(res1)) {
36676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
36677 }
36678 arg1 = reinterpret_cast< wxWindow * >(argp1);
36679 ecode2 = SWIG_AsVal_int(obj1, &val2);
36680 if (!SWIG_IsOK(ecode2)) {
36681 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollWindow" "', expected argument " "2"" of type '" "int""'");
36682 }
36683 arg2 = static_cast< int >(val2);
36684 ecode3 = SWIG_AsVal_int(obj2, &val3);
36685 if (!SWIG_IsOK(ecode3)) {
36686 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_ScrollWindow" "', expected argument " "3"" of type '" "int""'");
36687 }
36688 arg3 = static_cast< int >(val3);
36689 if (obj3) {
36690 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxRect, 0 | 0 );
36691 if (!SWIG_IsOK(res4)) {
36692 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Window_ScrollWindow" "', expected argument " "4"" of type '" "wxRect const *""'");
36693 }
36694 arg4 = reinterpret_cast< wxRect * >(argp4);
36695 }
36696 {
36697 PyThreadState* __tstate = wxPyBeginAllowThreads();
36698 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
36699 wxPyEndAllowThreads(__tstate);
36700 if (PyErr_Occurred()) SWIG_fail;
36701 }
36702 resultobj = SWIG_Py_Void();
36703 return resultobj;
36704 fail:
36705 return NULL;
36706 }
36707
36708
36709 SWIGINTERN PyObject *_wrap_Window_ScrollLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36710 PyObject *resultobj = 0;
36711 wxWindow *arg1 = (wxWindow *) 0 ;
36712 int arg2 ;
36713 bool result;
36714 void *argp1 = 0 ;
36715 int res1 = 0 ;
36716 int val2 ;
36717 int ecode2 = 0 ;
36718 PyObject * obj0 = 0 ;
36719 PyObject * obj1 = 0 ;
36720 char * kwnames[] = {
36721 (char *) "self",(char *) "lines", NULL
36722 };
36723
36724 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) SWIG_fail;
36725 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36726 if (!SWIG_IsOK(res1)) {
36727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollLines" "', expected argument " "1"" of type '" "wxWindow *""'");
36728 }
36729 arg1 = reinterpret_cast< wxWindow * >(argp1);
36730 ecode2 = SWIG_AsVal_int(obj1, &val2);
36731 if (!SWIG_IsOK(ecode2)) {
36732 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollLines" "', expected argument " "2"" of type '" "int""'");
36733 }
36734 arg2 = static_cast< int >(val2);
36735 {
36736 PyThreadState* __tstate = wxPyBeginAllowThreads();
36737 result = (bool)(arg1)->ScrollLines(arg2);
36738 wxPyEndAllowThreads(__tstate);
36739 if (PyErr_Occurred()) SWIG_fail;
36740 }
36741 {
36742 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36743 }
36744 return resultobj;
36745 fail:
36746 return NULL;
36747 }
36748
36749
36750 SWIGINTERN PyObject *_wrap_Window_ScrollPages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36751 PyObject *resultobj = 0;
36752 wxWindow *arg1 = (wxWindow *) 0 ;
36753 int arg2 ;
36754 bool result;
36755 void *argp1 = 0 ;
36756 int res1 = 0 ;
36757 int val2 ;
36758 int ecode2 = 0 ;
36759 PyObject * obj0 = 0 ;
36760 PyObject * obj1 = 0 ;
36761 char * kwnames[] = {
36762 (char *) "self",(char *) "pages", NULL
36763 };
36764
36765 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) SWIG_fail;
36766 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36767 if (!SWIG_IsOK(res1)) {
36768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollPages" "', expected argument " "1"" of type '" "wxWindow *""'");
36769 }
36770 arg1 = reinterpret_cast< wxWindow * >(argp1);
36771 ecode2 = SWIG_AsVal_int(obj1, &val2);
36772 if (!SWIG_IsOK(ecode2)) {
36773 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollPages" "', expected argument " "2"" of type '" "int""'");
36774 }
36775 arg2 = static_cast< int >(val2);
36776 {
36777 PyThreadState* __tstate = wxPyBeginAllowThreads();
36778 result = (bool)(arg1)->ScrollPages(arg2);
36779 wxPyEndAllowThreads(__tstate);
36780 if (PyErr_Occurred()) SWIG_fail;
36781 }
36782 {
36783 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36784 }
36785 return resultobj;
36786 fail:
36787 return NULL;
36788 }
36789
36790
36791 SWIGINTERN PyObject *_wrap_Window_LineUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36792 PyObject *resultobj = 0;
36793 wxWindow *arg1 = (wxWindow *) 0 ;
36794 bool result;
36795 void *argp1 = 0 ;
36796 int res1 = 0 ;
36797 PyObject *swig_obj[1] ;
36798
36799 if (!args) SWIG_fail;
36800 swig_obj[0] = args;
36801 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36802 if (!SWIG_IsOK(res1)) {
36803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineUp" "', expected argument " "1"" of type '" "wxWindow *""'");
36804 }
36805 arg1 = reinterpret_cast< wxWindow * >(argp1);
36806 {
36807 PyThreadState* __tstate = wxPyBeginAllowThreads();
36808 result = (bool)(arg1)->LineUp();
36809 wxPyEndAllowThreads(__tstate);
36810 if (PyErr_Occurred()) SWIG_fail;
36811 }
36812 {
36813 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36814 }
36815 return resultobj;
36816 fail:
36817 return NULL;
36818 }
36819
36820
36821 SWIGINTERN PyObject *_wrap_Window_LineDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36822 PyObject *resultobj = 0;
36823 wxWindow *arg1 = (wxWindow *) 0 ;
36824 bool result;
36825 void *argp1 = 0 ;
36826 int res1 = 0 ;
36827 PyObject *swig_obj[1] ;
36828
36829 if (!args) SWIG_fail;
36830 swig_obj[0] = args;
36831 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36832 if (!SWIG_IsOK(res1)) {
36833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineDown" "', expected argument " "1"" of type '" "wxWindow *""'");
36834 }
36835 arg1 = reinterpret_cast< wxWindow * >(argp1);
36836 {
36837 PyThreadState* __tstate = wxPyBeginAllowThreads();
36838 result = (bool)(arg1)->LineDown();
36839 wxPyEndAllowThreads(__tstate);
36840 if (PyErr_Occurred()) SWIG_fail;
36841 }
36842 {
36843 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36844 }
36845 return resultobj;
36846 fail:
36847 return NULL;
36848 }
36849
36850
36851 SWIGINTERN PyObject *_wrap_Window_PageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36852 PyObject *resultobj = 0;
36853 wxWindow *arg1 = (wxWindow *) 0 ;
36854 bool result;
36855 void *argp1 = 0 ;
36856 int res1 = 0 ;
36857 PyObject *swig_obj[1] ;
36858
36859 if (!args) SWIG_fail;
36860 swig_obj[0] = args;
36861 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36862 if (!SWIG_IsOK(res1)) {
36863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageUp" "', expected argument " "1"" of type '" "wxWindow *""'");
36864 }
36865 arg1 = reinterpret_cast< wxWindow * >(argp1);
36866 {
36867 PyThreadState* __tstate = wxPyBeginAllowThreads();
36868 result = (bool)(arg1)->PageUp();
36869 wxPyEndAllowThreads(__tstate);
36870 if (PyErr_Occurred()) SWIG_fail;
36871 }
36872 {
36873 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36874 }
36875 return resultobj;
36876 fail:
36877 return NULL;
36878 }
36879
36880
36881 SWIGINTERN PyObject *_wrap_Window_PageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36882 PyObject *resultobj = 0;
36883 wxWindow *arg1 = (wxWindow *) 0 ;
36884 bool result;
36885 void *argp1 = 0 ;
36886 int res1 = 0 ;
36887 PyObject *swig_obj[1] ;
36888
36889 if (!args) SWIG_fail;
36890 swig_obj[0] = args;
36891 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36892 if (!SWIG_IsOK(res1)) {
36893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageDown" "', expected argument " "1"" of type '" "wxWindow *""'");
36894 }
36895 arg1 = reinterpret_cast< wxWindow * >(argp1);
36896 {
36897 PyThreadState* __tstate = wxPyBeginAllowThreads();
36898 result = (bool)(arg1)->PageDown();
36899 wxPyEndAllowThreads(__tstate);
36900 if (PyErr_Occurred()) SWIG_fail;
36901 }
36902 {
36903 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36904 }
36905 return resultobj;
36906 fail:
36907 return NULL;
36908 }
36909
36910
36911 SWIGINTERN PyObject *_wrap_Window_SetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36912 PyObject *resultobj = 0;
36913 wxWindow *arg1 = (wxWindow *) 0 ;
36914 wxString *arg2 = 0 ;
36915 void *argp1 = 0 ;
36916 int res1 = 0 ;
36917 bool temp2 = false ;
36918 PyObject * obj0 = 0 ;
36919 PyObject * obj1 = 0 ;
36920 char * kwnames[] = {
36921 (char *) "self",(char *) "text", NULL
36922 };
36923
36924 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) SWIG_fail;
36925 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36926 if (!SWIG_IsOK(res1)) {
36927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpText" "', expected argument " "1"" of type '" "wxWindow *""'");
36928 }
36929 arg1 = reinterpret_cast< wxWindow * >(argp1);
36930 {
36931 arg2 = wxString_in_helper(obj1);
36932 if (arg2 == NULL) SWIG_fail;
36933 temp2 = true;
36934 }
36935 {
36936 PyThreadState* __tstate = wxPyBeginAllowThreads();
36937 (arg1)->SetHelpText((wxString const &)*arg2);
36938 wxPyEndAllowThreads(__tstate);
36939 if (PyErr_Occurred()) SWIG_fail;
36940 }
36941 resultobj = SWIG_Py_Void();
36942 {
36943 if (temp2)
36944 delete arg2;
36945 }
36946 return resultobj;
36947 fail:
36948 {
36949 if (temp2)
36950 delete arg2;
36951 }
36952 return NULL;
36953 }
36954
36955
36956 SWIGINTERN PyObject *_wrap_Window_SetHelpTextForId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36957 PyObject *resultobj = 0;
36958 wxWindow *arg1 = (wxWindow *) 0 ;
36959 wxString *arg2 = 0 ;
36960 void *argp1 = 0 ;
36961 int res1 = 0 ;
36962 bool temp2 = false ;
36963 PyObject * obj0 = 0 ;
36964 PyObject * obj1 = 0 ;
36965 char * kwnames[] = {
36966 (char *) "self",(char *) "text", NULL
36967 };
36968
36969 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) SWIG_fail;
36970 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36971 if (!SWIG_IsOK(res1)) {
36972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpTextForId" "', expected argument " "1"" of type '" "wxWindow *""'");
36973 }
36974 arg1 = reinterpret_cast< wxWindow * >(argp1);
36975 {
36976 arg2 = wxString_in_helper(obj1);
36977 if (arg2 == NULL) SWIG_fail;
36978 temp2 = true;
36979 }
36980 {
36981 PyThreadState* __tstate = wxPyBeginAllowThreads();
36982 (arg1)->SetHelpTextForId((wxString const &)*arg2);
36983 wxPyEndAllowThreads(__tstate);
36984 if (PyErr_Occurred()) SWIG_fail;
36985 }
36986 resultobj = SWIG_Py_Void();
36987 {
36988 if (temp2)
36989 delete arg2;
36990 }
36991 return resultobj;
36992 fail:
36993 {
36994 if (temp2)
36995 delete arg2;
36996 }
36997 return NULL;
36998 }
36999
37000
37001 SWIGINTERN PyObject *_wrap_Window_GetHelpTextAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37002 PyObject *resultobj = 0;
37003 wxWindow *arg1 = (wxWindow *) 0 ;
37004 wxPoint *arg2 = 0 ;
37005 wxHelpEvent::Origin arg3 ;
37006 wxString result;
37007 void *argp1 = 0 ;
37008 int res1 = 0 ;
37009 wxPoint temp2 ;
37010 void *argp3 ;
37011 int res3 = 0 ;
37012 PyObject * obj0 = 0 ;
37013 PyObject * obj1 = 0 ;
37014 PyObject * obj2 = 0 ;
37015 char * kwnames[] = {
37016 (char *) "self",(char *) "pt",(char *) "origin", NULL
37017 };
37018
37019 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_GetHelpTextAtPoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37020 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37021 if (!SWIG_IsOK(res1)) {
37022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
37023 }
37024 arg1 = reinterpret_cast< wxWindow * >(argp1);
37025 {
37026 arg2 = &temp2;
37027 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37028 }
37029 {
37030 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxHelpEvent__Origin, 0 | 0);
37031 if (!SWIG_IsOK(res3)) {
37032 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
37033 }
37034 if (!argp3) {
37035 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
37036 } else {
37037 wxHelpEvent::Origin * temp = reinterpret_cast< wxHelpEvent::Origin * >(argp3);
37038 arg3 = *temp;
37039 if (SWIG_IsNewObj(res3)) delete temp;
37040 }
37041 }
37042 {
37043 PyThreadState* __tstate = wxPyBeginAllowThreads();
37044 result = ((wxWindow const *)arg1)->GetHelpTextAtPoint((wxPoint const &)*arg2,arg3);
37045 wxPyEndAllowThreads(__tstate);
37046 if (PyErr_Occurred()) SWIG_fail;
37047 }
37048 {
37049 #if wxUSE_UNICODE
37050 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37051 #else
37052 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37053 #endif
37054 }
37055 return resultobj;
37056 fail:
37057 return NULL;
37058 }
37059
37060
37061 SWIGINTERN PyObject *_wrap_Window_GetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37062 PyObject *resultobj = 0;
37063 wxWindow *arg1 = (wxWindow *) 0 ;
37064 wxString result;
37065 void *argp1 = 0 ;
37066 int res1 = 0 ;
37067 PyObject *swig_obj[1] ;
37068
37069 if (!args) SWIG_fail;
37070 swig_obj[0] = args;
37071 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37072 if (!SWIG_IsOK(res1)) {
37073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpText" "', expected argument " "1"" of type '" "wxWindow const *""'");
37074 }
37075 arg1 = reinterpret_cast< wxWindow * >(argp1);
37076 {
37077 PyThreadState* __tstate = wxPyBeginAllowThreads();
37078 result = ((wxWindow const *)arg1)->GetHelpText();
37079 wxPyEndAllowThreads(__tstate);
37080 if (PyErr_Occurred()) SWIG_fail;
37081 }
37082 {
37083 #if wxUSE_UNICODE
37084 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37085 #else
37086 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37087 #endif
37088 }
37089 return resultobj;
37090 fail:
37091 return NULL;
37092 }
37093
37094
37095 SWIGINTERN PyObject *_wrap_Window_SetToolTipString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37096 PyObject *resultobj = 0;
37097 wxWindow *arg1 = (wxWindow *) 0 ;
37098 wxString *arg2 = 0 ;
37099 void *argp1 = 0 ;
37100 int res1 = 0 ;
37101 bool temp2 = false ;
37102 PyObject * obj0 = 0 ;
37103 PyObject * obj1 = 0 ;
37104 char * kwnames[] = {
37105 (char *) "self",(char *) "tip", NULL
37106 };
37107
37108 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) SWIG_fail;
37109 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37110 if (!SWIG_IsOK(res1)) {
37111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTipString" "', expected argument " "1"" of type '" "wxWindow *""'");
37112 }
37113 arg1 = reinterpret_cast< wxWindow * >(argp1);
37114 {
37115 arg2 = wxString_in_helper(obj1);
37116 if (arg2 == NULL) SWIG_fail;
37117 temp2 = true;
37118 }
37119 {
37120 PyThreadState* __tstate = wxPyBeginAllowThreads();
37121 (arg1)->SetToolTip((wxString const &)*arg2);
37122 wxPyEndAllowThreads(__tstate);
37123 if (PyErr_Occurred()) SWIG_fail;
37124 }
37125 resultobj = SWIG_Py_Void();
37126 {
37127 if (temp2)
37128 delete arg2;
37129 }
37130 return resultobj;
37131 fail:
37132 {
37133 if (temp2)
37134 delete arg2;
37135 }
37136 return NULL;
37137 }
37138
37139
37140 SWIGINTERN PyObject *_wrap_Window_SetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37141 PyObject *resultobj = 0;
37142 wxWindow *arg1 = (wxWindow *) 0 ;
37143 wxToolTip *arg2 = (wxToolTip *) 0 ;
37144 void *argp1 = 0 ;
37145 int res1 = 0 ;
37146 int res2 = 0 ;
37147 PyObject * obj0 = 0 ;
37148 PyObject * obj1 = 0 ;
37149 char * kwnames[] = {
37150 (char *) "self",(char *) "tip", NULL
37151 };
37152
37153 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) SWIG_fail;
37154 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37155 if (!SWIG_IsOK(res1)) {
37156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTip" "', expected argument " "1"" of type '" "wxWindow *""'");
37157 }
37158 arg1 = reinterpret_cast< wxWindow * >(argp1);
37159 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
37160 if (!SWIG_IsOK(res2)) {
37161 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetToolTip" "', expected argument " "2"" of type '" "wxToolTip *""'");
37162 }
37163 {
37164 PyThreadState* __tstate = wxPyBeginAllowThreads();
37165 (arg1)->SetToolTip(arg2);
37166 wxPyEndAllowThreads(__tstate);
37167 if (PyErr_Occurred()) SWIG_fail;
37168 }
37169 resultobj = SWIG_Py_Void();
37170 return resultobj;
37171 fail:
37172 return NULL;
37173 }
37174
37175
37176 SWIGINTERN PyObject *_wrap_Window_GetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37177 PyObject *resultobj = 0;
37178 wxWindow *arg1 = (wxWindow *) 0 ;
37179 wxToolTip *result = 0 ;
37180 void *argp1 = 0 ;
37181 int res1 = 0 ;
37182 PyObject *swig_obj[1] ;
37183
37184 if (!args) SWIG_fail;
37185 swig_obj[0] = args;
37186 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37187 if (!SWIG_IsOK(res1)) {
37188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetToolTip" "', expected argument " "1"" of type '" "wxWindow const *""'");
37189 }
37190 arg1 = reinterpret_cast< wxWindow * >(argp1);
37191 {
37192 PyThreadState* __tstate = wxPyBeginAllowThreads();
37193 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
37194 wxPyEndAllowThreads(__tstate);
37195 if (PyErr_Occurred()) SWIG_fail;
37196 }
37197 {
37198 resultobj = wxPyMake_wxObject(result, (bool)0);
37199 }
37200 return resultobj;
37201 fail:
37202 return NULL;
37203 }
37204
37205
37206 SWIGINTERN PyObject *_wrap_Window_SetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37207 PyObject *resultobj = 0;
37208 wxWindow *arg1 = (wxWindow *) 0 ;
37209 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
37210 void *argp1 = 0 ;
37211 int res1 = 0 ;
37212 int res2 = 0 ;
37213 PyObject * obj0 = 0 ;
37214 PyObject * obj1 = 0 ;
37215 char * kwnames[] = {
37216 (char *) "self",(char *) "dropTarget", NULL
37217 };
37218
37219 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) SWIG_fail;
37220 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37221 if (!SWIG_IsOK(res1)) {
37222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDropTarget" "', expected argument " "1"" of type '" "wxWindow *""'");
37223 }
37224 arg1 = reinterpret_cast< wxWindow * >(argp1);
37225 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
37226 if (!SWIG_IsOK(res2)) {
37227 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDropTarget" "', expected argument " "2"" of type '" "wxPyDropTarget *""'");
37228 }
37229 {
37230 PyThreadState* __tstate = wxPyBeginAllowThreads();
37231 (arg1)->SetDropTarget(arg2);
37232 wxPyEndAllowThreads(__tstate);
37233 if (PyErr_Occurred()) SWIG_fail;
37234 }
37235 resultobj = SWIG_Py_Void();
37236 return resultobj;
37237 fail:
37238 return NULL;
37239 }
37240
37241
37242 SWIGINTERN PyObject *_wrap_Window_GetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37243 PyObject *resultobj = 0;
37244 wxWindow *arg1 = (wxWindow *) 0 ;
37245 wxPyDropTarget *result = 0 ;
37246 void *argp1 = 0 ;
37247 int res1 = 0 ;
37248 PyObject *swig_obj[1] ;
37249
37250 if (!args) SWIG_fail;
37251 swig_obj[0] = args;
37252 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37253 if (!SWIG_IsOK(res1)) {
37254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDropTarget" "', expected argument " "1"" of type '" "wxWindow const *""'");
37255 }
37256 arg1 = reinterpret_cast< wxWindow * >(argp1);
37257 {
37258 PyThreadState* __tstate = wxPyBeginAllowThreads();
37259 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
37260 wxPyEndAllowThreads(__tstate);
37261 if (PyErr_Occurred()) SWIG_fail;
37262 }
37263 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
37264 return resultobj;
37265 fail:
37266 return NULL;
37267 }
37268
37269
37270 SWIGINTERN PyObject *_wrap_Window_DragAcceptFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37271 PyObject *resultobj = 0;
37272 wxWindow *arg1 = (wxWindow *) 0 ;
37273 bool arg2 ;
37274 void *argp1 = 0 ;
37275 int res1 = 0 ;
37276 bool val2 ;
37277 int ecode2 = 0 ;
37278 PyObject * obj0 = 0 ;
37279 PyObject * obj1 = 0 ;
37280 char * kwnames[] = {
37281 (char *) "self",(char *) "accept", NULL
37282 };
37283
37284 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) SWIG_fail;
37285 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37286 if (!SWIG_IsOK(res1)) {
37287 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DragAcceptFiles" "', expected argument " "1"" of type '" "wxWindow *""'");
37288 }
37289 arg1 = reinterpret_cast< wxWindow * >(argp1);
37290 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37291 if (!SWIG_IsOK(ecode2)) {
37292 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_DragAcceptFiles" "', expected argument " "2"" of type '" "bool""'");
37293 }
37294 arg2 = static_cast< bool >(val2);
37295 {
37296 PyThreadState* __tstate = wxPyBeginAllowThreads();
37297 (arg1)->DragAcceptFiles(arg2);
37298 wxPyEndAllowThreads(__tstate);
37299 if (PyErr_Occurred()) SWIG_fail;
37300 }
37301 resultobj = SWIG_Py_Void();
37302 return resultobj;
37303 fail:
37304 return NULL;
37305 }
37306
37307
37308 SWIGINTERN PyObject *_wrap_Window_SetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37309 PyObject *resultobj = 0;
37310 wxWindow *arg1 = (wxWindow *) 0 ;
37311 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
37312 void *argp1 = 0 ;
37313 int res1 = 0 ;
37314 int res2 = 0 ;
37315 PyObject * obj0 = 0 ;
37316 PyObject * obj1 = 0 ;
37317 char * kwnames[] = {
37318 (char *) "self",(char *) "constraints", NULL
37319 };
37320
37321 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
37322 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37323 if (!SWIG_IsOK(res1)) {
37324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetConstraints" "', expected argument " "1"" of type '" "wxWindow *""'");
37325 }
37326 arg1 = reinterpret_cast< wxWindow * >(argp1);
37327 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
37328 if (!SWIG_IsOK(res2)) {
37329 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetConstraints" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
37330 }
37331 {
37332 PyThreadState* __tstate = wxPyBeginAllowThreads();
37333 (arg1)->SetConstraints(arg2);
37334 wxPyEndAllowThreads(__tstate);
37335 if (PyErr_Occurred()) SWIG_fail;
37336 }
37337 resultobj = SWIG_Py_Void();
37338 return resultobj;
37339 fail:
37340 return NULL;
37341 }
37342
37343
37344 SWIGINTERN PyObject *_wrap_Window_GetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37345 PyObject *resultobj = 0;
37346 wxWindow *arg1 = (wxWindow *) 0 ;
37347 wxLayoutConstraints *result = 0 ;
37348 void *argp1 = 0 ;
37349 int res1 = 0 ;
37350 PyObject *swig_obj[1] ;
37351
37352 if (!args) SWIG_fail;
37353 swig_obj[0] = args;
37354 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37355 if (!SWIG_IsOK(res1)) {
37356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetConstraints" "', expected argument " "1"" of type '" "wxWindow const *""'");
37357 }
37358 arg1 = reinterpret_cast< wxWindow * >(argp1);
37359 {
37360 PyThreadState* __tstate = wxPyBeginAllowThreads();
37361 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
37362 wxPyEndAllowThreads(__tstate);
37363 if (PyErr_Occurred()) SWIG_fail;
37364 }
37365 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
37366 return resultobj;
37367 fail:
37368 return NULL;
37369 }
37370
37371
37372 SWIGINTERN PyObject *_wrap_Window_SetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37373 PyObject *resultobj = 0;
37374 wxWindow *arg1 = (wxWindow *) 0 ;
37375 bool arg2 ;
37376 void *argp1 = 0 ;
37377 int res1 = 0 ;
37378 bool val2 ;
37379 int ecode2 = 0 ;
37380 PyObject * obj0 = 0 ;
37381 PyObject * obj1 = 0 ;
37382 char * kwnames[] = {
37383 (char *) "self",(char *) "autoLayout", NULL
37384 };
37385
37386 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) SWIG_fail;
37387 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37388 if (!SWIG_IsOK(res1)) {
37389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAutoLayout" "', expected argument " "1"" of type '" "wxWindow *""'");
37390 }
37391 arg1 = reinterpret_cast< wxWindow * >(argp1);
37392 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37393 if (!SWIG_IsOK(ecode2)) {
37394 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetAutoLayout" "', expected argument " "2"" of type '" "bool""'");
37395 }
37396 arg2 = static_cast< bool >(val2);
37397 {
37398 PyThreadState* __tstate = wxPyBeginAllowThreads();
37399 (arg1)->SetAutoLayout(arg2);
37400 wxPyEndAllowThreads(__tstate);
37401 if (PyErr_Occurred()) SWIG_fail;
37402 }
37403 resultobj = SWIG_Py_Void();
37404 return resultobj;
37405 fail:
37406 return NULL;
37407 }
37408
37409
37410 SWIGINTERN PyObject *_wrap_Window_GetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37411 PyObject *resultobj = 0;
37412 wxWindow *arg1 = (wxWindow *) 0 ;
37413 bool result;
37414 void *argp1 = 0 ;
37415 int res1 = 0 ;
37416 PyObject *swig_obj[1] ;
37417
37418 if (!args) SWIG_fail;
37419 swig_obj[0] = args;
37420 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37421 if (!SWIG_IsOK(res1)) {
37422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAutoLayout" "', expected argument " "1"" of type '" "wxWindow const *""'");
37423 }
37424 arg1 = reinterpret_cast< wxWindow * >(argp1);
37425 {
37426 PyThreadState* __tstate = wxPyBeginAllowThreads();
37427 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
37428 wxPyEndAllowThreads(__tstate);
37429 if (PyErr_Occurred()) SWIG_fail;
37430 }
37431 {
37432 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37433 }
37434 return resultobj;
37435 fail:
37436 return NULL;
37437 }
37438
37439
37440 SWIGINTERN PyObject *_wrap_Window_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37441 PyObject *resultobj = 0;
37442 wxWindow *arg1 = (wxWindow *) 0 ;
37443 bool result;
37444 void *argp1 = 0 ;
37445 int res1 = 0 ;
37446 PyObject *swig_obj[1] ;
37447
37448 if (!args) SWIG_fail;
37449 swig_obj[0] = args;
37450 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37451 if (!SWIG_IsOK(res1)) {
37452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Layout" "', expected argument " "1"" of type '" "wxWindow *""'");
37453 }
37454 arg1 = reinterpret_cast< wxWindow * >(argp1);
37455 {
37456 PyThreadState* __tstate = wxPyBeginAllowThreads();
37457 result = (bool)(arg1)->Layout();
37458 wxPyEndAllowThreads(__tstate);
37459 if (PyErr_Occurred()) SWIG_fail;
37460 }
37461 {
37462 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37463 }
37464 return resultobj;
37465 fail:
37466 return NULL;
37467 }
37468
37469
37470 SWIGINTERN PyObject *_wrap_Window_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37471 PyObject *resultobj = 0;
37472 wxWindow *arg1 = (wxWindow *) 0 ;
37473 wxSizer *arg2 = (wxSizer *) 0 ;
37474 bool arg3 = (bool) true ;
37475 void *argp1 = 0 ;
37476 int res1 = 0 ;
37477 int res2 = 0 ;
37478 bool val3 ;
37479 int ecode3 = 0 ;
37480 PyObject * obj0 = 0 ;
37481 PyObject * obj1 = 0 ;
37482 PyObject * obj2 = 0 ;
37483 char * kwnames[] = {
37484 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
37485 };
37486
37487 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37488 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37489 if (!SWIG_IsOK(res1)) {
37490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
37491 }
37492 arg1 = reinterpret_cast< wxWindow * >(argp1);
37493 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
37494 if (!SWIG_IsOK(res2)) {
37495 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
37496 }
37497 if (obj2) {
37498 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37499 if (!SWIG_IsOK(ecode3)) {
37500 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizer" "', expected argument " "3"" of type '" "bool""'");
37501 }
37502 arg3 = static_cast< bool >(val3);
37503 }
37504 {
37505 PyThreadState* __tstate = wxPyBeginAllowThreads();
37506 (arg1)->SetSizer(arg2,arg3);
37507 wxPyEndAllowThreads(__tstate);
37508 if (PyErr_Occurred()) SWIG_fail;
37509 }
37510 resultobj = SWIG_Py_Void();
37511 return resultobj;
37512 fail:
37513 return NULL;
37514 }
37515
37516
37517 SWIGINTERN PyObject *_wrap_Window_SetSizerAndFit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37518 PyObject *resultobj = 0;
37519 wxWindow *arg1 = (wxWindow *) 0 ;
37520 wxSizer *arg2 = (wxSizer *) 0 ;
37521 bool arg3 = (bool) true ;
37522 void *argp1 = 0 ;
37523 int res1 = 0 ;
37524 int res2 = 0 ;
37525 bool val3 ;
37526 int ecode3 = 0 ;
37527 PyObject * obj0 = 0 ;
37528 PyObject * obj1 = 0 ;
37529 PyObject * obj2 = 0 ;
37530 char * kwnames[] = {
37531 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
37532 };
37533
37534 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37535 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37536 if (!SWIG_IsOK(res1)) {
37537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizerAndFit" "', expected argument " "1"" of type '" "wxWindow *""'");
37538 }
37539 arg1 = reinterpret_cast< wxWindow * >(argp1);
37540 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
37541 if (!SWIG_IsOK(res2)) {
37542 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizerAndFit" "', expected argument " "2"" of type '" "wxSizer *""'");
37543 }
37544 if (obj2) {
37545 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37546 if (!SWIG_IsOK(ecode3)) {
37547 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizerAndFit" "', expected argument " "3"" of type '" "bool""'");
37548 }
37549 arg3 = static_cast< bool >(val3);
37550 }
37551 {
37552 PyThreadState* __tstate = wxPyBeginAllowThreads();
37553 (arg1)->SetSizerAndFit(arg2,arg3);
37554 wxPyEndAllowThreads(__tstate);
37555 if (PyErr_Occurred()) SWIG_fail;
37556 }
37557 resultobj = SWIG_Py_Void();
37558 return resultobj;
37559 fail:
37560 return NULL;
37561 }
37562
37563
37564 SWIGINTERN PyObject *_wrap_Window_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37565 PyObject *resultobj = 0;
37566 wxWindow *arg1 = (wxWindow *) 0 ;
37567 wxSizer *result = 0 ;
37568 void *argp1 = 0 ;
37569 int res1 = 0 ;
37570 PyObject *swig_obj[1] ;
37571
37572 if (!args) SWIG_fail;
37573 swig_obj[0] = args;
37574 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37575 if (!SWIG_IsOK(res1)) {
37576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
37577 }
37578 arg1 = reinterpret_cast< wxWindow * >(argp1);
37579 {
37580 PyThreadState* __tstate = wxPyBeginAllowThreads();
37581 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
37582 wxPyEndAllowThreads(__tstate);
37583 if (PyErr_Occurred()) SWIG_fail;
37584 }
37585 {
37586 resultobj = wxPyMake_wxObject(result, (bool)0);
37587 }
37588 return resultobj;
37589 fail:
37590 return NULL;
37591 }
37592
37593
37594 SWIGINTERN PyObject *_wrap_Window_SetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37595 PyObject *resultobj = 0;
37596 wxWindow *arg1 = (wxWindow *) 0 ;
37597 wxSizer *arg2 = (wxSizer *) 0 ;
37598 void *argp1 = 0 ;
37599 int res1 = 0 ;
37600 void *argp2 = 0 ;
37601 int res2 = 0 ;
37602 PyObject * obj0 = 0 ;
37603 PyObject * obj1 = 0 ;
37604 char * kwnames[] = {
37605 (char *) "self",(char *) "sizer", NULL
37606 };
37607
37608 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) SWIG_fail;
37609 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37610 if (!SWIG_IsOK(res1)) {
37611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetContainingSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
37612 }
37613 arg1 = reinterpret_cast< wxWindow * >(argp1);
37614 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
37615 if (!SWIG_IsOK(res2)) {
37616 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetContainingSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
37617 }
37618 arg2 = reinterpret_cast< wxSizer * >(argp2);
37619 {
37620 PyThreadState* __tstate = wxPyBeginAllowThreads();
37621 (arg1)->SetContainingSizer(arg2);
37622 wxPyEndAllowThreads(__tstate);
37623 if (PyErr_Occurred()) SWIG_fail;
37624 }
37625 resultobj = SWIG_Py_Void();
37626 return resultobj;
37627 fail:
37628 return NULL;
37629 }
37630
37631
37632 SWIGINTERN PyObject *_wrap_Window_GetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37633 PyObject *resultobj = 0;
37634 wxWindow *arg1 = (wxWindow *) 0 ;
37635 wxSizer *result = 0 ;
37636 void *argp1 = 0 ;
37637 int res1 = 0 ;
37638 PyObject *swig_obj[1] ;
37639
37640 if (!args) SWIG_fail;
37641 swig_obj[0] = args;
37642 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37643 if (!SWIG_IsOK(res1)) {
37644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetContainingSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
37645 }
37646 arg1 = reinterpret_cast< wxWindow * >(argp1);
37647 {
37648 PyThreadState* __tstate = wxPyBeginAllowThreads();
37649 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
37650 wxPyEndAllowThreads(__tstate);
37651 if (PyErr_Occurred()) SWIG_fail;
37652 }
37653 {
37654 resultobj = wxPyMake_wxObject(result, (bool)0);
37655 }
37656 return resultobj;
37657 fail:
37658 return NULL;
37659 }
37660
37661
37662 SWIGINTERN PyObject *_wrap_Window_InheritAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37663 PyObject *resultobj = 0;
37664 wxWindow *arg1 = (wxWindow *) 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_wxWindow, 0 | 0 );
37672 if (!SWIG_IsOK(res1)) {
37673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritAttributes" "', expected argument " "1"" of type '" "wxWindow *""'");
37674 }
37675 arg1 = reinterpret_cast< wxWindow * >(argp1);
37676 {
37677 PyThreadState* __tstate = wxPyBeginAllowThreads();
37678 (arg1)->InheritAttributes();
37679 wxPyEndAllowThreads(__tstate);
37680 if (PyErr_Occurred()) SWIG_fail;
37681 }
37682 resultobj = SWIG_Py_Void();
37683 return resultobj;
37684 fail:
37685 return NULL;
37686 }
37687
37688
37689 SWIGINTERN PyObject *_wrap_Window_ShouldInheritColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37690 PyObject *resultobj = 0;
37691 wxWindow *arg1 = (wxWindow *) 0 ;
37692 bool result;
37693 void *argp1 = 0 ;
37694 int res1 = 0 ;
37695 PyObject *swig_obj[1] ;
37696
37697 if (!args) SWIG_fail;
37698 swig_obj[0] = args;
37699 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37700 if (!SWIG_IsOK(res1)) {
37701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ShouldInheritColours" "', expected argument " "1"" of type '" "wxWindow const *""'");
37702 }
37703 arg1 = reinterpret_cast< wxWindow * >(argp1);
37704 {
37705 PyThreadState* __tstate = wxPyBeginAllowThreads();
37706 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
37707 wxPyEndAllowThreads(__tstate);
37708 if (PyErr_Occurred()) SWIG_fail;
37709 }
37710 {
37711 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37712 }
37713 return resultobj;
37714 fail:
37715 return NULL;
37716 }
37717
37718
37719 SWIGINTERN PyObject *Window_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37720 PyObject *obj;
37721 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37722 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindow, SWIG_NewClientData(obj));
37723 return SWIG_Py_Void();
37724 }
37725
37726 SWIGINTERN PyObject *Window_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37727 return SWIG_Python_InitShadowInstance(args);
37728 }
37729
37730 SWIGINTERN PyObject *_wrap_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37731 PyObject *resultobj = 0;
37732 long arg1 ;
37733 wxWindow *arg2 = (wxWindow *) NULL ;
37734 wxWindow *result = 0 ;
37735 long val1 ;
37736 int ecode1 = 0 ;
37737 void *argp2 = 0 ;
37738 int res2 = 0 ;
37739 PyObject * obj0 = 0 ;
37740 PyObject * obj1 = 0 ;
37741 char * kwnames[] = {
37742 (char *) "id",(char *) "parent", NULL
37743 };
37744
37745 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
37746 ecode1 = SWIG_AsVal_long(obj0, &val1);
37747 if (!SWIG_IsOK(ecode1)) {
37748 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FindWindowById" "', expected argument " "1"" of type '" "long""'");
37749 }
37750 arg1 = static_cast< long >(val1);
37751 if (obj1) {
37752 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37753 if (!SWIG_IsOK(res2)) {
37754 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowById" "', expected argument " "2"" of type '" "wxWindow const *""'");
37755 }
37756 arg2 = reinterpret_cast< wxWindow * >(argp2);
37757 }
37758 {
37759 if (!wxPyCheckForApp()) SWIG_fail;
37760 PyThreadState* __tstate = wxPyBeginAllowThreads();
37761 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
37762 wxPyEndAllowThreads(__tstate);
37763 if (PyErr_Occurred()) SWIG_fail;
37764 }
37765 {
37766 resultobj = wxPyMake_wxObject(result, 0);
37767 }
37768 return resultobj;
37769 fail:
37770 return NULL;
37771 }
37772
37773
37774 SWIGINTERN PyObject *_wrap_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37775 PyObject *resultobj = 0;
37776 wxString *arg1 = 0 ;
37777 wxWindow *arg2 = (wxWindow *) NULL ;
37778 wxWindow *result = 0 ;
37779 bool temp1 = false ;
37780 void *argp2 = 0 ;
37781 int res2 = 0 ;
37782 PyObject * obj0 = 0 ;
37783 PyObject * obj1 = 0 ;
37784 char * kwnames[] = {
37785 (char *) "name",(char *) "parent", NULL
37786 };
37787
37788 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
37789 {
37790 arg1 = wxString_in_helper(obj0);
37791 if (arg1 == NULL) SWIG_fail;
37792 temp1 = true;
37793 }
37794 if (obj1) {
37795 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37796 if (!SWIG_IsOK(res2)) {
37797 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByName" "', expected argument " "2"" of type '" "wxWindow const *""'");
37798 }
37799 arg2 = reinterpret_cast< wxWindow * >(argp2);
37800 }
37801 {
37802 if (!wxPyCheckForApp()) SWIG_fail;
37803 PyThreadState* __tstate = wxPyBeginAllowThreads();
37804 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
37805 wxPyEndAllowThreads(__tstate);
37806 if (PyErr_Occurred()) SWIG_fail;
37807 }
37808 {
37809 resultobj = wxPyMake_wxObject(result, 0);
37810 }
37811 {
37812 if (temp1)
37813 delete arg1;
37814 }
37815 return resultobj;
37816 fail:
37817 {
37818 if (temp1)
37819 delete arg1;
37820 }
37821 return NULL;
37822 }
37823
37824
37825 SWIGINTERN PyObject *_wrap_FindWindowByLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37826 PyObject *resultobj = 0;
37827 wxString *arg1 = 0 ;
37828 wxWindow *arg2 = (wxWindow *) NULL ;
37829 wxWindow *result = 0 ;
37830 bool temp1 = false ;
37831 void *argp2 = 0 ;
37832 int res2 = 0 ;
37833 PyObject * obj0 = 0 ;
37834 PyObject * obj1 = 0 ;
37835 char * kwnames[] = {
37836 (char *) "label",(char *) "parent", NULL
37837 };
37838
37839 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) SWIG_fail;
37840 {
37841 arg1 = wxString_in_helper(obj0);
37842 if (arg1 == NULL) SWIG_fail;
37843 temp1 = true;
37844 }
37845 if (obj1) {
37846 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37847 if (!SWIG_IsOK(res2)) {
37848 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByLabel" "', expected argument " "2"" of type '" "wxWindow const *""'");
37849 }
37850 arg2 = reinterpret_cast< wxWindow * >(argp2);
37851 }
37852 {
37853 if (!wxPyCheckForApp()) SWIG_fail;
37854 PyThreadState* __tstate = wxPyBeginAllowThreads();
37855 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
37856 wxPyEndAllowThreads(__tstate);
37857 if (PyErr_Occurred()) SWIG_fail;
37858 }
37859 {
37860 resultobj = wxPyMake_wxObject(result, 0);
37861 }
37862 {
37863 if (temp1)
37864 delete arg1;
37865 }
37866 return resultobj;
37867 fail:
37868 {
37869 if (temp1)
37870 delete arg1;
37871 }
37872 return NULL;
37873 }
37874
37875
37876 SWIGINTERN PyObject *_wrap_Window_FromHWND(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37877 PyObject *resultobj = 0;
37878 wxWindow *arg1 = (wxWindow *) 0 ;
37879 unsigned long arg2 ;
37880 wxWindow *result = 0 ;
37881 void *argp1 = 0 ;
37882 int res1 = 0 ;
37883 unsigned long val2 ;
37884 int ecode2 = 0 ;
37885 PyObject * obj0 = 0 ;
37886 PyObject * obj1 = 0 ;
37887 char * kwnames[] = {
37888 (char *) "parent",(char *) "_hWnd", NULL
37889 };
37890
37891 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) SWIG_fail;
37892 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37893 if (!SWIG_IsOK(res1)) {
37894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FromHWND" "', expected argument " "1"" of type '" "wxWindow *""'");
37895 }
37896 arg1 = reinterpret_cast< wxWindow * >(argp1);
37897 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
37898 if (!SWIG_IsOK(ecode2)) {
37899 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FromHWND" "', expected argument " "2"" of type '" "unsigned long""'");
37900 }
37901 arg2 = static_cast< unsigned long >(val2);
37902 {
37903 PyThreadState* __tstate = wxPyBeginAllowThreads();
37904 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
37905 wxPyEndAllowThreads(__tstate);
37906 if (PyErr_Occurred()) SWIG_fail;
37907 }
37908 {
37909 resultobj = wxPyMake_wxObject(result, 0);
37910 }
37911 return resultobj;
37912 fail:
37913 return NULL;
37914 }
37915
37916
37917 SWIGINTERN PyObject *_wrap_GetTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37918 PyObject *resultobj = 0;
37919 PyObject *result = 0 ;
37920
37921 if (!SWIG_Python_UnpackTuple(args,"GetTopLevelWindows",0,0,0)) SWIG_fail;
37922 {
37923 PyThreadState* __tstate = wxPyBeginAllowThreads();
37924 result = (PyObject *)GetTopLevelWindows();
37925 wxPyEndAllowThreads(__tstate);
37926 if (PyErr_Occurred()) SWIG_fail;
37927 }
37928 resultobj = result;
37929 return resultobj;
37930 fail:
37931 return NULL;
37932 }
37933
37934
37935 SWIGINTERN PyObject *_wrap_new_Validator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37936 PyObject *resultobj = 0;
37937 wxValidator *result = 0 ;
37938
37939 if (!SWIG_Python_UnpackTuple(args,"new_Validator",0,0,0)) SWIG_fail;
37940 {
37941 PyThreadState* __tstate = wxPyBeginAllowThreads();
37942 result = (wxValidator *)new wxValidator();
37943 wxPyEndAllowThreads(__tstate);
37944 if (PyErr_Occurred()) SWIG_fail;
37945 }
37946 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxValidator, SWIG_POINTER_NEW | 0 );
37947 return resultobj;
37948 fail:
37949 return NULL;
37950 }
37951
37952
37953 SWIGINTERN PyObject *_wrap_Validator_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37954 PyObject *resultobj = 0;
37955 wxValidator *arg1 = (wxValidator *) 0 ;
37956 wxValidator *result = 0 ;
37957 void *argp1 = 0 ;
37958 int res1 = 0 ;
37959 PyObject *swig_obj[1] ;
37960
37961 if (!args) SWIG_fail;
37962 swig_obj[0] = args;
37963 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37964 if (!SWIG_IsOK(res1)) {
37965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Clone" "', expected argument " "1"" of type '" "wxValidator *""'");
37966 }
37967 arg1 = reinterpret_cast< wxValidator * >(argp1);
37968 {
37969 PyThreadState* __tstate = wxPyBeginAllowThreads();
37970 result = (wxValidator *)(arg1)->Clone();
37971 wxPyEndAllowThreads(__tstate);
37972 if (PyErr_Occurred()) SWIG_fail;
37973 }
37974 {
37975 resultobj = wxPyMake_wxObject(result, 0);
37976 }
37977 return resultobj;
37978 fail:
37979 return NULL;
37980 }
37981
37982
37983 SWIGINTERN PyObject *_wrap_Validator_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37984 PyObject *resultobj = 0;
37985 wxValidator *arg1 = (wxValidator *) 0 ;
37986 wxWindow *arg2 = (wxWindow *) 0 ;
37987 bool result;
37988 void *argp1 = 0 ;
37989 int res1 = 0 ;
37990 void *argp2 = 0 ;
37991 int res2 = 0 ;
37992 PyObject * obj0 = 0 ;
37993 PyObject * obj1 = 0 ;
37994 char * kwnames[] = {
37995 (char *) "self",(char *) "parent", NULL
37996 };
37997
37998 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) SWIG_fail;
37999 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38000 if (!SWIG_IsOK(res1)) {
38001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Validate" "', expected argument " "1"" of type '" "wxValidator *""'");
38002 }
38003 arg1 = reinterpret_cast< wxValidator * >(argp1);
38004 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38005 if (!SWIG_IsOK(res2)) {
38006 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_Validate" "', expected argument " "2"" of type '" "wxWindow *""'");
38007 }
38008 arg2 = reinterpret_cast< wxWindow * >(argp2);
38009 {
38010 PyThreadState* __tstate = wxPyBeginAllowThreads();
38011 result = (bool)(arg1)->Validate(arg2);
38012 wxPyEndAllowThreads(__tstate);
38013 if (PyErr_Occurred()) SWIG_fail;
38014 }
38015 {
38016 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38017 }
38018 return resultobj;
38019 fail:
38020 return NULL;
38021 }
38022
38023
38024 SWIGINTERN PyObject *_wrap_Validator_TransferToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38025 PyObject *resultobj = 0;
38026 wxValidator *arg1 = (wxValidator *) 0 ;
38027 bool result;
38028 void *argp1 = 0 ;
38029 int res1 = 0 ;
38030 PyObject *swig_obj[1] ;
38031
38032 if (!args) SWIG_fail;
38033 swig_obj[0] = args;
38034 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38035 if (!SWIG_IsOK(res1)) {
38036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferToWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38037 }
38038 arg1 = reinterpret_cast< wxValidator * >(argp1);
38039 {
38040 PyThreadState* __tstate = wxPyBeginAllowThreads();
38041 result = (bool)(arg1)->TransferToWindow();
38042 wxPyEndAllowThreads(__tstate);
38043 if (PyErr_Occurred()) SWIG_fail;
38044 }
38045 {
38046 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38047 }
38048 return resultobj;
38049 fail:
38050 return NULL;
38051 }
38052
38053
38054 SWIGINTERN PyObject *_wrap_Validator_TransferFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38055 PyObject *resultobj = 0;
38056 wxValidator *arg1 = (wxValidator *) 0 ;
38057 bool result;
38058 void *argp1 = 0 ;
38059 int res1 = 0 ;
38060 PyObject *swig_obj[1] ;
38061
38062 if (!args) SWIG_fail;
38063 swig_obj[0] = args;
38064 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38065 if (!SWIG_IsOK(res1)) {
38066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferFromWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38067 }
38068 arg1 = reinterpret_cast< wxValidator * >(argp1);
38069 {
38070 PyThreadState* __tstate = wxPyBeginAllowThreads();
38071 result = (bool)(arg1)->TransferFromWindow();
38072 wxPyEndAllowThreads(__tstate);
38073 if (PyErr_Occurred()) SWIG_fail;
38074 }
38075 {
38076 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38077 }
38078 return resultobj;
38079 fail:
38080 return NULL;
38081 }
38082
38083
38084 SWIGINTERN PyObject *_wrap_Validator_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38085 PyObject *resultobj = 0;
38086 wxValidator *arg1 = (wxValidator *) 0 ;
38087 wxWindow *result = 0 ;
38088 void *argp1 = 0 ;
38089 int res1 = 0 ;
38090 PyObject *swig_obj[1] ;
38091
38092 if (!args) SWIG_fail;
38093 swig_obj[0] = args;
38094 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38095 if (!SWIG_IsOK(res1)) {
38096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_GetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38097 }
38098 arg1 = reinterpret_cast< wxValidator * >(argp1);
38099 {
38100 PyThreadState* __tstate = wxPyBeginAllowThreads();
38101 result = (wxWindow *)(arg1)->GetWindow();
38102 wxPyEndAllowThreads(__tstate);
38103 if (PyErr_Occurred()) SWIG_fail;
38104 }
38105 {
38106 resultobj = wxPyMake_wxObject(result, 0);
38107 }
38108 return resultobj;
38109 fail:
38110 return NULL;
38111 }
38112
38113
38114 SWIGINTERN PyObject *_wrap_Validator_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38115 PyObject *resultobj = 0;
38116 wxValidator *arg1 = (wxValidator *) 0 ;
38117 wxWindow *arg2 = (wxWindow *) 0 ;
38118 void *argp1 = 0 ;
38119 int res1 = 0 ;
38120 void *argp2 = 0 ;
38121 int res2 = 0 ;
38122 PyObject * obj0 = 0 ;
38123 PyObject * obj1 = 0 ;
38124 char * kwnames[] = {
38125 (char *) "self",(char *) "window", NULL
38126 };
38127
38128 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
38129 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38130 if (!SWIG_IsOK(res1)) {
38131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_SetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38132 }
38133 arg1 = reinterpret_cast< wxValidator * >(argp1);
38134 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38135 if (!SWIG_IsOK(res2)) {
38136 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
38137 }
38138 arg2 = reinterpret_cast< wxWindow * >(argp2);
38139 {
38140 PyThreadState* __tstate = wxPyBeginAllowThreads();
38141 (arg1)->SetWindow(arg2);
38142 wxPyEndAllowThreads(__tstate);
38143 if (PyErr_Occurred()) SWIG_fail;
38144 }
38145 resultobj = SWIG_Py_Void();
38146 return resultobj;
38147 fail:
38148 return NULL;
38149 }
38150
38151
38152 SWIGINTERN PyObject *_wrap_Validator_IsSilent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38153 PyObject *resultobj = 0;
38154 bool result;
38155
38156 if (!SWIG_Python_UnpackTuple(args,"Validator_IsSilent",0,0,0)) SWIG_fail;
38157 {
38158 PyThreadState* __tstate = wxPyBeginAllowThreads();
38159 result = (bool)wxValidator::IsSilent();
38160 wxPyEndAllowThreads(__tstate);
38161 if (PyErr_Occurred()) SWIG_fail;
38162 }
38163 {
38164 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38165 }
38166 return resultobj;
38167 fail:
38168 return NULL;
38169 }
38170
38171
38172 SWIGINTERN PyObject *_wrap_Validator_SetBellOnError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38173 PyObject *resultobj = 0;
38174 int arg1 = (int) true ;
38175 int val1 ;
38176 int ecode1 = 0 ;
38177 PyObject * obj0 = 0 ;
38178 char * kwnames[] = {
38179 (char *) "doIt", NULL
38180 };
38181
38182 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) SWIG_fail;
38183 if (obj0) {
38184 ecode1 = SWIG_AsVal_int(obj0, &val1);
38185 if (!SWIG_IsOK(ecode1)) {
38186 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Validator_SetBellOnError" "', expected argument " "1"" of type '" "int""'");
38187 }
38188 arg1 = static_cast< int >(val1);
38189 }
38190 {
38191 PyThreadState* __tstate = wxPyBeginAllowThreads();
38192 wxValidator::SetBellOnError(arg1);
38193 wxPyEndAllowThreads(__tstate);
38194 if (PyErr_Occurred()) SWIG_fail;
38195 }
38196 resultobj = SWIG_Py_Void();
38197 return resultobj;
38198 fail:
38199 return NULL;
38200 }
38201
38202
38203 SWIGINTERN PyObject *Validator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38204 PyObject *obj;
38205 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
38206 SWIG_TypeNewClientData(SWIGTYPE_p_wxValidator, SWIG_NewClientData(obj));
38207 return SWIG_Py_Void();
38208 }
38209
38210 SWIGINTERN PyObject *Validator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38211 return SWIG_Python_InitShadowInstance(args);
38212 }
38213
38214 SWIGINTERN PyObject *_wrap_new_PyValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38215 PyObject *resultobj = 0;
38216 wxPyValidator *result = 0 ;
38217
38218 if (!SWIG_Python_UnpackTuple(args,"new_PyValidator",0,0,0)) SWIG_fail;
38219 {
38220 PyThreadState* __tstate = wxPyBeginAllowThreads();
38221 result = (wxPyValidator *)new wxPyValidator();
38222 wxPyEndAllowThreads(__tstate);
38223 if (PyErr_Occurred()) SWIG_fail;
38224 }
38225 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyValidator, SWIG_POINTER_NEW | 0 );
38226 return resultobj;
38227 fail:
38228 return NULL;
38229 }
38230
38231
38232 SWIGINTERN PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38233 PyObject *resultobj = 0;
38234 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
38235 PyObject *arg2 = (PyObject *) 0 ;
38236 PyObject *arg3 = (PyObject *) 0 ;
38237 int arg4 = (int) true ;
38238 void *argp1 = 0 ;
38239 int res1 = 0 ;
38240 int val4 ;
38241 int ecode4 = 0 ;
38242 PyObject * obj0 = 0 ;
38243 PyObject * obj1 = 0 ;
38244 PyObject * obj2 = 0 ;
38245 PyObject * obj3 = 0 ;
38246 char * kwnames[] = {
38247 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
38248 };
38249
38250 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38251 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyValidator, 0 | 0 );
38252 if (!SWIG_IsOK(res1)) {
38253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyValidator *""'");
38254 }
38255 arg1 = reinterpret_cast< wxPyValidator * >(argp1);
38256 arg2 = obj1;
38257 arg3 = obj2;
38258 if (obj3) {
38259 ecode4 = SWIG_AsVal_int(obj3, &val4);
38260 if (!SWIG_IsOK(ecode4)) {
38261 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
38262 }
38263 arg4 = static_cast< int >(val4);
38264 }
38265 {
38266 PyThreadState* __tstate = wxPyBeginAllowThreads();
38267 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
38268 wxPyEndAllowThreads(__tstate);
38269 if (PyErr_Occurred()) SWIG_fail;
38270 }
38271 resultobj = SWIG_Py_Void();
38272 return resultobj;
38273 fail:
38274 return NULL;
38275 }
38276
38277
38278 SWIGINTERN PyObject *PyValidator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38279 PyObject *obj;
38280 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
38281 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyValidator, SWIG_NewClientData(obj));
38282 return SWIG_Py_Void();
38283 }
38284
38285 SWIGINTERN PyObject *PyValidator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38286 return SWIG_Python_InitShadowInstance(args);
38287 }
38288
38289 SWIGINTERN int DefaultValidator_set(PyObject *) {
38290 SWIG_Error(SWIG_AttributeError,"Variable DefaultValidator is read-only.");
38291 return 1;
38292 }
38293
38294
38295 SWIGINTERN PyObject *DefaultValidator_get(void) {
38296 PyObject *pyobj = 0;
38297
38298 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0 );
38299 return pyobj;
38300 }
38301
38302
38303 SWIGINTERN PyObject *_wrap_new_Menu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38304 PyObject *resultobj = 0;
38305 wxString const &arg1_defvalue = wxPyEmptyString ;
38306 wxString *arg1 = (wxString *) &arg1_defvalue ;
38307 long arg2 = (long) 0 ;
38308 wxMenu *result = 0 ;
38309 bool temp1 = false ;
38310 long val2 ;
38311 int ecode2 = 0 ;
38312 PyObject * obj0 = 0 ;
38313 PyObject * obj1 = 0 ;
38314 char * kwnames[] = {
38315 (char *) "title",(char *) "style", NULL
38316 };
38317
38318 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) SWIG_fail;
38319 if (obj0) {
38320 {
38321 arg1 = wxString_in_helper(obj0);
38322 if (arg1 == NULL) SWIG_fail;
38323 temp1 = true;
38324 }
38325 }
38326 if (obj1) {
38327 ecode2 = SWIG_AsVal_long(obj1, &val2);
38328 if (!SWIG_IsOK(ecode2)) {
38329 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Menu" "', expected argument " "2"" of type '" "long""'");
38330 }
38331 arg2 = static_cast< long >(val2);
38332 }
38333 {
38334 if (!wxPyCheckForApp()) SWIG_fail;
38335 PyThreadState* __tstate = wxPyBeginAllowThreads();
38336 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
38337 wxPyEndAllowThreads(__tstate);
38338 if (PyErr_Occurred()) SWIG_fail;
38339 }
38340 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenu, SWIG_POINTER_NEW | 0 );
38341 {
38342 if (temp1)
38343 delete arg1;
38344 }
38345 return resultobj;
38346 fail:
38347 {
38348 if (temp1)
38349 delete arg1;
38350 }
38351 return NULL;
38352 }
38353
38354
38355 SWIGINTERN PyObject *_wrap_Menu_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38356 PyObject *resultobj = 0;
38357 wxMenu *arg1 = (wxMenu *) 0 ;
38358 int arg2 ;
38359 wxString *arg3 = 0 ;
38360 wxString const &arg4_defvalue = wxPyEmptyString ;
38361 wxString *arg4 = (wxString *) &arg4_defvalue ;
38362 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
38363 wxMenuItem *result = 0 ;
38364 void *argp1 = 0 ;
38365 int res1 = 0 ;
38366 int val2 ;
38367 int ecode2 = 0 ;
38368 bool temp3 = false ;
38369 bool temp4 = false ;
38370 int val5 ;
38371 int ecode5 = 0 ;
38372 PyObject * obj0 = 0 ;
38373 PyObject * obj1 = 0 ;
38374 PyObject * obj2 = 0 ;
38375 PyObject * obj3 = 0 ;
38376 PyObject * obj4 = 0 ;
38377 char * kwnames[] = {
38378 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
38379 };
38380
38381 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38382 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38383 if (!SWIG_IsOK(res1)) {
38384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Append" "', expected argument " "1"" of type '" "wxMenu *""'");
38385 }
38386 arg1 = reinterpret_cast< wxMenu * >(argp1);
38387 ecode2 = SWIG_AsVal_int(obj1, &val2);
38388 if (!SWIG_IsOK(ecode2)) {
38389 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Append" "', expected argument " "2"" of type '" "int""'");
38390 }
38391 arg2 = static_cast< int >(val2);
38392 {
38393 arg3 = wxString_in_helper(obj2);
38394 if (arg3 == NULL) SWIG_fail;
38395 temp3 = true;
38396 }
38397 if (obj3) {
38398 {
38399 arg4 = wxString_in_helper(obj3);
38400 if (arg4 == NULL) SWIG_fail;
38401 temp4 = true;
38402 }
38403 }
38404 if (obj4) {
38405 ecode5 = SWIG_AsVal_int(obj4, &val5);
38406 if (!SWIG_IsOK(ecode5)) {
38407 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Append" "', expected argument " "5"" of type '" "wxItemKind""'");
38408 }
38409 arg5 = static_cast< wxItemKind >(val5);
38410 }
38411 {
38412 PyThreadState* __tstate = wxPyBeginAllowThreads();
38413 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
38414 wxPyEndAllowThreads(__tstate);
38415 if (PyErr_Occurred()) SWIG_fail;
38416 }
38417 {
38418 resultobj = wxPyMake_wxObject(result, (bool)0);
38419 }
38420 {
38421 if (temp3)
38422 delete arg3;
38423 }
38424 {
38425 if (temp4)
38426 delete arg4;
38427 }
38428 return resultobj;
38429 fail:
38430 {
38431 if (temp3)
38432 delete arg3;
38433 }
38434 {
38435 if (temp4)
38436 delete arg4;
38437 }
38438 return NULL;
38439 }
38440
38441
38442 SWIGINTERN PyObject *_wrap_Menu_AppendSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38443 PyObject *resultobj = 0;
38444 wxMenu *arg1 = (wxMenu *) 0 ;
38445 wxMenuItem *result = 0 ;
38446 void *argp1 = 0 ;
38447 int res1 = 0 ;
38448 PyObject *swig_obj[1] ;
38449
38450 if (!args) SWIG_fail;
38451 swig_obj[0] = args;
38452 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38453 if (!SWIG_IsOK(res1)) {
38454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
38455 }
38456 arg1 = reinterpret_cast< wxMenu * >(argp1);
38457 {
38458 PyThreadState* __tstate = wxPyBeginAllowThreads();
38459 result = (wxMenuItem *)(arg1)->AppendSeparator();
38460 wxPyEndAllowThreads(__tstate);
38461 if (PyErr_Occurred()) SWIG_fail;
38462 }
38463 {
38464 resultobj = wxPyMake_wxObject(result, (bool)0);
38465 }
38466 return resultobj;
38467 fail:
38468 return NULL;
38469 }
38470
38471
38472 SWIGINTERN PyObject *_wrap_Menu_AppendCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38473 PyObject *resultobj = 0;
38474 wxMenu *arg1 = (wxMenu *) 0 ;
38475 int arg2 ;
38476 wxString *arg3 = 0 ;
38477 wxString const &arg4_defvalue = wxPyEmptyString ;
38478 wxString *arg4 = (wxString *) &arg4_defvalue ;
38479 wxMenuItem *result = 0 ;
38480 void *argp1 = 0 ;
38481 int res1 = 0 ;
38482 int val2 ;
38483 int ecode2 = 0 ;
38484 bool temp3 = false ;
38485 bool temp4 = false ;
38486 PyObject * obj0 = 0 ;
38487 PyObject * obj1 = 0 ;
38488 PyObject * obj2 = 0 ;
38489 PyObject * obj3 = 0 ;
38490 char * kwnames[] = {
38491 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
38492 };
38493
38494 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38495 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38496 if (!SWIG_IsOK(res1)) {
38497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38498 }
38499 arg1 = reinterpret_cast< wxMenu * >(argp1);
38500 ecode2 = SWIG_AsVal_int(obj1, &val2);
38501 if (!SWIG_IsOK(ecode2)) {
38502 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendCheckItem" "', expected argument " "2"" of type '" "int""'");
38503 }
38504 arg2 = static_cast< int >(val2);
38505 {
38506 arg3 = wxString_in_helper(obj2);
38507 if (arg3 == NULL) SWIG_fail;
38508 temp3 = true;
38509 }
38510 if (obj3) {
38511 {
38512 arg4 = wxString_in_helper(obj3);
38513 if (arg4 == NULL) SWIG_fail;
38514 temp4 = true;
38515 }
38516 }
38517 {
38518 PyThreadState* __tstate = wxPyBeginAllowThreads();
38519 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38520 wxPyEndAllowThreads(__tstate);
38521 if (PyErr_Occurred()) SWIG_fail;
38522 }
38523 {
38524 resultobj = wxPyMake_wxObject(result, (bool)0);
38525 }
38526 {
38527 if (temp3)
38528 delete arg3;
38529 }
38530 {
38531 if (temp4)
38532 delete arg4;
38533 }
38534 return resultobj;
38535 fail:
38536 {
38537 if (temp3)
38538 delete arg3;
38539 }
38540 {
38541 if (temp4)
38542 delete arg4;
38543 }
38544 return NULL;
38545 }
38546
38547
38548 SWIGINTERN PyObject *_wrap_Menu_AppendRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38549 PyObject *resultobj = 0;
38550 wxMenu *arg1 = (wxMenu *) 0 ;
38551 int arg2 ;
38552 wxString *arg3 = 0 ;
38553 wxString const &arg4_defvalue = wxPyEmptyString ;
38554 wxString *arg4 = (wxString *) &arg4_defvalue ;
38555 wxMenuItem *result = 0 ;
38556 void *argp1 = 0 ;
38557 int res1 = 0 ;
38558 int val2 ;
38559 int ecode2 = 0 ;
38560 bool temp3 = false ;
38561 bool temp4 = false ;
38562 PyObject * obj0 = 0 ;
38563 PyObject * obj1 = 0 ;
38564 PyObject * obj2 = 0 ;
38565 PyObject * obj3 = 0 ;
38566 char * kwnames[] = {
38567 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
38568 };
38569
38570 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38571 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38572 if (!SWIG_IsOK(res1)) {
38573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38574 }
38575 arg1 = reinterpret_cast< wxMenu * >(argp1);
38576 ecode2 = SWIG_AsVal_int(obj1, &val2);
38577 if (!SWIG_IsOK(ecode2)) {
38578 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendRadioItem" "', expected argument " "2"" of type '" "int""'");
38579 }
38580 arg2 = static_cast< int >(val2);
38581 {
38582 arg3 = wxString_in_helper(obj2);
38583 if (arg3 == NULL) SWIG_fail;
38584 temp3 = true;
38585 }
38586 if (obj3) {
38587 {
38588 arg4 = wxString_in_helper(obj3);
38589 if (arg4 == NULL) SWIG_fail;
38590 temp4 = true;
38591 }
38592 }
38593 {
38594 PyThreadState* __tstate = wxPyBeginAllowThreads();
38595 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38596 wxPyEndAllowThreads(__tstate);
38597 if (PyErr_Occurred()) SWIG_fail;
38598 }
38599 {
38600 resultobj = wxPyMake_wxObject(result, (bool)0);
38601 }
38602 {
38603 if (temp3)
38604 delete arg3;
38605 }
38606 {
38607 if (temp4)
38608 delete arg4;
38609 }
38610 return resultobj;
38611 fail:
38612 {
38613 if (temp3)
38614 delete arg3;
38615 }
38616 {
38617 if (temp4)
38618 delete arg4;
38619 }
38620 return NULL;
38621 }
38622
38623
38624 SWIGINTERN PyObject *_wrap_Menu_AppendMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38625 PyObject *resultobj = 0;
38626 wxMenu *arg1 = (wxMenu *) 0 ;
38627 int arg2 ;
38628 wxString *arg3 = 0 ;
38629 wxMenu *arg4 = (wxMenu *) 0 ;
38630 wxString const &arg5_defvalue = wxPyEmptyString ;
38631 wxString *arg5 = (wxString *) &arg5_defvalue ;
38632 wxMenuItem *result = 0 ;
38633 void *argp1 = 0 ;
38634 int res1 = 0 ;
38635 int val2 ;
38636 int ecode2 = 0 ;
38637 bool temp3 = false ;
38638 void *argp4 = 0 ;
38639 int res4 = 0 ;
38640 bool temp5 = false ;
38641 PyObject * obj0 = 0 ;
38642 PyObject * obj1 = 0 ;
38643 PyObject * obj2 = 0 ;
38644 PyObject * obj3 = 0 ;
38645 PyObject * obj4 = 0 ;
38646 char * kwnames[] = {
38647 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
38648 };
38649
38650 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38651 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38652 if (!SWIG_IsOK(res1)) {
38653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
38654 }
38655 arg1 = reinterpret_cast< wxMenu * >(argp1);
38656 ecode2 = SWIG_AsVal_int(obj1, &val2);
38657 if (!SWIG_IsOK(ecode2)) {
38658 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendMenu" "', expected argument " "2"" of type '" "int""'");
38659 }
38660 arg2 = static_cast< int >(val2);
38661 {
38662 arg3 = wxString_in_helper(obj2);
38663 if (arg3 == NULL) SWIG_fail;
38664 temp3 = true;
38665 }
38666 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
38667 if (!SWIG_IsOK(res4)) {
38668 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_AppendMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
38669 }
38670 arg4 = reinterpret_cast< wxMenu * >(argp4);
38671 if (obj4) {
38672 {
38673 arg5 = wxString_in_helper(obj4);
38674 if (arg5 == NULL) SWIG_fail;
38675 temp5 = true;
38676 }
38677 }
38678 {
38679 PyThreadState* __tstate = wxPyBeginAllowThreads();
38680 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
38681 wxPyEndAllowThreads(__tstate);
38682 if (PyErr_Occurred()) SWIG_fail;
38683 }
38684 {
38685 resultobj = wxPyMake_wxObject(result, (bool)0);
38686 }
38687 {
38688 if (temp3)
38689 delete arg3;
38690 }
38691 {
38692 if (temp5)
38693 delete arg5;
38694 }
38695 return resultobj;
38696 fail:
38697 {
38698 if (temp3)
38699 delete arg3;
38700 }
38701 {
38702 if (temp5)
38703 delete arg5;
38704 }
38705 return NULL;
38706 }
38707
38708
38709 SWIGINTERN PyObject *_wrap_Menu_AppendSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38710 PyObject *resultobj = 0;
38711 wxMenu *arg1 = (wxMenu *) 0 ;
38712 wxMenu *arg2 = (wxMenu *) 0 ;
38713 wxString *arg3 = 0 ;
38714 wxString const &arg4_defvalue = wxPyEmptyString ;
38715 wxString *arg4 = (wxString *) &arg4_defvalue ;
38716 wxMenuItem *result = 0 ;
38717 void *argp1 = 0 ;
38718 int res1 = 0 ;
38719 void *argp2 = 0 ;
38720 int res2 = 0 ;
38721 bool temp3 = false ;
38722 bool temp4 = false ;
38723 PyObject * obj0 = 0 ;
38724 PyObject * obj1 = 0 ;
38725 PyObject * obj2 = 0 ;
38726 PyObject * obj3 = 0 ;
38727 char * kwnames[] = {
38728 (char *) "self",(char *) "submenu",(char *) "text",(char *) "help", NULL
38729 };
38730
38731 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendSubMenu",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38732 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38733 if (!SWIG_IsOK(res1)) {
38734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSubMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
38735 }
38736 arg1 = reinterpret_cast< wxMenu * >(argp1);
38737 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
38738 if (!SWIG_IsOK(res2)) {
38739 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
38740 }
38741 arg2 = reinterpret_cast< wxMenu * >(argp2);
38742 {
38743 arg3 = wxString_in_helper(obj2);
38744 if (arg3 == NULL) SWIG_fail;
38745 temp3 = true;
38746 }
38747 if (obj3) {
38748 {
38749 arg4 = wxString_in_helper(obj3);
38750 if (arg4 == NULL) SWIG_fail;
38751 temp4 = true;
38752 }
38753 }
38754 {
38755 PyThreadState* __tstate = wxPyBeginAllowThreads();
38756 result = (wxMenuItem *)(arg1)->AppendSubMenu(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38757 wxPyEndAllowThreads(__tstate);
38758 if (PyErr_Occurred()) SWIG_fail;
38759 }
38760 {
38761 resultobj = wxPyMake_wxObject(result, (bool)0);
38762 }
38763 {
38764 if (temp3)
38765 delete arg3;
38766 }
38767 {
38768 if (temp4)
38769 delete arg4;
38770 }
38771 return resultobj;
38772 fail:
38773 {
38774 if (temp3)
38775 delete arg3;
38776 }
38777 {
38778 if (temp4)
38779 delete arg4;
38780 }
38781 return NULL;
38782 }
38783
38784
38785 SWIGINTERN PyObject *_wrap_Menu_AppendItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38786 PyObject *resultobj = 0;
38787 wxMenu *arg1 = (wxMenu *) 0 ;
38788 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
38789 wxMenuItem *result = 0 ;
38790 void *argp1 = 0 ;
38791 int res1 = 0 ;
38792 int res2 = 0 ;
38793 PyObject * obj0 = 0 ;
38794 PyObject * obj1 = 0 ;
38795 char * kwnames[] = {
38796 (char *) "self",(char *) "item", NULL
38797 };
38798
38799 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) SWIG_fail;
38800 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38801 if (!SWIG_IsOK(res1)) {
38802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38803 }
38804 arg1 = reinterpret_cast< wxMenu * >(argp1);
38805 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38806 if (!SWIG_IsOK(res2)) {
38807 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
38808 }
38809 {
38810 PyThreadState* __tstate = wxPyBeginAllowThreads();
38811 result = (wxMenuItem *)(arg1)->Append(arg2);
38812 wxPyEndAllowThreads(__tstate);
38813 if (PyErr_Occurred()) SWIG_fail;
38814 }
38815 {
38816 resultobj = wxPyMake_wxObject(result, (bool)0);
38817 }
38818 return resultobj;
38819 fail:
38820 return NULL;
38821 }
38822
38823
38824 SWIGINTERN PyObject *_wrap_Menu_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38825 PyObject *resultobj = 0;
38826 wxMenu *arg1 = (wxMenu *) 0 ;
38827 size_t arg2 ;
38828 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
38829 wxMenuItem *result = 0 ;
38830 void *argp1 = 0 ;
38831 int res1 = 0 ;
38832 size_t val2 ;
38833 int ecode2 = 0 ;
38834 int res3 = 0 ;
38835 PyObject * obj0 = 0 ;
38836 PyObject * obj1 = 0 ;
38837 PyObject * obj2 = 0 ;
38838 char * kwnames[] = {
38839 (char *) "self",(char *) "pos",(char *) "item", NULL
38840 };
38841
38842 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38843 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38844 if (!SWIG_IsOK(res1)) {
38845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38846 }
38847 arg1 = reinterpret_cast< wxMenu * >(argp1);
38848 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38849 if (!SWIG_IsOK(ecode2)) {
38850 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
38851 }
38852 arg2 = static_cast< size_t >(val2);
38853 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38854 if (!SWIG_IsOK(res3)) {
38855 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Menu_InsertItem" "', expected argument " "3"" of type '" "wxMenuItem *""'");
38856 }
38857 {
38858 PyThreadState* __tstate = wxPyBeginAllowThreads();
38859 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
38860 wxPyEndAllowThreads(__tstate);
38861 if (PyErr_Occurred()) SWIG_fail;
38862 }
38863 {
38864 resultobj = wxPyMake_wxObject(result, (bool)0);
38865 }
38866 return resultobj;
38867 fail:
38868 return NULL;
38869 }
38870
38871
38872 SWIGINTERN PyObject *_wrap_Menu_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38873 PyObject *resultobj = 0;
38874 wxMenu *arg1 = (wxMenu *) 0 ;
38875 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
38876 wxMenuItem *result = 0 ;
38877 void *argp1 = 0 ;
38878 int res1 = 0 ;
38879 int res2 = 0 ;
38880 PyObject * obj0 = 0 ;
38881 PyObject * obj1 = 0 ;
38882 char * kwnames[] = {
38883 (char *) "self",(char *) "item", NULL
38884 };
38885
38886 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
38887 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38888 if (!SWIG_IsOK(res1)) {
38889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38890 }
38891 arg1 = reinterpret_cast< wxMenu * >(argp1);
38892 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38893 if (!SWIG_IsOK(res2)) {
38894 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_PrependItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
38895 }
38896 {
38897 PyThreadState* __tstate = wxPyBeginAllowThreads();
38898 result = (wxMenuItem *)(arg1)->Prepend(arg2);
38899 wxPyEndAllowThreads(__tstate);
38900 if (PyErr_Occurred()) SWIG_fail;
38901 }
38902 {
38903 resultobj = wxPyMake_wxObject(result, (bool)0);
38904 }
38905 return resultobj;
38906 fail:
38907 return NULL;
38908 }
38909
38910
38911 SWIGINTERN PyObject *_wrap_Menu_Break(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38912 PyObject *resultobj = 0;
38913 wxMenu *arg1 = (wxMenu *) 0 ;
38914 void *argp1 = 0 ;
38915 int res1 = 0 ;
38916 PyObject *swig_obj[1] ;
38917
38918 if (!args) SWIG_fail;
38919 swig_obj[0] = args;
38920 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38921 if (!SWIG_IsOK(res1)) {
38922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Break" "', expected argument " "1"" of type '" "wxMenu *""'");
38923 }
38924 arg1 = reinterpret_cast< wxMenu * >(argp1);
38925 {
38926 PyThreadState* __tstate = wxPyBeginAllowThreads();
38927 (arg1)->Break();
38928 wxPyEndAllowThreads(__tstate);
38929 if (PyErr_Occurred()) SWIG_fail;
38930 }
38931 resultobj = SWIG_Py_Void();
38932 return resultobj;
38933 fail:
38934 return NULL;
38935 }
38936
38937
38938 SWIGINTERN PyObject *_wrap_Menu_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38939 PyObject *resultobj = 0;
38940 wxMenu *arg1 = (wxMenu *) 0 ;
38941 size_t arg2 ;
38942 int arg3 ;
38943 wxString *arg4 = 0 ;
38944 wxString const &arg5_defvalue = wxPyEmptyString ;
38945 wxString *arg5 = (wxString *) &arg5_defvalue ;
38946 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
38947 wxMenuItem *result = 0 ;
38948 void *argp1 = 0 ;
38949 int res1 = 0 ;
38950 size_t val2 ;
38951 int ecode2 = 0 ;
38952 int val3 ;
38953 int ecode3 = 0 ;
38954 bool temp4 = false ;
38955 bool temp5 = false ;
38956 int val6 ;
38957 int ecode6 = 0 ;
38958 PyObject * obj0 = 0 ;
38959 PyObject * obj1 = 0 ;
38960 PyObject * obj2 = 0 ;
38961 PyObject * obj3 = 0 ;
38962 PyObject * obj4 = 0 ;
38963 PyObject * obj5 = 0 ;
38964 char * kwnames[] = {
38965 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
38966 };
38967
38968 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
38969 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38970 if (!SWIG_IsOK(res1)) {
38971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Insert" "', expected argument " "1"" of type '" "wxMenu *""'");
38972 }
38973 arg1 = reinterpret_cast< wxMenu * >(argp1);
38974 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38975 if (!SWIG_IsOK(ecode2)) {
38976 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Insert" "', expected argument " "2"" of type '" "size_t""'");
38977 }
38978 arg2 = static_cast< size_t >(val2);
38979 ecode3 = SWIG_AsVal_int(obj2, &val3);
38980 if (!SWIG_IsOK(ecode3)) {
38981 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Insert" "', expected argument " "3"" of type '" "int""'");
38982 }
38983 arg3 = static_cast< int >(val3);
38984 {
38985 arg4 = wxString_in_helper(obj3);
38986 if (arg4 == NULL) SWIG_fail;
38987 temp4 = true;
38988 }
38989 if (obj4) {
38990 {
38991 arg5 = wxString_in_helper(obj4);
38992 if (arg5 == NULL) SWIG_fail;
38993 temp5 = true;
38994 }
38995 }
38996 if (obj5) {
38997 ecode6 = SWIG_AsVal_int(obj5, &val6);
38998 if (!SWIG_IsOK(ecode6)) {
38999 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Menu_Insert" "', expected argument " "6"" of type '" "wxItemKind""'");
39000 }
39001 arg6 = static_cast< wxItemKind >(val6);
39002 }
39003 {
39004 PyThreadState* __tstate = wxPyBeginAllowThreads();
39005 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6);
39006 wxPyEndAllowThreads(__tstate);
39007 if (PyErr_Occurred()) SWIG_fail;
39008 }
39009 {
39010 resultobj = wxPyMake_wxObject(result, (bool)0);
39011 }
39012 {
39013 if (temp4)
39014 delete arg4;
39015 }
39016 {
39017 if (temp5)
39018 delete arg5;
39019 }
39020 return resultobj;
39021 fail:
39022 {
39023 if (temp4)
39024 delete arg4;
39025 }
39026 {
39027 if (temp5)
39028 delete arg5;
39029 }
39030 return NULL;
39031 }
39032
39033
39034 SWIGINTERN PyObject *_wrap_Menu_InsertSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39035 PyObject *resultobj = 0;
39036 wxMenu *arg1 = (wxMenu *) 0 ;
39037 size_t arg2 ;
39038 wxMenuItem *result = 0 ;
39039 void *argp1 = 0 ;
39040 int res1 = 0 ;
39041 size_t val2 ;
39042 int ecode2 = 0 ;
39043 PyObject * obj0 = 0 ;
39044 PyObject * obj1 = 0 ;
39045 char * kwnames[] = {
39046 (char *) "self",(char *) "pos", NULL
39047 };
39048
39049 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) SWIG_fail;
39050 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39051 if (!SWIG_IsOK(res1)) {
39052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
39053 }
39054 arg1 = reinterpret_cast< wxMenu * >(argp1);
39055 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39056 if (!SWIG_IsOK(ecode2)) {
39057 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertSeparator" "', expected argument " "2"" of type '" "size_t""'");
39058 }
39059 arg2 = static_cast< size_t >(val2);
39060 {
39061 PyThreadState* __tstate = wxPyBeginAllowThreads();
39062 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
39063 wxPyEndAllowThreads(__tstate);
39064 if (PyErr_Occurred()) SWIG_fail;
39065 }
39066 {
39067 resultobj = wxPyMake_wxObject(result, (bool)0);
39068 }
39069 return resultobj;
39070 fail:
39071 return NULL;
39072 }
39073
39074
39075 SWIGINTERN PyObject *_wrap_Menu_InsertCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39076 PyObject *resultobj = 0;
39077 wxMenu *arg1 = (wxMenu *) 0 ;
39078 size_t arg2 ;
39079 int arg3 ;
39080 wxString *arg4 = 0 ;
39081 wxString const &arg5_defvalue = wxPyEmptyString ;
39082 wxString *arg5 = (wxString *) &arg5_defvalue ;
39083 wxMenuItem *result = 0 ;
39084 void *argp1 = 0 ;
39085 int res1 = 0 ;
39086 size_t val2 ;
39087 int ecode2 = 0 ;
39088 int val3 ;
39089 int ecode3 = 0 ;
39090 bool temp4 = false ;
39091 bool temp5 = false ;
39092 PyObject * obj0 = 0 ;
39093 PyObject * obj1 = 0 ;
39094 PyObject * obj2 = 0 ;
39095 PyObject * obj3 = 0 ;
39096 PyObject * obj4 = 0 ;
39097 char * kwnames[] = {
39098 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
39099 };
39100
39101 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39102 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39103 if (!SWIG_IsOK(res1)) {
39104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39105 }
39106 arg1 = reinterpret_cast< wxMenu * >(argp1);
39107 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39108 if (!SWIG_IsOK(ecode2)) {
39109 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertCheckItem" "', expected argument " "2"" of type '" "size_t""'");
39110 }
39111 arg2 = static_cast< size_t >(val2);
39112 ecode3 = SWIG_AsVal_int(obj2, &val3);
39113 if (!SWIG_IsOK(ecode3)) {
39114 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertCheckItem" "', expected argument " "3"" of type '" "int""'");
39115 }
39116 arg3 = static_cast< int >(val3);
39117 {
39118 arg4 = wxString_in_helper(obj3);
39119 if (arg4 == NULL) SWIG_fail;
39120 temp4 = true;
39121 }
39122 if (obj4) {
39123 {
39124 arg5 = wxString_in_helper(obj4);
39125 if (arg5 == NULL) SWIG_fail;
39126 temp5 = true;
39127 }
39128 }
39129 {
39130 PyThreadState* __tstate = wxPyBeginAllowThreads();
39131 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
39132 wxPyEndAllowThreads(__tstate);
39133 if (PyErr_Occurred()) SWIG_fail;
39134 }
39135 {
39136 resultobj = wxPyMake_wxObject(result, (bool)0);
39137 }
39138 {
39139 if (temp4)
39140 delete arg4;
39141 }
39142 {
39143 if (temp5)
39144 delete arg5;
39145 }
39146 return resultobj;
39147 fail:
39148 {
39149 if (temp4)
39150 delete arg4;
39151 }
39152 {
39153 if (temp5)
39154 delete arg5;
39155 }
39156 return NULL;
39157 }
39158
39159
39160 SWIGINTERN PyObject *_wrap_Menu_InsertRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39161 PyObject *resultobj = 0;
39162 wxMenu *arg1 = (wxMenu *) 0 ;
39163 size_t arg2 ;
39164 int arg3 ;
39165 wxString *arg4 = 0 ;
39166 wxString const &arg5_defvalue = wxPyEmptyString ;
39167 wxString *arg5 = (wxString *) &arg5_defvalue ;
39168 wxMenuItem *result = 0 ;
39169 void *argp1 = 0 ;
39170 int res1 = 0 ;
39171 size_t val2 ;
39172 int ecode2 = 0 ;
39173 int val3 ;
39174 int ecode3 = 0 ;
39175 bool temp4 = false ;
39176 bool temp5 = false ;
39177 PyObject * obj0 = 0 ;
39178 PyObject * obj1 = 0 ;
39179 PyObject * obj2 = 0 ;
39180 PyObject * obj3 = 0 ;
39181 PyObject * obj4 = 0 ;
39182 char * kwnames[] = {
39183 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
39184 };
39185
39186 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) 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_InsertRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39190 }
39191 arg1 = reinterpret_cast< wxMenu * >(argp1);
39192 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39193 if (!SWIG_IsOK(ecode2)) {
39194 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertRadioItem" "', expected argument " "2"" of type '" "size_t""'");
39195 }
39196 arg2 = static_cast< size_t >(val2);
39197 ecode3 = SWIG_AsVal_int(obj2, &val3);
39198 if (!SWIG_IsOK(ecode3)) {
39199 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertRadioItem" "', expected argument " "3"" of type '" "int""'");
39200 }
39201 arg3 = static_cast< int >(val3);
39202 {
39203 arg4 = wxString_in_helper(obj3);
39204 if (arg4 == NULL) SWIG_fail;
39205 temp4 = true;
39206 }
39207 if (obj4) {
39208 {
39209 arg5 = wxString_in_helper(obj4);
39210 if (arg5 == NULL) SWIG_fail;
39211 temp5 = true;
39212 }
39213 }
39214 {
39215 PyThreadState* __tstate = wxPyBeginAllowThreads();
39216 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
39217 wxPyEndAllowThreads(__tstate);
39218 if (PyErr_Occurred()) SWIG_fail;
39219 }
39220 {
39221 resultobj = wxPyMake_wxObject(result, (bool)0);
39222 }
39223 {
39224 if (temp4)
39225 delete arg4;
39226 }
39227 {
39228 if (temp5)
39229 delete arg5;
39230 }
39231 return resultobj;
39232 fail:
39233 {
39234 if (temp4)
39235 delete arg4;
39236 }
39237 {
39238 if (temp5)
39239 delete arg5;
39240 }
39241 return NULL;
39242 }
39243
39244
39245 SWIGINTERN PyObject *_wrap_Menu_InsertMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39246 PyObject *resultobj = 0;
39247 wxMenu *arg1 = (wxMenu *) 0 ;
39248 size_t arg2 ;
39249 int arg3 ;
39250 wxString *arg4 = 0 ;
39251 wxMenu *arg5 = (wxMenu *) 0 ;
39252 wxString const &arg6_defvalue = wxPyEmptyString ;
39253 wxString *arg6 = (wxString *) &arg6_defvalue ;
39254 wxMenuItem *result = 0 ;
39255 void *argp1 = 0 ;
39256 int res1 = 0 ;
39257 size_t val2 ;
39258 int ecode2 = 0 ;
39259 int val3 ;
39260 int ecode3 = 0 ;
39261 bool temp4 = false ;
39262 void *argp5 = 0 ;
39263 int res5 = 0 ;
39264 bool temp6 = false ;
39265 PyObject * obj0 = 0 ;
39266 PyObject * obj1 = 0 ;
39267 PyObject * obj2 = 0 ;
39268 PyObject * obj3 = 0 ;
39269 PyObject * obj4 = 0 ;
39270 PyObject * obj5 = 0 ;
39271 char * kwnames[] = {
39272 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39273 };
39274
39275 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
39276 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39277 if (!SWIG_IsOK(res1)) {
39278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39279 }
39280 arg1 = reinterpret_cast< wxMenu * >(argp1);
39281 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39282 if (!SWIG_IsOK(ecode2)) {
39283 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertMenu" "', expected argument " "2"" of type '" "size_t""'");
39284 }
39285 arg2 = static_cast< size_t >(val2);
39286 ecode3 = SWIG_AsVal_int(obj2, &val3);
39287 if (!SWIG_IsOK(ecode3)) {
39288 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertMenu" "', expected argument " "3"" of type '" "int""'");
39289 }
39290 arg3 = static_cast< int >(val3);
39291 {
39292 arg4 = wxString_in_helper(obj3);
39293 if (arg4 == NULL) SWIG_fail;
39294 temp4 = true;
39295 }
39296 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxMenu, 0 | 0 );
39297 if (!SWIG_IsOK(res5)) {
39298 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Menu_InsertMenu" "', expected argument " "5"" of type '" "wxMenu *""'");
39299 }
39300 arg5 = reinterpret_cast< wxMenu * >(argp5);
39301 if (obj5) {
39302 {
39303 arg6 = wxString_in_helper(obj5);
39304 if (arg6 == NULL) SWIG_fail;
39305 temp6 = true;
39306 }
39307 }
39308 {
39309 PyThreadState* __tstate = wxPyBeginAllowThreads();
39310 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
39311 wxPyEndAllowThreads(__tstate);
39312 if (PyErr_Occurred()) SWIG_fail;
39313 }
39314 {
39315 resultobj = wxPyMake_wxObject(result, (bool)0);
39316 }
39317 {
39318 if (temp4)
39319 delete arg4;
39320 }
39321 {
39322 if (temp6)
39323 delete arg6;
39324 }
39325 return resultobj;
39326 fail:
39327 {
39328 if (temp4)
39329 delete arg4;
39330 }
39331 {
39332 if (temp6)
39333 delete arg6;
39334 }
39335 return NULL;
39336 }
39337
39338
39339 SWIGINTERN PyObject *_wrap_Menu_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39340 PyObject *resultobj = 0;
39341 wxMenu *arg1 = (wxMenu *) 0 ;
39342 int arg2 ;
39343 wxString *arg3 = 0 ;
39344 wxString const &arg4_defvalue = wxPyEmptyString ;
39345 wxString *arg4 = (wxString *) &arg4_defvalue ;
39346 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
39347 wxMenuItem *result = 0 ;
39348 void *argp1 = 0 ;
39349 int res1 = 0 ;
39350 int val2 ;
39351 int ecode2 = 0 ;
39352 bool temp3 = false ;
39353 bool temp4 = false ;
39354 int val5 ;
39355 int ecode5 = 0 ;
39356 PyObject * obj0 = 0 ;
39357 PyObject * obj1 = 0 ;
39358 PyObject * obj2 = 0 ;
39359 PyObject * obj3 = 0 ;
39360 PyObject * obj4 = 0 ;
39361 char * kwnames[] = {
39362 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
39363 };
39364
39365 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39366 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39367 if (!SWIG_IsOK(res1)) {
39368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Prepend" "', expected argument " "1"" of type '" "wxMenu *""'");
39369 }
39370 arg1 = reinterpret_cast< wxMenu * >(argp1);
39371 ecode2 = SWIG_AsVal_int(obj1, &val2);
39372 if (!SWIG_IsOK(ecode2)) {
39373 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Prepend" "', expected argument " "2"" of type '" "int""'");
39374 }
39375 arg2 = static_cast< int >(val2);
39376 {
39377 arg3 = wxString_in_helper(obj2);
39378 if (arg3 == NULL) SWIG_fail;
39379 temp3 = true;
39380 }
39381 if (obj3) {
39382 {
39383 arg4 = wxString_in_helper(obj3);
39384 if (arg4 == NULL) SWIG_fail;
39385 temp4 = true;
39386 }
39387 }
39388 if (obj4) {
39389 ecode5 = SWIG_AsVal_int(obj4, &val5);
39390 if (!SWIG_IsOK(ecode5)) {
39391 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Prepend" "', expected argument " "5"" of type '" "wxItemKind""'");
39392 }
39393 arg5 = static_cast< wxItemKind >(val5);
39394 }
39395 {
39396 PyThreadState* __tstate = wxPyBeginAllowThreads();
39397 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
39398 wxPyEndAllowThreads(__tstate);
39399 if (PyErr_Occurred()) SWIG_fail;
39400 }
39401 {
39402 resultobj = wxPyMake_wxObject(result, (bool)0);
39403 }
39404 {
39405 if (temp3)
39406 delete arg3;
39407 }
39408 {
39409 if (temp4)
39410 delete arg4;
39411 }
39412 return resultobj;
39413 fail:
39414 {
39415 if (temp3)
39416 delete arg3;
39417 }
39418 {
39419 if (temp4)
39420 delete arg4;
39421 }
39422 return NULL;
39423 }
39424
39425
39426 SWIGINTERN PyObject *_wrap_Menu_PrependSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39427 PyObject *resultobj = 0;
39428 wxMenu *arg1 = (wxMenu *) 0 ;
39429 wxMenuItem *result = 0 ;
39430 void *argp1 = 0 ;
39431 int res1 = 0 ;
39432 PyObject *swig_obj[1] ;
39433
39434 if (!args) SWIG_fail;
39435 swig_obj[0] = args;
39436 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39437 if (!SWIG_IsOK(res1)) {
39438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
39439 }
39440 arg1 = reinterpret_cast< wxMenu * >(argp1);
39441 {
39442 PyThreadState* __tstate = wxPyBeginAllowThreads();
39443 result = (wxMenuItem *)(arg1)->PrependSeparator();
39444 wxPyEndAllowThreads(__tstate);
39445 if (PyErr_Occurred()) SWIG_fail;
39446 }
39447 {
39448 resultobj = wxPyMake_wxObject(result, (bool)0);
39449 }
39450 return resultobj;
39451 fail:
39452 return NULL;
39453 }
39454
39455
39456 SWIGINTERN PyObject *_wrap_Menu_PrependCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39457 PyObject *resultobj = 0;
39458 wxMenu *arg1 = (wxMenu *) 0 ;
39459 int arg2 ;
39460 wxString *arg3 = 0 ;
39461 wxString const &arg4_defvalue = wxPyEmptyString ;
39462 wxString *arg4 = (wxString *) &arg4_defvalue ;
39463 wxMenuItem *result = 0 ;
39464 void *argp1 = 0 ;
39465 int res1 = 0 ;
39466 int val2 ;
39467 int ecode2 = 0 ;
39468 bool temp3 = false ;
39469 bool temp4 = false ;
39470 PyObject * obj0 = 0 ;
39471 PyObject * obj1 = 0 ;
39472 PyObject * obj2 = 0 ;
39473 PyObject * obj3 = 0 ;
39474 char * kwnames[] = {
39475 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39476 };
39477
39478 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39479 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39480 if (!SWIG_IsOK(res1)) {
39481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39482 }
39483 arg1 = reinterpret_cast< wxMenu * >(argp1);
39484 ecode2 = SWIG_AsVal_int(obj1, &val2);
39485 if (!SWIG_IsOK(ecode2)) {
39486 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependCheckItem" "', expected argument " "2"" of type '" "int""'");
39487 }
39488 arg2 = static_cast< int >(val2);
39489 {
39490 arg3 = wxString_in_helper(obj2);
39491 if (arg3 == NULL) SWIG_fail;
39492 temp3 = true;
39493 }
39494 if (obj3) {
39495 {
39496 arg4 = wxString_in_helper(obj3);
39497 if (arg4 == NULL) SWIG_fail;
39498 temp4 = true;
39499 }
39500 }
39501 {
39502 PyThreadState* __tstate = wxPyBeginAllowThreads();
39503 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39504 wxPyEndAllowThreads(__tstate);
39505 if (PyErr_Occurred()) SWIG_fail;
39506 }
39507 {
39508 resultobj = wxPyMake_wxObject(result, (bool)0);
39509 }
39510 {
39511 if (temp3)
39512 delete arg3;
39513 }
39514 {
39515 if (temp4)
39516 delete arg4;
39517 }
39518 return resultobj;
39519 fail:
39520 {
39521 if (temp3)
39522 delete arg3;
39523 }
39524 {
39525 if (temp4)
39526 delete arg4;
39527 }
39528 return NULL;
39529 }
39530
39531
39532 SWIGINTERN PyObject *_wrap_Menu_PrependRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39533 PyObject *resultobj = 0;
39534 wxMenu *arg1 = (wxMenu *) 0 ;
39535 int arg2 ;
39536 wxString *arg3 = 0 ;
39537 wxString const &arg4_defvalue = wxPyEmptyString ;
39538 wxString *arg4 = (wxString *) &arg4_defvalue ;
39539 wxMenuItem *result = 0 ;
39540 void *argp1 = 0 ;
39541 int res1 = 0 ;
39542 int val2 ;
39543 int ecode2 = 0 ;
39544 bool temp3 = false ;
39545 bool temp4 = false ;
39546 PyObject * obj0 = 0 ;
39547 PyObject * obj1 = 0 ;
39548 PyObject * obj2 = 0 ;
39549 PyObject * obj3 = 0 ;
39550 char * kwnames[] = {
39551 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39552 };
39553
39554 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39555 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39556 if (!SWIG_IsOK(res1)) {
39557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39558 }
39559 arg1 = reinterpret_cast< wxMenu * >(argp1);
39560 ecode2 = SWIG_AsVal_int(obj1, &val2);
39561 if (!SWIG_IsOK(ecode2)) {
39562 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependRadioItem" "', expected argument " "2"" of type '" "int""'");
39563 }
39564 arg2 = static_cast< int >(val2);
39565 {
39566 arg3 = wxString_in_helper(obj2);
39567 if (arg3 == NULL) SWIG_fail;
39568 temp3 = true;
39569 }
39570 if (obj3) {
39571 {
39572 arg4 = wxString_in_helper(obj3);
39573 if (arg4 == NULL) SWIG_fail;
39574 temp4 = true;
39575 }
39576 }
39577 {
39578 PyThreadState* __tstate = wxPyBeginAllowThreads();
39579 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39580 wxPyEndAllowThreads(__tstate);
39581 if (PyErr_Occurred()) SWIG_fail;
39582 }
39583 {
39584 resultobj = wxPyMake_wxObject(result, (bool)0);
39585 }
39586 {
39587 if (temp3)
39588 delete arg3;
39589 }
39590 {
39591 if (temp4)
39592 delete arg4;
39593 }
39594 return resultobj;
39595 fail:
39596 {
39597 if (temp3)
39598 delete arg3;
39599 }
39600 {
39601 if (temp4)
39602 delete arg4;
39603 }
39604 return NULL;
39605 }
39606
39607
39608 SWIGINTERN PyObject *_wrap_Menu_PrependMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39609 PyObject *resultobj = 0;
39610 wxMenu *arg1 = (wxMenu *) 0 ;
39611 int arg2 ;
39612 wxString *arg3 = 0 ;
39613 wxMenu *arg4 = (wxMenu *) 0 ;
39614 wxString const &arg5_defvalue = wxPyEmptyString ;
39615 wxString *arg5 = (wxString *) &arg5_defvalue ;
39616 wxMenuItem *result = 0 ;
39617 void *argp1 = 0 ;
39618 int res1 = 0 ;
39619 int val2 ;
39620 int ecode2 = 0 ;
39621 bool temp3 = false ;
39622 void *argp4 = 0 ;
39623 int res4 = 0 ;
39624 bool temp5 = false ;
39625 PyObject * obj0 = 0 ;
39626 PyObject * obj1 = 0 ;
39627 PyObject * obj2 = 0 ;
39628 PyObject * obj3 = 0 ;
39629 PyObject * obj4 = 0 ;
39630 char * kwnames[] = {
39631 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39632 };
39633
39634 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39635 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39636 if (!SWIG_IsOK(res1)) {
39637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39638 }
39639 arg1 = reinterpret_cast< wxMenu * >(argp1);
39640 ecode2 = SWIG_AsVal_int(obj1, &val2);
39641 if (!SWIG_IsOK(ecode2)) {
39642 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependMenu" "', expected argument " "2"" of type '" "int""'");
39643 }
39644 arg2 = static_cast< int >(val2);
39645 {
39646 arg3 = wxString_in_helper(obj2);
39647 if (arg3 == NULL) SWIG_fail;
39648 temp3 = true;
39649 }
39650 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
39651 if (!SWIG_IsOK(res4)) {
39652 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_PrependMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
39653 }
39654 arg4 = reinterpret_cast< wxMenu * >(argp4);
39655 if (obj4) {
39656 {
39657 arg5 = wxString_in_helper(obj4);
39658 if (arg5 == NULL) SWIG_fail;
39659 temp5 = true;
39660 }
39661 }
39662 {
39663 PyThreadState* __tstate = wxPyBeginAllowThreads();
39664 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
39665 wxPyEndAllowThreads(__tstate);
39666 if (PyErr_Occurred()) SWIG_fail;
39667 }
39668 {
39669 resultobj = wxPyMake_wxObject(result, (bool)0);
39670 }
39671 {
39672 if (temp3)
39673 delete arg3;
39674 }
39675 {
39676 if (temp5)
39677 delete arg5;
39678 }
39679 return resultobj;
39680 fail:
39681 {
39682 if (temp3)
39683 delete arg3;
39684 }
39685 {
39686 if (temp5)
39687 delete arg5;
39688 }
39689 return NULL;
39690 }
39691
39692
39693 SWIGINTERN PyObject *_wrap_Menu_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39694 PyObject *resultobj = 0;
39695 wxMenu *arg1 = (wxMenu *) 0 ;
39696 int arg2 ;
39697 wxMenuItem *result = 0 ;
39698 void *argp1 = 0 ;
39699 int res1 = 0 ;
39700 int val2 ;
39701 int ecode2 = 0 ;
39702 PyObject * obj0 = 0 ;
39703 PyObject * obj1 = 0 ;
39704 char * kwnames[] = {
39705 (char *) "self",(char *) "id", NULL
39706 };
39707
39708 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
39709 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39710 if (!SWIG_IsOK(res1)) {
39711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Remove" "', expected argument " "1"" of type '" "wxMenu *""'");
39712 }
39713 arg1 = reinterpret_cast< wxMenu * >(argp1);
39714 ecode2 = SWIG_AsVal_int(obj1, &val2);
39715 if (!SWIG_IsOK(ecode2)) {
39716 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Remove" "', expected argument " "2"" of type '" "int""'");
39717 }
39718 arg2 = static_cast< int >(val2);
39719 {
39720 PyThreadState* __tstate = wxPyBeginAllowThreads();
39721 result = (wxMenuItem *)(arg1)->Remove(arg2);
39722 wxPyEndAllowThreads(__tstate);
39723 if (PyErr_Occurred()) SWIG_fail;
39724 }
39725 {
39726 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
39727 }
39728 return resultobj;
39729 fail:
39730 return NULL;
39731 }
39732
39733
39734 SWIGINTERN PyObject *_wrap_Menu_RemoveItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39735 PyObject *resultobj = 0;
39736 wxMenu *arg1 = (wxMenu *) 0 ;
39737 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39738 wxMenuItem *result = 0 ;
39739 void *argp1 = 0 ;
39740 int res1 = 0 ;
39741 void *argp2 = 0 ;
39742 int res2 = 0 ;
39743 PyObject * obj0 = 0 ;
39744 PyObject * obj1 = 0 ;
39745 char * kwnames[] = {
39746 (char *) "self",(char *) "item", NULL
39747 };
39748
39749 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) SWIG_fail;
39750 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39751 if (!SWIG_IsOK(res1)) {
39752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_RemoveItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39753 }
39754 arg1 = reinterpret_cast< wxMenu * >(argp1);
39755 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39756 if (!SWIG_IsOK(res2)) {
39757 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_RemoveItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39758 }
39759 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39760 {
39761 PyThreadState* __tstate = wxPyBeginAllowThreads();
39762 result = (wxMenuItem *)(arg1)->Remove(arg2);
39763 wxPyEndAllowThreads(__tstate);
39764 if (PyErr_Occurred()) SWIG_fail;
39765 }
39766 {
39767 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
39768 }
39769 return resultobj;
39770 fail:
39771 return NULL;
39772 }
39773
39774
39775 SWIGINTERN PyObject *_wrap_Menu_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39776 PyObject *resultobj = 0;
39777 wxMenu *arg1 = (wxMenu *) 0 ;
39778 int arg2 ;
39779 bool result;
39780 void *argp1 = 0 ;
39781 int res1 = 0 ;
39782 int val2 ;
39783 int ecode2 = 0 ;
39784 PyObject * obj0 = 0 ;
39785 PyObject * obj1 = 0 ;
39786 char * kwnames[] = {
39787 (char *) "self",(char *) "id", NULL
39788 };
39789
39790 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
39791 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39792 if (!SWIG_IsOK(res1)) {
39793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Delete" "', expected argument " "1"" of type '" "wxMenu *""'");
39794 }
39795 arg1 = reinterpret_cast< wxMenu * >(argp1);
39796 ecode2 = SWIG_AsVal_int(obj1, &val2);
39797 if (!SWIG_IsOK(ecode2)) {
39798 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Delete" "', expected argument " "2"" of type '" "int""'");
39799 }
39800 arg2 = static_cast< int >(val2);
39801 {
39802 PyThreadState* __tstate = wxPyBeginAllowThreads();
39803 result = (bool)(arg1)->Delete(arg2);
39804 wxPyEndAllowThreads(__tstate);
39805 if (PyErr_Occurred()) SWIG_fail;
39806 }
39807 {
39808 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39809 }
39810 return resultobj;
39811 fail:
39812 return NULL;
39813 }
39814
39815
39816 SWIGINTERN PyObject *_wrap_Menu_DeleteItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39817 PyObject *resultobj = 0;
39818 wxMenu *arg1 = (wxMenu *) 0 ;
39819 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39820 bool result;
39821 void *argp1 = 0 ;
39822 int res1 = 0 ;
39823 void *argp2 = 0 ;
39824 int res2 = 0 ;
39825 PyObject * obj0 = 0 ;
39826 PyObject * obj1 = 0 ;
39827 char * kwnames[] = {
39828 (char *) "self",(char *) "item", NULL
39829 };
39830
39831 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) SWIG_fail;
39832 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39833 if (!SWIG_IsOK(res1)) {
39834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DeleteItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39835 }
39836 arg1 = reinterpret_cast< wxMenu * >(argp1);
39837 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39838 if (!SWIG_IsOK(res2)) {
39839 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DeleteItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39840 }
39841 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39842 {
39843 PyThreadState* __tstate = wxPyBeginAllowThreads();
39844 result = (bool)(arg1)->Delete(arg2);
39845 wxPyEndAllowThreads(__tstate);
39846 if (PyErr_Occurred()) SWIG_fail;
39847 }
39848 {
39849 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39850 }
39851 return resultobj;
39852 fail:
39853 return NULL;
39854 }
39855
39856
39857 SWIGINTERN PyObject *_wrap_Menu_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39858 PyObject *resultobj = 0;
39859 wxMenu *arg1 = (wxMenu *) 0 ;
39860 void *argp1 = 0 ;
39861 int res1 = 0 ;
39862 PyObject *swig_obj[1] ;
39863
39864 if (!args) SWIG_fail;
39865 swig_obj[0] = args;
39866 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39867 if (!SWIG_IsOK(res1)) {
39868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Destroy" "', expected argument " "1"" of type '" "wxMenu *""'");
39869 }
39870 arg1 = reinterpret_cast< wxMenu * >(argp1);
39871 {
39872 PyThreadState* __tstate = wxPyBeginAllowThreads();
39873 wxMenu_Destroy(arg1);
39874 wxPyEndAllowThreads(__tstate);
39875 if (PyErr_Occurred()) SWIG_fail;
39876 }
39877 resultobj = SWIG_Py_Void();
39878 return resultobj;
39879 fail:
39880 return NULL;
39881 }
39882
39883
39884 SWIGINTERN PyObject *_wrap_Menu_DestroyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39885 PyObject *resultobj = 0;
39886 wxMenu *arg1 = (wxMenu *) 0 ;
39887 int arg2 ;
39888 bool result;
39889 void *argp1 = 0 ;
39890 int res1 = 0 ;
39891 int val2 ;
39892 int ecode2 = 0 ;
39893 PyObject * obj0 = 0 ;
39894 PyObject * obj1 = 0 ;
39895 char * kwnames[] = {
39896 (char *) "self",(char *) "id", NULL
39897 };
39898
39899 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) SWIG_fail;
39900 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39901 if (!SWIG_IsOK(res1)) {
39902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyId" "', expected argument " "1"" of type '" "wxMenu *""'");
39903 }
39904 arg1 = reinterpret_cast< wxMenu * >(argp1);
39905 ecode2 = SWIG_AsVal_int(obj1, &val2);
39906 if (!SWIG_IsOK(ecode2)) {
39907 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_DestroyId" "', expected argument " "2"" of type '" "int""'");
39908 }
39909 arg2 = static_cast< int >(val2);
39910 {
39911 PyThreadState* __tstate = wxPyBeginAllowThreads();
39912 result = (bool)(arg1)->Destroy(arg2);
39913 wxPyEndAllowThreads(__tstate);
39914 if (PyErr_Occurred()) SWIG_fail;
39915 }
39916 {
39917 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39918 }
39919 return resultobj;
39920 fail:
39921 return NULL;
39922 }
39923
39924
39925 SWIGINTERN PyObject *_wrap_Menu_DestroyItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39926 PyObject *resultobj = 0;
39927 wxMenu *arg1 = (wxMenu *) 0 ;
39928 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39929 bool result;
39930 void *argp1 = 0 ;
39931 int res1 = 0 ;
39932 void *argp2 = 0 ;
39933 int res2 = 0 ;
39934 PyObject * obj0 = 0 ;
39935 PyObject * obj1 = 0 ;
39936 char * kwnames[] = {
39937 (char *) "self",(char *) "item", NULL
39938 };
39939
39940 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) SWIG_fail;
39941 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39942 if (!SWIG_IsOK(res1)) {
39943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39944 }
39945 arg1 = reinterpret_cast< wxMenu * >(argp1);
39946 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39947 if (!SWIG_IsOK(res2)) {
39948 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DestroyItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39949 }
39950 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39951 {
39952 PyThreadState* __tstate = wxPyBeginAllowThreads();
39953 result = (bool)(arg1)->Destroy(arg2);
39954 wxPyEndAllowThreads(__tstate);
39955 if (PyErr_Occurred()) SWIG_fail;
39956 }
39957 {
39958 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39959 }
39960 return resultobj;
39961 fail:
39962 return NULL;
39963 }
39964
39965
39966 SWIGINTERN PyObject *_wrap_Menu_GetMenuItemCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39967 PyObject *resultobj = 0;
39968 wxMenu *arg1 = (wxMenu *) 0 ;
39969 size_t result;
39970 void *argp1 = 0 ;
39971 int res1 = 0 ;
39972 PyObject *swig_obj[1] ;
39973
39974 if (!args) SWIG_fail;
39975 swig_obj[0] = args;
39976 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39977 if (!SWIG_IsOK(res1)) {
39978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItemCount" "', expected argument " "1"" of type '" "wxMenu const *""'");
39979 }
39980 arg1 = reinterpret_cast< wxMenu * >(argp1);
39981 {
39982 PyThreadState* __tstate = wxPyBeginAllowThreads();
39983 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
39984 wxPyEndAllowThreads(__tstate);
39985 if (PyErr_Occurred()) SWIG_fail;
39986 }
39987 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
39988 return resultobj;
39989 fail:
39990 return NULL;
39991 }
39992
39993
39994 SWIGINTERN PyObject *_wrap_Menu_GetMenuItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39995 PyObject *resultobj = 0;
39996 wxMenu *arg1 = (wxMenu *) 0 ;
39997 PyObject *result = 0 ;
39998 void *argp1 = 0 ;
39999 int res1 = 0 ;
40000 PyObject *swig_obj[1] ;
40001
40002 if (!args) SWIG_fail;
40003 swig_obj[0] = args;
40004 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40005 if (!SWIG_IsOK(res1)) {
40006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItems" "', expected argument " "1"" of type '" "wxMenu *""'");
40007 }
40008 arg1 = reinterpret_cast< wxMenu * >(argp1);
40009 {
40010 PyThreadState* __tstate = wxPyBeginAllowThreads();
40011 result = (PyObject *)wxMenu_GetMenuItems(arg1);
40012 wxPyEndAllowThreads(__tstate);
40013 if (PyErr_Occurred()) SWIG_fail;
40014 }
40015 resultobj = result;
40016 return resultobj;
40017 fail:
40018 return NULL;
40019 }
40020
40021
40022 SWIGINTERN PyObject *_wrap_Menu_FindItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40023 PyObject *resultobj = 0;
40024 wxMenu *arg1 = (wxMenu *) 0 ;
40025 wxString *arg2 = 0 ;
40026 int result;
40027 void *argp1 = 0 ;
40028 int res1 = 0 ;
40029 bool temp2 = false ;
40030 PyObject * obj0 = 0 ;
40031 PyObject * obj1 = 0 ;
40032 char * kwnames[] = {
40033 (char *) "self",(char *) "item", NULL
40034 };
40035
40036 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) SWIG_fail;
40037 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40038 if (!SWIG_IsOK(res1)) {
40039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItem" "', expected argument " "1"" of type '" "wxMenu const *""'");
40040 }
40041 arg1 = reinterpret_cast< wxMenu * >(argp1);
40042 {
40043 arg2 = wxString_in_helper(obj1);
40044 if (arg2 == NULL) SWIG_fail;
40045 temp2 = true;
40046 }
40047 {
40048 PyThreadState* __tstate = wxPyBeginAllowThreads();
40049 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
40050 wxPyEndAllowThreads(__tstate);
40051 if (PyErr_Occurred()) SWIG_fail;
40052 }
40053 resultobj = SWIG_From_int(static_cast< int >(result));
40054 {
40055 if (temp2)
40056 delete arg2;
40057 }
40058 return resultobj;
40059 fail:
40060 {
40061 if (temp2)
40062 delete arg2;
40063 }
40064 return NULL;
40065 }
40066
40067
40068 SWIGINTERN PyObject *_wrap_Menu_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40069 PyObject *resultobj = 0;
40070 wxMenu *arg1 = (wxMenu *) 0 ;
40071 int arg2 ;
40072 wxMenuItem *result = 0 ;
40073 void *argp1 = 0 ;
40074 int res1 = 0 ;
40075 int val2 ;
40076 int ecode2 = 0 ;
40077 PyObject * obj0 = 0 ;
40078 PyObject * obj1 = 0 ;
40079 char * kwnames[] = {
40080 (char *) "self",(char *) "id", NULL
40081 };
40082
40083 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
40084 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40085 if (!SWIG_IsOK(res1)) {
40086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemById" "', expected argument " "1"" of type '" "wxMenu const *""'");
40087 }
40088 arg1 = reinterpret_cast< wxMenu * >(argp1);
40089 ecode2 = SWIG_AsVal_int(obj1, &val2);
40090 if (!SWIG_IsOK(ecode2)) {
40091 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemById" "', expected argument " "2"" of type '" "int""'");
40092 }
40093 arg2 = static_cast< int >(val2);
40094 {
40095 PyThreadState* __tstate = wxPyBeginAllowThreads();
40096 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
40097 wxPyEndAllowThreads(__tstate);
40098 if (PyErr_Occurred()) SWIG_fail;
40099 }
40100 {
40101 resultobj = wxPyMake_wxObject(result, (bool)0);
40102 }
40103 return resultobj;
40104 fail:
40105 return NULL;
40106 }
40107
40108
40109 SWIGINTERN PyObject *_wrap_Menu_FindItemByPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40110 PyObject *resultobj = 0;
40111 wxMenu *arg1 = (wxMenu *) 0 ;
40112 size_t arg2 ;
40113 wxMenuItem *result = 0 ;
40114 void *argp1 = 0 ;
40115 int res1 = 0 ;
40116 size_t val2 ;
40117 int ecode2 = 0 ;
40118 PyObject * obj0 = 0 ;
40119 PyObject * obj1 = 0 ;
40120 char * kwnames[] = {
40121 (char *) "self",(char *) "position", NULL
40122 };
40123
40124 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) SWIG_fail;
40125 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40126 if (!SWIG_IsOK(res1)) {
40127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemByPosition" "', expected argument " "1"" of type '" "wxMenu const *""'");
40128 }
40129 arg1 = reinterpret_cast< wxMenu * >(argp1);
40130 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40131 if (!SWIG_IsOK(ecode2)) {
40132 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemByPosition" "', expected argument " "2"" of type '" "size_t""'");
40133 }
40134 arg2 = static_cast< size_t >(val2);
40135 {
40136 PyThreadState* __tstate = wxPyBeginAllowThreads();
40137 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
40138 wxPyEndAllowThreads(__tstate);
40139 if (PyErr_Occurred()) SWIG_fail;
40140 }
40141 {
40142 resultobj = wxPyMake_wxObject(result, (bool)0);
40143 }
40144 return resultobj;
40145 fail:
40146 return NULL;
40147 }
40148
40149
40150 SWIGINTERN PyObject *_wrap_Menu_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40151 PyObject *resultobj = 0;
40152 wxMenu *arg1 = (wxMenu *) 0 ;
40153 int arg2 ;
40154 bool arg3 ;
40155 void *argp1 = 0 ;
40156 int res1 = 0 ;
40157 int val2 ;
40158 int ecode2 = 0 ;
40159 bool val3 ;
40160 int ecode3 = 0 ;
40161 PyObject * obj0 = 0 ;
40162 PyObject * obj1 = 0 ;
40163 PyObject * obj2 = 0 ;
40164 char * kwnames[] = {
40165 (char *) "self",(char *) "id",(char *) "enable", NULL
40166 };
40167
40168 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40169 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40170 if (!SWIG_IsOK(res1)) {
40171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Enable" "', expected argument " "1"" of type '" "wxMenu *""'");
40172 }
40173 arg1 = reinterpret_cast< wxMenu * >(argp1);
40174 ecode2 = SWIG_AsVal_int(obj1, &val2);
40175 if (!SWIG_IsOK(ecode2)) {
40176 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Enable" "', expected argument " "2"" of type '" "int""'");
40177 }
40178 arg2 = static_cast< int >(val2);
40179 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40180 if (!SWIG_IsOK(ecode3)) {
40181 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Enable" "', expected argument " "3"" of type '" "bool""'");
40182 }
40183 arg3 = static_cast< bool >(val3);
40184 {
40185 PyThreadState* __tstate = wxPyBeginAllowThreads();
40186 (arg1)->Enable(arg2,arg3);
40187 wxPyEndAllowThreads(__tstate);
40188 if (PyErr_Occurred()) SWIG_fail;
40189 }
40190 resultobj = SWIG_Py_Void();
40191 return resultobj;
40192 fail:
40193 return NULL;
40194 }
40195
40196
40197 SWIGINTERN PyObject *_wrap_Menu_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40198 PyObject *resultobj = 0;
40199 wxMenu *arg1 = (wxMenu *) 0 ;
40200 int arg2 ;
40201 bool result;
40202 void *argp1 = 0 ;
40203 int res1 = 0 ;
40204 int val2 ;
40205 int ecode2 = 0 ;
40206 PyObject * obj0 = 0 ;
40207 PyObject * obj1 = 0 ;
40208 char * kwnames[] = {
40209 (char *) "self",(char *) "id", NULL
40210 };
40211
40212 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
40213 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40214 if (!SWIG_IsOK(res1)) {
40215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsEnabled" "', expected argument " "1"" of type '" "wxMenu const *""'");
40216 }
40217 arg1 = reinterpret_cast< wxMenu * >(argp1);
40218 ecode2 = SWIG_AsVal_int(obj1, &val2);
40219 if (!SWIG_IsOK(ecode2)) {
40220 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsEnabled" "', expected argument " "2"" of type '" "int""'");
40221 }
40222 arg2 = static_cast< int >(val2);
40223 {
40224 PyThreadState* __tstate = wxPyBeginAllowThreads();
40225 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
40226 wxPyEndAllowThreads(__tstate);
40227 if (PyErr_Occurred()) SWIG_fail;
40228 }
40229 {
40230 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40231 }
40232 return resultobj;
40233 fail:
40234 return NULL;
40235 }
40236
40237
40238 SWIGINTERN PyObject *_wrap_Menu_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40239 PyObject *resultobj = 0;
40240 wxMenu *arg1 = (wxMenu *) 0 ;
40241 int arg2 ;
40242 bool arg3 ;
40243 void *argp1 = 0 ;
40244 int res1 = 0 ;
40245 int val2 ;
40246 int ecode2 = 0 ;
40247 bool val3 ;
40248 int ecode3 = 0 ;
40249 PyObject * obj0 = 0 ;
40250 PyObject * obj1 = 0 ;
40251 PyObject * obj2 = 0 ;
40252 char * kwnames[] = {
40253 (char *) "self",(char *) "id",(char *) "check", NULL
40254 };
40255
40256 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40257 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40258 if (!SWIG_IsOK(res1)) {
40259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Check" "', expected argument " "1"" of type '" "wxMenu *""'");
40260 }
40261 arg1 = reinterpret_cast< wxMenu * >(argp1);
40262 ecode2 = SWIG_AsVal_int(obj1, &val2);
40263 if (!SWIG_IsOK(ecode2)) {
40264 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Check" "', expected argument " "2"" of type '" "int""'");
40265 }
40266 arg2 = static_cast< int >(val2);
40267 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40268 if (!SWIG_IsOK(ecode3)) {
40269 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Check" "', expected argument " "3"" of type '" "bool""'");
40270 }
40271 arg3 = static_cast< bool >(val3);
40272 {
40273 PyThreadState* __tstate = wxPyBeginAllowThreads();
40274 (arg1)->Check(arg2,arg3);
40275 wxPyEndAllowThreads(__tstate);
40276 if (PyErr_Occurred()) SWIG_fail;
40277 }
40278 resultobj = SWIG_Py_Void();
40279 return resultobj;
40280 fail:
40281 return NULL;
40282 }
40283
40284
40285 SWIGINTERN PyObject *_wrap_Menu_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40286 PyObject *resultobj = 0;
40287 wxMenu *arg1 = (wxMenu *) 0 ;
40288 int arg2 ;
40289 bool result;
40290 void *argp1 = 0 ;
40291 int res1 = 0 ;
40292 int val2 ;
40293 int ecode2 = 0 ;
40294 PyObject * obj0 = 0 ;
40295 PyObject * obj1 = 0 ;
40296 char * kwnames[] = {
40297 (char *) "self",(char *) "id", NULL
40298 };
40299
40300 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
40301 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40302 if (!SWIG_IsOK(res1)) {
40303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsChecked" "', expected argument " "1"" of type '" "wxMenu const *""'");
40304 }
40305 arg1 = reinterpret_cast< wxMenu * >(argp1);
40306 ecode2 = SWIG_AsVal_int(obj1, &val2);
40307 if (!SWIG_IsOK(ecode2)) {
40308 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsChecked" "', expected argument " "2"" of type '" "int""'");
40309 }
40310 arg2 = static_cast< int >(val2);
40311 {
40312 PyThreadState* __tstate = wxPyBeginAllowThreads();
40313 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
40314 wxPyEndAllowThreads(__tstate);
40315 if (PyErr_Occurred()) SWIG_fail;
40316 }
40317 {
40318 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40319 }
40320 return resultobj;
40321 fail:
40322 return NULL;
40323 }
40324
40325
40326 SWIGINTERN PyObject *_wrap_Menu_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40327 PyObject *resultobj = 0;
40328 wxMenu *arg1 = (wxMenu *) 0 ;
40329 int arg2 ;
40330 wxString *arg3 = 0 ;
40331 void *argp1 = 0 ;
40332 int res1 = 0 ;
40333 int val2 ;
40334 int ecode2 = 0 ;
40335 bool temp3 = false ;
40336 PyObject * obj0 = 0 ;
40337 PyObject * obj1 = 0 ;
40338 PyObject * obj2 = 0 ;
40339 char * kwnames[] = {
40340 (char *) "self",(char *) "id",(char *) "label", NULL
40341 };
40342
40343 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40344 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40345 if (!SWIG_IsOK(res1)) {
40346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetLabel" "', expected argument " "1"" of type '" "wxMenu *""'");
40347 }
40348 arg1 = reinterpret_cast< wxMenu * >(argp1);
40349 ecode2 = SWIG_AsVal_int(obj1, &val2);
40350 if (!SWIG_IsOK(ecode2)) {
40351 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetLabel" "', expected argument " "2"" of type '" "int""'");
40352 }
40353 arg2 = static_cast< int >(val2);
40354 {
40355 arg3 = wxString_in_helper(obj2);
40356 if (arg3 == NULL) SWIG_fail;
40357 temp3 = true;
40358 }
40359 {
40360 PyThreadState* __tstate = wxPyBeginAllowThreads();
40361 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
40362 wxPyEndAllowThreads(__tstate);
40363 if (PyErr_Occurred()) SWIG_fail;
40364 }
40365 resultobj = SWIG_Py_Void();
40366 {
40367 if (temp3)
40368 delete arg3;
40369 }
40370 return resultobj;
40371 fail:
40372 {
40373 if (temp3)
40374 delete arg3;
40375 }
40376 return NULL;
40377 }
40378
40379
40380 SWIGINTERN PyObject *_wrap_Menu_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40381 PyObject *resultobj = 0;
40382 wxMenu *arg1 = (wxMenu *) 0 ;
40383 int arg2 ;
40384 wxString result;
40385 void *argp1 = 0 ;
40386 int res1 = 0 ;
40387 int val2 ;
40388 int ecode2 = 0 ;
40389 PyObject * obj0 = 0 ;
40390 PyObject * obj1 = 0 ;
40391 char * kwnames[] = {
40392 (char *) "self",(char *) "id", NULL
40393 };
40394
40395 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
40396 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40397 if (!SWIG_IsOK(res1)) {
40398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetLabel" "', expected argument " "1"" of type '" "wxMenu const *""'");
40399 }
40400 arg1 = reinterpret_cast< wxMenu * >(argp1);
40401 ecode2 = SWIG_AsVal_int(obj1, &val2);
40402 if (!SWIG_IsOK(ecode2)) {
40403 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetLabel" "', expected argument " "2"" of type '" "int""'");
40404 }
40405 arg2 = static_cast< int >(val2);
40406 {
40407 PyThreadState* __tstate = wxPyBeginAllowThreads();
40408 result = ((wxMenu const *)arg1)->GetLabel(arg2);
40409 wxPyEndAllowThreads(__tstate);
40410 if (PyErr_Occurred()) SWIG_fail;
40411 }
40412 {
40413 #if wxUSE_UNICODE
40414 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40415 #else
40416 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40417 #endif
40418 }
40419 return resultobj;
40420 fail:
40421 return NULL;
40422 }
40423
40424
40425 SWIGINTERN PyObject *_wrap_Menu_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40426 PyObject *resultobj = 0;
40427 wxMenu *arg1 = (wxMenu *) 0 ;
40428 int arg2 ;
40429 wxString *arg3 = 0 ;
40430 void *argp1 = 0 ;
40431 int res1 = 0 ;
40432 int val2 ;
40433 int ecode2 = 0 ;
40434 bool temp3 = false ;
40435 PyObject * obj0 = 0 ;
40436 PyObject * obj1 = 0 ;
40437 PyObject * obj2 = 0 ;
40438 char * kwnames[] = {
40439 (char *) "self",(char *) "id",(char *) "helpString", NULL
40440 };
40441
40442 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40443 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40444 if (!SWIG_IsOK(res1)) {
40445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetHelpString" "', expected argument " "1"" of type '" "wxMenu *""'");
40446 }
40447 arg1 = reinterpret_cast< wxMenu * >(argp1);
40448 ecode2 = SWIG_AsVal_int(obj1, &val2);
40449 if (!SWIG_IsOK(ecode2)) {
40450 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetHelpString" "', expected argument " "2"" of type '" "int""'");
40451 }
40452 arg2 = static_cast< int >(val2);
40453 {
40454 arg3 = wxString_in_helper(obj2);
40455 if (arg3 == NULL) SWIG_fail;
40456 temp3 = true;
40457 }
40458 {
40459 PyThreadState* __tstate = wxPyBeginAllowThreads();
40460 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
40461 wxPyEndAllowThreads(__tstate);
40462 if (PyErr_Occurred()) SWIG_fail;
40463 }
40464 resultobj = SWIG_Py_Void();
40465 {
40466 if (temp3)
40467 delete arg3;
40468 }
40469 return resultobj;
40470 fail:
40471 {
40472 if (temp3)
40473 delete arg3;
40474 }
40475 return NULL;
40476 }
40477
40478
40479 SWIGINTERN PyObject *_wrap_Menu_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40480 PyObject *resultobj = 0;
40481 wxMenu *arg1 = (wxMenu *) 0 ;
40482 int arg2 ;
40483 wxString result;
40484 void *argp1 = 0 ;
40485 int res1 = 0 ;
40486 int val2 ;
40487 int ecode2 = 0 ;
40488 PyObject * obj0 = 0 ;
40489 PyObject * obj1 = 0 ;
40490 char * kwnames[] = {
40491 (char *) "self",(char *) "id", NULL
40492 };
40493
40494 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
40495 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40496 if (!SWIG_IsOK(res1)) {
40497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetHelpString" "', expected argument " "1"" of type '" "wxMenu const *""'");
40498 }
40499 arg1 = reinterpret_cast< wxMenu * >(argp1);
40500 ecode2 = SWIG_AsVal_int(obj1, &val2);
40501 if (!SWIG_IsOK(ecode2)) {
40502 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetHelpString" "', expected argument " "2"" of type '" "int""'");
40503 }
40504 arg2 = static_cast< int >(val2);
40505 {
40506 PyThreadState* __tstate = wxPyBeginAllowThreads();
40507 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
40508 wxPyEndAllowThreads(__tstate);
40509 if (PyErr_Occurred()) SWIG_fail;
40510 }
40511 {
40512 #if wxUSE_UNICODE
40513 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40514 #else
40515 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40516 #endif
40517 }
40518 return resultobj;
40519 fail:
40520 return NULL;
40521 }
40522
40523
40524 SWIGINTERN PyObject *_wrap_Menu_SetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40525 PyObject *resultobj = 0;
40526 wxMenu *arg1 = (wxMenu *) 0 ;
40527 wxString *arg2 = 0 ;
40528 void *argp1 = 0 ;
40529 int res1 = 0 ;
40530 bool temp2 = false ;
40531 PyObject * obj0 = 0 ;
40532 PyObject * obj1 = 0 ;
40533 char * kwnames[] = {
40534 (char *) "self",(char *) "title", NULL
40535 };
40536
40537 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) SWIG_fail;
40538 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40539 if (!SWIG_IsOK(res1)) {
40540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetTitle" "', expected argument " "1"" of type '" "wxMenu *""'");
40541 }
40542 arg1 = reinterpret_cast< wxMenu * >(argp1);
40543 {
40544 arg2 = wxString_in_helper(obj1);
40545 if (arg2 == NULL) SWIG_fail;
40546 temp2 = true;
40547 }
40548 {
40549 PyThreadState* __tstate = wxPyBeginAllowThreads();
40550 (arg1)->SetTitle((wxString const &)*arg2);
40551 wxPyEndAllowThreads(__tstate);
40552 if (PyErr_Occurred()) SWIG_fail;
40553 }
40554 resultobj = SWIG_Py_Void();
40555 {
40556 if (temp2)
40557 delete arg2;
40558 }
40559 return resultobj;
40560 fail:
40561 {
40562 if (temp2)
40563 delete arg2;
40564 }
40565 return NULL;
40566 }
40567
40568
40569 SWIGINTERN PyObject *_wrap_Menu_GetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40570 PyObject *resultobj = 0;
40571 wxMenu *arg1 = (wxMenu *) 0 ;
40572 wxString result;
40573 void *argp1 = 0 ;
40574 int res1 = 0 ;
40575 PyObject *swig_obj[1] ;
40576
40577 if (!args) SWIG_fail;
40578 swig_obj[0] = args;
40579 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40580 if (!SWIG_IsOK(res1)) {
40581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetTitle" "', expected argument " "1"" of type '" "wxMenu const *""'");
40582 }
40583 arg1 = reinterpret_cast< wxMenu * >(argp1);
40584 {
40585 PyThreadState* __tstate = wxPyBeginAllowThreads();
40586 result = ((wxMenu const *)arg1)->GetTitle();
40587 wxPyEndAllowThreads(__tstate);
40588 if (PyErr_Occurred()) SWIG_fail;
40589 }
40590 {
40591 #if wxUSE_UNICODE
40592 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40593 #else
40594 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40595 #endif
40596 }
40597 return resultobj;
40598 fail:
40599 return NULL;
40600 }
40601
40602
40603 SWIGINTERN PyObject *_wrap_Menu_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40604 PyObject *resultobj = 0;
40605 wxMenu *arg1 = (wxMenu *) 0 ;
40606 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
40607 void *argp1 = 0 ;
40608 int res1 = 0 ;
40609 void *argp2 = 0 ;
40610 int res2 = 0 ;
40611 PyObject * obj0 = 0 ;
40612 PyObject * obj1 = 0 ;
40613 char * kwnames[] = {
40614 (char *) "self",(char *) "handler", NULL
40615 };
40616
40617 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
40618 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40619 if (!SWIG_IsOK(res1)) {
40620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetEventHandler" "', expected argument " "1"" of type '" "wxMenu *""'");
40621 }
40622 arg1 = reinterpret_cast< wxMenu * >(argp1);
40623 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
40624 if (!SWIG_IsOK(res2)) {
40625 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
40626 }
40627 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
40628 {
40629 PyThreadState* __tstate = wxPyBeginAllowThreads();
40630 (arg1)->SetEventHandler(arg2);
40631 wxPyEndAllowThreads(__tstate);
40632 if (PyErr_Occurred()) SWIG_fail;
40633 }
40634 resultobj = SWIG_Py_Void();
40635 return resultobj;
40636 fail:
40637 return NULL;
40638 }
40639
40640
40641 SWIGINTERN PyObject *_wrap_Menu_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40642 PyObject *resultobj = 0;
40643 wxMenu *arg1 = (wxMenu *) 0 ;
40644 wxEvtHandler *result = 0 ;
40645 void *argp1 = 0 ;
40646 int res1 = 0 ;
40647 PyObject *swig_obj[1] ;
40648
40649 if (!args) SWIG_fail;
40650 swig_obj[0] = args;
40651 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40652 if (!SWIG_IsOK(res1)) {
40653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetEventHandler" "', expected argument " "1"" of type '" "wxMenu const *""'");
40654 }
40655 arg1 = reinterpret_cast< wxMenu * >(argp1);
40656 {
40657 PyThreadState* __tstate = wxPyBeginAllowThreads();
40658 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
40659 wxPyEndAllowThreads(__tstate);
40660 if (PyErr_Occurred()) SWIG_fail;
40661 }
40662 {
40663 resultobj = wxPyMake_wxObject(result, 0);
40664 }
40665 return resultobj;
40666 fail:
40667 return NULL;
40668 }
40669
40670
40671 SWIGINTERN PyObject *_wrap_Menu_SetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40672 PyObject *resultobj = 0;
40673 wxMenu *arg1 = (wxMenu *) 0 ;
40674 wxWindow *arg2 = (wxWindow *) 0 ;
40675 void *argp1 = 0 ;
40676 int res1 = 0 ;
40677 void *argp2 = 0 ;
40678 int res2 = 0 ;
40679 PyObject * obj0 = 0 ;
40680 PyObject * obj1 = 0 ;
40681 char * kwnames[] = {
40682 (char *) "self",(char *) "win", NULL
40683 };
40684
40685 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
40686 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40687 if (!SWIG_IsOK(res1)) {
40688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu *""'");
40689 }
40690 arg1 = reinterpret_cast< wxMenu * >(argp1);
40691 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
40692 if (!SWIG_IsOK(res2)) {
40693 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetInvokingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
40694 }
40695 arg2 = reinterpret_cast< wxWindow * >(argp2);
40696 {
40697 PyThreadState* __tstate = wxPyBeginAllowThreads();
40698 (arg1)->SetInvokingWindow(arg2);
40699 wxPyEndAllowThreads(__tstate);
40700 if (PyErr_Occurred()) SWIG_fail;
40701 }
40702 resultobj = SWIG_Py_Void();
40703 return resultobj;
40704 fail:
40705 return NULL;
40706 }
40707
40708
40709 SWIGINTERN PyObject *_wrap_Menu_GetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40710 PyObject *resultobj = 0;
40711 wxMenu *arg1 = (wxMenu *) 0 ;
40712 wxWindow *result = 0 ;
40713 void *argp1 = 0 ;
40714 int res1 = 0 ;
40715 PyObject *swig_obj[1] ;
40716
40717 if (!args) SWIG_fail;
40718 swig_obj[0] = args;
40719 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40720 if (!SWIG_IsOK(res1)) {
40721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu const *""'");
40722 }
40723 arg1 = reinterpret_cast< wxMenu * >(argp1);
40724 {
40725 PyThreadState* __tstate = wxPyBeginAllowThreads();
40726 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
40727 wxPyEndAllowThreads(__tstate);
40728 if (PyErr_Occurred()) SWIG_fail;
40729 }
40730 {
40731 resultobj = wxPyMake_wxObject(result, 0);
40732 }
40733 return resultobj;
40734 fail:
40735 return NULL;
40736 }
40737
40738
40739 SWIGINTERN PyObject *_wrap_Menu_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40740 PyObject *resultobj = 0;
40741 wxMenu *arg1 = (wxMenu *) 0 ;
40742 long result;
40743 void *argp1 = 0 ;
40744 int res1 = 0 ;
40745 PyObject *swig_obj[1] ;
40746
40747 if (!args) SWIG_fail;
40748 swig_obj[0] = args;
40749 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40750 if (!SWIG_IsOK(res1)) {
40751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetStyle" "', expected argument " "1"" of type '" "wxMenu const *""'");
40752 }
40753 arg1 = reinterpret_cast< wxMenu * >(argp1);
40754 {
40755 PyThreadState* __tstate = wxPyBeginAllowThreads();
40756 result = (long)((wxMenu const *)arg1)->GetStyle();
40757 wxPyEndAllowThreads(__tstate);
40758 if (PyErr_Occurred()) SWIG_fail;
40759 }
40760 resultobj = SWIG_From_long(static_cast< long >(result));
40761 return resultobj;
40762 fail:
40763 return NULL;
40764 }
40765
40766
40767 SWIGINTERN PyObject *_wrap_Menu_UpdateUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40768 PyObject *resultobj = 0;
40769 wxMenu *arg1 = (wxMenu *) 0 ;
40770 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
40771 void *argp1 = 0 ;
40772 int res1 = 0 ;
40773 void *argp2 = 0 ;
40774 int res2 = 0 ;
40775 PyObject * obj0 = 0 ;
40776 PyObject * obj1 = 0 ;
40777 char * kwnames[] = {
40778 (char *) "self",(char *) "source", NULL
40779 };
40780
40781 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) SWIG_fail;
40782 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40783 if (!SWIG_IsOK(res1)) {
40784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_UpdateUI" "', expected argument " "1"" of type '" "wxMenu *""'");
40785 }
40786 arg1 = reinterpret_cast< wxMenu * >(argp1);
40787 if (obj1) {
40788 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
40789 if (!SWIG_IsOK(res2)) {
40790 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_UpdateUI" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
40791 }
40792 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
40793 }
40794 {
40795 PyThreadState* __tstate = wxPyBeginAllowThreads();
40796 (arg1)->UpdateUI(arg2);
40797 wxPyEndAllowThreads(__tstate);
40798 if (PyErr_Occurred()) SWIG_fail;
40799 }
40800 resultobj = SWIG_Py_Void();
40801 return resultobj;
40802 fail:
40803 return NULL;
40804 }
40805
40806
40807 SWIGINTERN PyObject *_wrap_Menu_GetMenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40808 PyObject *resultobj = 0;
40809 wxMenu *arg1 = (wxMenu *) 0 ;
40810 wxMenuBar *result = 0 ;
40811 void *argp1 = 0 ;
40812 int res1 = 0 ;
40813 PyObject *swig_obj[1] ;
40814
40815 if (!args) SWIG_fail;
40816 swig_obj[0] = args;
40817 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40818 if (!SWIG_IsOK(res1)) {
40819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuBar" "', expected argument " "1"" of type '" "wxMenu const *""'");
40820 }
40821 arg1 = reinterpret_cast< wxMenu * >(argp1);
40822 {
40823 PyThreadState* __tstate = wxPyBeginAllowThreads();
40824 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
40825 wxPyEndAllowThreads(__tstate);
40826 if (PyErr_Occurred()) SWIG_fail;
40827 }
40828 {
40829 resultobj = wxPyMake_wxObject(result, (bool)0);
40830 }
40831 return resultobj;
40832 fail:
40833 return NULL;
40834 }
40835
40836
40837 SWIGINTERN PyObject *_wrap_Menu_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40838 PyObject *resultobj = 0;
40839 wxMenu *arg1 = (wxMenu *) 0 ;
40840 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
40841 void *argp1 = 0 ;
40842 int res1 = 0 ;
40843 void *argp2 = 0 ;
40844 int res2 = 0 ;
40845 PyObject * obj0 = 0 ;
40846 PyObject * obj1 = 0 ;
40847 char * kwnames[] = {
40848 (char *) "self",(char *) "menubar", NULL
40849 };
40850
40851 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
40852 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40853 if (!SWIG_IsOK(res1)) {
40854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Attach" "', expected argument " "1"" of type '" "wxMenu *""'");
40855 }
40856 arg1 = reinterpret_cast< wxMenu * >(argp1);
40857 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuBarBase, 0 | 0 );
40858 if (!SWIG_IsOK(res2)) {
40859 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_Attach" "', expected argument " "2"" of type '" "wxMenuBarBase *""'");
40860 }
40861 arg2 = reinterpret_cast< wxMenuBarBase * >(argp2);
40862 {
40863 PyThreadState* __tstate = wxPyBeginAllowThreads();
40864 (arg1)->Attach(arg2);
40865 wxPyEndAllowThreads(__tstate);
40866 if (PyErr_Occurred()) SWIG_fail;
40867 }
40868 resultobj = SWIG_Py_Void();
40869 return resultobj;
40870 fail:
40871 return NULL;
40872 }
40873
40874
40875 SWIGINTERN PyObject *_wrap_Menu_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40876 PyObject *resultobj = 0;
40877 wxMenu *arg1 = (wxMenu *) 0 ;
40878 void *argp1 = 0 ;
40879 int res1 = 0 ;
40880 PyObject *swig_obj[1] ;
40881
40882 if (!args) SWIG_fail;
40883 swig_obj[0] = args;
40884 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40885 if (!SWIG_IsOK(res1)) {
40886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Detach" "', expected argument " "1"" of type '" "wxMenu *""'");
40887 }
40888 arg1 = reinterpret_cast< wxMenu * >(argp1);
40889 {
40890 PyThreadState* __tstate = wxPyBeginAllowThreads();
40891 (arg1)->Detach();
40892 wxPyEndAllowThreads(__tstate);
40893 if (PyErr_Occurred()) SWIG_fail;
40894 }
40895 resultobj = SWIG_Py_Void();
40896 return resultobj;
40897 fail:
40898 return NULL;
40899 }
40900
40901
40902 SWIGINTERN PyObject *_wrap_Menu_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40903 PyObject *resultobj = 0;
40904 wxMenu *arg1 = (wxMenu *) 0 ;
40905 bool result;
40906 void *argp1 = 0 ;
40907 int res1 = 0 ;
40908 PyObject *swig_obj[1] ;
40909
40910 if (!args) SWIG_fail;
40911 swig_obj[0] = args;
40912 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40913 if (!SWIG_IsOK(res1)) {
40914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsAttached" "', expected argument " "1"" of type '" "wxMenu const *""'");
40915 }
40916 arg1 = reinterpret_cast< wxMenu * >(argp1);
40917 {
40918 PyThreadState* __tstate = wxPyBeginAllowThreads();
40919 result = (bool)((wxMenu const *)arg1)->IsAttached();
40920 wxPyEndAllowThreads(__tstate);
40921 if (PyErr_Occurred()) SWIG_fail;
40922 }
40923 {
40924 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40925 }
40926 return resultobj;
40927 fail:
40928 return NULL;
40929 }
40930
40931
40932 SWIGINTERN PyObject *_wrap_Menu_SetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40933 PyObject *resultobj = 0;
40934 wxMenu *arg1 = (wxMenu *) 0 ;
40935 wxMenu *arg2 = (wxMenu *) 0 ;
40936 void *argp1 = 0 ;
40937 int res1 = 0 ;
40938 void *argp2 = 0 ;
40939 int res2 = 0 ;
40940 PyObject * obj0 = 0 ;
40941 PyObject * obj1 = 0 ;
40942 char * kwnames[] = {
40943 (char *) "self",(char *) "parent", NULL
40944 };
40945
40946 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) SWIG_fail;
40947 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40948 if (!SWIG_IsOK(res1)) {
40949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetParent" "', expected argument " "1"" of type '" "wxMenu *""'");
40950 }
40951 arg1 = reinterpret_cast< wxMenu * >(argp1);
40952 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
40953 if (!SWIG_IsOK(res2)) {
40954 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetParent" "', expected argument " "2"" of type '" "wxMenu *""'");
40955 }
40956 arg2 = reinterpret_cast< wxMenu * >(argp2);
40957 {
40958 PyThreadState* __tstate = wxPyBeginAllowThreads();
40959 (arg1)->SetParent(arg2);
40960 wxPyEndAllowThreads(__tstate);
40961 if (PyErr_Occurred()) SWIG_fail;
40962 }
40963 resultobj = SWIG_Py_Void();
40964 return resultobj;
40965 fail:
40966 return NULL;
40967 }
40968
40969
40970 SWIGINTERN PyObject *_wrap_Menu_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40971 PyObject *resultobj = 0;
40972 wxMenu *arg1 = (wxMenu *) 0 ;
40973 wxMenu *result = 0 ;
40974 void *argp1 = 0 ;
40975 int res1 = 0 ;
40976 PyObject *swig_obj[1] ;
40977
40978 if (!args) SWIG_fail;
40979 swig_obj[0] = args;
40980 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40981 if (!SWIG_IsOK(res1)) {
40982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetParent" "', expected argument " "1"" of type '" "wxMenu const *""'");
40983 }
40984 arg1 = reinterpret_cast< wxMenu * >(argp1);
40985 {
40986 PyThreadState* __tstate = wxPyBeginAllowThreads();
40987 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
40988 wxPyEndAllowThreads(__tstate);
40989 if (PyErr_Occurred()) SWIG_fail;
40990 }
40991 {
40992 resultobj = wxPyMake_wxObject(result, 0);
40993 }
40994 return resultobj;
40995 fail:
40996 return NULL;
40997 }
40998
40999
41000 SWIGINTERN PyObject *Menu_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41001 PyObject *obj;
41002 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41003 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenu, SWIG_NewClientData(obj));
41004 return SWIG_Py_Void();
41005 }
41006
41007 SWIGINTERN PyObject *Menu_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41008 return SWIG_Python_InitShadowInstance(args);
41009 }
41010
41011 SWIGINTERN PyObject *_wrap_new_MenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41012 PyObject *resultobj = 0;
41013 long arg1 = (long) 0 ;
41014 wxMenuBar *result = 0 ;
41015 long val1 ;
41016 int ecode1 = 0 ;
41017 PyObject * obj0 = 0 ;
41018 char * kwnames[] = {
41019 (char *) "style", NULL
41020 };
41021
41022 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) SWIG_fail;
41023 if (obj0) {
41024 ecode1 = SWIG_AsVal_long(obj0, &val1);
41025 if (!SWIG_IsOK(ecode1)) {
41026 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuBar" "', expected argument " "1"" of type '" "long""'");
41027 }
41028 arg1 = static_cast< long >(val1);
41029 }
41030 {
41031 if (!wxPyCheckForApp()) SWIG_fail;
41032 PyThreadState* __tstate = wxPyBeginAllowThreads();
41033 result = (wxMenuBar *)new wxMenuBar(arg1);
41034 wxPyEndAllowThreads(__tstate);
41035 if (PyErr_Occurred()) SWIG_fail;
41036 }
41037 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuBar, SWIG_POINTER_NEW | 0 );
41038 return resultobj;
41039 fail:
41040 return NULL;
41041 }
41042
41043
41044 SWIGINTERN PyObject *_wrap_MenuBar_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41045 PyObject *resultobj = 0;
41046 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41047 wxMenu *arg2 = (wxMenu *) 0 ;
41048 wxString *arg3 = 0 ;
41049 bool result;
41050 void *argp1 = 0 ;
41051 int res1 = 0 ;
41052 void *argp2 = 0 ;
41053 int res2 = 0 ;
41054 bool temp3 = false ;
41055 PyObject * obj0 = 0 ;
41056 PyObject * obj1 = 0 ;
41057 PyObject * obj2 = 0 ;
41058 char * kwnames[] = {
41059 (char *) "self",(char *) "menu",(char *) "title", NULL
41060 };
41061
41062 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41063 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41064 if (!SWIG_IsOK(res1)) {
41065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Append" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41066 }
41067 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41068 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
41069 if (!SWIG_IsOK(res2)) {
41070 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Append" "', expected argument " "2"" of type '" "wxMenu *""'");
41071 }
41072 arg2 = reinterpret_cast< wxMenu * >(argp2);
41073 {
41074 arg3 = wxString_in_helper(obj2);
41075 if (arg3 == NULL) SWIG_fail;
41076 temp3 = true;
41077 }
41078 {
41079 PyThreadState* __tstate = wxPyBeginAllowThreads();
41080 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
41081 wxPyEndAllowThreads(__tstate);
41082 if (PyErr_Occurred()) SWIG_fail;
41083 }
41084 {
41085 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41086 }
41087 {
41088 if (temp3)
41089 delete arg3;
41090 }
41091 return resultobj;
41092 fail:
41093 {
41094 if (temp3)
41095 delete arg3;
41096 }
41097 return NULL;
41098 }
41099
41100
41101 SWIGINTERN PyObject *_wrap_MenuBar_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41102 PyObject *resultobj = 0;
41103 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41104 size_t arg2 ;
41105 wxMenu *arg3 = (wxMenu *) 0 ;
41106 wxString *arg4 = 0 ;
41107 bool result;
41108 void *argp1 = 0 ;
41109 int res1 = 0 ;
41110 size_t val2 ;
41111 int ecode2 = 0 ;
41112 void *argp3 = 0 ;
41113 int res3 = 0 ;
41114 bool temp4 = false ;
41115 PyObject * obj0 = 0 ;
41116 PyObject * obj1 = 0 ;
41117 PyObject * obj2 = 0 ;
41118 PyObject * obj3 = 0 ;
41119 char * kwnames[] = {
41120 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
41121 };
41122
41123 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41124 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41125 if (!SWIG_IsOK(res1)) {
41126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Insert" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41127 }
41128 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41129 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41130 if (!SWIG_IsOK(ecode2)) {
41131 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Insert" "', expected argument " "2"" of type '" "size_t""'");
41132 }
41133 arg2 = static_cast< size_t >(val2);
41134 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
41135 if (!SWIG_IsOK(res3)) {
41136 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Insert" "', expected argument " "3"" of type '" "wxMenu *""'");
41137 }
41138 arg3 = reinterpret_cast< wxMenu * >(argp3);
41139 {
41140 arg4 = wxString_in_helper(obj3);
41141 if (arg4 == NULL) SWIG_fail;
41142 temp4 = true;
41143 }
41144 {
41145 PyThreadState* __tstate = wxPyBeginAllowThreads();
41146 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
41147 wxPyEndAllowThreads(__tstate);
41148 if (PyErr_Occurred()) SWIG_fail;
41149 }
41150 {
41151 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41152 }
41153 {
41154 if (temp4)
41155 delete arg4;
41156 }
41157 return resultobj;
41158 fail:
41159 {
41160 if (temp4)
41161 delete arg4;
41162 }
41163 return NULL;
41164 }
41165
41166
41167 SWIGINTERN PyObject *_wrap_MenuBar_GetMenuCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41168 PyObject *resultobj = 0;
41169 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41170 size_t result;
41171 void *argp1 = 0 ;
41172 int res1 = 0 ;
41173 PyObject *swig_obj[1] ;
41174
41175 if (!args) SWIG_fail;
41176 swig_obj[0] = args;
41177 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41178 if (!SWIG_IsOK(res1)) {
41179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenuCount" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41180 }
41181 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41182 {
41183 PyThreadState* __tstate = wxPyBeginAllowThreads();
41184 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
41185 wxPyEndAllowThreads(__tstate);
41186 if (PyErr_Occurred()) SWIG_fail;
41187 }
41188 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
41189 return resultobj;
41190 fail:
41191 return NULL;
41192 }
41193
41194
41195 SWIGINTERN PyObject *_wrap_MenuBar_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41196 PyObject *resultobj = 0;
41197 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41198 size_t arg2 ;
41199 wxMenu *result = 0 ;
41200 void *argp1 = 0 ;
41201 int res1 = 0 ;
41202 size_t val2 ;
41203 int ecode2 = 0 ;
41204 PyObject * obj0 = 0 ;
41205 PyObject * obj1 = 0 ;
41206 char * kwnames[] = {
41207 (char *) "self",(char *) "pos", NULL
41208 };
41209
41210 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
41211 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41212 if (!SWIG_IsOK(res1)) {
41213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenu" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41214 }
41215 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41216 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41217 if (!SWIG_IsOK(ecode2)) {
41218 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetMenu" "', expected argument " "2"" of type '" "size_t""'");
41219 }
41220 arg2 = static_cast< size_t >(val2);
41221 {
41222 PyThreadState* __tstate = wxPyBeginAllowThreads();
41223 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
41224 wxPyEndAllowThreads(__tstate);
41225 if (PyErr_Occurred()) SWIG_fail;
41226 }
41227 {
41228 resultobj = wxPyMake_wxObject(result, 0);
41229 }
41230 return resultobj;
41231 fail:
41232 return NULL;
41233 }
41234
41235
41236 SWIGINTERN PyObject *_wrap_MenuBar_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41237 PyObject *resultobj = 0;
41238 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41239 size_t arg2 ;
41240 wxMenu *arg3 = (wxMenu *) 0 ;
41241 wxString *arg4 = 0 ;
41242 wxMenu *result = 0 ;
41243 void *argp1 = 0 ;
41244 int res1 = 0 ;
41245 size_t val2 ;
41246 int ecode2 = 0 ;
41247 void *argp3 = 0 ;
41248 int res3 = 0 ;
41249 bool temp4 = false ;
41250 PyObject * obj0 = 0 ;
41251 PyObject * obj1 = 0 ;
41252 PyObject * obj2 = 0 ;
41253 PyObject * obj3 = 0 ;
41254 char * kwnames[] = {
41255 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
41256 };
41257
41258 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41259 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41260 if (!SWIG_IsOK(res1)) {
41261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Replace" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41262 }
41263 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41264 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41265 if (!SWIG_IsOK(ecode2)) {
41266 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Replace" "', expected argument " "2"" of type '" "size_t""'");
41267 }
41268 arg2 = static_cast< size_t >(val2);
41269 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
41270 if (!SWIG_IsOK(res3)) {
41271 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Replace" "', expected argument " "3"" of type '" "wxMenu *""'");
41272 }
41273 arg3 = reinterpret_cast< wxMenu * >(argp3);
41274 {
41275 arg4 = wxString_in_helper(obj3);
41276 if (arg4 == NULL) SWIG_fail;
41277 temp4 = true;
41278 }
41279 {
41280 PyThreadState* __tstate = wxPyBeginAllowThreads();
41281 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
41282 wxPyEndAllowThreads(__tstate);
41283 if (PyErr_Occurred()) SWIG_fail;
41284 }
41285 {
41286 resultobj = wxPyMake_wxObject(result, 0);
41287 }
41288 {
41289 if (temp4)
41290 delete arg4;
41291 }
41292 return resultobj;
41293 fail:
41294 {
41295 if (temp4)
41296 delete arg4;
41297 }
41298 return NULL;
41299 }
41300
41301
41302 SWIGINTERN PyObject *_wrap_MenuBar_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41303 PyObject *resultobj = 0;
41304 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41305 size_t arg2 ;
41306 wxMenu *result = 0 ;
41307 void *argp1 = 0 ;
41308 int res1 = 0 ;
41309 size_t val2 ;
41310 int ecode2 = 0 ;
41311 PyObject * obj0 = 0 ;
41312 PyObject * obj1 = 0 ;
41313 char * kwnames[] = {
41314 (char *) "self",(char *) "pos", NULL
41315 };
41316
41317 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
41318 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41319 if (!SWIG_IsOK(res1)) {
41320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Remove" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41321 }
41322 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41323 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41324 if (!SWIG_IsOK(ecode2)) {
41325 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Remove" "', expected argument " "2"" of type '" "size_t""'");
41326 }
41327 arg2 = static_cast< size_t >(val2);
41328 {
41329 PyThreadState* __tstate = wxPyBeginAllowThreads();
41330 result = (wxMenu *)(arg1)->Remove(arg2);
41331 wxPyEndAllowThreads(__tstate);
41332 if (PyErr_Occurred()) SWIG_fail;
41333 }
41334 {
41335 resultobj = wxPyMake_wxObject(result, 0);
41336 }
41337 return resultobj;
41338 fail:
41339 return NULL;
41340 }
41341
41342
41343 SWIGINTERN PyObject *_wrap_MenuBar_EnableTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41344 PyObject *resultobj = 0;
41345 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41346 size_t arg2 ;
41347 bool arg3 ;
41348 void *argp1 = 0 ;
41349 int res1 = 0 ;
41350 size_t val2 ;
41351 int ecode2 = 0 ;
41352 bool val3 ;
41353 int ecode3 = 0 ;
41354 PyObject * obj0 = 0 ;
41355 PyObject * obj1 = 0 ;
41356 PyObject * obj2 = 0 ;
41357 char * kwnames[] = {
41358 (char *) "self",(char *) "pos",(char *) "enable", NULL
41359 };
41360
41361 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41362 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41363 if (!SWIG_IsOK(res1)) {
41364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_EnableTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41365 }
41366 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41367 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41368 if (!SWIG_IsOK(ecode2)) {
41369 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_EnableTop" "', expected argument " "2"" of type '" "size_t""'");
41370 }
41371 arg2 = static_cast< size_t >(val2);
41372 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41373 if (!SWIG_IsOK(ecode3)) {
41374 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_EnableTop" "', expected argument " "3"" of type '" "bool""'");
41375 }
41376 arg3 = static_cast< bool >(val3);
41377 {
41378 PyThreadState* __tstate = wxPyBeginAllowThreads();
41379 (arg1)->EnableTop(arg2,arg3);
41380 wxPyEndAllowThreads(__tstate);
41381 if (PyErr_Occurred()) SWIG_fail;
41382 }
41383 resultobj = SWIG_Py_Void();
41384 return resultobj;
41385 fail:
41386 return NULL;
41387 }
41388
41389
41390 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41391 PyObject *resultobj = 0;
41392 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41393 size_t arg2 ;
41394 bool result;
41395 void *argp1 = 0 ;
41396 int res1 = 0 ;
41397 size_t val2 ;
41398 int ecode2 = 0 ;
41399 PyObject * obj0 = 0 ;
41400 PyObject * obj1 = 0 ;
41401 char * kwnames[] = {
41402 (char *) "self",(char *) "pos", NULL
41403 };
41404
41405 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) 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_IsEnabledTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41409 }
41410 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41411 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41412 if (!SWIG_IsOK(ecode2)) {
41413 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "2"" of type '" "size_t""'");
41414 }
41415 arg2 = static_cast< size_t >(val2);
41416 {
41417 PyThreadState* __tstate = wxPyBeginAllowThreads();
41418 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
41419 wxPyEndAllowThreads(__tstate);
41420 if (PyErr_Occurred()) SWIG_fail;
41421 }
41422 {
41423 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41424 }
41425 return resultobj;
41426 fail:
41427 return NULL;
41428 }
41429
41430
41431 SWIGINTERN PyObject *_wrap_MenuBar_SetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41432 PyObject *resultobj = 0;
41433 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41434 size_t arg2 ;
41435 wxString *arg3 = 0 ;
41436 void *argp1 = 0 ;
41437 int res1 = 0 ;
41438 size_t val2 ;
41439 int ecode2 = 0 ;
41440 bool temp3 = false ;
41441 PyObject * obj0 = 0 ;
41442 PyObject * obj1 = 0 ;
41443 PyObject * obj2 = 0 ;
41444 char * kwnames[] = {
41445 (char *) "self",(char *) "pos",(char *) "label", NULL
41446 };
41447
41448 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41449 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41450 if (!SWIG_IsOK(res1)) {
41451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41452 }
41453 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41454 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41455 if (!SWIG_IsOK(ecode2)) {
41456 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
41457 }
41458 arg2 = static_cast< size_t >(val2);
41459 {
41460 arg3 = wxString_in_helper(obj2);
41461 if (arg3 == NULL) SWIG_fail;
41462 temp3 = true;
41463 }
41464 {
41465 PyThreadState* __tstate = wxPyBeginAllowThreads();
41466 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
41467 wxPyEndAllowThreads(__tstate);
41468 if (PyErr_Occurred()) SWIG_fail;
41469 }
41470 resultobj = SWIG_Py_Void();
41471 {
41472 if (temp3)
41473 delete arg3;
41474 }
41475 return resultobj;
41476 fail:
41477 {
41478 if (temp3)
41479 delete arg3;
41480 }
41481 return NULL;
41482 }
41483
41484
41485 SWIGINTERN PyObject *_wrap_MenuBar_GetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41486 PyObject *resultobj = 0;
41487 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41488 size_t arg2 ;
41489 wxString result;
41490 void *argp1 = 0 ;
41491 int res1 = 0 ;
41492 size_t val2 ;
41493 int ecode2 = 0 ;
41494 PyObject * obj0 = 0 ;
41495 PyObject * obj1 = 0 ;
41496 char * kwnames[] = {
41497 (char *) "self",(char *) "pos", NULL
41498 };
41499
41500 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) SWIG_fail;
41501 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41502 if (!SWIG_IsOK(res1)) {
41503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41504 }
41505 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41506 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41507 if (!SWIG_IsOK(ecode2)) {
41508 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
41509 }
41510 arg2 = static_cast< size_t >(val2);
41511 {
41512 PyThreadState* __tstate = wxPyBeginAllowThreads();
41513 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
41514 wxPyEndAllowThreads(__tstate);
41515 if (PyErr_Occurred()) SWIG_fail;
41516 }
41517 {
41518 #if wxUSE_UNICODE
41519 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41520 #else
41521 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41522 #endif
41523 }
41524 return resultobj;
41525 fail:
41526 return NULL;
41527 }
41528
41529
41530 SWIGINTERN PyObject *_wrap_MenuBar_FindMenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41531 PyObject *resultobj = 0;
41532 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41533 wxString *arg2 = 0 ;
41534 wxString *arg3 = 0 ;
41535 int result;
41536 void *argp1 = 0 ;
41537 int res1 = 0 ;
41538 bool temp2 = false ;
41539 bool temp3 = false ;
41540 PyObject * obj0 = 0 ;
41541 PyObject * obj1 = 0 ;
41542 PyObject * obj2 = 0 ;
41543 char * kwnames[] = {
41544 (char *) "self",(char *) "menu",(char *) "item", NULL
41545 };
41546
41547 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41548 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41549 if (!SWIG_IsOK(res1)) {
41550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenuItem" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41551 }
41552 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41553 {
41554 arg2 = wxString_in_helper(obj1);
41555 if (arg2 == NULL) SWIG_fail;
41556 temp2 = true;
41557 }
41558 {
41559 arg3 = wxString_in_helper(obj2);
41560 if (arg3 == NULL) SWIG_fail;
41561 temp3 = true;
41562 }
41563 {
41564 PyThreadState* __tstate = wxPyBeginAllowThreads();
41565 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
41566 wxPyEndAllowThreads(__tstate);
41567 if (PyErr_Occurred()) SWIG_fail;
41568 }
41569 resultobj = SWIG_From_int(static_cast< int >(result));
41570 {
41571 if (temp2)
41572 delete arg2;
41573 }
41574 {
41575 if (temp3)
41576 delete arg3;
41577 }
41578 return resultobj;
41579 fail:
41580 {
41581 if (temp2)
41582 delete arg2;
41583 }
41584 {
41585 if (temp3)
41586 delete arg3;
41587 }
41588 return NULL;
41589 }
41590
41591
41592 SWIGINTERN PyObject *_wrap_MenuBar_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41593 PyObject *resultobj = 0;
41594 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41595 int arg2 ;
41596 wxMenuItem *result = 0 ;
41597 void *argp1 = 0 ;
41598 int res1 = 0 ;
41599 int val2 ;
41600 int ecode2 = 0 ;
41601 PyObject * obj0 = 0 ;
41602 PyObject * obj1 = 0 ;
41603 char * kwnames[] = {
41604 (char *) "self",(char *) "id", NULL
41605 };
41606
41607 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
41608 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41609 if (!SWIG_IsOK(res1)) {
41610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindItemById" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41611 }
41612 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41613 ecode2 = SWIG_AsVal_int(obj1, &val2);
41614 if (!SWIG_IsOK(ecode2)) {
41615 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_FindItemById" "', expected argument " "2"" of type '" "int""'");
41616 }
41617 arg2 = static_cast< int >(val2);
41618 {
41619 PyThreadState* __tstate = wxPyBeginAllowThreads();
41620 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
41621 wxPyEndAllowThreads(__tstate);
41622 if (PyErr_Occurred()) SWIG_fail;
41623 }
41624 {
41625 resultobj = wxPyMake_wxObject(result, (bool)0);
41626 }
41627 return resultobj;
41628 fail:
41629 return NULL;
41630 }
41631
41632
41633 SWIGINTERN PyObject *_wrap_MenuBar_FindMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41634 PyObject *resultobj = 0;
41635 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41636 wxString *arg2 = 0 ;
41637 int result;
41638 void *argp1 = 0 ;
41639 int res1 = 0 ;
41640 bool temp2 = false ;
41641 PyObject * obj0 = 0 ;
41642 PyObject * obj1 = 0 ;
41643 char * kwnames[] = {
41644 (char *) "self",(char *) "title", NULL
41645 };
41646
41647 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) SWIG_fail;
41648 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41649 if (!SWIG_IsOK(res1)) {
41650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenu" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41651 }
41652 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41653 {
41654 arg2 = wxString_in_helper(obj1);
41655 if (arg2 == NULL) SWIG_fail;
41656 temp2 = true;
41657 }
41658 {
41659 PyThreadState* __tstate = wxPyBeginAllowThreads();
41660 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
41661 wxPyEndAllowThreads(__tstate);
41662 if (PyErr_Occurred()) SWIG_fail;
41663 }
41664 resultobj = SWIG_From_int(static_cast< int >(result));
41665 {
41666 if (temp2)
41667 delete arg2;
41668 }
41669 return resultobj;
41670 fail:
41671 {
41672 if (temp2)
41673 delete arg2;
41674 }
41675 return NULL;
41676 }
41677
41678
41679 SWIGINTERN PyObject *_wrap_MenuBar_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41680 PyObject *resultobj = 0;
41681 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41682 int arg2 ;
41683 bool arg3 ;
41684 void *argp1 = 0 ;
41685 int res1 = 0 ;
41686 int val2 ;
41687 int ecode2 = 0 ;
41688 bool val3 ;
41689 int ecode3 = 0 ;
41690 PyObject * obj0 = 0 ;
41691 PyObject * obj1 = 0 ;
41692 PyObject * obj2 = 0 ;
41693 char * kwnames[] = {
41694 (char *) "self",(char *) "id",(char *) "enable", NULL
41695 };
41696
41697 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41698 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41699 if (!SWIG_IsOK(res1)) {
41700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Enable" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41701 }
41702 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41703 ecode2 = SWIG_AsVal_int(obj1, &val2);
41704 if (!SWIG_IsOK(ecode2)) {
41705 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Enable" "', expected argument " "2"" of type '" "int""'");
41706 }
41707 arg2 = static_cast< int >(val2);
41708 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41709 if (!SWIG_IsOK(ecode3)) {
41710 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Enable" "', expected argument " "3"" of type '" "bool""'");
41711 }
41712 arg3 = static_cast< bool >(val3);
41713 {
41714 PyThreadState* __tstate = wxPyBeginAllowThreads();
41715 (arg1)->Enable(arg2,arg3);
41716 wxPyEndAllowThreads(__tstate);
41717 if (PyErr_Occurred()) SWIG_fail;
41718 }
41719 resultobj = SWIG_Py_Void();
41720 return resultobj;
41721 fail:
41722 return NULL;
41723 }
41724
41725
41726 SWIGINTERN PyObject *_wrap_MenuBar_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41727 PyObject *resultobj = 0;
41728 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41729 int arg2 ;
41730 bool arg3 ;
41731 void *argp1 = 0 ;
41732 int res1 = 0 ;
41733 int val2 ;
41734 int ecode2 = 0 ;
41735 bool val3 ;
41736 int ecode3 = 0 ;
41737 PyObject * obj0 = 0 ;
41738 PyObject * obj1 = 0 ;
41739 PyObject * obj2 = 0 ;
41740 char * kwnames[] = {
41741 (char *) "self",(char *) "id",(char *) "check", NULL
41742 };
41743
41744 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41745 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41746 if (!SWIG_IsOK(res1)) {
41747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Check" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41748 }
41749 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41750 ecode2 = SWIG_AsVal_int(obj1, &val2);
41751 if (!SWIG_IsOK(ecode2)) {
41752 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Check" "', expected argument " "2"" of type '" "int""'");
41753 }
41754 arg2 = static_cast< int >(val2);
41755 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41756 if (!SWIG_IsOK(ecode3)) {
41757 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Check" "', expected argument " "3"" of type '" "bool""'");
41758 }
41759 arg3 = static_cast< bool >(val3);
41760 {
41761 PyThreadState* __tstate = wxPyBeginAllowThreads();
41762 (arg1)->Check(arg2,arg3);
41763 wxPyEndAllowThreads(__tstate);
41764 if (PyErr_Occurred()) SWIG_fail;
41765 }
41766 resultobj = SWIG_Py_Void();
41767 return resultobj;
41768 fail:
41769 return NULL;
41770 }
41771
41772
41773 SWIGINTERN PyObject *_wrap_MenuBar_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41774 PyObject *resultobj = 0;
41775 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41776 int arg2 ;
41777 bool result;
41778 void *argp1 = 0 ;
41779 int res1 = 0 ;
41780 int val2 ;
41781 int ecode2 = 0 ;
41782 PyObject * obj0 = 0 ;
41783 PyObject * obj1 = 0 ;
41784 char * kwnames[] = {
41785 (char *) "self",(char *) "id", NULL
41786 };
41787
41788 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
41789 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41790 if (!SWIG_IsOK(res1)) {
41791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsChecked" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41792 }
41793 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41794 ecode2 = SWIG_AsVal_int(obj1, &val2);
41795 if (!SWIG_IsOK(ecode2)) {
41796 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsChecked" "', expected argument " "2"" of type '" "int""'");
41797 }
41798 arg2 = static_cast< int >(val2);
41799 {
41800 PyThreadState* __tstate = wxPyBeginAllowThreads();
41801 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
41802 wxPyEndAllowThreads(__tstate);
41803 if (PyErr_Occurred()) SWIG_fail;
41804 }
41805 {
41806 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41807 }
41808 return resultobj;
41809 fail:
41810 return NULL;
41811 }
41812
41813
41814 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41815 PyObject *resultobj = 0;
41816 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41817 int arg2 ;
41818 bool result;
41819 void *argp1 = 0 ;
41820 int res1 = 0 ;
41821 int val2 ;
41822 int ecode2 = 0 ;
41823 PyObject * obj0 = 0 ;
41824 PyObject * obj1 = 0 ;
41825 char * kwnames[] = {
41826 (char *) "self",(char *) "id", NULL
41827 };
41828
41829 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
41830 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41831 if (!SWIG_IsOK(res1)) {
41832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabled" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41833 }
41834 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41835 ecode2 = SWIG_AsVal_int(obj1, &val2);
41836 if (!SWIG_IsOK(ecode2)) {
41837 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabled" "', expected argument " "2"" of type '" "int""'");
41838 }
41839 arg2 = static_cast< int >(val2);
41840 {
41841 PyThreadState* __tstate = wxPyBeginAllowThreads();
41842 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
41843 wxPyEndAllowThreads(__tstate);
41844 if (PyErr_Occurred()) SWIG_fail;
41845 }
41846 {
41847 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41848 }
41849 return resultobj;
41850 fail:
41851 return NULL;
41852 }
41853
41854
41855 SWIGINTERN PyObject *_wrap_MenuBar_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41856 PyObject *resultobj = 0;
41857 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41858 int arg2 ;
41859 wxString *arg3 = 0 ;
41860 void *argp1 = 0 ;
41861 int res1 = 0 ;
41862 int val2 ;
41863 int ecode2 = 0 ;
41864 bool temp3 = false ;
41865 PyObject * obj0 = 0 ;
41866 PyObject * obj1 = 0 ;
41867 PyObject * obj2 = 0 ;
41868 char * kwnames[] = {
41869 (char *) "self",(char *) "id",(char *) "label", NULL
41870 };
41871
41872 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41873 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41874 if (!SWIG_IsOK(res1)) {
41875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabel" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41876 }
41877 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41878 ecode2 = SWIG_AsVal_int(obj1, &val2);
41879 if (!SWIG_IsOK(ecode2)) {
41880 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabel" "', expected argument " "2"" of type '" "int""'");
41881 }
41882 arg2 = static_cast< int >(val2);
41883 {
41884 arg3 = wxString_in_helper(obj2);
41885 if (arg3 == NULL) SWIG_fail;
41886 temp3 = true;
41887 }
41888 {
41889 PyThreadState* __tstate = wxPyBeginAllowThreads();
41890 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
41891 wxPyEndAllowThreads(__tstate);
41892 if (PyErr_Occurred()) SWIG_fail;
41893 }
41894 resultobj = SWIG_Py_Void();
41895 {
41896 if (temp3)
41897 delete arg3;
41898 }
41899 return resultobj;
41900 fail:
41901 {
41902 if (temp3)
41903 delete arg3;
41904 }
41905 return NULL;
41906 }
41907
41908
41909 SWIGINTERN PyObject *_wrap_MenuBar_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41910 PyObject *resultobj = 0;
41911 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41912 int arg2 ;
41913 wxString result;
41914 void *argp1 = 0 ;
41915 int res1 = 0 ;
41916 int val2 ;
41917 int ecode2 = 0 ;
41918 PyObject * obj0 = 0 ;
41919 PyObject * obj1 = 0 ;
41920 char * kwnames[] = {
41921 (char *) "self",(char *) "id", NULL
41922 };
41923
41924 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
41925 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41926 if (!SWIG_IsOK(res1)) {
41927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabel" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41928 }
41929 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41930 ecode2 = SWIG_AsVal_int(obj1, &val2);
41931 if (!SWIG_IsOK(ecode2)) {
41932 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabel" "', expected argument " "2"" of type '" "int""'");
41933 }
41934 arg2 = static_cast< int >(val2);
41935 {
41936 PyThreadState* __tstate = wxPyBeginAllowThreads();
41937 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
41938 wxPyEndAllowThreads(__tstate);
41939 if (PyErr_Occurred()) SWIG_fail;
41940 }
41941 {
41942 #if wxUSE_UNICODE
41943 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41944 #else
41945 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41946 #endif
41947 }
41948 return resultobj;
41949 fail:
41950 return NULL;
41951 }
41952
41953
41954 SWIGINTERN PyObject *_wrap_MenuBar_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41955 PyObject *resultobj = 0;
41956 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41957 int arg2 ;
41958 wxString *arg3 = 0 ;
41959 void *argp1 = 0 ;
41960 int res1 = 0 ;
41961 int val2 ;
41962 int ecode2 = 0 ;
41963 bool temp3 = false ;
41964 PyObject * obj0 = 0 ;
41965 PyObject * obj1 = 0 ;
41966 PyObject * obj2 = 0 ;
41967 char * kwnames[] = {
41968 (char *) "self",(char *) "id",(char *) "helpString", NULL
41969 };
41970
41971 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41972 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41973 if (!SWIG_IsOK(res1)) {
41974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetHelpString" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41975 }
41976 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41977 ecode2 = SWIG_AsVal_int(obj1, &val2);
41978 if (!SWIG_IsOK(ecode2)) {
41979 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetHelpString" "', expected argument " "2"" of type '" "int""'");
41980 }
41981 arg2 = static_cast< int >(val2);
41982 {
41983 arg3 = wxString_in_helper(obj2);
41984 if (arg3 == NULL) SWIG_fail;
41985 temp3 = true;
41986 }
41987 {
41988 PyThreadState* __tstate = wxPyBeginAllowThreads();
41989 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
41990 wxPyEndAllowThreads(__tstate);
41991 if (PyErr_Occurred()) SWIG_fail;
41992 }
41993 resultobj = SWIG_Py_Void();
41994 {
41995 if (temp3)
41996 delete arg3;
41997 }
41998 return resultobj;
41999 fail:
42000 {
42001 if (temp3)
42002 delete arg3;
42003 }
42004 return NULL;
42005 }
42006
42007
42008 SWIGINTERN PyObject *_wrap_MenuBar_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42009 PyObject *resultobj = 0;
42010 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42011 int arg2 ;
42012 wxString result;
42013 void *argp1 = 0 ;
42014 int res1 = 0 ;
42015 int val2 ;
42016 int ecode2 = 0 ;
42017 PyObject * obj0 = 0 ;
42018 PyObject * obj1 = 0 ;
42019 char * kwnames[] = {
42020 (char *) "self",(char *) "id", NULL
42021 };
42022
42023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
42024 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42025 if (!SWIG_IsOK(res1)) {
42026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetHelpString" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42027 }
42028 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42029 ecode2 = SWIG_AsVal_int(obj1, &val2);
42030 if (!SWIG_IsOK(ecode2)) {
42031 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetHelpString" "', expected argument " "2"" of type '" "int""'");
42032 }
42033 arg2 = static_cast< int >(val2);
42034 {
42035 PyThreadState* __tstate = wxPyBeginAllowThreads();
42036 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
42037 wxPyEndAllowThreads(__tstate);
42038 if (PyErr_Occurred()) SWIG_fail;
42039 }
42040 {
42041 #if wxUSE_UNICODE
42042 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42043 #else
42044 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42045 #endif
42046 }
42047 return resultobj;
42048 fail:
42049 return NULL;
42050 }
42051
42052
42053 SWIGINTERN PyObject *_wrap_MenuBar_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42054 PyObject *resultobj = 0;
42055 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42056 wxFrame *result = 0 ;
42057 void *argp1 = 0 ;
42058 int res1 = 0 ;
42059 PyObject *swig_obj[1] ;
42060
42061 if (!args) SWIG_fail;
42062 swig_obj[0] = args;
42063 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42064 if (!SWIG_IsOK(res1)) {
42065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetFrame" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42066 }
42067 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42068 {
42069 PyThreadState* __tstate = wxPyBeginAllowThreads();
42070 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
42071 wxPyEndAllowThreads(__tstate);
42072 if (PyErr_Occurred()) SWIG_fail;
42073 }
42074 {
42075 resultobj = wxPyMake_wxObject(result, (bool)0);
42076 }
42077 return resultobj;
42078 fail:
42079 return NULL;
42080 }
42081
42082
42083 SWIGINTERN PyObject *_wrap_MenuBar_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42084 PyObject *resultobj = 0;
42085 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42086 bool result;
42087 void *argp1 = 0 ;
42088 int res1 = 0 ;
42089 PyObject *swig_obj[1] ;
42090
42091 if (!args) SWIG_fail;
42092 swig_obj[0] = args;
42093 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42094 if (!SWIG_IsOK(res1)) {
42095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsAttached" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42096 }
42097 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42098 {
42099 PyThreadState* __tstate = wxPyBeginAllowThreads();
42100 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
42101 wxPyEndAllowThreads(__tstate);
42102 if (PyErr_Occurred()) SWIG_fail;
42103 }
42104 {
42105 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42106 }
42107 return resultobj;
42108 fail:
42109 return NULL;
42110 }
42111
42112
42113 SWIGINTERN PyObject *_wrap_MenuBar_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42114 PyObject *resultobj = 0;
42115 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42116 wxFrame *arg2 = (wxFrame *) 0 ;
42117 void *argp1 = 0 ;
42118 int res1 = 0 ;
42119 void *argp2 = 0 ;
42120 int res2 = 0 ;
42121 PyObject * obj0 = 0 ;
42122 PyObject * obj1 = 0 ;
42123 char * kwnames[] = {
42124 (char *) "self",(char *) "frame", NULL
42125 };
42126
42127 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
42128 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42129 if (!SWIG_IsOK(res1)) {
42130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Attach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42131 }
42132 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42133 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFrame, 0 | 0 );
42134 if (!SWIG_IsOK(res2)) {
42135 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Attach" "', expected argument " "2"" of type '" "wxFrame *""'");
42136 }
42137 arg2 = reinterpret_cast< wxFrame * >(argp2);
42138 {
42139 PyThreadState* __tstate = wxPyBeginAllowThreads();
42140 (arg1)->Attach(arg2);
42141 wxPyEndAllowThreads(__tstate);
42142 if (PyErr_Occurred()) SWIG_fail;
42143 }
42144 resultobj = SWIG_Py_Void();
42145 return resultobj;
42146 fail:
42147 return NULL;
42148 }
42149
42150
42151 SWIGINTERN PyObject *_wrap_MenuBar_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42152 PyObject *resultobj = 0;
42153 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42154 void *argp1 = 0 ;
42155 int res1 = 0 ;
42156 PyObject *swig_obj[1] ;
42157
42158 if (!args) SWIG_fail;
42159 swig_obj[0] = args;
42160 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42161 if (!SWIG_IsOK(res1)) {
42162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Detach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42163 }
42164 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42165 {
42166 PyThreadState* __tstate = wxPyBeginAllowThreads();
42167 (arg1)->Detach();
42168 wxPyEndAllowThreads(__tstate);
42169 if (PyErr_Occurred()) SWIG_fail;
42170 }
42171 resultobj = SWIG_Py_Void();
42172 return resultobj;
42173 fail:
42174 return NULL;
42175 }
42176
42177
42178 SWIGINTERN PyObject *_wrap_MenuBar_UpdateMenus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42179 PyObject *resultobj = 0;
42180 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42181 void *argp1 = 0 ;
42182 int res1 = 0 ;
42183 PyObject *swig_obj[1] ;
42184
42185 if (!args) SWIG_fail;
42186 swig_obj[0] = args;
42187 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42188 if (!SWIG_IsOK(res1)) {
42189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_UpdateMenus" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42190 }
42191 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42192 {
42193 PyThreadState* __tstate = wxPyBeginAllowThreads();
42194 (arg1)->UpdateMenus();
42195 wxPyEndAllowThreads(__tstate);
42196 if (PyErr_Occurred()) SWIG_fail;
42197 }
42198 resultobj = SWIG_Py_Void();
42199 return resultobj;
42200 fail:
42201 return NULL;
42202 }
42203
42204
42205 SWIGINTERN PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42206 PyObject *resultobj = 0;
42207 bool arg1 ;
42208 bool val1 ;
42209 int ecode1 = 0 ;
42210 PyObject * obj0 = 0 ;
42211 char * kwnames[] = {
42212 (char *) "enable", NULL
42213 };
42214
42215 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) SWIG_fail;
42216 ecode1 = SWIG_AsVal_bool(obj0, &val1);
42217 if (!SWIG_IsOK(ecode1)) {
42218 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MenuBar_SetAutoWindowMenu" "', expected argument " "1"" of type '" "bool""'");
42219 }
42220 arg1 = static_cast< bool >(val1);
42221 {
42222 PyThreadState* __tstate = wxPyBeginAllowThreads();
42223 wxMenuBar_SetAutoWindowMenu(arg1);
42224 wxPyEndAllowThreads(__tstate);
42225 if (PyErr_Occurred()) SWIG_fail;
42226 }
42227 resultobj = SWIG_Py_Void();
42228 return resultobj;
42229 fail:
42230 return NULL;
42231 }
42232
42233
42234 SWIGINTERN PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42235 PyObject *resultobj = 0;
42236 bool result;
42237
42238 if (!SWIG_Python_UnpackTuple(args,"MenuBar_GetAutoWindowMenu",0,0,0)) SWIG_fail;
42239 {
42240 PyThreadState* __tstate = wxPyBeginAllowThreads();
42241 result = (bool)wxMenuBar_GetAutoWindowMenu();
42242 wxPyEndAllowThreads(__tstate);
42243 if (PyErr_Occurred()) SWIG_fail;
42244 }
42245 {
42246 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42247 }
42248 return resultobj;
42249 fail:
42250 return NULL;
42251 }
42252
42253
42254 SWIGINTERN PyObject *MenuBar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42255 PyObject *obj;
42256 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
42257 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuBar, SWIG_NewClientData(obj));
42258 return SWIG_Py_Void();
42259 }
42260
42261 SWIGINTERN PyObject *MenuBar_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42262 return SWIG_Python_InitShadowInstance(args);
42263 }
42264
42265 SWIGINTERN PyObject *_wrap_new_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42266 PyObject *resultobj = 0;
42267 wxMenu *arg1 = (wxMenu *) NULL ;
42268 int arg2 = (int) wxID_ANY ;
42269 wxString const &arg3_defvalue = wxPyEmptyString ;
42270 wxString *arg3 = (wxString *) &arg3_defvalue ;
42271 wxString const &arg4_defvalue = wxPyEmptyString ;
42272 wxString *arg4 = (wxString *) &arg4_defvalue ;
42273 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
42274 wxMenu *arg6 = (wxMenu *) NULL ;
42275 wxMenuItem *result = 0 ;
42276 void *argp1 = 0 ;
42277 int res1 = 0 ;
42278 int val2 ;
42279 int ecode2 = 0 ;
42280 bool temp3 = false ;
42281 bool temp4 = false ;
42282 int val5 ;
42283 int ecode5 = 0 ;
42284 void *argp6 = 0 ;
42285 int res6 = 0 ;
42286 PyObject * obj0 = 0 ;
42287 PyObject * obj1 = 0 ;
42288 PyObject * obj2 = 0 ;
42289 PyObject * obj3 = 0 ;
42290 PyObject * obj4 = 0 ;
42291 PyObject * obj5 = 0 ;
42292 char * kwnames[] = {
42293 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
42294 };
42295
42296 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
42297 if (obj0) {
42298 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42299 if (!SWIG_IsOK(res1)) {
42300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MenuItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42301 }
42302 arg1 = reinterpret_cast< wxMenu * >(argp1);
42303 }
42304 if (obj1) {
42305 ecode2 = SWIG_AsVal_int(obj1, &val2);
42306 if (!SWIG_IsOK(ecode2)) {
42307 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuItem" "', expected argument " "2"" of type '" "int""'");
42308 }
42309 arg2 = static_cast< int >(val2);
42310 }
42311 if (obj2) {
42312 {
42313 arg3 = wxString_in_helper(obj2);
42314 if (arg3 == NULL) SWIG_fail;
42315 temp3 = true;
42316 }
42317 }
42318 if (obj3) {
42319 {
42320 arg4 = wxString_in_helper(obj3);
42321 if (arg4 == NULL) SWIG_fail;
42322 temp4 = true;
42323 }
42324 }
42325 if (obj4) {
42326 ecode5 = SWIG_AsVal_int(obj4, &val5);
42327 if (!SWIG_IsOK(ecode5)) {
42328 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MenuItem" "', expected argument " "5"" of type '" "wxItemKind""'");
42329 }
42330 arg5 = static_cast< wxItemKind >(val5);
42331 }
42332 if (obj5) {
42333 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxMenu, 0 | 0 );
42334 if (!SWIG_IsOK(res6)) {
42335 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MenuItem" "', expected argument " "6"" of type '" "wxMenu *""'");
42336 }
42337 arg6 = reinterpret_cast< wxMenu * >(argp6);
42338 }
42339 {
42340 PyThreadState* __tstate = wxPyBeginAllowThreads();
42341 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
42342 wxPyEndAllowThreads(__tstate);
42343 if (PyErr_Occurred()) SWIG_fail;
42344 }
42345 {
42346 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
42347 }
42348 {
42349 if (temp3)
42350 delete arg3;
42351 }
42352 {
42353 if (temp4)
42354 delete arg4;
42355 }
42356 return resultobj;
42357 fail:
42358 {
42359 if (temp3)
42360 delete arg3;
42361 }
42362 {
42363 if (temp4)
42364 delete arg4;
42365 }
42366 return NULL;
42367 }
42368
42369
42370 SWIGINTERN PyObject *_wrap_delete_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42371 PyObject *resultobj = 0;
42372 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42373 void *argp1 = 0 ;
42374 int res1 = 0 ;
42375 PyObject *swig_obj[1] ;
42376
42377 if (!args) SWIG_fail;
42378 swig_obj[0] = args;
42379 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42380 if (!SWIG_IsOK(res1)) {
42381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MenuItem" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42382 }
42383 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42384 {
42385 PyThreadState* __tstate = wxPyBeginAllowThreads();
42386 delete arg1;
42387
42388 wxPyEndAllowThreads(__tstate);
42389 if (PyErr_Occurred()) SWIG_fail;
42390 }
42391 resultobj = SWIG_Py_Void();
42392 return resultobj;
42393 fail:
42394 return NULL;
42395 }
42396
42397
42398 SWIGINTERN PyObject *_wrap_MenuItem_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42399 PyObject *resultobj = 0;
42400 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42401 wxMenu *result = 0 ;
42402 void *argp1 = 0 ;
42403 int res1 = 0 ;
42404 PyObject *swig_obj[1] ;
42405
42406 if (!args) SWIG_fail;
42407 swig_obj[0] = args;
42408 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42409 if (!SWIG_IsOK(res1)) {
42410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42411 }
42412 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42413 {
42414 PyThreadState* __tstate = wxPyBeginAllowThreads();
42415 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
42416 wxPyEndAllowThreads(__tstate);
42417 if (PyErr_Occurred()) SWIG_fail;
42418 }
42419 {
42420 resultobj = wxPyMake_wxObject(result, 0);
42421 }
42422 return resultobj;
42423 fail:
42424 return NULL;
42425 }
42426
42427
42428 SWIGINTERN PyObject *_wrap_MenuItem_SetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42429 PyObject *resultobj = 0;
42430 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42431 wxMenu *arg2 = (wxMenu *) 0 ;
42432 void *argp1 = 0 ;
42433 int res1 = 0 ;
42434 void *argp2 = 0 ;
42435 int res2 = 0 ;
42436 PyObject * obj0 = 0 ;
42437 PyObject * obj1 = 0 ;
42438 char * kwnames[] = {
42439 (char *) "self",(char *) "menu", NULL
42440 };
42441
42442 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42443 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42444 if (!SWIG_IsOK(res1)) {
42445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42446 }
42447 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42448 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42449 if (!SWIG_IsOK(res2)) {
42450 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
42451 }
42452 arg2 = reinterpret_cast< wxMenu * >(argp2);
42453 {
42454 PyThreadState* __tstate = wxPyBeginAllowThreads();
42455 (arg1)->SetMenu(arg2);
42456 wxPyEndAllowThreads(__tstate);
42457 if (PyErr_Occurred()) SWIG_fail;
42458 }
42459 resultobj = SWIG_Py_Void();
42460 return resultobj;
42461 fail:
42462 return NULL;
42463 }
42464
42465
42466 SWIGINTERN PyObject *_wrap_MenuItem_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42467 PyObject *resultobj = 0;
42468 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42469 int arg2 ;
42470 void *argp1 = 0 ;
42471 int res1 = 0 ;
42472 int val2 ;
42473 int ecode2 = 0 ;
42474 PyObject * obj0 = 0 ;
42475 PyObject * obj1 = 0 ;
42476 char * kwnames[] = {
42477 (char *) "self",(char *) "id", NULL
42478 };
42479
42480 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
42481 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42482 if (!SWIG_IsOK(res1)) {
42483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetId" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42484 }
42485 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42486 ecode2 = SWIG_AsVal_int(obj1, &val2);
42487 if (!SWIG_IsOK(ecode2)) {
42488 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetId" "', expected argument " "2"" of type '" "int""'");
42489 }
42490 arg2 = static_cast< int >(val2);
42491 {
42492 PyThreadState* __tstate = wxPyBeginAllowThreads();
42493 (arg1)->SetId(arg2);
42494 wxPyEndAllowThreads(__tstate);
42495 if (PyErr_Occurred()) SWIG_fail;
42496 }
42497 resultobj = SWIG_Py_Void();
42498 return resultobj;
42499 fail:
42500 return NULL;
42501 }
42502
42503
42504 SWIGINTERN PyObject *_wrap_MenuItem_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42505 PyObject *resultobj = 0;
42506 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42507 int result;
42508 void *argp1 = 0 ;
42509 int res1 = 0 ;
42510 PyObject *swig_obj[1] ;
42511
42512 if (!args) SWIG_fail;
42513 swig_obj[0] = args;
42514 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42515 if (!SWIG_IsOK(res1)) {
42516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetId" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42517 }
42518 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42519 {
42520 PyThreadState* __tstate = wxPyBeginAllowThreads();
42521 result = (int)((wxMenuItem const *)arg1)->GetId();
42522 wxPyEndAllowThreads(__tstate);
42523 if (PyErr_Occurred()) SWIG_fail;
42524 }
42525 resultobj = SWIG_From_int(static_cast< int >(result));
42526 return resultobj;
42527 fail:
42528 return NULL;
42529 }
42530
42531
42532 SWIGINTERN PyObject *_wrap_MenuItem_IsSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42533 PyObject *resultobj = 0;
42534 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42535 bool result;
42536 void *argp1 = 0 ;
42537 int res1 = 0 ;
42538 PyObject *swig_obj[1] ;
42539
42540 if (!args) SWIG_fail;
42541 swig_obj[0] = args;
42542 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42543 if (!SWIG_IsOK(res1)) {
42544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSeparator" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42545 }
42546 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42547 {
42548 PyThreadState* __tstate = wxPyBeginAllowThreads();
42549 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
42550 wxPyEndAllowThreads(__tstate);
42551 if (PyErr_Occurred()) SWIG_fail;
42552 }
42553 {
42554 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42555 }
42556 return resultobj;
42557 fail:
42558 return NULL;
42559 }
42560
42561
42562 SWIGINTERN PyObject *_wrap_MenuItem_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42563 PyObject *resultobj = 0;
42564 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42565 wxString *arg2 = 0 ;
42566 void *argp1 = 0 ;
42567 int res1 = 0 ;
42568 bool temp2 = false ;
42569 PyObject * obj0 = 0 ;
42570 PyObject * obj1 = 0 ;
42571 char * kwnames[] = {
42572 (char *) "self",(char *) "str", NULL
42573 };
42574
42575 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
42576 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42577 if (!SWIG_IsOK(res1)) {
42578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetText" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42579 }
42580 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42581 {
42582 arg2 = wxString_in_helper(obj1);
42583 if (arg2 == NULL) SWIG_fail;
42584 temp2 = true;
42585 }
42586 {
42587 PyThreadState* __tstate = wxPyBeginAllowThreads();
42588 (arg1)->SetText((wxString const &)*arg2);
42589 wxPyEndAllowThreads(__tstate);
42590 if (PyErr_Occurred()) SWIG_fail;
42591 }
42592 resultobj = SWIG_Py_Void();
42593 {
42594 if (temp2)
42595 delete arg2;
42596 }
42597 return resultobj;
42598 fail:
42599 {
42600 if (temp2)
42601 delete arg2;
42602 }
42603 return NULL;
42604 }
42605
42606
42607 SWIGINTERN PyObject *_wrap_MenuItem_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42608 PyObject *resultobj = 0;
42609 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42610 wxString result;
42611 void *argp1 = 0 ;
42612 int res1 = 0 ;
42613 PyObject *swig_obj[1] ;
42614
42615 if (!args) SWIG_fail;
42616 swig_obj[0] = args;
42617 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42618 if (!SWIG_IsOK(res1)) {
42619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetLabel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42620 }
42621 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42622 {
42623 PyThreadState* __tstate = wxPyBeginAllowThreads();
42624 result = ((wxMenuItem const *)arg1)->GetLabel();
42625 wxPyEndAllowThreads(__tstate);
42626 if (PyErr_Occurred()) SWIG_fail;
42627 }
42628 {
42629 #if wxUSE_UNICODE
42630 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42631 #else
42632 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42633 #endif
42634 }
42635 return resultobj;
42636 fail:
42637 return NULL;
42638 }
42639
42640
42641 SWIGINTERN PyObject *_wrap_MenuItem_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42642 PyObject *resultobj = 0;
42643 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42644 wxString *result = 0 ;
42645 void *argp1 = 0 ;
42646 int res1 = 0 ;
42647 PyObject *swig_obj[1] ;
42648
42649 if (!args) SWIG_fail;
42650 swig_obj[0] = args;
42651 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42652 if (!SWIG_IsOK(res1)) {
42653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetText" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42654 }
42655 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42656 {
42657 PyThreadState* __tstate = wxPyBeginAllowThreads();
42658 {
42659 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
42660 result = (wxString *) &_result_ref;
42661 }
42662 wxPyEndAllowThreads(__tstate);
42663 if (PyErr_Occurred()) SWIG_fail;
42664 }
42665 {
42666 #if wxUSE_UNICODE
42667 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
42668 #else
42669 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
42670 #endif
42671 }
42672 return resultobj;
42673 fail:
42674 return NULL;
42675 }
42676
42677
42678 SWIGINTERN PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42679 PyObject *resultobj = 0;
42680 wxString *arg1 = 0 ;
42681 wxString result;
42682 bool temp1 = false ;
42683 PyObject * obj0 = 0 ;
42684 char * kwnames[] = {
42685 (char *) "text", NULL
42686 };
42687
42688 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) SWIG_fail;
42689 {
42690 arg1 = wxString_in_helper(obj0);
42691 if (arg1 == NULL) SWIG_fail;
42692 temp1 = true;
42693 }
42694 {
42695 PyThreadState* __tstate = wxPyBeginAllowThreads();
42696 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
42697 wxPyEndAllowThreads(__tstate);
42698 if (PyErr_Occurred()) SWIG_fail;
42699 }
42700 {
42701 #if wxUSE_UNICODE
42702 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42703 #else
42704 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42705 #endif
42706 }
42707 {
42708 if (temp1)
42709 delete arg1;
42710 }
42711 return resultobj;
42712 fail:
42713 {
42714 if (temp1)
42715 delete arg1;
42716 }
42717 return NULL;
42718 }
42719
42720
42721 SWIGINTERN PyObject *_wrap_MenuItem_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42722 PyObject *resultobj = 0;
42723 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42724 wxItemKind result;
42725 void *argp1 = 0 ;
42726 int res1 = 0 ;
42727 PyObject *swig_obj[1] ;
42728
42729 if (!args) SWIG_fail;
42730 swig_obj[0] = args;
42731 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42732 if (!SWIG_IsOK(res1)) {
42733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetKind" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42734 }
42735 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42736 {
42737 PyThreadState* __tstate = wxPyBeginAllowThreads();
42738 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
42739 wxPyEndAllowThreads(__tstate);
42740 if (PyErr_Occurred()) SWIG_fail;
42741 }
42742 resultobj = SWIG_From_int(static_cast< int >(result));
42743 return resultobj;
42744 fail:
42745 return NULL;
42746 }
42747
42748
42749 SWIGINTERN PyObject *_wrap_MenuItem_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42750 PyObject *resultobj = 0;
42751 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42752 wxItemKind arg2 ;
42753 void *argp1 = 0 ;
42754 int res1 = 0 ;
42755 int val2 ;
42756 int ecode2 = 0 ;
42757 PyObject * obj0 = 0 ;
42758 PyObject * obj1 = 0 ;
42759 char * kwnames[] = {
42760 (char *) "self",(char *) "kind", NULL
42761 };
42762
42763 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
42764 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42765 if (!SWIG_IsOK(res1)) {
42766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetKind" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42767 }
42768 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42769 ecode2 = SWIG_AsVal_int(obj1, &val2);
42770 if (!SWIG_IsOK(ecode2)) {
42771 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetKind" "', expected argument " "2"" of type '" "wxItemKind""'");
42772 }
42773 arg2 = static_cast< wxItemKind >(val2);
42774 {
42775 PyThreadState* __tstate = wxPyBeginAllowThreads();
42776 (arg1)->SetKind(arg2);
42777 wxPyEndAllowThreads(__tstate);
42778 if (PyErr_Occurred()) SWIG_fail;
42779 }
42780 resultobj = SWIG_Py_Void();
42781 return resultobj;
42782 fail:
42783 return NULL;
42784 }
42785
42786
42787 SWIGINTERN PyObject *_wrap_MenuItem_SetCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42788 PyObject *resultobj = 0;
42789 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42790 bool arg2 ;
42791 void *argp1 = 0 ;
42792 int res1 = 0 ;
42793 bool val2 ;
42794 int ecode2 = 0 ;
42795 PyObject * obj0 = 0 ;
42796 PyObject * obj1 = 0 ;
42797 char * kwnames[] = {
42798 (char *) "self",(char *) "checkable", NULL
42799 };
42800
42801 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) SWIG_fail;
42802 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42803 if (!SWIG_IsOK(res1)) {
42804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetCheckable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42805 }
42806 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42807 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42808 if (!SWIG_IsOK(ecode2)) {
42809 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetCheckable" "', expected argument " "2"" of type '" "bool""'");
42810 }
42811 arg2 = static_cast< bool >(val2);
42812 {
42813 PyThreadState* __tstate = wxPyBeginAllowThreads();
42814 (arg1)->SetCheckable(arg2);
42815 wxPyEndAllowThreads(__tstate);
42816 if (PyErr_Occurred()) SWIG_fail;
42817 }
42818 resultobj = SWIG_Py_Void();
42819 return resultobj;
42820 fail:
42821 return NULL;
42822 }
42823
42824
42825 SWIGINTERN PyObject *_wrap_MenuItem_IsCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42826 PyObject *resultobj = 0;
42827 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42828 bool result;
42829 void *argp1 = 0 ;
42830 int res1 = 0 ;
42831 PyObject *swig_obj[1] ;
42832
42833 if (!args) SWIG_fail;
42834 swig_obj[0] = args;
42835 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42836 if (!SWIG_IsOK(res1)) {
42837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsCheckable" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42838 }
42839 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42840 {
42841 PyThreadState* __tstate = wxPyBeginAllowThreads();
42842 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
42843 wxPyEndAllowThreads(__tstate);
42844 if (PyErr_Occurred()) SWIG_fail;
42845 }
42846 {
42847 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42848 }
42849 return resultobj;
42850 fail:
42851 return NULL;
42852 }
42853
42854
42855 SWIGINTERN PyObject *_wrap_MenuItem_IsSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42856 PyObject *resultobj = 0;
42857 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42858 bool result;
42859 void *argp1 = 0 ;
42860 int res1 = 0 ;
42861 PyObject *swig_obj[1] ;
42862
42863 if (!args) SWIG_fail;
42864 swig_obj[0] = args;
42865 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42866 if (!SWIG_IsOK(res1)) {
42867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42868 }
42869 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42870 {
42871 PyThreadState* __tstate = wxPyBeginAllowThreads();
42872 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
42873 wxPyEndAllowThreads(__tstate);
42874 if (PyErr_Occurred()) SWIG_fail;
42875 }
42876 {
42877 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42878 }
42879 return resultobj;
42880 fail:
42881 return NULL;
42882 }
42883
42884
42885 SWIGINTERN PyObject *_wrap_MenuItem_SetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42886 PyObject *resultobj = 0;
42887 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42888 wxMenu *arg2 = (wxMenu *) 0 ;
42889 void *argp1 = 0 ;
42890 int res1 = 0 ;
42891 void *argp2 = 0 ;
42892 int res2 = 0 ;
42893 PyObject * obj0 = 0 ;
42894 PyObject * obj1 = 0 ;
42895 char * kwnames[] = {
42896 (char *) "self",(char *) "menu", NULL
42897 };
42898
42899 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42900 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42901 if (!SWIG_IsOK(res1)) {
42902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42903 }
42904 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42905 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42906 if (!SWIG_IsOK(res2)) {
42907 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
42908 }
42909 arg2 = reinterpret_cast< wxMenu * >(argp2);
42910 {
42911 PyThreadState* __tstate = wxPyBeginAllowThreads();
42912 (arg1)->SetSubMenu(arg2);
42913 wxPyEndAllowThreads(__tstate);
42914 if (PyErr_Occurred()) SWIG_fail;
42915 }
42916 resultobj = SWIG_Py_Void();
42917 return resultobj;
42918 fail:
42919 return NULL;
42920 }
42921
42922
42923 SWIGINTERN PyObject *_wrap_MenuItem_GetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42924 PyObject *resultobj = 0;
42925 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42926 wxMenu *result = 0 ;
42927 void *argp1 = 0 ;
42928 int res1 = 0 ;
42929 PyObject *swig_obj[1] ;
42930
42931 if (!args) SWIG_fail;
42932 swig_obj[0] = args;
42933 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42934 if (!SWIG_IsOK(res1)) {
42935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42936 }
42937 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42938 {
42939 PyThreadState* __tstate = wxPyBeginAllowThreads();
42940 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
42941 wxPyEndAllowThreads(__tstate);
42942 if (PyErr_Occurred()) SWIG_fail;
42943 }
42944 {
42945 resultobj = wxPyMake_wxObject(result, 0);
42946 }
42947 return resultobj;
42948 fail:
42949 return NULL;
42950 }
42951
42952
42953 SWIGINTERN PyObject *_wrap_MenuItem_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42954 PyObject *resultobj = 0;
42955 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42956 bool arg2 = (bool) true ;
42957 void *argp1 = 0 ;
42958 int res1 = 0 ;
42959 bool val2 ;
42960 int ecode2 = 0 ;
42961 PyObject * obj0 = 0 ;
42962 PyObject * obj1 = 0 ;
42963 char * kwnames[] = {
42964 (char *) "self",(char *) "enable", NULL
42965 };
42966
42967 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
42968 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42969 if (!SWIG_IsOK(res1)) {
42970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Enable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42971 }
42972 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42973 if (obj1) {
42974 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42975 if (!SWIG_IsOK(ecode2)) {
42976 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Enable" "', expected argument " "2"" of type '" "bool""'");
42977 }
42978 arg2 = static_cast< bool >(val2);
42979 }
42980 {
42981 PyThreadState* __tstate = wxPyBeginAllowThreads();
42982 (arg1)->Enable(arg2);
42983 wxPyEndAllowThreads(__tstate);
42984 if (PyErr_Occurred()) SWIG_fail;
42985 }
42986 resultobj = SWIG_Py_Void();
42987 return resultobj;
42988 fail:
42989 return NULL;
42990 }
42991
42992
42993 SWIGINTERN PyObject *_wrap_MenuItem_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42994 PyObject *resultobj = 0;
42995 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42996 bool result;
42997 void *argp1 = 0 ;
42998 int res1 = 0 ;
42999 PyObject *swig_obj[1] ;
43000
43001 if (!args) SWIG_fail;
43002 swig_obj[0] = args;
43003 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43004 if (!SWIG_IsOK(res1)) {
43005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsEnabled" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43006 }
43007 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43008 {
43009 PyThreadState* __tstate = wxPyBeginAllowThreads();
43010 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
43011 wxPyEndAllowThreads(__tstate);
43012 if (PyErr_Occurred()) SWIG_fail;
43013 }
43014 {
43015 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43016 }
43017 return resultobj;
43018 fail:
43019 return NULL;
43020 }
43021
43022
43023 SWIGINTERN PyObject *_wrap_MenuItem_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43024 PyObject *resultobj = 0;
43025 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43026 bool arg2 = (bool) true ;
43027 void *argp1 = 0 ;
43028 int res1 = 0 ;
43029 bool val2 ;
43030 int ecode2 = 0 ;
43031 PyObject * obj0 = 0 ;
43032 PyObject * obj1 = 0 ;
43033 char * kwnames[] = {
43034 (char *) "self",(char *) "check", NULL
43035 };
43036
43037 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) SWIG_fail;
43038 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43039 if (!SWIG_IsOK(res1)) {
43040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Check" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43041 }
43042 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43043 if (obj1) {
43044 ecode2 = SWIG_AsVal_bool(obj1, &val2);
43045 if (!SWIG_IsOK(ecode2)) {
43046 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Check" "', expected argument " "2"" of type '" "bool""'");
43047 }
43048 arg2 = static_cast< bool >(val2);
43049 }
43050 {
43051 PyThreadState* __tstate = wxPyBeginAllowThreads();
43052 (arg1)->Check(arg2);
43053 wxPyEndAllowThreads(__tstate);
43054 if (PyErr_Occurred()) SWIG_fail;
43055 }
43056 resultobj = SWIG_Py_Void();
43057 return resultobj;
43058 fail:
43059 return NULL;
43060 }
43061
43062
43063 SWIGINTERN PyObject *_wrap_MenuItem_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43064 PyObject *resultobj = 0;
43065 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43066 bool result;
43067 void *argp1 = 0 ;
43068 int res1 = 0 ;
43069 PyObject *swig_obj[1] ;
43070
43071 if (!args) SWIG_fail;
43072 swig_obj[0] = args;
43073 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43074 if (!SWIG_IsOK(res1)) {
43075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsChecked" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43076 }
43077 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43078 {
43079 PyThreadState* __tstate = wxPyBeginAllowThreads();
43080 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
43081 wxPyEndAllowThreads(__tstate);
43082 if (PyErr_Occurred()) SWIG_fail;
43083 }
43084 {
43085 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43086 }
43087 return resultobj;
43088 fail:
43089 return NULL;
43090 }
43091
43092
43093 SWIGINTERN PyObject *_wrap_MenuItem_Toggle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43094 PyObject *resultobj = 0;
43095 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43096 void *argp1 = 0 ;
43097 int res1 = 0 ;
43098 PyObject *swig_obj[1] ;
43099
43100 if (!args) SWIG_fail;
43101 swig_obj[0] = args;
43102 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43103 if (!SWIG_IsOK(res1)) {
43104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Toggle" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43105 }
43106 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43107 {
43108 PyThreadState* __tstate = wxPyBeginAllowThreads();
43109 (arg1)->Toggle();
43110 wxPyEndAllowThreads(__tstate);
43111 if (PyErr_Occurred()) SWIG_fail;
43112 }
43113 resultobj = SWIG_Py_Void();
43114 return resultobj;
43115 fail:
43116 return NULL;
43117 }
43118
43119
43120 SWIGINTERN PyObject *_wrap_MenuItem_SetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43121 PyObject *resultobj = 0;
43122 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43123 wxString *arg2 = 0 ;
43124 void *argp1 = 0 ;
43125 int res1 = 0 ;
43126 bool temp2 = false ;
43127 PyObject * obj0 = 0 ;
43128 PyObject * obj1 = 0 ;
43129 char * kwnames[] = {
43130 (char *) "self",(char *) "str", NULL
43131 };
43132
43133 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) SWIG_fail;
43134 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43135 if (!SWIG_IsOK(res1)) {
43136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetHelp" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43137 }
43138 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43139 {
43140 arg2 = wxString_in_helper(obj1);
43141 if (arg2 == NULL) SWIG_fail;
43142 temp2 = true;
43143 }
43144 {
43145 PyThreadState* __tstate = wxPyBeginAllowThreads();
43146 (arg1)->SetHelp((wxString const &)*arg2);
43147 wxPyEndAllowThreads(__tstate);
43148 if (PyErr_Occurred()) SWIG_fail;
43149 }
43150 resultobj = SWIG_Py_Void();
43151 {
43152 if (temp2)
43153 delete arg2;
43154 }
43155 return resultobj;
43156 fail:
43157 {
43158 if (temp2)
43159 delete arg2;
43160 }
43161 return NULL;
43162 }
43163
43164
43165 SWIGINTERN PyObject *_wrap_MenuItem_GetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43166 PyObject *resultobj = 0;
43167 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43168 wxString *result = 0 ;
43169 void *argp1 = 0 ;
43170 int res1 = 0 ;
43171 PyObject *swig_obj[1] ;
43172
43173 if (!args) SWIG_fail;
43174 swig_obj[0] = args;
43175 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43176 if (!SWIG_IsOK(res1)) {
43177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetHelp" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43178 }
43179 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43180 {
43181 PyThreadState* __tstate = wxPyBeginAllowThreads();
43182 {
43183 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
43184 result = (wxString *) &_result_ref;
43185 }
43186 wxPyEndAllowThreads(__tstate);
43187 if (PyErr_Occurred()) SWIG_fail;
43188 }
43189 {
43190 #if wxUSE_UNICODE
43191 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
43192 #else
43193 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
43194 #endif
43195 }
43196 return resultobj;
43197 fail:
43198 return NULL;
43199 }
43200
43201
43202 SWIGINTERN PyObject *_wrap_MenuItem_GetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43203 PyObject *resultobj = 0;
43204 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43205 wxAcceleratorEntry *result = 0 ;
43206 void *argp1 = 0 ;
43207 int res1 = 0 ;
43208 PyObject *swig_obj[1] ;
43209
43210 if (!args) SWIG_fail;
43211 swig_obj[0] = args;
43212 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43213 if (!SWIG_IsOK(res1)) {
43214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetAccel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43215 }
43216 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43217 {
43218 PyThreadState* __tstate = wxPyBeginAllowThreads();
43219 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
43220 wxPyEndAllowThreads(__tstate);
43221 if (PyErr_Occurred()) SWIG_fail;
43222 }
43223 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
43224 return resultobj;
43225 fail:
43226 return NULL;
43227 }
43228
43229
43230 SWIGINTERN PyObject *_wrap_MenuItem_SetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43231 PyObject *resultobj = 0;
43232 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43233 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
43234 void *argp1 = 0 ;
43235 int res1 = 0 ;
43236 void *argp2 = 0 ;
43237 int res2 = 0 ;
43238 PyObject * obj0 = 0 ;
43239 PyObject * obj1 = 0 ;
43240 char * kwnames[] = {
43241 (char *) "self",(char *) "accel", NULL
43242 };
43243
43244 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) SWIG_fail;
43245 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43246 if (!SWIG_IsOK(res1)) {
43247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetAccel" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43248 }
43249 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43250 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
43251 if (!SWIG_IsOK(res2)) {
43252 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetAccel" "', expected argument " "2"" of type '" "wxAcceleratorEntry *""'");
43253 }
43254 arg2 = reinterpret_cast< wxAcceleratorEntry * >(argp2);
43255 {
43256 PyThreadState* __tstate = wxPyBeginAllowThreads();
43257 (arg1)->SetAccel(arg2);
43258 wxPyEndAllowThreads(__tstate);
43259 if (PyErr_Occurred()) SWIG_fail;
43260 }
43261 resultobj = SWIG_Py_Void();
43262 return resultobj;
43263 fail:
43264 return NULL;
43265 }
43266
43267
43268 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43269 PyObject *resultobj = 0;
43270 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43271 wxBitmap *arg2 = 0 ;
43272 void *argp1 = 0 ;
43273 int res1 = 0 ;
43274 void *argp2 = 0 ;
43275 int res2 = 0 ;
43276 PyObject * obj0 = 0 ;
43277 PyObject * obj1 = 0 ;
43278 char * kwnames[] = {
43279 (char *) "self",(char *) "bitmap", NULL
43280 };
43281
43282 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
43283 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43284 if (!SWIG_IsOK(res1)) {
43285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43286 }
43287 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43288 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43289 if (!SWIG_IsOK(res2)) {
43290 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43291 }
43292 if (!argp2) {
43293 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43294 }
43295 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43296 {
43297 PyThreadState* __tstate = wxPyBeginAllowThreads();
43298 (arg1)->SetBitmap((wxBitmap const &)*arg2);
43299 wxPyEndAllowThreads(__tstate);
43300 if (PyErr_Occurred()) SWIG_fail;
43301 }
43302 resultobj = SWIG_Py_Void();
43303 return resultobj;
43304 fail:
43305 return NULL;
43306 }
43307
43308
43309 SWIGINTERN PyObject *_wrap_MenuItem_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43310 PyObject *resultobj = 0;
43311 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43312 wxBitmap *result = 0 ;
43313 void *argp1 = 0 ;
43314 int res1 = 0 ;
43315 PyObject *swig_obj[1] ;
43316
43317 if (!args) SWIG_fail;
43318 swig_obj[0] = args;
43319 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43320 if (!SWIG_IsOK(res1)) {
43321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43322 }
43323 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43324 {
43325 PyThreadState* __tstate = wxPyBeginAllowThreads();
43326 {
43327 wxBitmap const &_result_ref = (arg1)->GetBitmap();
43328 result = (wxBitmap *) &_result_ref;
43329 }
43330 wxPyEndAllowThreads(__tstate);
43331 if (PyErr_Occurred()) SWIG_fail;
43332 }
43333 {
43334 wxBitmap* resultptr = new wxBitmap(*result);
43335 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
43336 }
43337 return resultobj;
43338 fail:
43339 return NULL;
43340 }
43341
43342
43343 SWIGINTERN PyObject *_wrap_MenuItem_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43344 PyObject *resultobj = 0;
43345 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43346 wxFont *arg2 = 0 ;
43347 void *argp1 = 0 ;
43348 int res1 = 0 ;
43349 void *argp2 = 0 ;
43350 int res2 = 0 ;
43351 PyObject * obj0 = 0 ;
43352 PyObject * obj1 = 0 ;
43353 char * kwnames[] = {
43354 (char *) "self",(char *) "font", NULL
43355 };
43356
43357 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
43358 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43359 if (!SWIG_IsOK(res1)) {
43360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43361 }
43362 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43363 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
43364 if (!SWIG_IsOK(res2)) {
43365 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
43366 }
43367 if (!argp2) {
43368 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
43369 }
43370 arg2 = reinterpret_cast< wxFont * >(argp2);
43371 {
43372 PyThreadState* __tstate = wxPyBeginAllowThreads();
43373 (arg1)->SetFont((wxFont const &)*arg2);
43374 wxPyEndAllowThreads(__tstate);
43375 if (PyErr_Occurred()) SWIG_fail;
43376 }
43377 resultobj = SWIG_Py_Void();
43378 return resultobj;
43379 fail:
43380 return NULL;
43381 }
43382
43383
43384 SWIGINTERN PyObject *_wrap_MenuItem_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43385 PyObject *resultobj = 0;
43386 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43387 wxFont result;
43388 void *argp1 = 0 ;
43389 int res1 = 0 ;
43390 PyObject *swig_obj[1] ;
43391
43392 if (!args) SWIG_fail;
43393 swig_obj[0] = args;
43394 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43395 if (!SWIG_IsOK(res1)) {
43396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43397 }
43398 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43399 {
43400 PyThreadState* __tstate = wxPyBeginAllowThreads();
43401 result = (arg1)->GetFont();
43402 wxPyEndAllowThreads(__tstate);
43403 if (PyErr_Occurred()) SWIG_fail;
43404 }
43405 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
43406 return resultobj;
43407 fail:
43408 return NULL;
43409 }
43410
43411
43412 SWIGINTERN PyObject *_wrap_MenuItem_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43413 PyObject *resultobj = 0;
43414 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43415 wxColour *arg2 = 0 ;
43416 void *argp1 = 0 ;
43417 int res1 = 0 ;
43418 wxColour temp2 ;
43419 PyObject * obj0 = 0 ;
43420 PyObject * obj1 = 0 ;
43421 char * kwnames[] = {
43422 (char *) "self",(char *) "colText", NULL
43423 };
43424
43425 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
43426 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43427 if (!SWIG_IsOK(res1)) {
43428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43429 }
43430 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43431 {
43432 arg2 = &temp2;
43433 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
43434 }
43435 {
43436 PyThreadState* __tstate = wxPyBeginAllowThreads();
43437 (arg1)->SetTextColour((wxColour const &)*arg2);
43438 wxPyEndAllowThreads(__tstate);
43439 if (PyErr_Occurred()) SWIG_fail;
43440 }
43441 resultobj = SWIG_Py_Void();
43442 return resultobj;
43443 fail:
43444 return NULL;
43445 }
43446
43447
43448 SWIGINTERN PyObject *_wrap_MenuItem_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43449 PyObject *resultobj = 0;
43450 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43451 wxColour result;
43452 void *argp1 = 0 ;
43453 int res1 = 0 ;
43454 PyObject *swig_obj[1] ;
43455
43456 if (!args) SWIG_fail;
43457 swig_obj[0] = args;
43458 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43459 if (!SWIG_IsOK(res1)) {
43460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43461 }
43462 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43463 {
43464 PyThreadState* __tstate = wxPyBeginAllowThreads();
43465 result = (arg1)->GetTextColour();
43466 wxPyEndAllowThreads(__tstate);
43467 if (PyErr_Occurred()) SWIG_fail;
43468 }
43469 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
43470 return resultobj;
43471 fail:
43472 return NULL;
43473 }
43474
43475
43476 SWIGINTERN PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43477 PyObject *resultobj = 0;
43478 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43479 wxColour *arg2 = 0 ;
43480 void *argp1 = 0 ;
43481 int res1 = 0 ;
43482 wxColour temp2 ;
43483 PyObject * obj0 = 0 ;
43484 PyObject * obj1 = 0 ;
43485 char * kwnames[] = {
43486 (char *) "self",(char *) "colBack", NULL
43487 };
43488
43489 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
43490 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43491 if (!SWIG_IsOK(res1)) {
43492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43493 }
43494 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43495 {
43496 arg2 = &temp2;
43497 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
43498 }
43499 {
43500 PyThreadState* __tstate = wxPyBeginAllowThreads();
43501 (arg1)->SetBackgroundColour((wxColour const &)*arg2);
43502 wxPyEndAllowThreads(__tstate);
43503 if (PyErr_Occurred()) SWIG_fail;
43504 }
43505 resultobj = SWIG_Py_Void();
43506 return resultobj;
43507 fail:
43508 return NULL;
43509 }
43510
43511
43512 SWIGINTERN PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43513 PyObject *resultobj = 0;
43514 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43515 wxColour result;
43516 void *argp1 = 0 ;
43517 int res1 = 0 ;
43518 PyObject *swig_obj[1] ;
43519
43520 if (!args) SWIG_fail;
43521 swig_obj[0] = args;
43522 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43523 if (!SWIG_IsOK(res1)) {
43524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43525 }
43526 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43527 {
43528 PyThreadState* __tstate = wxPyBeginAllowThreads();
43529 result = (arg1)->GetBackgroundColour();
43530 wxPyEndAllowThreads(__tstate);
43531 if (PyErr_Occurred()) SWIG_fail;
43532 }
43533 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
43534 return resultobj;
43535 fail:
43536 return NULL;
43537 }
43538
43539
43540 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43541 PyObject *resultobj = 0;
43542 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43543 wxBitmap *arg2 = 0 ;
43544 wxBitmap const &arg3_defvalue = wxNullBitmap ;
43545 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
43546 void *argp1 = 0 ;
43547 int res1 = 0 ;
43548 void *argp2 = 0 ;
43549 int res2 = 0 ;
43550 void *argp3 = 0 ;
43551 int res3 = 0 ;
43552 PyObject * obj0 = 0 ;
43553 PyObject * obj1 = 0 ;
43554 PyObject * obj2 = 0 ;
43555 char * kwnames[] = {
43556 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
43557 };
43558
43559 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43560 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43561 if (!SWIG_IsOK(res1)) {
43562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmaps" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43563 }
43564 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43565 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43566 if (!SWIG_IsOK(res2)) {
43567 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43568 }
43569 if (!argp2) {
43570 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43571 }
43572 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43573 if (obj2) {
43574 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
43575 if (!SWIG_IsOK(res3)) {
43576 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
43577 }
43578 if (!argp3) {
43579 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
43580 }
43581 arg3 = reinterpret_cast< wxBitmap * >(argp3);
43582 }
43583 {
43584 PyThreadState* __tstate = wxPyBeginAllowThreads();
43585 (arg1)->SetBitmaps((wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
43586 wxPyEndAllowThreads(__tstate);
43587 if (PyErr_Occurred()) SWIG_fail;
43588 }
43589 resultobj = SWIG_Py_Void();
43590 return resultobj;
43591 fail:
43592 return NULL;
43593 }
43594
43595
43596 SWIGINTERN PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43597 PyObject *resultobj = 0;
43598 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43599 wxBitmap *arg2 = 0 ;
43600 void *argp1 = 0 ;
43601 int res1 = 0 ;
43602 void *argp2 = 0 ;
43603 int res2 = 0 ;
43604 PyObject * obj0 = 0 ;
43605 PyObject * obj1 = 0 ;
43606 char * kwnames[] = {
43607 (char *) "self",(char *) "bmpDisabled", NULL
43608 };
43609
43610 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
43611 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43612 if (!SWIG_IsOK(res1)) {
43613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43614 }
43615 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43616 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43617 if (!SWIG_IsOK(res2)) {
43618 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43619 }
43620 if (!argp2) {
43621 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43622 }
43623 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43624 {
43625 PyThreadState* __tstate = wxPyBeginAllowThreads();
43626 (arg1)->SetDisabledBitmap((wxBitmap const &)*arg2);
43627 wxPyEndAllowThreads(__tstate);
43628 if (PyErr_Occurred()) SWIG_fail;
43629 }
43630 resultobj = SWIG_Py_Void();
43631 return resultobj;
43632 fail:
43633 return NULL;
43634 }
43635
43636
43637 SWIGINTERN PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43638 PyObject *resultobj = 0;
43639 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43640 wxBitmap *result = 0 ;
43641 void *argp1 = 0 ;
43642 int res1 = 0 ;
43643 PyObject *swig_obj[1] ;
43644
43645 if (!args) SWIG_fail;
43646 swig_obj[0] = args;
43647 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43648 if (!SWIG_IsOK(res1)) {
43649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43650 }
43651 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43652 {
43653 PyThreadState* __tstate = wxPyBeginAllowThreads();
43654 {
43655 wxBitmap const &_result_ref = ((wxMenuItem const *)arg1)->GetDisabledBitmap();
43656 result = (wxBitmap *) &_result_ref;
43657 }
43658 wxPyEndAllowThreads(__tstate);
43659 if (PyErr_Occurred()) SWIG_fail;
43660 }
43661 {
43662 wxBitmap* resultptr = new wxBitmap(*result);
43663 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
43664 }
43665 return resultobj;
43666 fail:
43667 return NULL;
43668 }
43669
43670
43671 SWIGINTERN PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43672 PyObject *resultobj = 0;
43673 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43674 int arg2 ;
43675 void *argp1 = 0 ;
43676 int res1 = 0 ;
43677 int val2 ;
43678 int ecode2 = 0 ;
43679 PyObject * obj0 = 0 ;
43680 PyObject * obj1 = 0 ;
43681 char * kwnames[] = {
43682 (char *) "self",(char *) "nWidth", NULL
43683 };
43684
43685 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) SWIG_fail;
43686 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43687 if (!SWIG_IsOK(res1)) {
43688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43689 }
43690 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43691 ecode2 = SWIG_AsVal_int(obj1, &val2);
43692 if (!SWIG_IsOK(ecode2)) {
43693 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "2"" of type '" "int""'");
43694 }
43695 arg2 = static_cast< int >(val2);
43696 {
43697 PyThreadState* __tstate = wxPyBeginAllowThreads();
43698 (arg1)->SetMarginWidth(arg2);
43699 wxPyEndAllowThreads(__tstate);
43700 if (PyErr_Occurred()) SWIG_fail;
43701 }
43702 resultobj = SWIG_Py_Void();
43703 return resultobj;
43704 fail:
43705 return NULL;
43706 }
43707
43708
43709 SWIGINTERN PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43710 PyObject *resultobj = 0;
43711 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43712 int result;
43713 void *argp1 = 0 ;
43714 int res1 = 0 ;
43715 PyObject *swig_obj[1] ;
43716
43717 if (!args) SWIG_fail;
43718 swig_obj[0] = args;
43719 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43720 if (!SWIG_IsOK(res1)) {
43721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43722 }
43723 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43724 {
43725 PyThreadState* __tstate = wxPyBeginAllowThreads();
43726 result = (int)(arg1)->GetMarginWidth();
43727 wxPyEndAllowThreads(__tstate);
43728 if (PyErr_Occurred()) SWIG_fail;
43729 }
43730 resultobj = SWIG_From_int(static_cast< int >(result));
43731 return resultobj;
43732 fail:
43733 return NULL;
43734 }
43735
43736
43737 SWIGINTERN PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43738 PyObject *resultobj = 0;
43739 int result;
43740
43741 if (!SWIG_Python_UnpackTuple(args,"MenuItem_GetDefaultMarginWidth",0,0,0)) SWIG_fail;
43742 {
43743 PyThreadState* __tstate = wxPyBeginAllowThreads();
43744 result = (int)wxMenuItem::GetDefaultMarginWidth();
43745 wxPyEndAllowThreads(__tstate);
43746 if (PyErr_Occurred()) SWIG_fail;
43747 }
43748 resultobj = SWIG_From_int(static_cast< int >(result));
43749 return resultobj;
43750 fail:
43751 return NULL;
43752 }
43753
43754
43755 SWIGINTERN PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43756 PyObject *resultobj = 0;
43757 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43758 bool result;
43759 void *argp1 = 0 ;
43760 int res1 = 0 ;
43761 PyObject *swig_obj[1] ;
43762
43763 if (!args) SWIG_fail;
43764 swig_obj[0] = args;
43765 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43766 if (!SWIG_IsOK(res1)) {
43767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43768 }
43769 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43770 {
43771 PyThreadState* __tstate = wxPyBeginAllowThreads();
43772 result = (bool)(arg1)->IsOwnerDrawn();
43773 wxPyEndAllowThreads(__tstate);
43774 if (PyErr_Occurred()) SWIG_fail;
43775 }
43776 {
43777 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43778 }
43779 return resultobj;
43780 fail:
43781 return NULL;
43782 }
43783
43784
43785 SWIGINTERN PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43786 PyObject *resultobj = 0;
43787 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43788 bool arg2 = (bool) true ;
43789 void *argp1 = 0 ;
43790 int res1 = 0 ;
43791 bool val2 ;
43792 int ecode2 = 0 ;
43793 PyObject * obj0 = 0 ;
43794 PyObject * obj1 = 0 ;
43795 char * kwnames[] = {
43796 (char *) "self",(char *) "ownerDrawn", NULL
43797 };
43798
43799 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) SWIG_fail;
43800 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43801 if (!SWIG_IsOK(res1)) {
43802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43803 }
43804 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43805 if (obj1) {
43806 ecode2 = SWIG_AsVal_bool(obj1, &val2);
43807 if (!SWIG_IsOK(ecode2)) {
43808 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "2"" of type '" "bool""'");
43809 }
43810 arg2 = static_cast< bool >(val2);
43811 }
43812 {
43813 PyThreadState* __tstate = wxPyBeginAllowThreads();
43814 (arg1)->SetOwnerDrawn(arg2);
43815 wxPyEndAllowThreads(__tstate);
43816 if (PyErr_Occurred()) SWIG_fail;
43817 }
43818 resultobj = SWIG_Py_Void();
43819 return resultobj;
43820 fail:
43821 return NULL;
43822 }
43823
43824
43825 SWIGINTERN PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43826 PyObject *resultobj = 0;
43827 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43828 void *argp1 = 0 ;
43829 int res1 = 0 ;
43830 PyObject *swig_obj[1] ;
43831
43832 if (!args) SWIG_fail;
43833 swig_obj[0] = args;
43834 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43835 if (!SWIG_IsOK(res1)) {
43836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_ResetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43837 }
43838 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43839 {
43840 PyThreadState* __tstate = wxPyBeginAllowThreads();
43841 (arg1)->ResetOwnerDrawn();
43842 wxPyEndAllowThreads(__tstate);
43843 if (PyErr_Occurred()) SWIG_fail;
43844 }
43845 resultobj = SWIG_Py_Void();
43846 return resultobj;
43847 fail:
43848 return NULL;
43849 }
43850
43851
43852 SWIGINTERN PyObject *MenuItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43853 PyObject *obj;
43854 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
43855 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuItem, SWIG_NewClientData(obj));
43856 return SWIG_Py_Void();
43857 }
43858
43859 SWIGINTERN PyObject *MenuItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43860 return SWIG_Python_InitShadowInstance(args);
43861 }
43862
43863 SWIGINTERN int ControlNameStr_set(PyObject *) {
43864 SWIG_Error(SWIG_AttributeError,"Variable ControlNameStr is read-only.");
43865 return 1;
43866 }
43867
43868
43869 SWIGINTERN PyObject *ControlNameStr_get(void) {
43870 PyObject *pyobj = 0;
43871
43872 {
43873 #if wxUSE_UNICODE
43874 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
43875 #else
43876 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
43877 #endif
43878 }
43879 return pyobj;
43880 }
43881
43882
43883 SWIGINTERN PyObject *_wrap_new_Control(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43884 PyObject *resultobj = 0;
43885 wxWindow *arg1 = (wxWindow *) 0 ;
43886 int arg2 = (int) -1 ;
43887 wxPoint const &arg3_defvalue = wxDefaultPosition ;
43888 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
43889 wxSize const &arg4_defvalue = wxDefaultSize ;
43890 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
43891 long arg5 = (long) 0 ;
43892 wxValidator const &arg6_defvalue = wxDefaultValidator ;
43893 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
43894 wxString const &arg7_defvalue = wxPyControlNameStr ;
43895 wxString *arg7 = (wxString *) &arg7_defvalue ;
43896 wxControl *result = 0 ;
43897 void *argp1 = 0 ;
43898 int res1 = 0 ;
43899 int val2 ;
43900 int ecode2 = 0 ;
43901 wxPoint temp3 ;
43902 wxSize temp4 ;
43903 long val5 ;
43904 int ecode5 = 0 ;
43905 void *argp6 = 0 ;
43906 int res6 = 0 ;
43907 bool temp7 = false ;
43908 PyObject * obj0 = 0 ;
43909 PyObject * obj1 = 0 ;
43910 PyObject * obj2 = 0 ;
43911 PyObject * obj3 = 0 ;
43912 PyObject * obj4 = 0 ;
43913 PyObject * obj5 = 0 ;
43914 PyObject * obj6 = 0 ;
43915 char * kwnames[] = {
43916 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
43917 };
43918
43919 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
43920 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
43921 if (!SWIG_IsOK(res1)) {
43922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Control" "', expected argument " "1"" of type '" "wxWindow *""'");
43923 }
43924 arg1 = reinterpret_cast< wxWindow * >(argp1);
43925 if (obj1) {
43926 ecode2 = SWIG_AsVal_int(obj1, &val2);
43927 if (!SWIG_IsOK(ecode2)) {
43928 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Control" "', expected argument " "2"" of type '" "int""'");
43929 }
43930 arg2 = static_cast< int >(val2);
43931 }
43932 if (obj2) {
43933 {
43934 arg3 = &temp3;
43935 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
43936 }
43937 }
43938 if (obj3) {
43939 {
43940 arg4 = &temp4;
43941 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
43942 }
43943 }
43944 if (obj4) {
43945 ecode5 = SWIG_AsVal_long(obj4, &val5);
43946 if (!SWIG_IsOK(ecode5)) {
43947 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Control" "', expected argument " "5"" of type '" "long""'");
43948 }
43949 arg5 = static_cast< long >(val5);
43950 }
43951 if (obj5) {
43952 res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_wxValidator, 0 | 0);
43953 if (!SWIG_IsOK(res6)) {
43954 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
43955 }
43956 if (!argp6) {
43957 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
43958 }
43959 arg6 = reinterpret_cast< wxValidator * >(argp6);
43960 }
43961 if (obj6) {
43962 {
43963 arg7 = wxString_in_helper(obj6);
43964 if (arg7 == NULL) SWIG_fail;
43965 temp7 = true;
43966 }
43967 }
43968 {
43969 if (!wxPyCheckForApp()) SWIG_fail;
43970 PyThreadState* __tstate = wxPyBeginAllowThreads();
43971 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
43972 wxPyEndAllowThreads(__tstate);
43973 if (PyErr_Occurred()) SWIG_fail;
43974 }
43975 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_NEW | 0 );
43976 {
43977 if (temp7)
43978 delete arg7;
43979 }
43980 return resultobj;
43981 fail:
43982 {
43983 if (temp7)
43984 delete arg7;
43985 }
43986 return NULL;
43987 }
43988
43989
43990 SWIGINTERN PyObject *_wrap_new_PreControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43991 PyObject *resultobj = 0;
43992 wxControl *result = 0 ;
43993
43994 if (!SWIG_Python_UnpackTuple(args,"new_PreControl",0,0,0)) SWIG_fail;
43995 {
43996 if (!wxPyCheckForApp()) SWIG_fail;
43997 PyThreadState* __tstate = wxPyBeginAllowThreads();
43998 result = (wxControl *)new wxControl();
43999 wxPyEndAllowThreads(__tstate);
44000 if (PyErr_Occurred()) SWIG_fail;
44001 }
44002 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_OWN | 0 );
44003 return resultobj;
44004 fail:
44005 return NULL;
44006 }
44007
44008
44009 SWIGINTERN PyObject *_wrap_Control_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44010 PyObject *resultobj = 0;
44011 wxControl *arg1 = (wxControl *) 0 ;
44012 wxWindow *arg2 = (wxWindow *) 0 ;
44013 int arg3 = (int) -1 ;
44014 wxPoint const &arg4_defvalue = wxDefaultPosition ;
44015 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
44016 wxSize const &arg5_defvalue = wxDefaultSize ;
44017 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
44018 long arg6 = (long) 0 ;
44019 wxValidator const &arg7_defvalue = wxDefaultValidator ;
44020 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
44021 wxString const &arg8_defvalue = wxPyControlNameStr ;
44022 wxString *arg8 = (wxString *) &arg8_defvalue ;
44023 bool result;
44024 void *argp1 = 0 ;
44025 int res1 = 0 ;
44026 void *argp2 = 0 ;
44027 int res2 = 0 ;
44028 int val3 ;
44029 int ecode3 = 0 ;
44030 wxPoint temp4 ;
44031 wxSize temp5 ;
44032 long val6 ;
44033 int ecode6 = 0 ;
44034 void *argp7 = 0 ;
44035 int res7 = 0 ;
44036 bool temp8 = false ;
44037 PyObject * obj0 = 0 ;
44038 PyObject * obj1 = 0 ;
44039 PyObject * obj2 = 0 ;
44040 PyObject * obj3 = 0 ;
44041 PyObject * obj4 = 0 ;
44042 PyObject * obj5 = 0 ;
44043 PyObject * obj6 = 0 ;
44044 PyObject * obj7 = 0 ;
44045 char * kwnames[] = {
44046 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
44047 };
44048
44049 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
44050 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44051 if (!SWIG_IsOK(res1)) {
44052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Create" "', expected argument " "1"" of type '" "wxControl *""'");
44053 }
44054 arg1 = reinterpret_cast< wxControl * >(argp1);
44055 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
44056 if (!SWIG_IsOK(res2)) {
44057 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
44058 }
44059 arg2 = reinterpret_cast< wxWindow * >(argp2);
44060 if (obj2) {
44061 ecode3 = SWIG_AsVal_int(obj2, &val3);
44062 if (!SWIG_IsOK(ecode3)) {
44063 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Control_Create" "', expected argument " "3"" of type '" "int""'");
44064 }
44065 arg3 = static_cast< int >(val3);
44066 }
44067 if (obj3) {
44068 {
44069 arg4 = &temp4;
44070 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
44071 }
44072 }
44073 if (obj4) {
44074 {
44075 arg5 = &temp5;
44076 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
44077 }
44078 }
44079 if (obj5) {
44080 ecode6 = SWIG_AsVal_long(obj5, &val6);
44081 if (!SWIG_IsOK(ecode6)) {
44082 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Control_Create" "', expected argument " "6"" of type '" "long""'");
44083 }
44084 arg6 = static_cast< long >(val6);
44085 }
44086 if (obj6) {
44087 res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator, 0 | 0);
44088 if (!SWIG_IsOK(res7)) {
44089 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
44090 }
44091 if (!argp7) {
44092 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
44093 }
44094 arg7 = reinterpret_cast< wxValidator * >(argp7);
44095 }
44096 if (obj7) {
44097 {
44098 arg8 = wxString_in_helper(obj7);
44099 if (arg8 == NULL) SWIG_fail;
44100 temp8 = true;
44101 }
44102 }
44103 {
44104 PyThreadState* __tstate = wxPyBeginAllowThreads();
44105 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
44106 wxPyEndAllowThreads(__tstate);
44107 if (PyErr_Occurred()) SWIG_fail;
44108 }
44109 {
44110 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44111 }
44112 {
44113 if (temp8)
44114 delete arg8;
44115 }
44116 return resultobj;
44117 fail:
44118 {
44119 if (temp8)
44120 delete arg8;
44121 }
44122 return NULL;
44123 }
44124
44125
44126 SWIGINTERN PyObject *_wrap_Control_GetAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44127 PyObject *resultobj = 0;
44128 wxControl *arg1 = (wxControl *) 0 ;
44129 int result;
44130 void *argp1 = 0 ;
44131 int res1 = 0 ;
44132 PyObject *swig_obj[1] ;
44133
44134 if (!args) SWIG_fail;
44135 swig_obj[0] = args;
44136 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44137 if (!SWIG_IsOK(res1)) {
44138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetAlignment" "', expected argument " "1"" of type '" "wxControl const *""'");
44139 }
44140 arg1 = reinterpret_cast< wxControl * >(argp1);
44141 {
44142 PyThreadState* __tstate = wxPyBeginAllowThreads();
44143 result = (int)((wxControl const *)arg1)->GetAlignment();
44144 wxPyEndAllowThreads(__tstate);
44145 if (PyErr_Occurred()) SWIG_fail;
44146 }
44147 resultobj = SWIG_From_int(static_cast< int >(result));
44148 return resultobj;
44149 fail:
44150 return NULL;
44151 }
44152
44153
44154 SWIGINTERN PyObject *_wrap_Control_GetLabelText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44155 PyObject *resultobj = 0;
44156 wxControl *arg1 = (wxControl *) 0 ;
44157 wxString result;
44158 void *argp1 = 0 ;
44159 int res1 = 0 ;
44160 PyObject *swig_obj[1] ;
44161
44162 if (!args) SWIG_fail;
44163 swig_obj[0] = args;
44164 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44165 if (!SWIG_IsOK(res1)) {
44166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabelText" "', expected argument " "1"" of type '" "wxControl const *""'");
44167 }
44168 arg1 = reinterpret_cast< wxControl * >(argp1);
44169 {
44170 PyThreadState* __tstate = wxPyBeginAllowThreads();
44171 result = ((wxControl const *)arg1)->GetLabelText();
44172 wxPyEndAllowThreads(__tstate);
44173 if (PyErr_Occurred()) SWIG_fail;
44174 }
44175 {
44176 #if wxUSE_UNICODE
44177 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44178 #else
44179 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44180 #endif
44181 }
44182 return resultobj;
44183 fail:
44184 return NULL;
44185 }
44186
44187
44188 SWIGINTERN PyObject *_wrap_Control_Command(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44189 PyObject *resultobj = 0;
44190 wxControl *arg1 = (wxControl *) 0 ;
44191 wxCommandEvent *arg2 = 0 ;
44192 void *argp1 = 0 ;
44193 int res1 = 0 ;
44194 void *argp2 = 0 ;
44195 int res2 = 0 ;
44196 PyObject * obj0 = 0 ;
44197 PyObject * obj1 = 0 ;
44198 char * kwnames[] = {
44199 (char *) "self",(char *) "event", NULL
44200 };
44201
44202 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) SWIG_fail;
44203 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44204 if (!SWIG_IsOK(res1)) {
44205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Command" "', expected argument " "1"" of type '" "wxControl *""'");
44206 }
44207 arg1 = reinterpret_cast< wxControl * >(argp1);
44208 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCommandEvent, 0 );
44209 if (!SWIG_IsOK(res2)) {
44210 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
44211 }
44212 if (!argp2) {
44213 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
44214 }
44215 arg2 = reinterpret_cast< wxCommandEvent * >(argp2);
44216 {
44217 PyThreadState* __tstate = wxPyBeginAllowThreads();
44218 (arg1)->Command(*arg2);
44219 wxPyEndAllowThreads(__tstate);
44220 if (PyErr_Occurred()) SWIG_fail;
44221 }
44222 resultobj = SWIG_Py_Void();
44223 return resultobj;
44224 fail:
44225 return NULL;
44226 }
44227
44228
44229 SWIGINTERN PyObject *_wrap_Control_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44230 PyObject *resultobj = 0;
44231 wxControl *arg1 = (wxControl *) 0 ;
44232 wxString result;
44233 void *argp1 = 0 ;
44234 int res1 = 0 ;
44235 PyObject *swig_obj[1] ;
44236
44237 if (!args) SWIG_fail;
44238 swig_obj[0] = args;
44239 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44240 if (!SWIG_IsOK(res1)) {
44241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabel" "', expected argument " "1"" of type '" "wxControl *""'");
44242 }
44243 arg1 = reinterpret_cast< wxControl * >(argp1);
44244 {
44245 PyThreadState* __tstate = wxPyBeginAllowThreads();
44246 result = (arg1)->GetLabel();
44247 wxPyEndAllowThreads(__tstate);
44248 if (PyErr_Occurred()) SWIG_fail;
44249 }
44250 {
44251 #if wxUSE_UNICODE
44252 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44253 #else
44254 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44255 #endif
44256 }
44257 return resultobj;
44258 fail:
44259 return NULL;
44260 }
44261
44262
44263 SWIGINTERN PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44264 PyObject *resultobj = 0;
44265 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
44266 SwigValueWrapper<wxVisualAttributes > result;
44267 int val1 ;
44268 int ecode1 = 0 ;
44269 PyObject * obj0 = 0 ;
44270 char * kwnames[] = {
44271 (char *) "variant", NULL
44272 };
44273
44274 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
44275 if (obj0) {
44276 ecode1 = SWIG_AsVal_int(obj0, &val1);
44277 if (!SWIG_IsOK(ecode1)) {
44278 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Control_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
44279 }
44280 arg1 = static_cast< wxWindowVariant >(val1);
44281 }
44282 {
44283 if (!wxPyCheckForApp()) SWIG_fail;
44284 PyThreadState* __tstate = wxPyBeginAllowThreads();
44285 result = wxControl::GetClassDefaultAttributes(arg1);
44286 wxPyEndAllowThreads(__tstate);
44287 if (PyErr_Occurred()) SWIG_fail;
44288 }
44289 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
44290 return resultobj;
44291 fail:
44292 return NULL;
44293 }
44294
44295
44296 SWIGINTERN PyObject *Control_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44297 PyObject *obj;
44298 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44299 SWIG_TypeNewClientData(SWIGTYPE_p_wxControl, SWIG_NewClientData(obj));
44300 return SWIG_Py_Void();
44301 }
44302
44303 SWIGINTERN PyObject *Control_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44304 return SWIG_Python_InitShadowInstance(args);
44305 }
44306
44307 SWIGINTERN PyObject *_wrap_ItemContainer_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44308 PyObject *resultobj = 0;
44309 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44310 wxString *arg2 = 0 ;
44311 PyObject *arg3 = (PyObject *) NULL ;
44312 int result;
44313 void *argp1 = 0 ;
44314 int res1 = 0 ;
44315 bool temp2 = false ;
44316 PyObject * obj0 = 0 ;
44317 PyObject * obj1 = 0 ;
44318 PyObject * obj2 = 0 ;
44319 char * kwnames[] = {
44320 (char *) "self",(char *) "item",(char *) "clientData", NULL
44321 };
44322
44323 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44324 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44325 if (!SWIG_IsOK(res1)) {
44326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Append" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44327 }
44328 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44329 {
44330 arg2 = wxString_in_helper(obj1);
44331 if (arg2 == NULL) SWIG_fail;
44332 temp2 = true;
44333 }
44334 if (obj2) {
44335 arg3 = obj2;
44336 }
44337 {
44338 PyThreadState* __tstate = wxPyBeginAllowThreads();
44339 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
44340 wxPyEndAllowThreads(__tstate);
44341 if (PyErr_Occurred()) SWIG_fail;
44342 }
44343 resultobj = SWIG_From_int(static_cast< int >(result));
44344 {
44345 if (temp2)
44346 delete arg2;
44347 }
44348 return resultobj;
44349 fail:
44350 {
44351 if (temp2)
44352 delete arg2;
44353 }
44354 return NULL;
44355 }
44356
44357
44358 SWIGINTERN PyObject *_wrap_ItemContainer_AppendItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44359 PyObject *resultobj = 0;
44360 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44361 wxArrayString *arg2 = 0 ;
44362 void *argp1 = 0 ;
44363 int res1 = 0 ;
44364 bool temp2 = false ;
44365 PyObject * obj0 = 0 ;
44366 PyObject * obj1 = 0 ;
44367 char * kwnames[] = {
44368 (char *) "self",(char *) "strings", NULL
44369 };
44370
44371 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) SWIG_fail;
44372 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44373 if (!SWIG_IsOK(res1)) {
44374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_AppendItems" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44375 }
44376 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44377 {
44378 if (! PySequence_Check(obj1)) {
44379 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
44380 SWIG_fail;
44381 }
44382 arg2 = new wxArrayString;
44383 temp2 = true;
44384 int i, len=PySequence_Length(obj1);
44385 for (i=0; i<len; i++) {
44386 PyObject* item = PySequence_GetItem(obj1, i);
44387 wxString* s = wxString_in_helper(item);
44388 if (PyErr_Occurred()) SWIG_fail;
44389 arg2->Add(*s);
44390 delete s;
44391 Py_DECREF(item);
44392 }
44393 }
44394 {
44395 PyThreadState* __tstate = wxPyBeginAllowThreads();
44396 (arg1)->Append((wxArrayString const &)*arg2);
44397 wxPyEndAllowThreads(__tstate);
44398 if (PyErr_Occurred()) SWIG_fail;
44399 }
44400 resultobj = SWIG_Py_Void();
44401 {
44402 if (temp2) delete arg2;
44403 }
44404 return resultobj;
44405 fail:
44406 {
44407 if (temp2) delete arg2;
44408 }
44409 return NULL;
44410 }
44411
44412
44413 SWIGINTERN PyObject *_wrap_ItemContainer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44414 PyObject *resultobj = 0;
44415 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44416 wxString *arg2 = 0 ;
44417 unsigned int arg3 ;
44418 PyObject *arg4 = (PyObject *) NULL ;
44419 int result;
44420 void *argp1 = 0 ;
44421 int res1 = 0 ;
44422 bool temp2 = false ;
44423 unsigned int val3 ;
44424 int ecode3 = 0 ;
44425 PyObject * obj0 = 0 ;
44426 PyObject * obj1 = 0 ;
44427 PyObject * obj2 = 0 ;
44428 PyObject * obj3 = 0 ;
44429 char * kwnames[] = {
44430 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
44431 };
44432
44433 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
44434 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44435 if (!SWIG_IsOK(res1)) {
44436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Insert" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44437 }
44438 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44439 {
44440 arg2 = wxString_in_helper(obj1);
44441 if (arg2 == NULL) SWIG_fail;
44442 temp2 = true;
44443 }
44444 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
44445 if (!SWIG_IsOK(ecode3)) {
44446 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ItemContainer_Insert" "', expected argument " "3"" of type '" "unsigned int""'");
44447 }
44448 arg3 = static_cast< unsigned int >(val3);
44449 if (obj3) {
44450 arg4 = obj3;
44451 }
44452 {
44453 PyThreadState* __tstate = wxPyBeginAllowThreads();
44454 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
44455 wxPyEndAllowThreads(__tstate);
44456 if (PyErr_Occurred()) SWIG_fail;
44457 }
44458 resultobj = SWIG_From_int(static_cast< int >(result));
44459 {
44460 if (temp2)
44461 delete arg2;
44462 }
44463 return resultobj;
44464 fail:
44465 {
44466 if (temp2)
44467 delete arg2;
44468 }
44469 return NULL;
44470 }
44471
44472
44473 SWIGINTERN PyObject *_wrap_ItemContainer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44474 PyObject *resultobj = 0;
44475 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44476 void *argp1 = 0 ;
44477 int res1 = 0 ;
44478 PyObject *swig_obj[1] ;
44479
44480 if (!args) SWIG_fail;
44481 swig_obj[0] = args;
44482 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44483 if (!SWIG_IsOK(res1)) {
44484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Clear" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44485 }
44486 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44487 {
44488 PyThreadState* __tstate = wxPyBeginAllowThreads();
44489 (arg1)->Clear();
44490 wxPyEndAllowThreads(__tstate);
44491 if (PyErr_Occurred()) SWIG_fail;
44492 }
44493 resultobj = SWIG_Py_Void();
44494 return resultobj;
44495 fail:
44496 return NULL;
44497 }
44498
44499
44500 SWIGINTERN PyObject *_wrap_ItemContainer_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44501 PyObject *resultobj = 0;
44502 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44503 unsigned int arg2 ;
44504 void *argp1 = 0 ;
44505 int res1 = 0 ;
44506 unsigned int val2 ;
44507 int ecode2 = 0 ;
44508 PyObject * obj0 = 0 ;
44509 PyObject * obj1 = 0 ;
44510 char * kwnames[] = {
44511 (char *) "self",(char *) "n", NULL
44512 };
44513
44514 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
44515 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44516 if (!SWIG_IsOK(res1)) {
44517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Delete" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44518 }
44519 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44520 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44521 if (!SWIG_IsOK(ecode2)) {
44522 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Delete" "', expected argument " "2"" of type '" "unsigned int""'");
44523 }
44524 arg2 = static_cast< unsigned int >(val2);
44525 {
44526 PyThreadState* __tstate = wxPyBeginAllowThreads();
44527 (arg1)->Delete(arg2);
44528 wxPyEndAllowThreads(__tstate);
44529 if (PyErr_Occurred()) SWIG_fail;
44530 }
44531 resultobj = SWIG_Py_Void();
44532 return resultobj;
44533 fail:
44534 return NULL;
44535 }
44536
44537
44538 SWIGINTERN PyObject *_wrap_ItemContainer_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44539 PyObject *resultobj = 0;
44540 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44541 unsigned int arg2 ;
44542 PyObject *result = 0 ;
44543 void *argp1 = 0 ;
44544 int res1 = 0 ;
44545 unsigned int val2 ;
44546 int ecode2 = 0 ;
44547 PyObject * obj0 = 0 ;
44548 PyObject * obj1 = 0 ;
44549 char * kwnames[] = {
44550 (char *) "self",(char *) "n", NULL
44551 };
44552
44553 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
44554 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44555 if (!SWIG_IsOK(res1)) {
44556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44557 }
44558 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44559 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44560 if (!SWIG_IsOK(ecode2)) {
44561 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
44562 }
44563 arg2 = static_cast< unsigned int >(val2);
44564 {
44565 PyThreadState* __tstate = wxPyBeginAllowThreads();
44566 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
44567 wxPyEndAllowThreads(__tstate);
44568 if (PyErr_Occurred()) SWIG_fail;
44569 }
44570 resultobj = result;
44571 return resultobj;
44572 fail:
44573 return NULL;
44574 }
44575
44576
44577 SWIGINTERN PyObject *_wrap_ItemContainer_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44578 PyObject *resultobj = 0;
44579 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44580 unsigned int arg2 ;
44581 PyObject *arg3 = (PyObject *) 0 ;
44582 void *argp1 = 0 ;
44583 int res1 = 0 ;
44584 unsigned int val2 ;
44585 int ecode2 = 0 ;
44586 PyObject * obj0 = 0 ;
44587 PyObject * obj1 = 0 ;
44588 PyObject * obj2 = 0 ;
44589 char * kwnames[] = {
44590 (char *) "self",(char *) "n",(char *) "clientData", NULL
44591 };
44592
44593 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44594 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44595 if (!SWIG_IsOK(res1)) {
44596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44597 }
44598 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44599 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44600 if (!SWIG_IsOK(ecode2)) {
44601 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
44602 }
44603 arg2 = static_cast< unsigned int >(val2);
44604 arg3 = obj2;
44605 {
44606 PyThreadState* __tstate = wxPyBeginAllowThreads();
44607 wxItemContainer_SetClientData(arg1,arg2,arg3);
44608 wxPyEndAllowThreads(__tstate);
44609 if (PyErr_Occurred()) SWIG_fail;
44610 }
44611 resultobj = SWIG_Py_Void();
44612 return resultobj;
44613 fail:
44614 return NULL;
44615 }
44616
44617
44618 SWIGINTERN PyObject *_wrap_ItemContainer_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44619 PyObject *resultobj = 0;
44620 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44621 unsigned int result;
44622 void *argp1 = 0 ;
44623 int res1 = 0 ;
44624 PyObject *swig_obj[1] ;
44625
44626 if (!args) SWIG_fail;
44627 swig_obj[0] = args;
44628 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44629 if (!SWIG_IsOK(res1)) {
44630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetCount" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44631 }
44632 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44633 {
44634 PyThreadState* __tstate = wxPyBeginAllowThreads();
44635 result = (unsigned int)((wxItemContainer const *)arg1)->GetCount();
44636 wxPyEndAllowThreads(__tstate);
44637 if (PyErr_Occurred()) SWIG_fail;
44638 }
44639 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
44640 return resultobj;
44641 fail:
44642 return NULL;
44643 }
44644
44645
44646 SWIGINTERN PyObject *_wrap_ItemContainer_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44647 PyObject *resultobj = 0;
44648 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44649 bool result;
44650 void *argp1 = 0 ;
44651 int res1 = 0 ;
44652 PyObject *swig_obj[1] ;
44653
44654 if (!args) SWIG_fail;
44655 swig_obj[0] = args;
44656 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44657 if (!SWIG_IsOK(res1)) {
44658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_IsEmpty" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44659 }
44660 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44661 {
44662 PyThreadState* __tstate = wxPyBeginAllowThreads();
44663 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
44664 wxPyEndAllowThreads(__tstate);
44665 if (PyErr_Occurred()) SWIG_fail;
44666 }
44667 {
44668 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44669 }
44670 return resultobj;
44671 fail:
44672 return NULL;
44673 }
44674
44675
44676 SWIGINTERN PyObject *_wrap_ItemContainer_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44677 PyObject *resultobj = 0;
44678 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44679 unsigned int arg2 ;
44680 wxString result;
44681 void *argp1 = 0 ;
44682 int res1 = 0 ;
44683 unsigned int val2 ;
44684 int ecode2 = 0 ;
44685 PyObject * obj0 = 0 ;
44686 PyObject * obj1 = 0 ;
44687 char * kwnames[] = {
44688 (char *) "self",(char *) "n", NULL
44689 };
44690
44691 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) SWIG_fail;
44692 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44693 if (!SWIG_IsOK(res1)) {
44694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44695 }
44696 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44697 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44698 if (!SWIG_IsOK(ecode2)) {
44699 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetString" "', expected argument " "2"" of type '" "unsigned int""'");
44700 }
44701 arg2 = static_cast< unsigned int >(val2);
44702 {
44703 PyThreadState* __tstate = wxPyBeginAllowThreads();
44704 result = ((wxItemContainer const *)arg1)->GetString(arg2);
44705 wxPyEndAllowThreads(__tstate);
44706 if (PyErr_Occurred()) SWIG_fail;
44707 }
44708 {
44709 #if wxUSE_UNICODE
44710 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44711 #else
44712 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44713 #endif
44714 }
44715 return resultobj;
44716 fail:
44717 return NULL;
44718 }
44719
44720
44721 SWIGINTERN PyObject *_wrap_ItemContainer_GetStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44722 PyObject *resultobj = 0;
44723 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44724 wxArrayString result;
44725 void *argp1 = 0 ;
44726 int res1 = 0 ;
44727 PyObject *swig_obj[1] ;
44728
44729 if (!args) SWIG_fail;
44730 swig_obj[0] = args;
44731 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44732 if (!SWIG_IsOK(res1)) {
44733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStrings" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44734 }
44735 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44736 {
44737 PyThreadState* __tstate = wxPyBeginAllowThreads();
44738 result = ((wxItemContainer const *)arg1)->GetStrings();
44739 wxPyEndAllowThreads(__tstate);
44740 if (PyErr_Occurred()) SWIG_fail;
44741 }
44742 {
44743 resultobj = wxArrayString2PyList_helper(result);
44744 }
44745 return resultobj;
44746 fail:
44747 return NULL;
44748 }
44749
44750
44751 SWIGINTERN PyObject *_wrap_ItemContainer_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44752 PyObject *resultobj = 0;
44753 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44754 unsigned int arg2 ;
44755 wxString *arg3 = 0 ;
44756 void *argp1 = 0 ;
44757 int res1 = 0 ;
44758 unsigned int val2 ;
44759 int ecode2 = 0 ;
44760 bool temp3 = false ;
44761 PyObject * obj0 = 0 ;
44762 PyObject * obj1 = 0 ;
44763 PyObject * obj2 = 0 ;
44764 char * kwnames[] = {
44765 (char *) "self",(char *) "n",(char *) "s", NULL
44766 };
44767
44768 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44769 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44770 if (!SWIG_IsOK(res1)) {
44771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetString" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44772 }
44773 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44774 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44775 if (!SWIG_IsOK(ecode2)) {
44776 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetString" "', expected argument " "2"" of type '" "unsigned int""'");
44777 }
44778 arg2 = static_cast< unsigned int >(val2);
44779 {
44780 arg3 = wxString_in_helper(obj2);
44781 if (arg3 == NULL) SWIG_fail;
44782 temp3 = true;
44783 }
44784 {
44785 PyThreadState* __tstate = wxPyBeginAllowThreads();
44786 (arg1)->SetString(arg2,(wxString const &)*arg3);
44787 wxPyEndAllowThreads(__tstate);
44788 if (PyErr_Occurred()) SWIG_fail;
44789 }
44790 resultobj = SWIG_Py_Void();
44791 {
44792 if (temp3)
44793 delete arg3;
44794 }
44795 return resultobj;
44796 fail:
44797 {
44798 if (temp3)
44799 delete arg3;
44800 }
44801 return NULL;
44802 }
44803
44804
44805 SWIGINTERN PyObject *_wrap_ItemContainer_FindString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44806 PyObject *resultobj = 0;
44807 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44808 wxString *arg2 = 0 ;
44809 int result;
44810 void *argp1 = 0 ;
44811 int res1 = 0 ;
44812 bool temp2 = false ;
44813 PyObject * obj0 = 0 ;
44814 PyObject * obj1 = 0 ;
44815 char * kwnames[] = {
44816 (char *) "self",(char *) "s", NULL
44817 };
44818
44819 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) SWIG_fail;
44820 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44821 if (!SWIG_IsOK(res1)) {
44822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_FindString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44823 }
44824 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44825 {
44826 arg2 = wxString_in_helper(obj1);
44827 if (arg2 == NULL) SWIG_fail;
44828 temp2 = true;
44829 }
44830 {
44831 PyThreadState* __tstate = wxPyBeginAllowThreads();
44832 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
44833 wxPyEndAllowThreads(__tstate);
44834 if (PyErr_Occurred()) SWIG_fail;
44835 }
44836 resultobj = SWIG_From_int(static_cast< int >(result));
44837 {
44838 if (temp2)
44839 delete arg2;
44840 }
44841 return resultobj;
44842 fail:
44843 {
44844 if (temp2)
44845 delete arg2;
44846 }
44847 return NULL;
44848 }
44849
44850
44851 SWIGINTERN PyObject *_wrap_ItemContainer_SetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44852 PyObject *resultobj = 0;
44853 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44854 int arg2 ;
44855 void *argp1 = 0 ;
44856 int res1 = 0 ;
44857 int val2 ;
44858 int ecode2 = 0 ;
44859 PyObject * obj0 = 0 ;
44860 PyObject * obj1 = 0 ;
44861 char * kwnames[] = {
44862 (char *) "self",(char *) "n", NULL
44863 };
44864
44865 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) SWIG_fail;
44866 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44867 if (!SWIG_IsOK(res1)) {
44868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44869 }
44870 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44871 ecode2 = SWIG_AsVal_int(obj1, &val2);
44872 if (!SWIG_IsOK(ecode2)) {
44873 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetSelection" "', expected argument " "2"" of type '" "int""'");
44874 }
44875 arg2 = static_cast< int >(val2);
44876 {
44877 PyThreadState* __tstate = wxPyBeginAllowThreads();
44878 (arg1)->SetSelection(arg2);
44879 wxPyEndAllowThreads(__tstate);
44880 if (PyErr_Occurred()) SWIG_fail;
44881 }
44882 resultobj = SWIG_Py_Void();
44883 return resultobj;
44884 fail:
44885 return NULL;
44886 }
44887
44888
44889 SWIGINTERN PyObject *_wrap_ItemContainer_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44890 PyObject *resultobj = 0;
44891 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44892 int result;
44893 void *argp1 = 0 ;
44894 int res1 = 0 ;
44895 PyObject *swig_obj[1] ;
44896
44897 if (!args) SWIG_fail;
44898 swig_obj[0] = args;
44899 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44900 if (!SWIG_IsOK(res1)) {
44901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44902 }
44903 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44904 {
44905 PyThreadState* __tstate = wxPyBeginAllowThreads();
44906 result = (int)((wxItemContainer const *)arg1)->GetSelection();
44907 wxPyEndAllowThreads(__tstate);
44908 if (PyErr_Occurred()) SWIG_fail;
44909 }
44910 resultobj = SWIG_From_int(static_cast< int >(result));
44911 return resultobj;
44912 fail:
44913 return NULL;
44914 }
44915
44916
44917 SWIGINTERN PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44918 PyObject *resultobj = 0;
44919 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44920 wxString *arg2 = 0 ;
44921 bool result;
44922 void *argp1 = 0 ;
44923 int res1 = 0 ;
44924 bool temp2 = false ;
44925 PyObject * obj0 = 0 ;
44926 PyObject * obj1 = 0 ;
44927 char * kwnames[] = {
44928 (char *) "self",(char *) "s", NULL
44929 };
44930
44931 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) SWIG_fail;
44932 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44933 if (!SWIG_IsOK(res1)) {
44934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44935 }
44936 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44937 {
44938 arg2 = wxString_in_helper(obj1);
44939 if (arg2 == NULL) SWIG_fail;
44940 temp2 = true;
44941 }
44942 {
44943 PyThreadState* __tstate = wxPyBeginAllowThreads();
44944 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
44945 wxPyEndAllowThreads(__tstate);
44946 if (PyErr_Occurred()) SWIG_fail;
44947 }
44948 {
44949 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44950 }
44951 {
44952 if (temp2)
44953 delete arg2;
44954 }
44955 return resultobj;
44956 fail:
44957 {
44958 if (temp2)
44959 delete arg2;
44960 }
44961 return NULL;
44962 }
44963
44964
44965 SWIGINTERN PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44966 PyObject *resultobj = 0;
44967 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44968 wxString result;
44969 void *argp1 = 0 ;
44970 int res1 = 0 ;
44971 PyObject *swig_obj[1] ;
44972
44973 if (!args) SWIG_fail;
44974 swig_obj[0] = args;
44975 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44976 if (!SWIG_IsOK(res1)) {
44977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44978 }
44979 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44980 {
44981 PyThreadState* __tstate = wxPyBeginAllowThreads();
44982 result = ((wxItemContainer const *)arg1)->GetStringSelection();
44983 wxPyEndAllowThreads(__tstate);
44984 if (PyErr_Occurred()) SWIG_fail;
44985 }
44986 {
44987 #if wxUSE_UNICODE
44988 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44989 #else
44990 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44991 #endif
44992 }
44993 return resultobj;
44994 fail:
44995 return NULL;
44996 }
44997
44998
44999 SWIGINTERN PyObject *_wrap_ItemContainer_Select(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45000 PyObject *resultobj = 0;
45001 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45002 int arg2 ;
45003 void *argp1 = 0 ;
45004 int res1 = 0 ;
45005 int val2 ;
45006 int ecode2 = 0 ;
45007 PyObject * obj0 = 0 ;
45008 PyObject * obj1 = 0 ;
45009 char * kwnames[] = {
45010 (char *) "self",(char *) "n", NULL
45011 };
45012
45013 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) SWIG_fail;
45014 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45015 if (!SWIG_IsOK(res1)) {
45016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Select" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45017 }
45018 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45019 ecode2 = SWIG_AsVal_int(obj1, &val2);
45020 if (!SWIG_IsOK(ecode2)) {
45021 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Select" "', expected argument " "2"" of type '" "int""'");
45022 }
45023 arg2 = static_cast< int >(val2);
45024 {
45025 PyThreadState* __tstate = wxPyBeginAllowThreads();
45026 (arg1)->Select(arg2);
45027 wxPyEndAllowThreads(__tstate);
45028 if (PyErr_Occurred()) SWIG_fail;
45029 }
45030 resultobj = SWIG_Py_Void();
45031 return resultobj;
45032 fail:
45033 return NULL;
45034 }
45035
45036
45037 SWIGINTERN PyObject *ItemContainer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45038 PyObject *obj;
45039 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45040 SWIG_TypeNewClientData(SWIGTYPE_p_wxItemContainer, SWIG_NewClientData(obj));
45041 return SWIG_Py_Void();
45042 }
45043
45044 SWIGINTERN PyObject *ControlWithItems_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45045 PyObject *obj;
45046 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45047 SWIG_TypeNewClientData(SWIGTYPE_p_wxControlWithItems, SWIG_NewClientData(obj));
45048 return SWIG_Py_Void();
45049 }
45050
45051 SWIGINTERN PyObject *_wrap_new_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45052 PyObject *resultobj = 0;
45053 wxSizerItem *result = 0 ;
45054
45055 if (!SWIG_Python_UnpackTuple(args,"new_SizerItem",0,0,0)) SWIG_fail;
45056 {
45057 PyThreadState* __tstate = wxPyBeginAllowThreads();
45058 result = (wxSizerItem *)new wxSizerItem();
45059 wxPyEndAllowThreads(__tstate);
45060 if (PyErr_Occurred()) SWIG_fail;
45061 }
45062 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_NEW | 0 );
45063 return resultobj;
45064 fail:
45065 return NULL;
45066 }
45067
45068
45069 SWIGINTERN PyObject *_wrap_delete_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45070 PyObject *resultobj = 0;
45071 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45072 void *argp1 = 0 ;
45073 int res1 = 0 ;
45074 PyObject *swig_obj[1] ;
45075
45076 if (!args) SWIG_fail;
45077 swig_obj[0] = args;
45078 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
45079 if (!SWIG_IsOK(res1)) {
45080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerItem" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45081 }
45082 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45083 {
45084 PyThreadState* __tstate = wxPyBeginAllowThreads();
45085 delete arg1;
45086
45087 wxPyEndAllowThreads(__tstate);
45088 if (PyErr_Occurred()) SWIG_fail;
45089 }
45090 resultobj = SWIG_Py_Void();
45091 return resultobj;
45092 fail:
45093 return NULL;
45094 }
45095
45096
45097 SWIGINTERN PyObject *_wrap_new_SizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45098 PyObject *resultobj = 0;
45099 wxWindow *arg1 = (wxWindow *) 0 ;
45100 int arg2 ;
45101 int arg3 ;
45102 int arg4 ;
45103 PyObject *arg5 = (PyObject *) NULL ;
45104 wxSizerItem *result = 0 ;
45105 void *argp1 = 0 ;
45106 int res1 = 0 ;
45107 int val2 ;
45108 int ecode2 = 0 ;
45109 int val3 ;
45110 int ecode3 = 0 ;
45111 int val4 ;
45112 int ecode4 = 0 ;
45113 PyObject * obj0 = 0 ;
45114 PyObject * obj1 = 0 ;
45115 PyObject * obj2 = 0 ;
45116 PyObject * obj3 = 0 ;
45117 PyObject * obj4 = 0 ;
45118 char * kwnames[] = {
45119 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45120 };
45121
45122 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
45123 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
45124 if (!SWIG_IsOK(res1)) {
45125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
45126 }
45127 arg1 = reinterpret_cast< wxWindow * >(argp1);
45128 ecode2 = SWIG_AsVal_int(obj1, &val2);
45129 if (!SWIG_IsOK(ecode2)) {
45130 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemWindow" "', expected argument " "2"" of type '" "int""'");
45131 }
45132 arg2 = static_cast< int >(val2);
45133 ecode3 = SWIG_AsVal_int(obj2, &val3);
45134 if (!SWIG_IsOK(ecode3)) {
45135 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemWindow" "', expected argument " "3"" of type '" "int""'");
45136 }
45137 arg3 = static_cast< int >(val3);
45138 ecode4 = SWIG_AsVal_int(obj3, &val4);
45139 if (!SWIG_IsOK(ecode4)) {
45140 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemWindow" "', expected argument " "4"" of type '" "int""'");
45141 }
45142 arg4 = static_cast< int >(val4);
45143 if (obj4) {
45144 arg5 = obj4;
45145 }
45146 {
45147 PyThreadState* __tstate = wxPyBeginAllowThreads();
45148 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
45149 wxPyEndAllowThreads(__tstate);
45150 if (PyErr_Occurred()) SWIG_fail;
45151 }
45152 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
45153 return resultobj;
45154 fail:
45155 return NULL;
45156 }
45157
45158
45159 SWIGINTERN PyObject *_wrap_new_SizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45160 PyObject *resultobj = 0;
45161 int arg1 ;
45162 int arg2 ;
45163 int arg3 ;
45164 int arg4 ;
45165 int arg5 ;
45166 PyObject *arg6 = (PyObject *) NULL ;
45167 wxSizerItem *result = 0 ;
45168 int val1 ;
45169 int ecode1 = 0 ;
45170 int val2 ;
45171 int ecode2 = 0 ;
45172 int val3 ;
45173 int ecode3 = 0 ;
45174 int val4 ;
45175 int ecode4 = 0 ;
45176 int val5 ;
45177 int ecode5 = 0 ;
45178 PyObject * obj0 = 0 ;
45179 PyObject * obj1 = 0 ;
45180 PyObject * obj2 = 0 ;
45181 PyObject * obj3 = 0 ;
45182 PyObject * obj4 = 0 ;
45183 PyObject * obj5 = 0 ;
45184 char * kwnames[] = {
45185 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45186 };
45187
45188 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
45189 ecode1 = SWIG_AsVal_int(obj0, &val1);
45190 if (!SWIG_IsOK(ecode1)) {
45191 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
45192 }
45193 arg1 = static_cast< int >(val1);
45194 ecode2 = SWIG_AsVal_int(obj1, &val2);
45195 if (!SWIG_IsOK(ecode2)) {
45196 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
45197 }
45198 arg2 = static_cast< int >(val2);
45199 ecode3 = SWIG_AsVal_int(obj2, &val3);
45200 if (!SWIG_IsOK(ecode3)) {
45201 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSpacer" "', expected argument " "3"" of type '" "int""'");
45202 }
45203 arg3 = static_cast< int >(val3);
45204 ecode4 = SWIG_AsVal_int(obj3, &val4);
45205 if (!SWIG_IsOK(ecode4)) {
45206 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSpacer" "', expected argument " "4"" of type '" "int""'");
45207 }
45208 arg4 = static_cast< int >(val4);
45209 ecode5 = SWIG_AsVal_int(obj4, &val5);
45210 if (!SWIG_IsOK(ecode5)) {
45211 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
45212 }
45213 arg5 = static_cast< int >(val5);
45214 if (obj5) {
45215 arg6 = obj5;
45216 }
45217 {
45218 PyThreadState* __tstate = wxPyBeginAllowThreads();
45219 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
45220 wxPyEndAllowThreads(__tstate);
45221 if (PyErr_Occurred()) SWIG_fail;
45222 }
45223 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
45224 return resultobj;
45225 fail:
45226 return NULL;
45227 }
45228
45229
45230 SWIGINTERN PyObject *_wrap_new_SizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45231 PyObject *resultobj = 0;
45232 wxSizer *arg1 = (wxSizer *) 0 ;
45233 int arg2 ;
45234 int arg3 ;
45235 int arg4 ;
45236 PyObject *arg5 = (PyObject *) NULL ;
45237 wxSizerItem *result = 0 ;
45238 int res1 = 0 ;
45239 int val2 ;
45240 int ecode2 = 0 ;
45241 int val3 ;
45242 int ecode3 = 0 ;
45243 int val4 ;
45244 int ecode4 = 0 ;
45245 PyObject * obj0 = 0 ;
45246 PyObject * obj1 = 0 ;
45247 PyObject * obj2 = 0 ;
45248 PyObject * obj3 = 0 ;
45249 PyObject * obj4 = 0 ;
45250 char * kwnames[] = {
45251 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45252 };
45253
45254 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
45255 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
45256 if (!SWIG_IsOK(res1)) {
45257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
45258 }
45259 ecode2 = SWIG_AsVal_int(obj1, &val2);
45260 if (!SWIG_IsOK(ecode2)) {
45261 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSizer" "', expected argument " "2"" of type '" "int""'");
45262 }
45263 arg2 = static_cast< int >(val2);
45264 ecode3 = SWIG_AsVal_int(obj2, &val3);
45265 if (!SWIG_IsOK(ecode3)) {
45266 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSizer" "', expected argument " "3"" of type '" "int""'");
45267 }
45268 arg3 = static_cast< int >(val3);
45269 ecode4 = SWIG_AsVal_int(obj3, &val4);
45270 if (!SWIG_IsOK(ecode4)) {
45271 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSizer" "', expected argument " "4"" of type '" "int""'");
45272 }
45273 arg4 = static_cast< int >(val4);
45274 if (obj4) {
45275 arg5 = obj4;
45276 }
45277 {
45278 PyThreadState* __tstate = wxPyBeginAllowThreads();
45279 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
45280 wxPyEndAllowThreads(__tstate);
45281 if (PyErr_Occurred()) SWIG_fail;
45282 }
45283 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
45284 return resultobj;
45285 fail:
45286 return NULL;
45287 }
45288
45289
45290 SWIGINTERN PyObject *_wrap_SizerItem_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45291 PyObject *resultobj = 0;
45292 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45293 void *argp1 = 0 ;
45294 int res1 = 0 ;
45295 PyObject *swig_obj[1] ;
45296
45297 if (!args) SWIG_fail;
45298 swig_obj[0] = args;
45299 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45300 if (!SWIG_IsOK(res1)) {
45301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DeleteWindows" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45302 }
45303 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45304 {
45305 PyThreadState* __tstate = wxPyBeginAllowThreads();
45306 (arg1)->DeleteWindows();
45307 wxPyEndAllowThreads(__tstate);
45308 if (PyErr_Occurred()) SWIG_fail;
45309 }
45310 resultobj = SWIG_Py_Void();
45311 return resultobj;
45312 fail:
45313 return NULL;
45314 }
45315
45316
45317 SWIGINTERN PyObject *_wrap_SizerItem_DetachSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45318 PyObject *resultobj = 0;
45319 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45320 void *argp1 = 0 ;
45321 int res1 = 0 ;
45322 PyObject *swig_obj[1] ;
45323
45324 if (!args) SWIG_fail;
45325 swig_obj[0] = args;
45326 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45327 if (!SWIG_IsOK(res1)) {
45328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DetachSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45329 }
45330 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45331 {
45332 PyThreadState* __tstate = wxPyBeginAllowThreads();
45333 (arg1)->DetachSizer();
45334 wxPyEndAllowThreads(__tstate);
45335 if (PyErr_Occurred()) SWIG_fail;
45336 }
45337 resultobj = SWIG_Py_Void();
45338 return resultobj;
45339 fail:
45340 return NULL;
45341 }
45342
45343
45344 SWIGINTERN PyObject *_wrap_SizerItem_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45345 PyObject *resultobj = 0;
45346 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45347 wxSize result;
45348 void *argp1 = 0 ;
45349 int res1 = 0 ;
45350 PyObject *swig_obj[1] ;
45351
45352 if (!args) SWIG_fail;
45353 swig_obj[0] = args;
45354 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45355 if (!SWIG_IsOK(res1)) {
45356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45357 }
45358 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45359 {
45360 PyThreadState* __tstate = wxPyBeginAllowThreads();
45361 result = (arg1)->GetSize();
45362 wxPyEndAllowThreads(__tstate);
45363 if (PyErr_Occurred()) SWIG_fail;
45364 }
45365 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45366 return resultobj;
45367 fail:
45368 return NULL;
45369 }
45370
45371
45372 SWIGINTERN PyObject *_wrap_SizerItem_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45373 PyObject *resultobj = 0;
45374 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45375 wxSize 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_CalcMin" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45385 }
45386 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45387 {
45388 PyThreadState* __tstate = wxPyBeginAllowThreads();
45389 result = (arg1)->CalcMin();
45390 wxPyEndAllowThreads(__tstate);
45391 if (PyErr_Occurred()) SWIG_fail;
45392 }
45393 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45394 return resultobj;
45395 fail:
45396 return NULL;
45397 }
45398
45399
45400 SWIGINTERN PyObject *_wrap_SizerItem_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45401 PyObject *resultobj = 0;
45402 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45403 wxPoint *arg2 = 0 ;
45404 wxSize *arg3 = 0 ;
45405 void *argp1 = 0 ;
45406 int res1 = 0 ;
45407 wxPoint temp2 ;
45408 wxSize temp3 ;
45409 PyObject * obj0 = 0 ;
45410 PyObject * obj1 = 0 ;
45411 PyObject * obj2 = 0 ;
45412 char * kwnames[] = {
45413 (char *) "self",(char *) "pos",(char *) "size", NULL
45414 };
45415
45416 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45417 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45418 if (!SWIG_IsOK(res1)) {
45419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetDimension" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45420 }
45421 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45422 {
45423 arg2 = &temp2;
45424 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
45425 }
45426 {
45427 arg3 = &temp3;
45428 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
45429 }
45430 {
45431 PyThreadState* __tstate = wxPyBeginAllowThreads();
45432 (arg1)->SetDimension((wxPoint const &)*arg2,(wxSize const &)*arg3);
45433 wxPyEndAllowThreads(__tstate);
45434 if (PyErr_Occurred()) SWIG_fail;
45435 }
45436 resultobj = SWIG_Py_Void();
45437 return resultobj;
45438 fail:
45439 return NULL;
45440 }
45441
45442
45443 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45444 PyObject *resultobj = 0;
45445 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45446 wxSize result;
45447 void *argp1 = 0 ;
45448 int res1 = 0 ;
45449 PyObject *swig_obj[1] ;
45450
45451 if (!args) SWIG_fail;
45452 swig_obj[0] = args;
45453 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45454 if (!SWIG_IsOK(res1)) {
45455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45456 }
45457 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45458 {
45459 PyThreadState* __tstate = wxPyBeginAllowThreads();
45460 result = (arg1)->GetMinSize();
45461 wxPyEndAllowThreads(__tstate);
45462 if (PyErr_Occurred()) SWIG_fail;
45463 }
45464 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45465 return resultobj;
45466 fail:
45467 return NULL;
45468 }
45469
45470
45471 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45472 PyObject *resultobj = 0;
45473 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45474 wxSize result;
45475 void *argp1 = 0 ;
45476 int res1 = 0 ;
45477 PyObject *swig_obj[1] ;
45478
45479 if (!args) SWIG_fail;
45480 swig_obj[0] = args;
45481 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45482 if (!SWIG_IsOK(res1)) {
45483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSizeWithBorder" "', expected argument " "1"" of type '" "wxSizerItem const *""'");
45484 }
45485 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45486 {
45487 PyThreadState* __tstate = wxPyBeginAllowThreads();
45488 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
45489 wxPyEndAllowThreads(__tstate);
45490 if (PyErr_Occurred()) SWIG_fail;
45491 }
45492 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45493 return resultobj;
45494 fail:
45495 return NULL;
45496 }
45497
45498
45499 SWIGINTERN PyObject *_wrap_SizerItem_SetInitSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45500 PyObject *resultobj = 0;
45501 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45502 int arg2 ;
45503 int arg3 ;
45504 void *argp1 = 0 ;
45505 int res1 = 0 ;
45506 int val2 ;
45507 int ecode2 = 0 ;
45508 int val3 ;
45509 int ecode3 = 0 ;
45510 PyObject * obj0 = 0 ;
45511 PyObject * obj1 = 0 ;
45512 PyObject * obj2 = 0 ;
45513 char * kwnames[] = {
45514 (char *) "self",(char *) "x",(char *) "y", NULL
45515 };
45516
45517 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45518 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45519 if (!SWIG_IsOK(res1)) {
45520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetInitSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45521 }
45522 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45523 ecode2 = SWIG_AsVal_int(obj1, &val2);
45524 if (!SWIG_IsOK(ecode2)) {
45525 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetInitSize" "', expected argument " "2"" of type '" "int""'");
45526 }
45527 arg2 = static_cast< int >(val2);
45528 ecode3 = SWIG_AsVal_int(obj2, &val3);
45529 if (!SWIG_IsOK(ecode3)) {
45530 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetInitSize" "', expected argument " "3"" of type '" "int""'");
45531 }
45532 arg3 = static_cast< int >(val3);
45533 {
45534 PyThreadState* __tstate = wxPyBeginAllowThreads();
45535 (arg1)->SetInitSize(arg2,arg3);
45536 wxPyEndAllowThreads(__tstate);
45537 if (PyErr_Occurred()) SWIG_fail;
45538 }
45539 resultobj = SWIG_Py_Void();
45540 return resultobj;
45541 fail:
45542 return NULL;
45543 }
45544
45545
45546 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45547 PyObject *resultobj = 0;
45548 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45549 int arg2 ;
45550 int arg3 ;
45551 void *argp1 = 0 ;
45552 int res1 = 0 ;
45553 int val2 ;
45554 int ecode2 = 0 ;
45555 int val3 ;
45556 int ecode3 = 0 ;
45557 PyObject * obj0 = 0 ;
45558 PyObject * obj1 = 0 ;
45559 PyObject * obj2 = 0 ;
45560 char * kwnames[] = {
45561 (char *) "self",(char *) "width",(char *) "height", NULL
45562 };
45563
45564 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45565 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45566 if (!SWIG_IsOK(res1)) {
45567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioWH" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45568 }
45569 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45570 ecode2 = SWIG_AsVal_int(obj1, &val2);
45571 if (!SWIG_IsOK(ecode2)) {
45572 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatioWH" "', expected argument " "2"" of type '" "int""'");
45573 }
45574 arg2 = static_cast< int >(val2);
45575 ecode3 = SWIG_AsVal_int(obj2, &val3);
45576 if (!SWIG_IsOK(ecode3)) {
45577 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetRatioWH" "', expected argument " "3"" of type '" "int""'");
45578 }
45579 arg3 = static_cast< int >(val3);
45580 {
45581 PyThreadState* __tstate = wxPyBeginAllowThreads();
45582 (arg1)->SetRatio(arg2,arg3);
45583 wxPyEndAllowThreads(__tstate);
45584 if (PyErr_Occurred()) SWIG_fail;
45585 }
45586 resultobj = SWIG_Py_Void();
45587 return resultobj;
45588 fail:
45589 return NULL;
45590 }
45591
45592
45593 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45594 PyObject *resultobj = 0;
45595 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45596 wxSize *arg2 = 0 ;
45597 void *argp1 = 0 ;
45598 int res1 = 0 ;
45599 wxSize temp2 ;
45600 PyObject * obj0 = 0 ;
45601 PyObject * obj1 = 0 ;
45602 char * kwnames[] = {
45603 (char *) "self",(char *) "size", NULL
45604 };
45605
45606 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) SWIG_fail;
45607 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45608 if (!SWIG_IsOK(res1)) {
45609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45610 }
45611 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45612 {
45613 arg2 = &temp2;
45614 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
45615 }
45616 {
45617 PyThreadState* __tstate = wxPyBeginAllowThreads();
45618 (arg1)->SetRatio((wxSize const &)*arg2);
45619 wxPyEndAllowThreads(__tstate);
45620 if (PyErr_Occurred()) SWIG_fail;
45621 }
45622 resultobj = SWIG_Py_Void();
45623 return resultobj;
45624 fail:
45625 return NULL;
45626 }
45627
45628
45629 SWIGINTERN PyObject *_wrap_SizerItem_SetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45630 PyObject *resultobj = 0;
45631 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45632 float arg2 ;
45633 void *argp1 = 0 ;
45634 int res1 = 0 ;
45635 float val2 ;
45636 int ecode2 = 0 ;
45637 PyObject * obj0 = 0 ;
45638 PyObject * obj1 = 0 ;
45639 char * kwnames[] = {
45640 (char *) "self",(char *) "ratio", NULL
45641 };
45642
45643 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) SWIG_fail;
45644 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45645 if (!SWIG_IsOK(res1)) {
45646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45647 }
45648 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45649 ecode2 = SWIG_AsVal_float(obj1, &val2);
45650 if (!SWIG_IsOK(ecode2)) {
45651 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatio" "', expected argument " "2"" of type '" "float""'");
45652 }
45653 arg2 = static_cast< float >(val2);
45654 {
45655 PyThreadState* __tstate = wxPyBeginAllowThreads();
45656 (arg1)->SetRatio(arg2);
45657 wxPyEndAllowThreads(__tstate);
45658 if (PyErr_Occurred()) SWIG_fail;
45659 }
45660 resultobj = SWIG_Py_Void();
45661 return resultobj;
45662 fail:
45663 return NULL;
45664 }
45665
45666
45667 SWIGINTERN PyObject *_wrap_SizerItem_GetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45668 PyObject *resultobj = 0;
45669 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45670 float result;
45671 void *argp1 = 0 ;
45672 int res1 = 0 ;
45673 PyObject *swig_obj[1] ;
45674
45675 if (!args) SWIG_fail;
45676 swig_obj[0] = args;
45677 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45678 if (!SWIG_IsOK(res1)) {
45679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45680 }
45681 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45682 {
45683 PyThreadState* __tstate = wxPyBeginAllowThreads();
45684 result = (float)(arg1)->GetRatio();
45685 wxPyEndAllowThreads(__tstate);
45686 if (PyErr_Occurred()) SWIG_fail;
45687 }
45688 resultobj = SWIG_From_float(static_cast< float >(result));
45689 return resultobj;
45690 fail:
45691 return NULL;
45692 }
45693
45694
45695 SWIGINTERN PyObject *_wrap_SizerItem_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45696 PyObject *resultobj = 0;
45697 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45698 wxRect result;
45699 void *argp1 = 0 ;
45700 int res1 = 0 ;
45701 PyObject *swig_obj[1] ;
45702
45703 if (!args) SWIG_fail;
45704 swig_obj[0] = args;
45705 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45706 if (!SWIG_IsOK(res1)) {
45707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRect" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45708 }
45709 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45710 {
45711 PyThreadState* __tstate = wxPyBeginAllowThreads();
45712 result = (arg1)->GetRect();
45713 wxPyEndAllowThreads(__tstate);
45714 if (PyErr_Occurred()) SWIG_fail;
45715 }
45716 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
45717 return resultobj;
45718 fail:
45719 return NULL;
45720 }
45721
45722
45723 SWIGINTERN PyObject *_wrap_SizerItem_IsWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45724 PyObject *resultobj = 0;
45725 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45726 bool result;
45727 void *argp1 = 0 ;
45728 int res1 = 0 ;
45729 PyObject *swig_obj[1] ;
45730
45731 if (!args) SWIG_fail;
45732 swig_obj[0] = args;
45733 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45734 if (!SWIG_IsOK(res1)) {
45735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45736 }
45737 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45738 {
45739 PyThreadState* __tstate = wxPyBeginAllowThreads();
45740 result = (bool)(arg1)->IsWindow();
45741 wxPyEndAllowThreads(__tstate);
45742 if (PyErr_Occurred()) SWIG_fail;
45743 }
45744 {
45745 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45746 }
45747 return resultobj;
45748 fail:
45749 return NULL;
45750 }
45751
45752
45753 SWIGINTERN PyObject *_wrap_SizerItem_IsSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45754 PyObject *resultobj = 0;
45755 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45756 bool result;
45757 void *argp1 = 0 ;
45758 int res1 = 0 ;
45759 PyObject *swig_obj[1] ;
45760
45761 if (!args) SWIG_fail;
45762 swig_obj[0] = args;
45763 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45764 if (!SWIG_IsOK(res1)) {
45765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45766 }
45767 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45768 {
45769 PyThreadState* __tstate = wxPyBeginAllowThreads();
45770 result = (bool)(arg1)->IsSizer();
45771 wxPyEndAllowThreads(__tstate);
45772 if (PyErr_Occurred()) SWIG_fail;
45773 }
45774 {
45775 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45776 }
45777 return resultobj;
45778 fail:
45779 return NULL;
45780 }
45781
45782
45783 SWIGINTERN PyObject *_wrap_SizerItem_IsSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45784 PyObject *resultobj = 0;
45785 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45786 bool result;
45787 void *argp1 = 0 ;
45788 int res1 = 0 ;
45789 PyObject *swig_obj[1] ;
45790
45791 if (!args) SWIG_fail;
45792 swig_obj[0] = args;
45793 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45794 if (!SWIG_IsOK(res1)) {
45795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45796 }
45797 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45798 {
45799 PyThreadState* __tstate = wxPyBeginAllowThreads();
45800 result = (bool)(arg1)->IsSpacer();
45801 wxPyEndAllowThreads(__tstate);
45802 if (PyErr_Occurred()) SWIG_fail;
45803 }
45804 {
45805 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45806 }
45807 return resultobj;
45808 fail:
45809 return NULL;
45810 }
45811
45812
45813 SWIGINTERN PyObject *_wrap_SizerItem_SetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45814 PyObject *resultobj = 0;
45815 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45816 int arg2 ;
45817 void *argp1 = 0 ;
45818 int res1 = 0 ;
45819 int val2 ;
45820 int ecode2 = 0 ;
45821 PyObject * obj0 = 0 ;
45822 PyObject * obj1 = 0 ;
45823 char * kwnames[] = {
45824 (char *) "self",(char *) "proportion", NULL
45825 };
45826
45827 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) SWIG_fail;
45828 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45829 if (!SWIG_IsOK(res1)) {
45830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45831 }
45832 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45833 ecode2 = SWIG_AsVal_int(obj1, &val2);
45834 if (!SWIG_IsOK(ecode2)) {
45835 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetProportion" "', expected argument " "2"" of type '" "int""'");
45836 }
45837 arg2 = static_cast< int >(val2);
45838 {
45839 PyThreadState* __tstate = wxPyBeginAllowThreads();
45840 (arg1)->SetProportion(arg2);
45841 wxPyEndAllowThreads(__tstate);
45842 if (PyErr_Occurred()) SWIG_fail;
45843 }
45844 resultobj = SWIG_Py_Void();
45845 return resultobj;
45846 fail:
45847 return NULL;
45848 }
45849
45850
45851 SWIGINTERN PyObject *_wrap_SizerItem_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45852 PyObject *resultobj = 0;
45853 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45854 int result;
45855 void *argp1 = 0 ;
45856 int res1 = 0 ;
45857 PyObject *swig_obj[1] ;
45858
45859 if (!args) SWIG_fail;
45860 swig_obj[0] = args;
45861 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45862 if (!SWIG_IsOK(res1)) {
45863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45864 }
45865 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45866 {
45867 PyThreadState* __tstate = wxPyBeginAllowThreads();
45868 result = (int)(arg1)->GetProportion();
45869 wxPyEndAllowThreads(__tstate);
45870 if (PyErr_Occurred()) SWIG_fail;
45871 }
45872 resultobj = SWIG_From_int(static_cast< int >(result));
45873 return resultobj;
45874 fail:
45875 return NULL;
45876 }
45877
45878
45879 SWIGINTERN PyObject *_wrap_SizerItem_SetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45880 PyObject *resultobj = 0;
45881 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45882 int arg2 ;
45883 void *argp1 = 0 ;
45884 int res1 = 0 ;
45885 int val2 ;
45886 int ecode2 = 0 ;
45887 PyObject * obj0 = 0 ;
45888 PyObject * obj1 = 0 ;
45889 char * kwnames[] = {
45890 (char *) "self",(char *) "flag", NULL
45891 };
45892
45893 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) SWIG_fail;
45894 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45895 if (!SWIG_IsOK(res1)) {
45896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45897 }
45898 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45899 ecode2 = SWIG_AsVal_int(obj1, &val2);
45900 if (!SWIG_IsOK(ecode2)) {
45901 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetFlag" "', expected argument " "2"" of type '" "int""'");
45902 }
45903 arg2 = static_cast< int >(val2);
45904 {
45905 PyThreadState* __tstate = wxPyBeginAllowThreads();
45906 (arg1)->SetFlag(arg2);
45907 wxPyEndAllowThreads(__tstate);
45908 if (PyErr_Occurred()) SWIG_fail;
45909 }
45910 resultobj = SWIG_Py_Void();
45911 return resultobj;
45912 fail:
45913 return NULL;
45914 }
45915
45916
45917 SWIGINTERN PyObject *_wrap_SizerItem_GetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45918 PyObject *resultobj = 0;
45919 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45920 int result;
45921 void *argp1 = 0 ;
45922 int res1 = 0 ;
45923 PyObject *swig_obj[1] ;
45924
45925 if (!args) SWIG_fail;
45926 swig_obj[0] = args;
45927 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45928 if (!SWIG_IsOK(res1)) {
45929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45930 }
45931 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45932 {
45933 PyThreadState* __tstate = wxPyBeginAllowThreads();
45934 result = (int)(arg1)->GetFlag();
45935 wxPyEndAllowThreads(__tstate);
45936 if (PyErr_Occurred()) SWIG_fail;
45937 }
45938 resultobj = SWIG_From_int(static_cast< int >(result));
45939 return resultobj;
45940 fail:
45941 return NULL;
45942 }
45943
45944
45945 SWIGINTERN PyObject *_wrap_SizerItem_SetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45946 PyObject *resultobj = 0;
45947 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45948 int arg2 ;
45949 void *argp1 = 0 ;
45950 int res1 = 0 ;
45951 int val2 ;
45952 int ecode2 = 0 ;
45953 PyObject * obj0 = 0 ;
45954 PyObject * obj1 = 0 ;
45955 char * kwnames[] = {
45956 (char *) "self",(char *) "border", NULL
45957 };
45958
45959 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) SWIG_fail;
45960 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45961 if (!SWIG_IsOK(res1)) {
45962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45963 }
45964 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45965 ecode2 = SWIG_AsVal_int(obj1, &val2);
45966 if (!SWIG_IsOK(ecode2)) {
45967 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetBorder" "', expected argument " "2"" of type '" "int""'");
45968 }
45969 arg2 = static_cast< int >(val2);
45970 {
45971 PyThreadState* __tstate = wxPyBeginAllowThreads();
45972 (arg1)->SetBorder(arg2);
45973 wxPyEndAllowThreads(__tstate);
45974 if (PyErr_Occurred()) SWIG_fail;
45975 }
45976 resultobj = SWIG_Py_Void();
45977 return resultobj;
45978 fail:
45979 return NULL;
45980 }
45981
45982
45983 SWIGINTERN PyObject *_wrap_SizerItem_GetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45984 PyObject *resultobj = 0;
45985 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45986 int result;
45987 void *argp1 = 0 ;
45988 int res1 = 0 ;
45989 PyObject *swig_obj[1] ;
45990
45991 if (!args) SWIG_fail;
45992 swig_obj[0] = args;
45993 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45994 if (!SWIG_IsOK(res1)) {
45995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45996 }
45997 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45998 {
45999 PyThreadState* __tstate = wxPyBeginAllowThreads();
46000 result = (int)(arg1)->GetBorder();
46001 wxPyEndAllowThreads(__tstate);
46002 if (PyErr_Occurred()) SWIG_fail;
46003 }
46004 resultobj = SWIG_From_int(static_cast< int >(result));
46005 return resultobj;
46006 fail:
46007 return NULL;
46008 }
46009
46010
46011 SWIGINTERN PyObject *_wrap_SizerItem_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46012 PyObject *resultobj = 0;
46013 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46014 wxWindow *result = 0 ;
46015 void *argp1 = 0 ;
46016 int res1 = 0 ;
46017 PyObject *swig_obj[1] ;
46018
46019 if (!args) SWIG_fail;
46020 swig_obj[0] = args;
46021 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46022 if (!SWIG_IsOK(res1)) {
46023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46024 }
46025 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46026 {
46027 PyThreadState* __tstate = wxPyBeginAllowThreads();
46028 result = (wxWindow *)(arg1)->GetWindow();
46029 wxPyEndAllowThreads(__tstate);
46030 if (PyErr_Occurred()) SWIG_fail;
46031 }
46032 {
46033 resultobj = wxPyMake_wxObject(result, 0);
46034 }
46035 return resultobj;
46036 fail:
46037 return NULL;
46038 }
46039
46040
46041 SWIGINTERN PyObject *_wrap_SizerItem_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46042 PyObject *resultobj = 0;
46043 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46044 wxWindow *arg2 = (wxWindow *) 0 ;
46045 void *argp1 = 0 ;
46046 int res1 = 0 ;
46047 void *argp2 = 0 ;
46048 int res2 = 0 ;
46049 PyObject * obj0 = 0 ;
46050 PyObject * obj1 = 0 ;
46051 char * kwnames[] = {
46052 (char *) "self",(char *) "window", NULL
46053 };
46054
46055 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
46056 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46057 if (!SWIG_IsOK(res1)) {
46058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46059 }
46060 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46061 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
46062 if (!SWIG_IsOK(res2)) {
46063 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
46064 }
46065 arg2 = reinterpret_cast< wxWindow * >(argp2);
46066 {
46067 PyThreadState* __tstate = wxPyBeginAllowThreads();
46068 (arg1)->SetWindow(arg2);
46069 wxPyEndAllowThreads(__tstate);
46070 if (PyErr_Occurred()) SWIG_fail;
46071 }
46072 resultobj = SWIG_Py_Void();
46073 return resultobj;
46074 fail:
46075 return NULL;
46076 }
46077
46078
46079 SWIGINTERN PyObject *_wrap_SizerItem_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46080 PyObject *resultobj = 0;
46081 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46082 wxSizer *result = 0 ;
46083 void *argp1 = 0 ;
46084 int res1 = 0 ;
46085 PyObject *swig_obj[1] ;
46086
46087 if (!args) SWIG_fail;
46088 swig_obj[0] = args;
46089 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46090 if (!SWIG_IsOK(res1)) {
46091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46092 }
46093 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46094 {
46095 PyThreadState* __tstate = wxPyBeginAllowThreads();
46096 result = (wxSizer *)(arg1)->GetSizer();
46097 wxPyEndAllowThreads(__tstate);
46098 if (PyErr_Occurred()) SWIG_fail;
46099 }
46100 {
46101 resultobj = wxPyMake_wxObject(result, (bool)0);
46102 }
46103 return resultobj;
46104 fail:
46105 return NULL;
46106 }
46107
46108
46109 SWIGINTERN PyObject *_wrap_SizerItem_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46110 PyObject *resultobj = 0;
46111 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46112 wxSizer *arg2 = (wxSizer *) 0 ;
46113 void *argp1 = 0 ;
46114 int res1 = 0 ;
46115 int res2 = 0 ;
46116 PyObject * obj0 = 0 ;
46117 PyObject * obj1 = 0 ;
46118 char * kwnames[] = {
46119 (char *) "self",(char *) "sizer", NULL
46120 };
46121
46122 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) SWIG_fail;
46123 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46124 if (!SWIG_IsOK(res1)) {
46125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46126 }
46127 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46128 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
46129 if (!SWIG_IsOK(res2)) {
46130 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
46131 }
46132 {
46133 PyThreadState* __tstate = wxPyBeginAllowThreads();
46134 (arg1)->SetSizer(arg2);
46135 wxPyEndAllowThreads(__tstate);
46136 if (PyErr_Occurred()) SWIG_fail;
46137 }
46138 resultobj = SWIG_Py_Void();
46139 return resultobj;
46140 fail:
46141 return NULL;
46142 }
46143
46144
46145 SWIGINTERN PyObject *_wrap_SizerItem_GetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46146 PyObject *resultobj = 0;
46147 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46148 wxSize *result = 0 ;
46149 void *argp1 = 0 ;
46150 int res1 = 0 ;
46151 PyObject *swig_obj[1] ;
46152
46153 if (!args) SWIG_fail;
46154 swig_obj[0] = args;
46155 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46156 if (!SWIG_IsOK(res1)) {
46157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46158 }
46159 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46160 {
46161 PyThreadState* __tstate = wxPyBeginAllowThreads();
46162 {
46163 wxSize const &_result_ref = (arg1)->GetSpacer();
46164 result = (wxSize *) &_result_ref;
46165 }
46166 wxPyEndAllowThreads(__tstate);
46167 if (PyErr_Occurred()) SWIG_fail;
46168 }
46169 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
46170 return resultobj;
46171 fail:
46172 return NULL;
46173 }
46174
46175
46176 SWIGINTERN PyObject *_wrap_SizerItem_SetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46177 PyObject *resultobj = 0;
46178 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46179 wxSize *arg2 = 0 ;
46180 void *argp1 = 0 ;
46181 int res1 = 0 ;
46182 wxSize temp2 ;
46183 PyObject * obj0 = 0 ;
46184 PyObject * obj1 = 0 ;
46185 char * kwnames[] = {
46186 (char *) "self",(char *) "size", NULL
46187 };
46188
46189 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) SWIG_fail;
46190 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46191 if (!SWIG_IsOK(res1)) {
46192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46193 }
46194 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46195 {
46196 arg2 = &temp2;
46197 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
46198 }
46199 {
46200 PyThreadState* __tstate = wxPyBeginAllowThreads();
46201 (arg1)->SetSpacer((wxSize const &)*arg2);
46202 wxPyEndAllowThreads(__tstate);
46203 if (PyErr_Occurred()) SWIG_fail;
46204 }
46205 resultobj = SWIG_Py_Void();
46206 return resultobj;
46207 fail:
46208 return NULL;
46209 }
46210
46211
46212 SWIGINTERN PyObject *_wrap_SizerItem_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46213 PyObject *resultobj = 0;
46214 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46215 bool arg2 ;
46216 void *argp1 = 0 ;
46217 int res1 = 0 ;
46218 bool val2 ;
46219 int ecode2 = 0 ;
46220 PyObject * obj0 = 0 ;
46221 PyObject * obj1 = 0 ;
46222 char * kwnames[] = {
46223 (char *) "self",(char *) "show", NULL
46224 };
46225
46226 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) SWIG_fail;
46227 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46228 if (!SWIG_IsOK(res1)) {
46229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_Show" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46230 }
46231 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46232 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46233 if (!SWIG_IsOK(ecode2)) {
46234 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_Show" "', expected argument " "2"" of type '" "bool""'");
46235 }
46236 arg2 = static_cast< bool >(val2);
46237 {
46238 PyThreadState* __tstate = wxPyBeginAllowThreads();
46239 (arg1)->Show(arg2);
46240 wxPyEndAllowThreads(__tstate);
46241 if (PyErr_Occurred()) SWIG_fail;
46242 }
46243 resultobj = SWIG_Py_Void();
46244 return resultobj;
46245 fail:
46246 return NULL;
46247 }
46248
46249
46250 SWIGINTERN PyObject *_wrap_SizerItem_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46251 PyObject *resultobj = 0;
46252 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46253 bool result;
46254 void *argp1 = 0 ;
46255 int res1 = 0 ;
46256 PyObject *swig_obj[1] ;
46257
46258 if (!args) SWIG_fail;
46259 swig_obj[0] = args;
46260 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46261 if (!SWIG_IsOK(res1)) {
46262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsShown" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46263 }
46264 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46265 {
46266 PyThreadState* __tstate = wxPyBeginAllowThreads();
46267 result = (bool)(arg1)->IsShown();
46268 wxPyEndAllowThreads(__tstate);
46269 if (PyErr_Occurred()) SWIG_fail;
46270 }
46271 {
46272 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46273 }
46274 return resultobj;
46275 fail:
46276 return NULL;
46277 }
46278
46279
46280 SWIGINTERN PyObject *_wrap_SizerItem_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46281 PyObject *resultobj = 0;
46282 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46283 wxPoint result;
46284 void *argp1 = 0 ;
46285 int res1 = 0 ;
46286 PyObject *swig_obj[1] ;
46287
46288 if (!args) SWIG_fail;
46289 swig_obj[0] = args;
46290 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46291 if (!SWIG_IsOK(res1)) {
46292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetPosition" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46293 }
46294 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46295 {
46296 PyThreadState* __tstate = wxPyBeginAllowThreads();
46297 result = (arg1)->GetPosition();
46298 wxPyEndAllowThreads(__tstate);
46299 if (PyErr_Occurred()) SWIG_fail;
46300 }
46301 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
46302 return resultobj;
46303 fail:
46304 return NULL;
46305 }
46306
46307
46308 SWIGINTERN PyObject *_wrap_SizerItem_GetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46309 PyObject *resultobj = 0;
46310 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46311 PyObject *result = 0 ;
46312 void *argp1 = 0 ;
46313 int res1 = 0 ;
46314 PyObject *swig_obj[1] ;
46315
46316 if (!args) SWIG_fail;
46317 swig_obj[0] = args;
46318 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46319 if (!SWIG_IsOK(res1)) {
46320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46321 }
46322 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46323 {
46324 PyThreadState* __tstate = wxPyBeginAllowThreads();
46325 result = (PyObject *)wxSizerItem_GetUserData(arg1);
46326 wxPyEndAllowThreads(__tstate);
46327 if (PyErr_Occurred()) SWIG_fail;
46328 }
46329 resultobj = result;
46330 return resultobj;
46331 fail:
46332 return NULL;
46333 }
46334
46335
46336 SWIGINTERN PyObject *_wrap_SizerItem_SetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46337 PyObject *resultobj = 0;
46338 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46339 PyObject *arg2 = (PyObject *) 0 ;
46340 void *argp1 = 0 ;
46341 int res1 = 0 ;
46342 PyObject * obj0 = 0 ;
46343 PyObject * obj1 = 0 ;
46344 char * kwnames[] = {
46345 (char *) "self",(char *) "userData", NULL
46346 };
46347
46348 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetUserData",kwnames,&obj0,&obj1)) SWIG_fail;
46349 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46350 if (!SWIG_IsOK(res1)) {
46351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46352 }
46353 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46354 arg2 = obj1;
46355 {
46356 PyThreadState* __tstate = wxPyBeginAllowThreads();
46357 wxSizerItem_SetUserData(arg1,arg2);
46358 wxPyEndAllowThreads(__tstate);
46359 if (PyErr_Occurred()) SWIG_fail;
46360 }
46361 resultobj = SWIG_Py_Void();
46362 return resultobj;
46363 fail:
46364 return NULL;
46365 }
46366
46367
46368 SWIGINTERN PyObject *SizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46369 PyObject *obj;
46370 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
46371 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerItem, SWIG_NewClientData(obj));
46372 return SWIG_Py_Void();
46373 }
46374
46375 SWIGINTERN PyObject *SizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46376 return SWIG_Python_InitShadowInstance(args);
46377 }
46378
46379 SWIGINTERN PyObject *_wrap_delete_Sizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46380 PyObject *resultobj = 0;
46381 wxSizer *arg1 = (wxSizer *) 0 ;
46382 void *argp1 = 0 ;
46383 int res1 = 0 ;
46384 PyObject *swig_obj[1] ;
46385
46386 if (!args) SWIG_fail;
46387 swig_obj[0] = args;
46388 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
46389 if (!SWIG_IsOK(res1)) {
46390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sizer" "', expected argument " "1"" of type '" "wxSizer *""'");
46391 }
46392 arg1 = reinterpret_cast< wxSizer * >(argp1);
46393 {
46394 PyThreadState* __tstate = wxPyBeginAllowThreads();
46395 delete arg1;
46396
46397 wxPyEndAllowThreads(__tstate);
46398 if (PyErr_Occurred()) SWIG_fail;
46399 }
46400 resultobj = SWIG_Py_Void();
46401 return resultobj;
46402 fail:
46403 return NULL;
46404 }
46405
46406
46407 SWIGINTERN PyObject *_wrap_Sizer__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46408 PyObject *resultobj = 0;
46409 wxSizer *arg1 = (wxSizer *) 0 ;
46410 PyObject *arg2 = (PyObject *) 0 ;
46411 void *argp1 = 0 ;
46412 int res1 = 0 ;
46413 PyObject * obj0 = 0 ;
46414 PyObject * obj1 = 0 ;
46415 char * kwnames[] = {
46416 (char *) "self",(char *) "_self", NULL
46417 };
46418
46419 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
46420 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46421 if (!SWIG_IsOK(res1)) {
46422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__setOORInfo" "', expected argument " "1"" of type '" "wxSizer *""'");
46423 }
46424 arg1 = reinterpret_cast< wxSizer * >(argp1);
46425 arg2 = obj1;
46426 {
46427 PyThreadState* __tstate = wxPyBeginAllowThreads();
46428 wxSizer__setOORInfo(arg1,arg2);
46429 wxPyEndAllowThreads(__tstate);
46430 if (PyErr_Occurred()) SWIG_fail;
46431 }
46432 resultobj = SWIG_Py_Void();
46433 return resultobj;
46434 fail:
46435 return NULL;
46436 }
46437
46438
46439 SWIGINTERN PyObject *_wrap_Sizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46440 PyObject *resultobj = 0;
46441 wxSizer *arg1 = (wxSizer *) 0 ;
46442 PyObject *arg2 = (PyObject *) 0 ;
46443 int arg3 = (int) 0 ;
46444 int arg4 = (int) 0 ;
46445 int arg5 = (int) 0 ;
46446 PyObject *arg6 = (PyObject *) NULL ;
46447 wxSizerItem *result = 0 ;
46448 void *argp1 = 0 ;
46449 int res1 = 0 ;
46450 int val3 ;
46451 int ecode3 = 0 ;
46452 int val4 ;
46453 int ecode4 = 0 ;
46454 int val5 ;
46455 int ecode5 = 0 ;
46456 PyObject * obj0 = 0 ;
46457 PyObject * obj1 = 0 ;
46458 PyObject * obj2 = 0 ;
46459 PyObject * obj3 = 0 ;
46460 PyObject * obj4 = 0 ;
46461 PyObject * obj5 = 0 ;
46462 char * kwnames[] = {
46463 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46464 };
46465
46466 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
46467 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46468 if (!SWIG_IsOK(res1)) {
46469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Add" "', expected argument " "1"" of type '" "wxSizer *""'");
46470 }
46471 arg1 = reinterpret_cast< wxSizer * >(argp1);
46472 arg2 = obj1;
46473 if (obj2) {
46474 ecode3 = SWIG_AsVal_int(obj2, &val3);
46475 if (!SWIG_IsOK(ecode3)) {
46476 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Add" "', expected argument " "3"" of type '" "int""'");
46477 }
46478 arg3 = static_cast< int >(val3);
46479 }
46480 if (obj3) {
46481 ecode4 = SWIG_AsVal_int(obj3, &val4);
46482 if (!SWIG_IsOK(ecode4)) {
46483 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Add" "', expected argument " "4"" of type '" "int""'");
46484 }
46485 arg4 = static_cast< int >(val4);
46486 }
46487 if (obj4) {
46488 ecode5 = SWIG_AsVal_int(obj4, &val5);
46489 if (!SWIG_IsOK(ecode5)) {
46490 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Add" "', expected argument " "5"" of type '" "int""'");
46491 }
46492 arg5 = static_cast< int >(val5);
46493 }
46494 if (obj5) {
46495 arg6 = obj5;
46496 }
46497 {
46498 PyThreadState* __tstate = wxPyBeginAllowThreads();
46499 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
46500 wxPyEndAllowThreads(__tstate);
46501 if (PyErr_Occurred()) SWIG_fail;
46502 }
46503 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46504 return resultobj;
46505 fail:
46506 return NULL;
46507 }
46508
46509
46510 SWIGINTERN PyObject *_wrap_Sizer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46511 PyObject *resultobj = 0;
46512 wxSizer *arg1 = (wxSizer *) 0 ;
46513 int arg2 ;
46514 PyObject *arg3 = (PyObject *) 0 ;
46515 int arg4 = (int) 0 ;
46516 int arg5 = (int) 0 ;
46517 int arg6 = (int) 0 ;
46518 PyObject *arg7 = (PyObject *) NULL ;
46519 wxSizerItem *result = 0 ;
46520 void *argp1 = 0 ;
46521 int res1 = 0 ;
46522 int val2 ;
46523 int ecode2 = 0 ;
46524 int val4 ;
46525 int ecode4 = 0 ;
46526 int val5 ;
46527 int ecode5 = 0 ;
46528 int val6 ;
46529 int ecode6 = 0 ;
46530 PyObject * obj0 = 0 ;
46531 PyObject * obj1 = 0 ;
46532 PyObject * obj2 = 0 ;
46533 PyObject * obj3 = 0 ;
46534 PyObject * obj4 = 0 ;
46535 PyObject * obj5 = 0 ;
46536 PyObject * obj6 = 0 ;
46537 char * kwnames[] = {
46538 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46539 };
46540
46541 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
46542 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46543 if (!SWIG_IsOK(res1)) {
46544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Insert" "', expected argument " "1"" of type '" "wxSizer *""'");
46545 }
46546 arg1 = reinterpret_cast< wxSizer * >(argp1);
46547 ecode2 = SWIG_AsVal_int(obj1, &val2);
46548 if (!SWIG_IsOK(ecode2)) {
46549 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Insert" "', expected argument " "2"" of type '" "int""'");
46550 }
46551 arg2 = static_cast< int >(val2);
46552 arg3 = obj2;
46553 if (obj3) {
46554 ecode4 = SWIG_AsVal_int(obj3, &val4);
46555 if (!SWIG_IsOK(ecode4)) {
46556 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Insert" "', expected argument " "4"" of type '" "int""'");
46557 }
46558 arg4 = static_cast< int >(val4);
46559 }
46560 if (obj4) {
46561 ecode5 = SWIG_AsVal_int(obj4, &val5);
46562 if (!SWIG_IsOK(ecode5)) {
46563 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Insert" "', expected argument " "5"" of type '" "int""'");
46564 }
46565 arg5 = static_cast< int >(val5);
46566 }
46567 if (obj5) {
46568 ecode6 = SWIG_AsVal_int(obj5, &val6);
46569 if (!SWIG_IsOK(ecode6)) {
46570 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Sizer_Insert" "', expected argument " "6"" of type '" "int""'");
46571 }
46572 arg6 = static_cast< int >(val6);
46573 }
46574 if (obj6) {
46575 arg7 = obj6;
46576 }
46577 {
46578 PyThreadState* __tstate = wxPyBeginAllowThreads();
46579 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
46580 wxPyEndAllowThreads(__tstate);
46581 if (PyErr_Occurred()) SWIG_fail;
46582 }
46583 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46584 return resultobj;
46585 fail:
46586 return NULL;
46587 }
46588
46589
46590 SWIGINTERN PyObject *_wrap_Sizer_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46591 PyObject *resultobj = 0;
46592 wxSizer *arg1 = (wxSizer *) 0 ;
46593 PyObject *arg2 = (PyObject *) 0 ;
46594 int arg3 = (int) 0 ;
46595 int arg4 = (int) 0 ;
46596 int arg5 = (int) 0 ;
46597 PyObject *arg6 = (PyObject *) NULL ;
46598 wxSizerItem *result = 0 ;
46599 void *argp1 = 0 ;
46600 int res1 = 0 ;
46601 int val3 ;
46602 int ecode3 = 0 ;
46603 int val4 ;
46604 int ecode4 = 0 ;
46605 int val5 ;
46606 int ecode5 = 0 ;
46607 PyObject * obj0 = 0 ;
46608 PyObject * obj1 = 0 ;
46609 PyObject * obj2 = 0 ;
46610 PyObject * obj3 = 0 ;
46611 PyObject * obj4 = 0 ;
46612 PyObject * obj5 = 0 ;
46613 char * kwnames[] = {
46614 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46615 };
46616
46617 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
46618 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46619 if (!SWIG_IsOK(res1)) {
46620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Prepend" "', expected argument " "1"" of type '" "wxSizer *""'");
46621 }
46622 arg1 = reinterpret_cast< wxSizer * >(argp1);
46623 arg2 = obj1;
46624 if (obj2) {
46625 ecode3 = SWIG_AsVal_int(obj2, &val3);
46626 if (!SWIG_IsOK(ecode3)) {
46627 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Prepend" "', expected argument " "3"" of type '" "int""'");
46628 }
46629 arg3 = static_cast< int >(val3);
46630 }
46631 if (obj3) {
46632 ecode4 = SWIG_AsVal_int(obj3, &val4);
46633 if (!SWIG_IsOK(ecode4)) {
46634 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Prepend" "', expected argument " "4"" of type '" "int""'");
46635 }
46636 arg4 = static_cast< int >(val4);
46637 }
46638 if (obj4) {
46639 ecode5 = SWIG_AsVal_int(obj4, &val5);
46640 if (!SWIG_IsOK(ecode5)) {
46641 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Prepend" "', expected argument " "5"" of type '" "int""'");
46642 }
46643 arg5 = static_cast< int >(val5);
46644 }
46645 if (obj5) {
46646 arg6 = obj5;
46647 }
46648 {
46649 PyThreadState* __tstate = wxPyBeginAllowThreads();
46650 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
46651 wxPyEndAllowThreads(__tstate);
46652 if (PyErr_Occurred()) SWIG_fail;
46653 }
46654 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46655 return resultobj;
46656 fail:
46657 return NULL;
46658 }
46659
46660
46661 SWIGINTERN PyObject *_wrap_Sizer_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46662 PyObject *resultobj = 0;
46663 wxSizer *arg1 = (wxSizer *) 0 ;
46664 PyObject *arg2 = (PyObject *) 0 ;
46665 bool result;
46666 void *argp1 = 0 ;
46667 int res1 = 0 ;
46668 PyObject * obj0 = 0 ;
46669 PyObject * obj1 = 0 ;
46670 char * kwnames[] = {
46671 (char *) "self",(char *) "item", NULL
46672 };
46673
46674 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
46675 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46676 if (!SWIG_IsOK(res1)) {
46677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Remove" "', expected argument " "1"" of type '" "wxSizer *""'");
46678 }
46679 arg1 = reinterpret_cast< wxSizer * >(argp1);
46680 arg2 = obj1;
46681 {
46682 PyThreadState* __tstate = wxPyBeginAllowThreads();
46683 result = (bool)wxSizer_Remove(arg1,arg2);
46684 wxPyEndAllowThreads(__tstate);
46685 if (PyErr_Occurred()) SWIG_fail;
46686 }
46687 {
46688 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46689 }
46690 return resultobj;
46691 fail:
46692 return NULL;
46693 }
46694
46695
46696 SWIGINTERN PyObject *_wrap_Sizer_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46697 PyObject *resultobj = 0;
46698 wxSizer *arg1 = (wxSizer *) 0 ;
46699 PyObject *arg2 = (PyObject *) 0 ;
46700 bool result;
46701 void *argp1 = 0 ;
46702 int res1 = 0 ;
46703 PyObject * obj0 = 0 ;
46704 PyObject * obj1 = 0 ;
46705 char * kwnames[] = {
46706 (char *) "self",(char *) "item", NULL
46707 };
46708
46709 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) SWIG_fail;
46710 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46711 if (!SWIG_IsOK(res1)) {
46712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Detach" "', expected argument " "1"" of type '" "wxSizer *""'");
46713 }
46714 arg1 = reinterpret_cast< wxSizer * >(argp1);
46715 arg2 = obj1;
46716 {
46717 PyThreadState* __tstate = wxPyBeginAllowThreads();
46718 result = (bool)wxSizer_Detach(arg1,arg2);
46719 wxPyEndAllowThreads(__tstate);
46720 if (PyErr_Occurred()) SWIG_fail;
46721 }
46722 {
46723 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46724 }
46725 return resultobj;
46726 fail:
46727 return NULL;
46728 }
46729
46730
46731 SWIGINTERN PyObject *_wrap_Sizer_GetItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46732 PyObject *resultobj = 0;
46733 wxSizer *arg1 = (wxSizer *) 0 ;
46734 PyObject *arg2 = (PyObject *) 0 ;
46735 wxSizerItem *result = 0 ;
46736 void *argp1 = 0 ;
46737 int res1 = 0 ;
46738 PyObject * obj0 = 0 ;
46739 PyObject * obj1 = 0 ;
46740 char * kwnames[] = {
46741 (char *) "self",(char *) "item", NULL
46742 };
46743
46744 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) SWIG_fail;
46745 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46746 if (!SWIG_IsOK(res1)) {
46747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46748 }
46749 arg1 = reinterpret_cast< wxSizer * >(argp1);
46750 arg2 = obj1;
46751 {
46752 PyThreadState* __tstate = wxPyBeginAllowThreads();
46753 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
46754 wxPyEndAllowThreads(__tstate);
46755 if (PyErr_Occurred()) SWIG_fail;
46756 }
46757 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46758 return resultobj;
46759 fail:
46760 return NULL;
46761 }
46762
46763
46764 SWIGINTERN PyObject *_wrap_Sizer__SetItemMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46765 PyObject *resultobj = 0;
46766 wxSizer *arg1 = (wxSizer *) 0 ;
46767 PyObject *arg2 = (PyObject *) 0 ;
46768 wxSize *arg3 = 0 ;
46769 void *argp1 = 0 ;
46770 int res1 = 0 ;
46771 wxSize temp3 ;
46772 PyObject * obj0 = 0 ;
46773 PyObject * obj1 = 0 ;
46774 PyObject * obj2 = 0 ;
46775 char * kwnames[] = {
46776 (char *) "self",(char *) "item",(char *) "size", NULL
46777 };
46778
46779 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46780 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46781 if (!SWIG_IsOK(res1)) {
46782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__SetItemMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46783 }
46784 arg1 = reinterpret_cast< wxSizer * >(argp1);
46785 arg2 = obj1;
46786 {
46787 arg3 = &temp3;
46788 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
46789 }
46790 {
46791 PyThreadState* __tstate = wxPyBeginAllowThreads();
46792 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
46793 wxPyEndAllowThreads(__tstate);
46794 if (PyErr_Occurred()) SWIG_fail;
46795 }
46796 resultobj = SWIG_Py_Void();
46797 return resultobj;
46798 fail:
46799 return NULL;
46800 }
46801
46802
46803 SWIGINTERN PyObject *_wrap_Sizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46804 PyObject *resultobj = 0;
46805 wxSizer *arg1 = (wxSizer *) 0 ;
46806 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
46807 wxSizerItem *result = 0 ;
46808 void *argp1 = 0 ;
46809 int res1 = 0 ;
46810 int res2 = 0 ;
46811 PyObject * obj0 = 0 ;
46812 PyObject * obj1 = 0 ;
46813 char * kwnames[] = {
46814 (char *) "self",(char *) "item", NULL
46815 };
46816
46817 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
46818 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46819 if (!SWIG_IsOK(res1)) {
46820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46821 }
46822 arg1 = reinterpret_cast< wxSizer * >(argp1);
46823 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46824 if (!SWIG_IsOK(res2)) {
46825 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_AddItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
46826 }
46827 {
46828 PyThreadState* __tstate = wxPyBeginAllowThreads();
46829 result = (wxSizerItem *)(arg1)->Add(arg2);
46830 wxPyEndAllowThreads(__tstate);
46831 if (PyErr_Occurred()) SWIG_fail;
46832 }
46833 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46834 return resultobj;
46835 fail:
46836 return NULL;
46837 }
46838
46839
46840 SWIGINTERN PyObject *_wrap_Sizer_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46841 PyObject *resultobj = 0;
46842 wxSizer *arg1 = (wxSizer *) 0 ;
46843 size_t arg2 ;
46844 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
46845 wxSizerItem *result = 0 ;
46846 void *argp1 = 0 ;
46847 int res1 = 0 ;
46848 size_t val2 ;
46849 int ecode2 = 0 ;
46850 int res3 = 0 ;
46851 PyObject * obj0 = 0 ;
46852 PyObject * obj1 = 0 ;
46853 PyObject * obj2 = 0 ;
46854 char * kwnames[] = {
46855 (char *) "self",(char *) "index",(char *) "item", NULL
46856 };
46857
46858 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46859 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46860 if (!SWIG_IsOK(res1)) {
46861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_InsertItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46862 }
46863 arg1 = reinterpret_cast< wxSizer * >(argp1);
46864 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
46865 if (!SWIG_IsOK(ecode2)) {
46866 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
46867 }
46868 arg2 = static_cast< size_t >(val2);
46869 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46870 if (!SWIG_IsOK(res3)) {
46871 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_InsertItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
46872 }
46873 {
46874 PyThreadState* __tstate = wxPyBeginAllowThreads();
46875 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
46876 wxPyEndAllowThreads(__tstate);
46877 if (PyErr_Occurred()) SWIG_fail;
46878 }
46879 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46880 return resultobj;
46881 fail:
46882 return NULL;
46883 }
46884
46885
46886 SWIGINTERN PyObject *_wrap_Sizer_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46887 PyObject *resultobj = 0;
46888 wxSizer *arg1 = (wxSizer *) 0 ;
46889 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
46890 wxSizerItem *result = 0 ;
46891 void *argp1 = 0 ;
46892 int res1 = 0 ;
46893 int res2 = 0 ;
46894 PyObject * obj0 = 0 ;
46895 PyObject * obj1 = 0 ;
46896 char * kwnames[] = {
46897 (char *) "self",(char *) "item", NULL
46898 };
46899
46900 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",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_PrependItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46904 }
46905 arg1 = reinterpret_cast< wxSizer * >(argp1);
46906 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46907 if (!SWIG_IsOK(res2)) {
46908 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_PrependItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
46909 }
46910 {
46911 PyThreadState* __tstate = wxPyBeginAllowThreads();
46912 result = (wxSizerItem *)(arg1)->Prepend(arg2);
46913 wxPyEndAllowThreads(__tstate);
46914 if (PyErr_Occurred()) SWIG_fail;
46915 }
46916 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46917 return resultobj;
46918 fail:
46919 return NULL;
46920 }
46921
46922
46923 SWIGINTERN PyObject *_wrap_Sizer_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46924 PyObject *resultobj = 0;
46925 wxSizer *arg1 = (wxSizer *) 0 ;
46926 int arg2 ;
46927 int arg3 ;
46928 int arg4 ;
46929 int arg5 ;
46930 void *argp1 = 0 ;
46931 int res1 = 0 ;
46932 int val2 ;
46933 int ecode2 = 0 ;
46934 int val3 ;
46935 int ecode3 = 0 ;
46936 int val4 ;
46937 int ecode4 = 0 ;
46938 int val5 ;
46939 int ecode5 = 0 ;
46940 PyObject * obj0 = 0 ;
46941 PyObject * obj1 = 0 ;
46942 PyObject * obj2 = 0 ;
46943 PyObject * obj3 = 0 ;
46944 PyObject * obj4 = 0 ;
46945 char * kwnames[] = {
46946 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
46947 };
46948
46949 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
46950 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46951 if (!SWIG_IsOK(res1)) {
46952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetDimension" "', expected argument " "1"" of type '" "wxSizer *""'");
46953 }
46954 arg1 = reinterpret_cast< wxSizer * >(argp1);
46955 ecode2 = SWIG_AsVal_int(obj1, &val2);
46956 if (!SWIG_IsOK(ecode2)) {
46957 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_SetDimension" "', expected argument " "2"" of type '" "int""'");
46958 }
46959 arg2 = static_cast< int >(val2);
46960 ecode3 = SWIG_AsVal_int(obj2, &val3);
46961 if (!SWIG_IsOK(ecode3)) {
46962 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_SetDimension" "', expected argument " "3"" of type '" "int""'");
46963 }
46964 arg3 = static_cast< int >(val3);
46965 ecode4 = SWIG_AsVal_int(obj3, &val4);
46966 if (!SWIG_IsOK(ecode4)) {
46967 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_SetDimension" "', expected argument " "4"" of type '" "int""'");
46968 }
46969 arg4 = static_cast< int >(val4);
46970 ecode5 = SWIG_AsVal_int(obj4, &val5);
46971 if (!SWIG_IsOK(ecode5)) {
46972 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_SetDimension" "', expected argument " "5"" of type '" "int""'");
46973 }
46974 arg5 = static_cast< int >(val5);
46975 {
46976 PyThreadState* __tstate = wxPyBeginAllowThreads();
46977 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
46978 wxPyEndAllowThreads(__tstate);
46979 if (PyErr_Occurred()) SWIG_fail;
46980 }
46981 resultobj = SWIG_Py_Void();
46982 return resultobj;
46983 fail:
46984 return NULL;
46985 }
46986
46987
46988 SWIGINTERN PyObject *_wrap_Sizer_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46989 PyObject *resultobj = 0;
46990 wxSizer *arg1 = (wxSizer *) 0 ;
46991 wxSize *arg2 = 0 ;
46992 void *argp1 = 0 ;
46993 int res1 = 0 ;
46994 wxSize temp2 ;
46995 PyObject * obj0 = 0 ;
46996 PyObject * obj1 = 0 ;
46997 char * kwnames[] = {
46998 (char *) "self",(char *) "size", NULL
46999 };
47000
47001 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
47002 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47003 if (!SWIG_IsOK(res1)) {
47004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
47005 }
47006 arg1 = reinterpret_cast< wxSizer * >(argp1);
47007 {
47008 arg2 = &temp2;
47009 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
47010 }
47011 {
47012 PyThreadState* __tstate = wxPyBeginAllowThreads();
47013 (arg1)->SetMinSize((wxSize const &)*arg2);
47014 wxPyEndAllowThreads(__tstate);
47015 if (PyErr_Occurred()) SWIG_fail;
47016 }
47017 resultobj = SWIG_Py_Void();
47018 return resultobj;
47019 fail:
47020 return NULL;
47021 }
47022
47023
47024 SWIGINTERN PyObject *_wrap_Sizer_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47025 PyObject *resultobj = 0;
47026 wxSizer *arg1 = (wxSizer *) 0 ;
47027 wxSize result;
47028 void *argp1 = 0 ;
47029 int res1 = 0 ;
47030 PyObject *swig_obj[1] ;
47031
47032 if (!args) SWIG_fail;
47033 swig_obj[0] = args;
47034 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47035 if (!SWIG_IsOK(res1)) {
47036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetSize" "', expected argument " "1"" of type '" "wxSizer *""'");
47037 }
47038 arg1 = reinterpret_cast< wxSizer * >(argp1);
47039 {
47040 PyThreadState* __tstate = wxPyBeginAllowThreads();
47041 result = (arg1)->GetSize();
47042 wxPyEndAllowThreads(__tstate);
47043 if (PyErr_Occurred()) SWIG_fail;
47044 }
47045 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
47046 return resultobj;
47047 fail:
47048 return NULL;
47049 }
47050
47051
47052 SWIGINTERN PyObject *_wrap_Sizer_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47053 PyObject *resultobj = 0;
47054 wxSizer *arg1 = (wxSizer *) 0 ;
47055 wxPoint result;
47056 void *argp1 = 0 ;
47057 int res1 = 0 ;
47058 PyObject *swig_obj[1] ;
47059
47060 if (!args) SWIG_fail;
47061 swig_obj[0] = args;
47062 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47063 if (!SWIG_IsOK(res1)) {
47064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetPosition" "', expected argument " "1"" of type '" "wxSizer *""'");
47065 }
47066 arg1 = reinterpret_cast< wxSizer * >(argp1);
47067 {
47068 PyThreadState* __tstate = wxPyBeginAllowThreads();
47069 result = (arg1)->GetPosition();
47070 wxPyEndAllowThreads(__tstate);
47071 if (PyErr_Occurred()) SWIG_fail;
47072 }
47073 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
47074 return resultobj;
47075 fail:
47076 return NULL;
47077 }
47078
47079
47080 SWIGINTERN PyObject *_wrap_Sizer_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47081 PyObject *resultobj = 0;
47082 wxSizer *arg1 = (wxSizer *) 0 ;
47083 wxSize result;
47084 void *argp1 = 0 ;
47085 int res1 = 0 ;
47086 PyObject *swig_obj[1] ;
47087
47088 if (!args) SWIG_fail;
47089 swig_obj[0] = args;
47090 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47091 if (!SWIG_IsOK(res1)) {
47092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
47093 }
47094 arg1 = reinterpret_cast< wxSizer * >(argp1);
47095 {
47096 PyThreadState* __tstate = wxPyBeginAllowThreads();
47097 result = (arg1)->GetMinSize();
47098 wxPyEndAllowThreads(__tstate);
47099 if (PyErr_Occurred()) SWIG_fail;
47100 }
47101 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
47102 return resultobj;
47103 fail:
47104 return NULL;
47105 }
47106
47107
47108 SWIGINTERN PyObject *_wrap_Sizer_RecalcSizes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47109 PyObject *resultobj = 0;
47110 wxSizer *arg1 = (wxSizer *) 0 ;
47111 void *argp1 = 0 ;
47112 int res1 = 0 ;
47113 PyObject *swig_obj[1] ;
47114
47115 if (!args) SWIG_fail;
47116 swig_obj[0] = args;
47117 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47118 if (!SWIG_IsOK(res1)) {
47119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_RecalcSizes" "', expected argument " "1"" of type '" "wxSizer *""'");
47120 }
47121 arg1 = reinterpret_cast< wxSizer * >(argp1);
47122 {
47123 PyThreadState* __tstate = wxPyBeginAllowThreads();
47124 (arg1)->RecalcSizes();
47125 wxPyEndAllowThreads(__tstate);
47126 if (PyErr_Occurred()) SWIG_fail;
47127 }
47128 resultobj = SWIG_Py_Void();
47129 return resultobj;
47130 fail:
47131 return NULL;
47132 }
47133
47134
47135 SWIGINTERN PyObject *_wrap_Sizer_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47136 PyObject *resultobj = 0;
47137 wxSizer *arg1 = (wxSizer *) 0 ;
47138 wxSize result;
47139 void *argp1 = 0 ;
47140 int res1 = 0 ;
47141 PyObject *swig_obj[1] ;
47142
47143 if (!args) SWIG_fail;
47144 swig_obj[0] = args;
47145 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47146 if (!SWIG_IsOK(res1)) {
47147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_CalcMin" "', expected argument " "1"" of type '" "wxSizer *""'");
47148 }
47149 arg1 = reinterpret_cast< wxSizer * >(argp1);
47150 {
47151 PyThreadState* __tstate = wxPyBeginAllowThreads();
47152 result = (arg1)->CalcMin();
47153 wxPyEndAllowThreads(__tstate);
47154 if (PyErr_Occurred()) SWIG_fail;
47155 }
47156 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
47157 return resultobj;
47158 fail:
47159 return NULL;
47160 }
47161
47162
47163 SWIGINTERN PyObject *_wrap_Sizer_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47164 PyObject *resultobj = 0;
47165 wxSizer *arg1 = (wxSizer *) 0 ;
47166 void *argp1 = 0 ;
47167 int res1 = 0 ;
47168 PyObject *swig_obj[1] ;
47169
47170 if (!args) SWIG_fail;
47171 swig_obj[0] = args;
47172 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47173 if (!SWIG_IsOK(res1)) {
47174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Layout" "', expected argument " "1"" of type '" "wxSizer *""'");
47175 }
47176 arg1 = reinterpret_cast< wxSizer * >(argp1);
47177 {
47178 PyThreadState* __tstate = wxPyBeginAllowThreads();
47179 (arg1)->Layout();
47180 wxPyEndAllowThreads(__tstate);
47181 if (PyErr_Occurred()) SWIG_fail;
47182 }
47183 resultobj = SWIG_Py_Void();
47184 return resultobj;
47185 fail:
47186 return NULL;
47187 }
47188
47189
47190 SWIGINTERN PyObject *_wrap_Sizer_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47191 PyObject *resultobj = 0;
47192 wxSizer *arg1 = (wxSizer *) 0 ;
47193 wxWindow *arg2 = (wxWindow *) 0 ;
47194 wxSize result;
47195 void *argp1 = 0 ;
47196 int res1 = 0 ;
47197 void *argp2 = 0 ;
47198 int res2 = 0 ;
47199 PyObject * obj0 = 0 ;
47200 PyObject * obj1 = 0 ;
47201 char * kwnames[] = {
47202 (char *) "self",(char *) "window", NULL
47203 };
47204
47205 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) SWIG_fail;
47206 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47207 if (!SWIG_IsOK(res1)) {
47208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Fit" "', expected argument " "1"" of type '" "wxSizer *""'");
47209 }
47210 arg1 = reinterpret_cast< wxSizer * >(argp1);
47211 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47212 if (!SWIG_IsOK(res2)) {
47213 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_Fit" "', expected argument " "2"" of type '" "wxWindow *""'");
47214 }
47215 arg2 = reinterpret_cast< wxWindow * >(argp2);
47216 {
47217 PyThreadState* __tstate = wxPyBeginAllowThreads();
47218 result = (arg1)->Fit(arg2);
47219 wxPyEndAllowThreads(__tstate);
47220 if (PyErr_Occurred()) SWIG_fail;
47221 }
47222 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
47223 return resultobj;
47224 fail:
47225 return NULL;
47226 }
47227
47228
47229 SWIGINTERN PyObject *_wrap_Sizer_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47230 PyObject *resultobj = 0;
47231 wxSizer *arg1 = (wxSizer *) 0 ;
47232 wxWindow *arg2 = (wxWindow *) 0 ;
47233 void *argp1 = 0 ;
47234 int res1 = 0 ;
47235 void *argp2 = 0 ;
47236 int res2 = 0 ;
47237 PyObject * obj0 = 0 ;
47238 PyObject * obj1 = 0 ;
47239 char * kwnames[] = {
47240 (char *) "self",(char *) "window", NULL
47241 };
47242
47243 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) SWIG_fail;
47244 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47245 if (!SWIG_IsOK(res1)) {
47246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_FitInside" "', expected argument " "1"" of type '" "wxSizer *""'");
47247 }
47248 arg1 = reinterpret_cast< wxSizer * >(argp1);
47249 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47250 if (!SWIG_IsOK(res2)) {
47251 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_FitInside" "', expected argument " "2"" of type '" "wxWindow *""'");
47252 }
47253 arg2 = reinterpret_cast< wxWindow * >(argp2);
47254 {
47255 PyThreadState* __tstate = wxPyBeginAllowThreads();
47256 (arg1)->FitInside(arg2);
47257 wxPyEndAllowThreads(__tstate);
47258 if (PyErr_Occurred()) SWIG_fail;
47259 }
47260 resultobj = SWIG_Py_Void();
47261 return resultobj;
47262 fail:
47263 return NULL;
47264 }
47265
47266
47267 SWIGINTERN PyObject *_wrap_Sizer_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47268 PyObject *resultobj = 0;
47269 wxSizer *arg1 = (wxSizer *) 0 ;
47270 wxWindow *arg2 = (wxWindow *) 0 ;
47271 void *argp1 = 0 ;
47272 int res1 = 0 ;
47273 void *argp2 = 0 ;
47274 int res2 = 0 ;
47275 PyObject * obj0 = 0 ;
47276 PyObject * obj1 = 0 ;
47277 char * kwnames[] = {
47278 (char *) "self",(char *) "window", NULL
47279 };
47280
47281 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
47282 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47283 if (!SWIG_IsOK(res1)) {
47284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
47285 }
47286 arg1 = reinterpret_cast< wxSizer * >(argp1);
47287 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47288 if (!SWIG_IsOK(res2)) {
47289 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
47290 }
47291 arg2 = reinterpret_cast< wxWindow * >(argp2);
47292 {
47293 PyThreadState* __tstate = wxPyBeginAllowThreads();
47294 (arg1)->SetSizeHints(arg2);
47295 wxPyEndAllowThreads(__tstate);
47296 if (PyErr_Occurred()) SWIG_fail;
47297 }
47298 resultobj = SWIG_Py_Void();
47299 return resultobj;
47300 fail:
47301 return NULL;
47302 }
47303
47304
47305 SWIGINTERN PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47306 PyObject *resultobj = 0;
47307 wxSizer *arg1 = (wxSizer *) 0 ;
47308 wxWindow *arg2 = (wxWindow *) 0 ;
47309 void *argp1 = 0 ;
47310 int res1 = 0 ;
47311 void *argp2 = 0 ;
47312 int res2 = 0 ;
47313 PyObject * obj0 = 0 ;
47314 PyObject * obj1 = 0 ;
47315 char * kwnames[] = {
47316 (char *) "self",(char *) "window", NULL
47317 };
47318
47319 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
47320 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47321 if (!SWIG_IsOK(res1)) {
47322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
47323 }
47324 arg1 = reinterpret_cast< wxSizer * >(argp1);
47325 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47326 if (!SWIG_IsOK(res2)) {
47327 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
47328 }
47329 arg2 = reinterpret_cast< wxWindow * >(argp2);
47330 {
47331 PyThreadState* __tstate = wxPyBeginAllowThreads();
47332 (arg1)->SetVirtualSizeHints(arg2);
47333 wxPyEndAllowThreads(__tstate);
47334 if (PyErr_Occurred()) SWIG_fail;
47335 }
47336 resultobj = SWIG_Py_Void();
47337 return resultobj;
47338 fail:
47339 return NULL;
47340 }
47341
47342
47343 SWIGINTERN PyObject *_wrap_Sizer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47344 PyObject *resultobj = 0;
47345 wxSizer *arg1 = (wxSizer *) 0 ;
47346 bool arg2 = (bool) false ;
47347 void *argp1 = 0 ;
47348 int res1 = 0 ;
47349 bool val2 ;
47350 int ecode2 = 0 ;
47351 PyObject * obj0 = 0 ;
47352 PyObject * obj1 = 0 ;
47353 char * kwnames[] = {
47354 (char *) "self",(char *) "deleteWindows", NULL
47355 };
47356
47357 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) SWIG_fail;
47358 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47359 if (!SWIG_IsOK(res1)) {
47360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Clear" "', expected argument " "1"" of type '" "wxSizer *""'");
47361 }
47362 arg1 = reinterpret_cast< wxSizer * >(argp1);
47363 if (obj1) {
47364 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47365 if (!SWIG_IsOK(ecode2)) {
47366 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Clear" "', expected argument " "2"" of type '" "bool""'");
47367 }
47368 arg2 = static_cast< bool >(val2);
47369 }
47370 {
47371 PyThreadState* __tstate = wxPyBeginAllowThreads();
47372 (arg1)->Clear(arg2);
47373 wxPyEndAllowThreads(__tstate);
47374 if (PyErr_Occurred()) SWIG_fail;
47375 }
47376 resultobj = SWIG_Py_Void();
47377 return resultobj;
47378 fail:
47379 return NULL;
47380 }
47381
47382
47383 SWIGINTERN PyObject *_wrap_Sizer_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47384 PyObject *resultobj = 0;
47385 wxSizer *arg1 = (wxSizer *) 0 ;
47386 void *argp1 = 0 ;
47387 int res1 = 0 ;
47388 PyObject *swig_obj[1] ;
47389
47390 if (!args) SWIG_fail;
47391 swig_obj[0] = args;
47392 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47393 if (!SWIG_IsOK(res1)) {
47394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_DeleteWindows" "', expected argument " "1"" of type '" "wxSizer *""'");
47395 }
47396 arg1 = reinterpret_cast< wxSizer * >(argp1);
47397 {
47398 PyThreadState* __tstate = wxPyBeginAllowThreads();
47399 (arg1)->DeleteWindows();
47400 wxPyEndAllowThreads(__tstate);
47401 if (PyErr_Occurred()) SWIG_fail;
47402 }
47403 resultobj = SWIG_Py_Void();
47404 return resultobj;
47405 fail:
47406 return NULL;
47407 }
47408
47409
47410 SWIGINTERN PyObject *_wrap_Sizer_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47411 PyObject *resultobj = 0;
47412 wxSizer *arg1 = (wxSizer *) 0 ;
47413 PyObject *result = 0 ;
47414 void *argp1 = 0 ;
47415 int res1 = 0 ;
47416 PyObject *swig_obj[1] ;
47417
47418 if (!args) SWIG_fail;
47419 swig_obj[0] = args;
47420 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47421 if (!SWIG_IsOK(res1)) {
47422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetChildren" "', expected argument " "1"" of type '" "wxSizer *""'");
47423 }
47424 arg1 = reinterpret_cast< wxSizer * >(argp1);
47425 {
47426 PyThreadState* __tstate = wxPyBeginAllowThreads();
47427 result = (PyObject *)wxSizer_GetChildren(arg1);
47428 wxPyEndAllowThreads(__tstate);
47429 if (PyErr_Occurred()) SWIG_fail;
47430 }
47431 resultobj = result;
47432 return resultobj;
47433 fail:
47434 return NULL;
47435 }
47436
47437
47438 SWIGINTERN PyObject *_wrap_Sizer_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47439 PyObject *resultobj = 0;
47440 wxSizer *arg1 = (wxSizer *) 0 ;
47441 PyObject *arg2 = (PyObject *) 0 ;
47442 bool arg3 = (bool) true ;
47443 bool arg4 = (bool) false ;
47444 bool result;
47445 void *argp1 = 0 ;
47446 int res1 = 0 ;
47447 bool val3 ;
47448 int ecode3 = 0 ;
47449 bool val4 ;
47450 int ecode4 = 0 ;
47451 PyObject * obj0 = 0 ;
47452 PyObject * obj1 = 0 ;
47453 PyObject * obj2 = 0 ;
47454 PyObject * obj3 = 0 ;
47455 char * kwnames[] = {
47456 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
47457 };
47458
47459 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47460 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47461 if (!SWIG_IsOK(res1)) {
47462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Show" "', expected argument " "1"" of type '" "wxSizer *""'");
47463 }
47464 arg1 = reinterpret_cast< wxSizer * >(argp1);
47465 arg2 = obj1;
47466 if (obj2) {
47467 ecode3 = SWIG_AsVal_bool(obj2, &val3);
47468 if (!SWIG_IsOK(ecode3)) {
47469 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Show" "', expected argument " "3"" of type '" "bool""'");
47470 }
47471 arg3 = static_cast< bool >(val3);
47472 }
47473 if (obj3) {
47474 ecode4 = SWIG_AsVal_bool(obj3, &val4);
47475 if (!SWIG_IsOK(ecode4)) {
47476 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Show" "', expected argument " "4"" of type '" "bool""'");
47477 }
47478 arg4 = static_cast< bool >(val4);
47479 }
47480 {
47481 PyThreadState* __tstate = wxPyBeginAllowThreads();
47482 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
47483 wxPyEndAllowThreads(__tstate);
47484 if (PyErr_Occurred()) SWIG_fail;
47485 }
47486 {
47487 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47488 }
47489 return resultobj;
47490 fail:
47491 return NULL;
47492 }
47493
47494
47495 SWIGINTERN PyObject *_wrap_Sizer_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47496 PyObject *resultobj = 0;
47497 wxSizer *arg1 = (wxSizer *) 0 ;
47498 PyObject *arg2 = (PyObject *) 0 ;
47499 bool result;
47500 void *argp1 = 0 ;
47501 int res1 = 0 ;
47502 PyObject * obj0 = 0 ;
47503 PyObject * obj1 = 0 ;
47504 char * kwnames[] = {
47505 (char *) "self",(char *) "item", NULL
47506 };
47507
47508 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) SWIG_fail;
47509 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47510 if (!SWIG_IsOK(res1)) {
47511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_IsShown" "', expected argument " "1"" of type '" "wxSizer *""'");
47512 }
47513 arg1 = reinterpret_cast< wxSizer * >(argp1);
47514 arg2 = obj1;
47515 {
47516 PyThreadState* __tstate = wxPyBeginAllowThreads();
47517 result = (bool)wxSizer_IsShown(arg1,arg2);
47518 wxPyEndAllowThreads(__tstate);
47519 if (PyErr_Occurred()) SWIG_fail;
47520 }
47521 {
47522 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47523 }
47524 return resultobj;
47525 fail:
47526 return NULL;
47527 }
47528
47529
47530 SWIGINTERN PyObject *_wrap_Sizer_ShowItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47531 PyObject *resultobj = 0;
47532 wxSizer *arg1 = (wxSizer *) 0 ;
47533 bool arg2 ;
47534 void *argp1 = 0 ;
47535 int res1 = 0 ;
47536 bool val2 ;
47537 int ecode2 = 0 ;
47538 PyObject * obj0 = 0 ;
47539 PyObject * obj1 = 0 ;
47540 char * kwnames[] = {
47541 (char *) "self",(char *) "show", NULL
47542 };
47543
47544 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) SWIG_fail;
47545 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47546 if (!SWIG_IsOK(res1)) {
47547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_ShowItems" "', expected argument " "1"" of type '" "wxSizer *""'");
47548 }
47549 arg1 = reinterpret_cast< wxSizer * >(argp1);
47550 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47551 if (!SWIG_IsOK(ecode2)) {
47552 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_ShowItems" "', expected argument " "2"" of type '" "bool""'");
47553 }
47554 arg2 = static_cast< bool >(val2);
47555 {
47556 PyThreadState* __tstate = wxPyBeginAllowThreads();
47557 (arg1)->ShowItems(arg2);
47558 wxPyEndAllowThreads(__tstate);
47559 if (PyErr_Occurred()) SWIG_fail;
47560 }
47561 resultobj = SWIG_Py_Void();
47562 return resultobj;
47563 fail:
47564 return NULL;
47565 }
47566
47567
47568 SWIGINTERN PyObject *Sizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47569 PyObject *obj;
47570 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47571 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizer, SWIG_NewClientData(obj));
47572 return SWIG_Py_Void();
47573 }
47574
47575 SWIGINTERN PyObject *_wrap_new_PySizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47576 PyObject *resultobj = 0;
47577 wxPySizer *result = 0 ;
47578
47579 if (!SWIG_Python_UnpackTuple(args,"new_PySizer",0,0,0)) SWIG_fail;
47580 {
47581 PyThreadState* __tstate = wxPyBeginAllowThreads();
47582 result = (wxPySizer *)new wxPySizer();
47583 wxPyEndAllowThreads(__tstate);
47584 if (PyErr_Occurred()) SWIG_fail;
47585 }
47586 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPySizer, SWIG_POINTER_NEW | 0 );
47587 return resultobj;
47588 fail:
47589 return NULL;
47590 }
47591
47592
47593 SWIGINTERN PyObject *_wrap_PySizer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47594 PyObject *resultobj = 0;
47595 wxPySizer *arg1 = (wxPySizer *) 0 ;
47596 PyObject *arg2 = (PyObject *) 0 ;
47597 PyObject *arg3 = (PyObject *) 0 ;
47598 void *argp1 = 0 ;
47599 int res1 = 0 ;
47600 PyObject * obj0 = 0 ;
47601 PyObject * obj1 = 0 ;
47602 PyObject * obj2 = 0 ;
47603 char * kwnames[] = {
47604 (char *) "self",(char *) "self",(char *) "_class", NULL
47605 };
47606
47607 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47608 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPySizer, 0 | 0 );
47609 if (!SWIG_IsOK(res1)) {
47610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySizer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPySizer *""'");
47611 }
47612 arg1 = reinterpret_cast< wxPySizer * >(argp1);
47613 arg2 = obj1;
47614 arg3 = obj2;
47615 {
47616 PyThreadState* __tstate = wxPyBeginAllowThreads();
47617 (arg1)->_setCallbackInfo(arg2,arg3);
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 *PySizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47629 PyObject *obj;
47630 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47631 SWIG_TypeNewClientData(SWIGTYPE_p_wxPySizer, SWIG_NewClientData(obj));
47632 return SWIG_Py_Void();
47633 }
47634
47635 SWIGINTERN PyObject *PySizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47636 return SWIG_Python_InitShadowInstance(args);
47637 }
47638
47639 SWIGINTERN PyObject *_wrap_new_BoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47640 PyObject *resultobj = 0;
47641 int arg1 = (int) wxHORIZONTAL ;
47642 wxBoxSizer *result = 0 ;
47643 int val1 ;
47644 int ecode1 = 0 ;
47645 PyObject * obj0 = 0 ;
47646 char * kwnames[] = {
47647 (char *) "orient", NULL
47648 };
47649
47650 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) SWIG_fail;
47651 if (obj0) {
47652 ecode1 = SWIG_AsVal_int(obj0, &val1);
47653 if (!SWIG_IsOK(ecode1)) {
47654 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BoxSizer" "', expected argument " "1"" of type '" "int""'");
47655 }
47656 arg1 = static_cast< int >(val1);
47657 }
47658 {
47659 PyThreadState* __tstate = wxPyBeginAllowThreads();
47660 result = (wxBoxSizer *)new wxBoxSizer(arg1);
47661 wxPyEndAllowThreads(__tstate);
47662 if (PyErr_Occurred()) SWIG_fail;
47663 }
47664 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_NEW | 0 );
47665 return resultobj;
47666 fail:
47667 return NULL;
47668 }
47669
47670
47671 SWIGINTERN PyObject *_wrap_BoxSizer_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47672 PyObject *resultobj = 0;
47673 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
47674 int result;
47675 void *argp1 = 0 ;
47676 int res1 = 0 ;
47677 PyObject *swig_obj[1] ;
47678
47679 if (!args) SWIG_fail;
47680 swig_obj[0] = args;
47681 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
47682 if (!SWIG_IsOK(res1)) {
47683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_GetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
47684 }
47685 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
47686 {
47687 PyThreadState* __tstate = wxPyBeginAllowThreads();
47688 result = (int)(arg1)->GetOrientation();
47689 wxPyEndAllowThreads(__tstate);
47690 if (PyErr_Occurred()) SWIG_fail;
47691 }
47692 resultobj = SWIG_From_int(static_cast< int >(result));
47693 return resultobj;
47694 fail:
47695 return NULL;
47696 }
47697
47698
47699 SWIGINTERN PyObject *_wrap_BoxSizer_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47700 PyObject *resultobj = 0;
47701 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
47702 int arg2 ;
47703 void *argp1 = 0 ;
47704 int res1 = 0 ;
47705 int val2 ;
47706 int ecode2 = 0 ;
47707 PyObject * obj0 = 0 ;
47708 PyObject * obj1 = 0 ;
47709 char * kwnames[] = {
47710 (char *) "self",(char *) "orient", NULL
47711 };
47712
47713 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
47714 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
47715 if (!SWIG_IsOK(res1)) {
47716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_SetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
47717 }
47718 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
47719 ecode2 = SWIG_AsVal_int(obj1, &val2);
47720 if (!SWIG_IsOK(ecode2)) {
47721 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoxSizer_SetOrientation" "', expected argument " "2"" of type '" "int""'");
47722 }
47723 arg2 = static_cast< int >(val2);
47724 {
47725 PyThreadState* __tstate = wxPyBeginAllowThreads();
47726 (arg1)->SetOrientation(arg2);
47727 wxPyEndAllowThreads(__tstate);
47728 if (PyErr_Occurred()) SWIG_fail;
47729 }
47730 resultobj = SWIG_Py_Void();
47731 return resultobj;
47732 fail:
47733 return NULL;
47734 }
47735
47736
47737 SWIGINTERN PyObject *BoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47738 PyObject *obj;
47739 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47740 SWIG_TypeNewClientData(SWIGTYPE_p_wxBoxSizer, SWIG_NewClientData(obj));
47741 return SWIG_Py_Void();
47742 }
47743
47744 SWIGINTERN PyObject *BoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47745 return SWIG_Python_InitShadowInstance(args);
47746 }
47747
47748 SWIGINTERN PyObject *_wrap_new_StaticBoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47749 PyObject *resultobj = 0;
47750 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
47751 int arg2 = (int) wxHORIZONTAL ;
47752 wxStaticBoxSizer *result = 0 ;
47753 void *argp1 = 0 ;
47754 int res1 = 0 ;
47755 int val2 ;
47756 int ecode2 = 0 ;
47757 PyObject * obj0 = 0 ;
47758 PyObject * obj1 = 0 ;
47759 char * kwnames[] = {
47760 (char *) "box",(char *) "orient", NULL
47761 };
47762
47763 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) SWIG_fail;
47764 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStaticBox, 0 | 0 );
47765 if (!SWIG_IsOK(res1)) {
47766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StaticBoxSizer" "', expected argument " "1"" of type '" "wxStaticBox *""'");
47767 }
47768 arg1 = reinterpret_cast< wxStaticBox * >(argp1);
47769 if (obj1) {
47770 ecode2 = SWIG_AsVal_int(obj1, &val2);
47771 if (!SWIG_IsOK(ecode2)) {
47772 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StaticBoxSizer" "', expected argument " "2"" of type '" "int""'");
47773 }
47774 arg2 = static_cast< int >(val2);
47775 }
47776 {
47777 PyThreadState* __tstate = wxPyBeginAllowThreads();
47778 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
47779 wxPyEndAllowThreads(__tstate);
47780 if (PyErr_Occurred()) SWIG_fail;
47781 }
47782 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_NEW | 0 );
47783 return resultobj;
47784 fail:
47785 return NULL;
47786 }
47787
47788
47789 SWIGINTERN PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47790 PyObject *resultobj = 0;
47791 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
47792 wxStaticBox *result = 0 ;
47793 void *argp1 = 0 ;
47794 int res1 = 0 ;
47795 PyObject *swig_obj[1] ;
47796
47797 if (!args) SWIG_fail;
47798 swig_obj[0] = args;
47799 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStaticBoxSizer, 0 | 0 );
47800 if (!SWIG_IsOK(res1)) {
47801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StaticBoxSizer_GetStaticBox" "', expected argument " "1"" of type '" "wxStaticBoxSizer *""'");
47802 }
47803 arg1 = reinterpret_cast< wxStaticBoxSizer * >(argp1);
47804 {
47805 PyThreadState* __tstate = wxPyBeginAllowThreads();
47806 result = (wxStaticBox *)(arg1)->GetStaticBox();
47807 wxPyEndAllowThreads(__tstate);
47808 if (PyErr_Occurred()) SWIG_fail;
47809 }
47810 {
47811 resultobj = wxPyMake_wxObject(result, (bool)0);
47812 }
47813 return resultobj;
47814 fail:
47815 return NULL;
47816 }
47817
47818
47819 SWIGINTERN PyObject *StaticBoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47820 PyObject *obj;
47821 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47822 SWIG_TypeNewClientData(SWIGTYPE_p_wxStaticBoxSizer, SWIG_NewClientData(obj));
47823 return SWIG_Py_Void();
47824 }
47825
47826 SWIGINTERN PyObject *StaticBoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47827 return SWIG_Python_InitShadowInstance(args);
47828 }
47829
47830 SWIGINTERN PyObject *_wrap_new_GridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47831 PyObject *resultobj = 0;
47832 int arg1 = (int) 1 ;
47833 int arg2 = (int) 0 ;
47834 int arg3 = (int) 0 ;
47835 int arg4 = (int) 0 ;
47836 wxGridSizer *result = 0 ;
47837 int val1 ;
47838 int ecode1 = 0 ;
47839 int val2 ;
47840 int ecode2 = 0 ;
47841 int val3 ;
47842 int ecode3 = 0 ;
47843 int val4 ;
47844 int ecode4 = 0 ;
47845 PyObject * obj0 = 0 ;
47846 PyObject * obj1 = 0 ;
47847 PyObject * obj2 = 0 ;
47848 PyObject * obj3 = 0 ;
47849 char * kwnames[] = {
47850 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
47851 };
47852
47853 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47854 if (obj0) {
47855 ecode1 = SWIG_AsVal_int(obj0, &val1);
47856 if (!SWIG_IsOK(ecode1)) {
47857 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizer" "', expected argument " "1"" of type '" "int""'");
47858 }
47859 arg1 = static_cast< int >(val1);
47860 }
47861 if (obj1) {
47862 ecode2 = SWIG_AsVal_int(obj1, &val2);
47863 if (!SWIG_IsOK(ecode2)) {
47864 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizer" "', expected argument " "2"" of type '" "int""'");
47865 }
47866 arg2 = static_cast< int >(val2);
47867 }
47868 if (obj2) {
47869 ecode3 = SWIG_AsVal_int(obj2, &val3);
47870 if (!SWIG_IsOK(ecode3)) {
47871 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridSizer" "', expected argument " "3"" of type '" "int""'");
47872 }
47873 arg3 = static_cast< int >(val3);
47874 }
47875 if (obj3) {
47876 ecode4 = SWIG_AsVal_int(obj3, &val4);
47877 if (!SWIG_IsOK(ecode4)) {
47878 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizer" "', expected argument " "4"" of type '" "int""'");
47879 }
47880 arg4 = static_cast< int >(val4);
47881 }
47882 {
47883 PyThreadState* __tstate = wxPyBeginAllowThreads();
47884 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
47885 wxPyEndAllowThreads(__tstate);
47886 if (PyErr_Occurred()) SWIG_fail;
47887 }
47888 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizer, SWIG_POINTER_NEW | 0 );
47889 return resultobj;
47890 fail:
47891 return NULL;
47892 }
47893
47894
47895 SWIGINTERN PyObject *_wrap_GridSizer_SetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47896 PyObject *resultobj = 0;
47897 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47898 int arg2 ;
47899 void *argp1 = 0 ;
47900 int res1 = 0 ;
47901 int val2 ;
47902 int ecode2 = 0 ;
47903 PyObject * obj0 = 0 ;
47904 PyObject * obj1 = 0 ;
47905 char * kwnames[] = {
47906 (char *) "self",(char *) "cols", NULL
47907 };
47908
47909 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) SWIG_fail;
47910 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47911 if (!SWIG_IsOK(res1)) {
47912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47913 }
47914 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47915 ecode2 = SWIG_AsVal_int(obj1, &val2);
47916 if (!SWIG_IsOK(ecode2)) {
47917 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetCols" "', expected argument " "2"" of type '" "int""'");
47918 }
47919 arg2 = static_cast< int >(val2);
47920 {
47921 PyThreadState* __tstate = wxPyBeginAllowThreads();
47922 (arg1)->SetCols(arg2);
47923 wxPyEndAllowThreads(__tstate);
47924 if (PyErr_Occurred()) SWIG_fail;
47925 }
47926 resultobj = SWIG_Py_Void();
47927 return resultobj;
47928 fail:
47929 return NULL;
47930 }
47931
47932
47933 SWIGINTERN PyObject *_wrap_GridSizer_SetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47934 PyObject *resultobj = 0;
47935 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47936 int arg2 ;
47937 void *argp1 = 0 ;
47938 int res1 = 0 ;
47939 int val2 ;
47940 int ecode2 = 0 ;
47941 PyObject * obj0 = 0 ;
47942 PyObject * obj1 = 0 ;
47943 char * kwnames[] = {
47944 (char *) "self",(char *) "rows", NULL
47945 };
47946
47947 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) SWIG_fail;
47948 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47949 if (!SWIG_IsOK(res1)) {
47950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47951 }
47952 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47953 ecode2 = SWIG_AsVal_int(obj1, &val2);
47954 if (!SWIG_IsOK(ecode2)) {
47955 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetRows" "', expected argument " "2"" of type '" "int""'");
47956 }
47957 arg2 = static_cast< int >(val2);
47958 {
47959 PyThreadState* __tstate = wxPyBeginAllowThreads();
47960 (arg1)->SetRows(arg2);
47961 wxPyEndAllowThreads(__tstate);
47962 if (PyErr_Occurred()) SWIG_fail;
47963 }
47964 resultobj = SWIG_Py_Void();
47965 return resultobj;
47966 fail:
47967 return NULL;
47968 }
47969
47970
47971 SWIGINTERN PyObject *_wrap_GridSizer_SetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47972 PyObject *resultobj = 0;
47973 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47974 int arg2 ;
47975 void *argp1 = 0 ;
47976 int res1 = 0 ;
47977 int val2 ;
47978 int ecode2 = 0 ;
47979 PyObject * obj0 = 0 ;
47980 PyObject * obj1 = 0 ;
47981 char * kwnames[] = {
47982 (char *) "self",(char *) "gap", NULL
47983 };
47984
47985 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) SWIG_fail;
47986 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47987 if (!SWIG_IsOK(res1)) {
47988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47989 }
47990 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47991 ecode2 = SWIG_AsVal_int(obj1, &val2);
47992 if (!SWIG_IsOK(ecode2)) {
47993 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetVGap" "', expected argument " "2"" of type '" "int""'");
47994 }
47995 arg2 = static_cast< int >(val2);
47996 {
47997 PyThreadState* __tstate = wxPyBeginAllowThreads();
47998 (arg1)->SetVGap(arg2);
47999 wxPyEndAllowThreads(__tstate);
48000 if (PyErr_Occurred()) SWIG_fail;
48001 }
48002 resultobj = SWIG_Py_Void();
48003 return resultobj;
48004 fail:
48005 return NULL;
48006 }
48007
48008
48009 SWIGINTERN PyObject *_wrap_GridSizer_SetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48010 PyObject *resultobj = 0;
48011 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48012 int arg2 ;
48013 void *argp1 = 0 ;
48014 int res1 = 0 ;
48015 int val2 ;
48016 int ecode2 = 0 ;
48017 PyObject * obj0 = 0 ;
48018 PyObject * obj1 = 0 ;
48019 char * kwnames[] = {
48020 (char *) "self",(char *) "gap", NULL
48021 };
48022
48023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) SWIG_fail;
48024 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48025 if (!SWIG_IsOK(res1)) {
48026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48027 }
48028 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48029 ecode2 = SWIG_AsVal_int(obj1, &val2);
48030 if (!SWIG_IsOK(ecode2)) {
48031 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetHGap" "', expected argument " "2"" of type '" "int""'");
48032 }
48033 arg2 = static_cast< int >(val2);
48034 {
48035 PyThreadState* __tstate = wxPyBeginAllowThreads();
48036 (arg1)->SetHGap(arg2);
48037 wxPyEndAllowThreads(__tstate);
48038 if (PyErr_Occurred()) SWIG_fail;
48039 }
48040 resultobj = SWIG_Py_Void();
48041 return resultobj;
48042 fail:
48043 return NULL;
48044 }
48045
48046
48047 SWIGINTERN PyObject *_wrap_GridSizer_GetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48048 PyObject *resultobj = 0;
48049 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48050 int result;
48051 void *argp1 = 0 ;
48052 int res1 = 0 ;
48053 PyObject *swig_obj[1] ;
48054
48055 if (!args) SWIG_fail;
48056 swig_obj[0] = args;
48057 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48058 if (!SWIG_IsOK(res1)) {
48059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48060 }
48061 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48062 {
48063 PyThreadState* __tstate = wxPyBeginAllowThreads();
48064 result = (int)(arg1)->GetCols();
48065 wxPyEndAllowThreads(__tstate);
48066 if (PyErr_Occurred()) SWIG_fail;
48067 }
48068 resultobj = SWIG_From_int(static_cast< int >(result));
48069 return resultobj;
48070 fail:
48071 return NULL;
48072 }
48073
48074
48075 SWIGINTERN PyObject *_wrap_GridSizer_GetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48076 PyObject *resultobj = 0;
48077 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48078 int result;
48079 void *argp1 = 0 ;
48080 int res1 = 0 ;
48081 PyObject *swig_obj[1] ;
48082
48083 if (!args) SWIG_fail;
48084 swig_obj[0] = args;
48085 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48086 if (!SWIG_IsOK(res1)) {
48087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48088 }
48089 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48090 {
48091 PyThreadState* __tstate = wxPyBeginAllowThreads();
48092 result = (int)(arg1)->GetRows();
48093 wxPyEndAllowThreads(__tstate);
48094 if (PyErr_Occurred()) SWIG_fail;
48095 }
48096 resultobj = SWIG_From_int(static_cast< int >(result));
48097 return resultobj;
48098 fail:
48099 return NULL;
48100 }
48101
48102
48103 SWIGINTERN PyObject *_wrap_GridSizer_GetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48104 PyObject *resultobj = 0;
48105 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48106 int result;
48107 void *argp1 = 0 ;
48108 int res1 = 0 ;
48109 PyObject *swig_obj[1] ;
48110
48111 if (!args) SWIG_fail;
48112 swig_obj[0] = args;
48113 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48114 if (!SWIG_IsOK(res1)) {
48115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48116 }
48117 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48118 {
48119 PyThreadState* __tstate = wxPyBeginAllowThreads();
48120 result = (int)(arg1)->GetVGap();
48121 wxPyEndAllowThreads(__tstate);
48122 if (PyErr_Occurred()) SWIG_fail;
48123 }
48124 resultobj = SWIG_From_int(static_cast< int >(result));
48125 return resultobj;
48126 fail:
48127 return NULL;
48128 }
48129
48130
48131 SWIGINTERN PyObject *_wrap_GridSizer_GetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48132 PyObject *resultobj = 0;
48133 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48134 int result;
48135 void *argp1 = 0 ;
48136 int res1 = 0 ;
48137 PyObject *swig_obj[1] ;
48138
48139 if (!args) SWIG_fail;
48140 swig_obj[0] = args;
48141 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48142 if (!SWIG_IsOK(res1)) {
48143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48144 }
48145 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48146 {
48147 PyThreadState* __tstate = wxPyBeginAllowThreads();
48148 result = (int)(arg1)->GetHGap();
48149 wxPyEndAllowThreads(__tstate);
48150 if (PyErr_Occurred()) SWIG_fail;
48151 }
48152 resultobj = SWIG_From_int(static_cast< int >(result));
48153 return resultobj;
48154 fail:
48155 return NULL;
48156 }
48157
48158
48159 SWIGINTERN PyObject *GridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48160 PyObject *obj;
48161 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48162 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizer, SWIG_NewClientData(obj));
48163 return SWIG_Py_Void();
48164 }
48165
48166 SWIGINTERN PyObject *GridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48167 return SWIG_Python_InitShadowInstance(args);
48168 }
48169
48170 SWIGINTERN PyObject *_wrap_new_FlexGridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48171 PyObject *resultobj = 0;
48172 int arg1 = (int) 1 ;
48173 int arg2 = (int) 0 ;
48174 int arg3 = (int) 0 ;
48175 int arg4 = (int) 0 ;
48176 wxFlexGridSizer *result = 0 ;
48177 int val1 ;
48178 int ecode1 = 0 ;
48179 int val2 ;
48180 int ecode2 = 0 ;
48181 int val3 ;
48182 int ecode3 = 0 ;
48183 int val4 ;
48184 int ecode4 = 0 ;
48185 PyObject * obj0 = 0 ;
48186 PyObject * obj1 = 0 ;
48187 PyObject * obj2 = 0 ;
48188 PyObject * obj3 = 0 ;
48189 char * kwnames[] = {
48190 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
48191 };
48192
48193 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
48194 if (obj0) {
48195 ecode1 = SWIG_AsVal_int(obj0, &val1);
48196 if (!SWIG_IsOK(ecode1)) {
48197 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlexGridSizer" "', expected argument " "1"" of type '" "int""'");
48198 }
48199 arg1 = static_cast< int >(val1);
48200 }
48201 if (obj1) {
48202 ecode2 = SWIG_AsVal_int(obj1, &val2);
48203 if (!SWIG_IsOK(ecode2)) {
48204 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlexGridSizer" "', expected argument " "2"" of type '" "int""'");
48205 }
48206 arg2 = static_cast< int >(val2);
48207 }
48208 if (obj2) {
48209 ecode3 = SWIG_AsVal_int(obj2, &val3);
48210 if (!SWIG_IsOK(ecode3)) {
48211 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FlexGridSizer" "', expected argument " "3"" of type '" "int""'");
48212 }
48213 arg3 = static_cast< int >(val3);
48214 }
48215 if (obj3) {
48216 ecode4 = SWIG_AsVal_int(obj3, &val4);
48217 if (!SWIG_IsOK(ecode4)) {
48218 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FlexGridSizer" "', expected argument " "4"" of type '" "int""'");
48219 }
48220 arg4 = static_cast< int >(val4);
48221 }
48222 {
48223 PyThreadState* __tstate = wxPyBeginAllowThreads();
48224 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
48225 wxPyEndAllowThreads(__tstate);
48226 if (PyErr_Occurred()) SWIG_fail;
48227 }
48228 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_NEW | 0 );
48229 return resultobj;
48230 fail:
48231 return NULL;
48232 }
48233
48234
48235 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48236 PyObject *resultobj = 0;
48237 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48238 size_t arg2 ;
48239 int arg3 = (int) 0 ;
48240 void *argp1 = 0 ;
48241 int res1 = 0 ;
48242 size_t val2 ;
48243 int ecode2 = 0 ;
48244 int val3 ;
48245 int ecode3 = 0 ;
48246 PyObject * obj0 = 0 ;
48247 PyObject * obj1 = 0 ;
48248 PyObject * obj2 = 0 ;
48249 char * kwnames[] = {
48250 (char *) "self",(char *) "idx",(char *) "proportion", NULL
48251 };
48252
48253 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48254 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48255 if (!SWIG_IsOK(res1)) {
48256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48257 }
48258 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48259 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48260 if (!SWIG_IsOK(ecode2)) {
48261 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
48262 }
48263 arg2 = static_cast< size_t >(val2);
48264 if (obj2) {
48265 ecode3 = SWIG_AsVal_int(obj2, &val3);
48266 if (!SWIG_IsOK(ecode3)) {
48267 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "3"" of type '" "int""'");
48268 }
48269 arg3 = static_cast< int >(val3);
48270 }
48271 {
48272 PyThreadState* __tstate = wxPyBeginAllowThreads();
48273 (arg1)->AddGrowableRow(arg2,arg3);
48274 wxPyEndAllowThreads(__tstate);
48275 if (PyErr_Occurred()) SWIG_fail;
48276 }
48277 resultobj = SWIG_Py_Void();
48278 return resultobj;
48279 fail:
48280 return NULL;
48281 }
48282
48283
48284 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48285 PyObject *resultobj = 0;
48286 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48287 size_t arg2 ;
48288 void *argp1 = 0 ;
48289 int res1 = 0 ;
48290 size_t val2 ;
48291 int ecode2 = 0 ;
48292 PyObject * obj0 = 0 ;
48293 PyObject * obj1 = 0 ;
48294 char * kwnames[] = {
48295 (char *) "self",(char *) "idx", NULL
48296 };
48297
48298 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) SWIG_fail;
48299 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48300 if (!SWIG_IsOK(res1)) {
48301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48302 }
48303 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48304 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48305 if (!SWIG_IsOK(ecode2)) {
48306 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
48307 }
48308 arg2 = static_cast< size_t >(val2);
48309 {
48310 PyThreadState* __tstate = wxPyBeginAllowThreads();
48311 (arg1)->RemoveGrowableRow(arg2);
48312 wxPyEndAllowThreads(__tstate);
48313 if (PyErr_Occurred()) SWIG_fail;
48314 }
48315 resultobj = SWIG_Py_Void();
48316 return resultobj;
48317 fail:
48318 return NULL;
48319 }
48320
48321
48322 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48323 PyObject *resultobj = 0;
48324 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48325 size_t arg2 ;
48326 int arg3 = (int) 0 ;
48327 void *argp1 = 0 ;
48328 int res1 = 0 ;
48329 size_t val2 ;
48330 int ecode2 = 0 ;
48331 int val3 ;
48332 int ecode3 = 0 ;
48333 PyObject * obj0 = 0 ;
48334 PyObject * obj1 = 0 ;
48335 PyObject * obj2 = 0 ;
48336 char * kwnames[] = {
48337 (char *) "self",(char *) "idx",(char *) "proportion", NULL
48338 };
48339
48340 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48341 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48342 if (!SWIG_IsOK(res1)) {
48343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48344 }
48345 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48346 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48347 if (!SWIG_IsOK(ecode2)) {
48348 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
48349 }
48350 arg2 = static_cast< size_t >(val2);
48351 if (obj2) {
48352 ecode3 = SWIG_AsVal_int(obj2, &val3);
48353 if (!SWIG_IsOK(ecode3)) {
48354 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "3"" of type '" "int""'");
48355 }
48356 arg3 = static_cast< int >(val3);
48357 }
48358 {
48359 PyThreadState* __tstate = wxPyBeginAllowThreads();
48360 (arg1)->AddGrowableCol(arg2,arg3);
48361 wxPyEndAllowThreads(__tstate);
48362 if (PyErr_Occurred()) SWIG_fail;
48363 }
48364 resultobj = SWIG_Py_Void();
48365 return resultobj;
48366 fail:
48367 return NULL;
48368 }
48369
48370
48371 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48372 PyObject *resultobj = 0;
48373 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48374 size_t arg2 ;
48375 void *argp1 = 0 ;
48376 int res1 = 0 ;
48377 size_t val2 ;
48378 int ecode2 = 0 ;
48379 PyObject * obj0 = 0 ;
48380 PyObject * obj1 = 0 ;
48381 char * kwnames[] = {
48382 (char *) "self",(char *) "idx", NULL
48383 };
48384
48385 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) SWIG_fail;
48386 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48387 if (!SWIG_IsOK(res1)) {
48388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48389 }
48390 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48391 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48392 if (!SWIG_IsOK(ecode2)) {
48393 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
48394 }
48395 arg2 = static_cast< size_t >(val2);
48396 {
48397 PyThreadState* __tstate = wxPyBeginAllowThreads();
48398 (arg1)->RemoveGrowableCol(arg2);
48399 wxPyEndAllowThreads(__tstate);
48400 if (PyErr_Occurred()) SWIG_fail;
48401 }
48402 resultobj = SWIG_Py_Void();
48403 return resultobj;
48404 fail:
48405 return NULL;
48406 }
48407
48408
48409 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48410 PyObject *resultobj = 0;
48411 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48412 int arg2 ;
48413 void *argp1 = 0 ;
48414 int res1 = 0 ;
48415 int val2 ;
48416 int ecode2 = 0 ;
48417 PyObject * obj0 = 0 ;
48418 PyObject * obj1 = 0 ;
48419 char * kwnames[] = {
48420 (char *) "self",(char *) "direction", NULL
48421 };
48422
48423 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) SWIG_fail;
48424 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48425 if (!SWIG_IsOK(res1)) {
48426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48427 }
48428 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48429 ecode2 = SWIG_AsVal_int(obj1, &val2);
48430 if (!SWIG_IsOK(ecode2)) {
48431 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "2"" of type '" "int""'");
48432 }
48433 arg2 = static_cast< int >(val2);
48434 {
48435 PyThreadState* __tstate = wxPyBeginAllowThreads();
48436 (arg1)->SetFlexibleDirection(arg2);
48437 wxPyEndAllowThreads(__tstate);
48438 if (PyErr_Occurred()) SWIG_fail;
48439 }
48440 resultobj = SWIG_Py_Void();
48441 return resultobj;
48442 fail:
48443 return NULL;
48444 }
48445
48446
48447 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48448 PyObject *resultobj = 0;
48449 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48450 int result;
48451 void *argp1 = 0 ;
48452 int res1 = 0 ;
48453 PyObject *swig_obj[1] ;
48454
48455 if (!args) SWIG_fail;
48456 swig_obj[0] = args;
48457 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48458 if (!SWIG_IsOK(res1)) {
48459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48460 }
48461 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48462 {
48463 PyThreadState* __tstate = wxPyBeginAllowThreads();
48464 result = (int)(arg1)->GetFlexibleDirection();
48465 wxPyEndAllowThreads(__tstate);
48466 if (PyErr_Occurred()) SWIG_fail;
48467 }
48468 resultobj = SWIG_From_int(static_cast< int >(result));
48469 return resultobj;
48470 fail:
48471 return NULL;
48472 }
48473
48474
48475 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48476 PyObject *resultobj = 0;
48477 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48478 wxFlexSizerGrowMode arg2 ;
48479 void *argp1 = 0 ;
48480 int res1 = 0 ;
48481 int val2 ;
48482 int ecode2 = 0 ;
48483 PyObject * obj0 = 0 ;
48484 PyObject * obj1 = 0 ;
48485 char * kwnames[] = {
48486 (char *) "self",(char *) "mode", NULL
48487 };
48488
48489 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) SWIG_fail;
48490 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48491 if (!SWIG_IsOK(res1)) {
48492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48493 }
48494 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48495 ecode2 = SWIG_AsVal_int(obj1, &val2);
48496 if (!SWIG_IsOK(ecode2)) {
48497 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "2"" of type '" "wxFlexSizerGrowMode""'");
48498 }
48499 arg2 = static_cast< wxFlexSizerGrowMode >(val2);
48500 {
48501 PyThreadState* __tstate = wxPyBeginAllowThreads();
48502 (arg1)->SetNonFlexibleGrowMode(arg2);
48503 wxPyEndAllowThreads(__tstate);
48504 if (PyErr_Occurred()) SWIG_fail;
48505 }
48506 resultobj = SWIG_Py_Void();
48507 return resultobj;
48508 fail:
48509 return NULL;
48510 }
48511
48512
48513 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48514 PyObject *resultobj = 0;
48515 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48516 wxFlexSizerGrowMode result;
48517 void *argp1 = 0 ;
48518 int res1 = 0 ;
48519 PyObject *swig_obj[1] ;
48520
48521 if (!args) SWIG_fail;
48522 swig_obj[0] = args;
48523 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48524 if (!SWIG_IsOK(res1)) {
48525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48526 }
48527 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48528 {
48529 PyThreadState* __tstate = wxPyBeginAllowThreads();
48530 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
48531 wxPyEndAllowThreads(__tstate);
48532 if (PyErr_Occurred()) SWIG_fail;
48533 }
48534 resultobj = SWIG_From_int(static_cast< int >(result));
48535 return resultobj;
48536 fail:
48537 return NULL;
48538 }
48539
48540
48541 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48542 PyObject *resultobj = 0;
48543 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48544 wxArrayInt *result = 0 ;
48545 void *argp1 = 0 ;
48546 int res1 = 0 ;
48547 PyObject *swig_obj[1] ;
48548
48549 if (!args) SWIG_fail;
48550 swig_obj[0] = args;
48551 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48552 if (!SWIG_IsOK(res1)) {
48553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetRowHeights" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
48554 }
48555 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48556 {
48557 PyThreadState* __tstate = wxPyBeginAllowThreads();
48558 {
48559 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
48560 result = (wxArrayInt *) &_result_ref;
48561 }
48562 wxPyEndAllowThreads(__tstate);
48563 if (PyErr_Occurred()) SWIG_fail;
48564 }
48565 {
48566 resultobj = PyList_New(0);
48567 size_t idx;
48568 for (idx = 0; idx < result->GetCount(); idx += 1) {
48569 PyObject* val = PyInt_FromLong( result->Item(idx) );
48570 PyList_Append(resultobj, val);
48571 Py_DECREF(val);
48572 }
48573 }
48574 return resultobj;
48575 fail:
48576 return NULL;
48577 }
48578
48579
48580 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48581 PyObject *resultobj = 0;
48582 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48583 wxArrayInt *result = 0 ;
48584 void *argp1 = 0 ;
48585 int res1 = 0 ;
48586 PyObject *swig_obj[1] ;
48587
48588 if (!args) SWIG_fail;
48589 swig_obj[0] = args;
48590 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48591 if (!SWIG_IsOK(res1)) {
48592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetColWidths" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
48593 }
48594 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48595 {
48596 PyThreadState* __tstate = wxPyBeginAllowThreads();
48597 {
48598 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
48599 result = (wxArrayInt *) &_result_ref;
48600 }
48601 wxPyEndAllowThreads(__tstate);
48602 if (PyErr_Occurred()) SWIG_fail;
48603 }
48604 {
48605 resultobj = PyList_New(0);
48606 size_t idx;
48607 for (idx = 0; idx < result->GetCount(); idx += 1) {
48608 PyObject* val = PyInt_FromLong( result->Item(idx) );
48609 PyList_Append(resultobj, val);
48610 Py_DECREF(val);
48611 }
48612 }
48613 return resultobj;
48614 fail:
48615 return NULL;
48616 }
48617
48618
48619 SWIGINTERN PyObject *FlexGridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48620 PyObject *obj;
48621 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48622 SWIG_TypeNewClientData(SWIGTYPE_p_wxFlexGridSizer, SWIG_NewClientData(obj));
48623 return SWIG_Py_Void();
48624 }
48625
48626 SWIGINTERN PyObject *FlexGridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48627 return SWIG_Python_InitShadowInstance(args);
48628 }
48629
48630 SWIGINTERN PyObject *_wrap_new_StdDialogButtonSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48631 PyObject *resultobj = 0;
48632 wxStdDialogButtonSizer *result = 0 ;
48633
48634 if (!SWIG_Python_UnpackTuple(args,"new_StdDialogButtonSizer",0,0,0)) SWIG_fail;
48635 {
48636 PyThreadState* __tstate = wxPyBeginAllowThreads();
48637 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
48638 wxPyEndAllowThreads(__tstate);
48639 if (PyErr_Occurred()) SWIG_fail;
48640 }
48641 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_NEW | 0 );
48642 return resultobj;
48643 fail:
48644 return NULL;
48645 }
48646
48647
48648 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48649 PyObject *resultobj = 0;
48650 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48651 wxButton *arg2 = (wxButton *) 0 ;
48652 void *argp1 = 0 ;
48653 int res1 = 0 ;
48654 void *argp2 = 0 ;
48655 int res2 = 0 ;
48656 PyObject * obj0 = 0 ;
48657 PyObject * obj1 = 0 ;
48658 char * kwnames[] = {
48659 (char *) "self",(char *) "button", NULL
48660 };
48661
48662 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) SWIG_fail;
48663 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48664 if (!SWIG_IsOK(res1)) {
48665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48666 }
48667 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48668 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48669 if (!SWIG_IsOK(res2)) {
48670 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "2"" of type '" "wxButton *""'");
48671 }
48672 arg2 = reinterpret_cast< wxButton * >(argp2);
48673 {
48674 PyThreadState* __tstate = wxPyBeginAllowThreads();
48675 (arg1)->AddButton(arg2);
48676 wxPyEndAllowThreads(__tstate);
48677 if (PyErr_Occurred()) SWIG_fail;
48678 }
48679 resultobj = SWIG_Py_Void();
48680 return resultobj;
48681 fail:
48682 return NULL;
48683 }
48684
48685
48686 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48687 PyObject *resultobj = 0;
48688 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48689 void *argp1 = 0 ;
48690 int res1 = 0 ;
48691 PyObject *swig_obj[1] ;
48692
48693 if (!args) SWIG_fail;
48694 swig_obj[0] = args;
48695 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48696 if (!SWIG_IsOK(res1)) {
48697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_Realize" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48698 }
48699 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48700 {
48701 PyThreadState* __tstate = wxPyBeginAllowThreads();
48702 (arg1)->Realize();
48703 wxPyEndAllowThreads(__tstate);
48704 if (PyErr_Occurred()) SWIG_fail;
48705 }
48706 resultobj = SWIG_Py_Void();
48707 return resultobj;
48708 fail:
48709 return NULL;
48710 }
48711
48712
48713 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48714 PyObject *resultobj = 0;
48715 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48716 wxButton *arg2 = (wxButton *) 0 ;
48717 void *argp1 = 0 ;
48718 int res1 = 0 ;
48719 void *argp2 = 0 ;
48720 int res2 = 0 ;
48721 PyObject * obj0 = 0 ;
48722 PyObject * obj1 = 0 ;
48723 char * kwnames[] = {
48724 (char *) "self",(char *) "button", NULL
48725 };
48726
48727 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
48728 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48729 if (!SWIG_IsOK(res1)) {
48730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48731 }
48732 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48733 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48734 if (!SWIG_IsOK(res2)) {
48735 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
48736 }
48737 arg2 = reinterpret_cast< wxButton * >(argp2);
48738 {
48739 PyThreadState* __tstate = wxPyBeginAllowThreads();
48740 (arg1)->SetAffirmativeButton(arg2);
48741 wxPyEndAllowThreads(__tstate);
48742 if (PyErr_Occurred()) SWIG_fail;
48743 }
48744 resultobj = SWIG_Py_Void();
48745 return resultobj;
48746 fail:
48747 return NULL;
48748 }
48749
48750
48751 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48752 PyObject *resultobj = 0;
48753 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48754 wxButton *arg2 = (wxButton *) 0 ;
48755 void *argp1 = 0 ;
48756 int res1 = 0 ;
48757 void *argp2 = 0 ;
48758 int res2 = 0 ;
48759 PyObject * obj0 = 0 ;
48760 PyObject * obj1 = 0 ;
48761 char * kwnames[] = {
48762 (char *) "self",(char *) "button", NULL
48763 };
48764
48765 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
48766 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48767 if (!SWIG_IsOK(res1)) {
48768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48769 }
48770 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48771 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48772 if (!SWIG_IsOK(res2)) {
48773 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
48774 }
48775 arg2 = reinterpret_cast< wxButton * >(argp2);
48776 {
48777 PyThreadState* __tstate = wxPyBeginAllowThreads();
48778 (arg1)->SetNegativeButton(arg2);
48779 wxPyEndAllowThreads(__tstate);
48780 if (PyErr_Occurred()) SWIG_fail;
48781 }
48782 resultobj = SWIG_Py_Void();
48783 return resultobj;
48784 fail:
48785 return NULL;
48786 }
48787
48788
48789 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48790 PyObject *resultobj = 0;
48791 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48792 wxButton *arg2 = (wxButton *) 0 ;
48793 void *argp1 = 0 ;
48794 int res1 = 0 ;
48795 void *argp2 = 0 ;
48796 int res2 = 0 ;
48797 PyObject * obj0 = 0 ;
48798 PyObject * obj1 = 0 ;
48799 char * kwnames[] = {
48800 (char *) "self",(char *) "button", NULL
48801 };
48802
48803 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) SWIG_fail;
48804 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48805 if (!SWIG_IsOK(res1)) {
48806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48807 }
48808 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48809 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48810 if (!SWIG_IsOK(res2)) {
48811 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "2"" of type '" "wxButton *""'");
48812 }
48813 arg2 = reinterpret_cast< wxButton * >(argp2);
48814 {
48815 PyThreadState* __tstate = wxPyBeginAllowThreads();
48816 (arg1)->SetCancelButton(arg2);
48817 wxPyEndAllowThreads(__tstate);
48818 if (PyErr_Occurred()) SWIG_fail;
48819 }
48820 resultobj = SWIG_Py_Void();
48821 return resultobj;
48822 fail:
48823 return NULL;
48824 }
48825
48826
48827 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48828 PyObject *resultobj = 0;
48829 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48830 wxButton *result = 0 ;
48831 void *argp1 = 0 ;
48832 int res1 = 0 ;
48833 PyObject *swig_obj[1] ;
48834
48835 if (!args) SWIG_fail;
48836 swig_obj[0] = args;
48837 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48838 if (!SWIG_IsOK(res1)) {
48839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48840 }
48841 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48842 {
48843 PyThreadState* __tstate = wxPyBeginAllowThreads();
48844 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
48845 wxPyEndAllowThreads(__tstate);
48846 if (PyErr_Occurred()) SWIG_fail;
48847 }
48848 {
48849 resultobj = wxPyMake_wxObject(result, (bool)0);
48850 }
48851 return resultobj;
48852 fail:
48853 return NULL;
48854 }
48855
48856
48857 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48858 PyObject *resultobj = 0;
48859 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48860 wxButton *result = 0 ;
48861 void *argp1 = 0 ;
48862 int res1 = 0 ;
48863 PyObject *swig_obj[1] ;
48864
48865 if (!args) SWIG_fail;
48866 swig_obj[0] = args;
48867 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48868 if (!SWIG_IsOK(res1)) {
48869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetApplyButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48870 }
48871 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48872 {
48873 PyThreadState* __tstate = wxPyBeginAllowThreads();
48874 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
48875 wxPyEndAllowThreads(__tstate);
48876 if (PyErr_Occurred()) SWIG_fail;
48877 }
48878 {
48879 resultobj = wxPyMake_wxObject(result, (bool)0);
48880 }
48881 return resultobj;
48882 fail:
48883 return NULL;
48884 }
48885
48886
48887 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48888 PyObject *resultobj = 0;
48889 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48890 wxButton *result = 0 ;
48891 void *argp1 = 0 ;
48892 int res1 = 0 ;
48893 PyObject *swig_obj[1] ;
48894
48895 if (!args) SWIG_fail;
48896 swig_obj[0] = args;
48897 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48898 if (!SWIG_IsOK(res1)) {
48899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48900 }
48901 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48902 {
48903 PyThreadState* __tstate = wxPyBeginAllowThreads();
48904 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
48905 wxPyEndAllowThreads(__tstate);
48906 if (PyErr_Occurred()) SWIG_fail;
48907 }
48908 {
48909 resultobj = wxPyMake_wxObject(result, (bool)0);
48910 }
48911 return resultobj;
48912 fail:
48913 return NULL;
48914 }
48915
48916
48917 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48918 PyObject *resultobj = 0;
48919 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48920 wxButton *result = 0 ;
48921 void *argp1 = 0 ;
48922 int res1 = 0 ;
48923 PyObject *swig_obj[1] ;
48924
48925 if (!args) SWIG_fail;
48926 swig_obj[0] = args;
48927 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48928 if (!SWIG_IsOK(res1)) {
48929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48930 }
48931 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48932 {
48933 PyThreadState* __tstate = wxPyBeginAllowThreads();
48934 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
48935 wxPyEndAllowThreads(__tstate);
48936 if (PyErr_Occurred()) SWIG_fail;
48937 }
48938 {
48939 resultobj = wxPyMake_wxObject(result, (bool)0);
48940 }
48941 return resultobj;
48942 fail:
48943 return NULL;
48944 }
48945
48946
48947 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48948 PyObject *resultobj = 0;
48949 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48950 wxButton *result = 0 ;
48951 void *argp1 = 0 ;
48952 int res1 = 0 ;
48953 PyObject *swig_obj[1] ;
48954
48955 if (!args) SWIG_fail;
48956 swig_obj[0] = args;
48957 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48958 if (!SWIG_IsOK(res1)) {
48959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetHelpButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48960 }
48961 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48962 {
48963 PyThreadState* __tstate = wxPyBeginAllowThreads();
48964 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
48965 wxPyEndAllowThreads(__tstate);
48966 if (PyErr_Occurred()) SWIG_fail;
48967 }
48968 {
48969 resultobj = wxPyMake_wxObject(result, (bool)0);
48970 }
48971 return resultobj;
48972 fail:
48973 return NULL;
48974 }
48975
48976
48977 SWIGINTERN PyObject *StdDialogButtonSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48978 PyObject *obj;
48979 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48980 SWIG_TypeNewClientData(SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_NewClientData(obj));
48981 return SWIG_Py_Void();
48982 }
48983
48984 SWIGINTERN PyObject *StdDialogButtonSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48985 return SWIG_Python_InitShadowInstance(args);
48986 }
48987
48988 SWIGINTERN PyObject *_wrap_new_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48989 PyObject *resultobj = 0;
48990 int arg1 = (int) 0 ;
48991 int arg2 = (int) 0 ;
48992 wxGBPosition *result = 0 ;
48993 int val1 ;
48994 int ecode1 = 0 ;
48995 int val2 ;
48996 int ecode2 = 0 ;
48997 PyObject * obj0 = 0 ;
48998 PyObject * obj1 = 0 ;
48999 char * kwnames[] = {
49000 (char *) "row",(char *) "col", NULL
49001 };
49002
49003 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) SWIG_fail;
49004 if (obj0) {
49005 ecode1 = SWIG_AsVal_int(obj0, &val1);
49006 if (!SWIG_IsOK(ecode1)) {
49007 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBPosition" "', expected argument " "1"" of type '" "int""'");
49008 }
49009 arg1 = static_cast< int >(val1);
49010 }
49011 if (obj1) {
49012 ecode2 = SWIG_AsVal_int(obj1, &val2);
49013 if (!SWIG_IsOK(ecode2)) {
49014 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBPosition" "', expected argument " "2"" of type '" "int""'");
49015 }
49016 arg2 = static_cast< int >(val2);
49017 }
49018 {
49019 PyThreadState* __tstate = wxPyBeginAllowThreads();
49020 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
49021 wxPyEndAllowThreads(__tstate);
49022 if (PyErr_Occurred()) SWIG_fail;
49023 }
49024 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_NEW | 0 );
49025 return resultobj;
49026 fail:
49027 return NULL;
49028 }
49029
49030
49031 SWIGINTERN PyObject *_wrap_delete_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49032 PyObject *resultobj = 0;
49033 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49034 void *argp1 = 0 ;
49035 int res1 = 0 ;
49036 PyObject *swig_obj[1] ;
49037
49038 if (!args) SWIG_fail;
49039 swig_obj[0] = args;
49040 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, SWIG_POINTER_DISOWN | 0 );
49041 if (!SWIG_IsOK(res1)) {
49042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBPosition" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49043 }
49044 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49045 {
49046 PyThreadState* __tstate = wxPyBeginAllowThreads();
49047 delete arg1;
49048
49049 wxPyEndAllowThreads(__tstate);
49050 if (PyErr_Occurred()) SWIG_fail;
49051 }
49052 resultobj = SWIG_Py_Void();
49053 return resultobj;
49054 fail:
49055 return NULL;
49056 }
49057
49058
49059 SWIGINTERN PyObject *_wrap_GBPosition_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49060 PyObject *resultobj = 0;
49061 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49062 int result;
49063 void *argp1 = 0 ;
49064 int res1 = 0 ;
49065 PyObject *swig_obj[1] ;
49066
49067 if (!args) SWIG_fail;
49068 swig_obj[0] = args;
49069 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49070 if (!SWIG_IsOK(res1)) {
49071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetRow" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
49072 }
49073 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49074 {
49075 PyThreadState* __tstate = wxPyBeginAllowThreads();
49076 result = (int)((wxGBPosition const *)arg1)->GetRow();
49077 wxPyEndAllowThreads(__tstate);
49078 if (PyErr_Occurred()) SWIG_fail;
49079 }
49080 resultobj = SWIG_From_int(static_cast< int >(result));
49081 return resultobj;
49082 fail:
49083 return NULL;
49084 }
49085
49086
49087 SWIGINTERN PyObject *_wrap_GBPosition_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49088 PyObject *resultobj = 0;
49089 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49090 int result;
49091 void *argp1 = 0 ;
49092 int res1 = 0 ;
49093 PyObject *swig_obj[1] ;
49094
49095 if (!args) SWIG_fail;
49096 swig_obj[0] = args;
49097 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49098 if (!SWIG_IsOK(res1)) {
49099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetCol" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
49100 }
49101 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49102 {
49103 PyThreadState* __tstate = wxPyBeginAllowThreads();
49104 result = (int)((wxGBPosition const *)arg1)->GetCol();
49105 wxPyEndAllowThreads(__tstate);
49106 if (PyErr_Occurred()) SWIG_fail;
49107 }
49108 resultobj = SWIG_From_int(static_cast< int >(result));
49109 return resultobj;
49110 fail:
49111 return NULL;
49112 }
49113
49114
49115 SWIGINTERN PyObject *_wrap_GBPosition_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49116 PyObject *resultobj = 0;
49117 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49118 int arg2 ;
49119 void *argp1 = 0 ;
49120 int res1 = 0 ;
49121 int val2 ;
49122 int ecode2 = 0 ;
49123 PyObject * obj0 = 0 ;
49124 PyObject * obj1 = 0 ;
49125 char * kwnames[] = {
49126 (char *) "self",(char *) "row", NULL
49127 };
49128
49129 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
49130 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49131 if (!SWIG_IsOK(res1)) {
49132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetRow" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49133 }
49134 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49135 ecode2 = SWIG_AsVal_int(obj1, &val2);
49136 if (!SWIG_IsOK(ecode2)) {
49137 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetRow" "', expected argument " "2"" of type '" "int""'");
49138 }
49139 arg2 = static_cast< int >(val2);
49140 {
49141 PyThreadState* __tstate = wxPyBeginAllowThreads();
49142 (arg1)->SetRow(arg2);
49143 wxPyEndAllowThreads(__tstate);
49144 if (PyErr_Occurred()) SWIG_fail;
49145 }
49146 resultobj = SWIG_Py_Void();
49147 return resultobj;
49148 fail:
49149 return NULL;
49150 }
49151
49152
49153 SWIGINTERN PyObject *_wrap_GBPosition_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49154 PyObject *resultobj = 0;
49155 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49156 int arg2 ;
49157 void *argp1 = 0 ;
49158 int res1 = 0 ;
49159 int val2 ;
49160 int ecode2 = 0 ;
49161 PyObject * obj0 = 0 ;
49162 PyObject * obj1 = 0 ;
49163 char * kwnames[] = {
49164 (char *) "self",(char *) "col", NULL
49165 };
49166
49167 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
49168 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49169 if (!SWIG_IsOK(res1)) {
49170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetCol" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49171 }
49172 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49173 ecode2 = SWIG_AsVal_int(obj1, &val2);
49174 if (!SWIG_IsOK(ecode2)) {
49175 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetCol" "', expected argument " "2"" of type '" "int""'");
49176 }
49177 arg2 = static_cast< int >(val2);
49178 {
49179 PyThreadState* __tstate = wxPyBeginAllowThreads();
49180 (arg1)->SetCol(arg2);
49181 wxPyEndAllowThreads(__tstate);
49182 if (PyErr_Occurred()) SWIG_fail;
49183 }
49184 resultobj = SWIG_Py_Void();
49185 return resultobj;
49186 fail:
49187 return NULL;
49188 }
49189
49190
49191 SWIGINTERN PyObject *_wrap_GBPosition___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49192 PyObject *resultobj = 0;
49193 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49194 PyObject *arg2 = (PyObject *) 0 ;
49195 bool result;
49196 void *argp1 = 0 ;
49197 int res1 = 0 ;
49198 PyObject * obj0 = 0 ;
49199 PyObject * obj1 = 0 ;
49200 char * kwnames[] = {
49201 (char *) "self",(char *) "other", NULL
49202 };
49203
49204 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
49205 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49206 if (!SWIG_IsOK(res1)) {
49207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___eq__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49208 }
49209 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49210 arg2 = obj1;
49211 {
49212 result = (bool)wxGBPosition___eq__(arg1,arg2);
49213 if (PyErr_Occurred()) SWIG_fail;
49214 }
49215 {
49216 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49217 }
49218 return resultobj;
49219 fail:
49220 return NULL;
49221 }
49222
49223
49224 SWIGINTERN PyObject *_wrap_GBPosition___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49225 PyObject *resultobj = 0;
49226 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49227 PyObject *arg2 = (PyObject *) 0 ;
49228 bool result;
49229 void *argp1 = 0 ;
49230 int res1 = 0 ;
49231 PyObject * obj0 = 0 ;
49232 PyObject * obj1 = 0 ;
49233 char * kwnames[] = {
49234 (char *) "self",(char *) "other", NULL
49235 };
49236
49237 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
49238 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49239 if (!SWIG_IsOK(res1)) {
49240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___ne__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49241 }
49242 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49243 arg2 = obj1;
49244 {
49245 result = (bool)wxGBPosition___ne__(arg1,arg2);
49246 if (PyErr_Occurred()) SWIG_fail;
49247 }
49248 {
49249 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49250 }
49251 return resultobj;
49252 fail:
49253 return NULL;
49254 }
49255
49256
49257 SWIGINTERN PyObject *_wrap_GBPosition_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49258 PyObject *resultobj = 0;
49259 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49260 int arg2 = (int) 0 ;
49261 int arg3 = (int) 0 ;
49262 void *argp1 = 0 ;
49263 int res1 = 0 ;
49264 int val2 ;
49265 int ecode2 = 0 ;
49266 int val3 ;
49267 int ecode3 = 0 ;
49268 PyObject * obj0 = 0 ;
49269 PyObject * obj1 = 0 ;
49270 PyObject * obj2 = 0 ;
49271 char * kwnames[] = {
49272 (char *) "self",(char *) "row",(char *) "col", NULL
49273 };
49274
49275 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49276 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49277 if (!SWIG_IsOK(res1)) {
49278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Set" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49279 }
49280 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49281 if (obj1) {
49282 ecode2 = SWIG_AsVal_int(obj1, &val2);
49283 if (!SWIG_IsOK(ecode2)) {
49284 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_Set" "', expected argument " "2"" of type '" "int""'");
49285 }
49286 arg2 = static_cast< int >(val2);
49287 }
49288 if (obj2) {
49289 ecode3 = SWIG_AsVal_int(obj2, &val3);
49290 if (!SWIG_IsOK(ecode3)) {
49291 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBPosition_Set" "', expected argument " "3"" of type '" "int""'");
49292 }
49293 arg3 = static_cast< int >(val3);
49294 }
49295 {
49296 PyThreadState* __tstate = wxPyBeginAllowThreads();
49297 wxGBPosition_Set(arg1,arg2,arg3);
49298 wxPyEndAllowThreads(__tstate);
49299 if (PyErr_Occurred()) SWIG_fail;
49300 }
49301 resultobj = SWIG_Py_Void();
49302 return resultobj;
49303 fail:
49304 return NULL;
49305 }
49306
49307
49308 SWIGINTERN PyObject *_wrap_GBPosition_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49309 PyObject *resultobj = 0;
49310 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49311 PyObject *result = 0 ;
49312 void *argp1 = 0 ;
49313 int res1 = 0 ;
49314 PyObject *swig_obj[1] ;
49315
49316 if (!args) SWIG_fail;
49317 swig_obj[0] = args;
49318 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49319 if (!SWIG_IsOK(res1)) {
49320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Get" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49321 }
49322 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49323 {
49324 PyThreadState* __tstate = wxPyBeginAllowThreads();
49325 result = (PyObject *)wxGBPosition_Get(arg1);
49326 wxPyEndAllowThreads(__tstate);
49327 if (PyErr_Occurred()) SWIG_fail;
49328 }
49329 resultobj = result;
49330 return resultobj;
49331 fail:
49332 return NULL;
49333 }
49334
49335
49336 SWIGINTERN PyObject *GBPosition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49337 PyObject *obj;
49338 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49339 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBPosition, SWIG_NewClientData(obj));
49340 return SWIG_Py_Void();
49341 }
49342
49343 SWIGINTERN PyObject *GBPosition_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49344 return SWIG_Python_InitShadowInstance(args);
49345 }
49346
49347 SWIGINTERN PyObject *_wrap_new_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49348 PyObject *resultobj = 0;
49349 int arg1 = (int) 1 ;
49350 int arg2 = (int) 1 ;
49351 wxGBSpan *result = 0 ;
49352 int val1 ;
49353 int ecode1 = 0 ;
49354 int val2 ;
49355 int ecode2 = 0 ;
49356 PyObject * obj0 = 0 ;
49357 PyObject * obj1 = 0 ;
49358 char * kwnames[] = {
49359 (char *) "rowspan",(char *) "colspan", NULL
49360 };
49361
49362 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) SWIG_fail;
49363 if (obj0) {
49364 ecode1 = SWIG_AsVal_int(obj0, &val1);
49365 if (!SWIG_IsOK(ecode1)) {
49366 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSpan" "', expected argument " "1"" of type '" "int""'");
49367 }
49368 arg1 = static_cast< int >(val1);
49369 }
49370 if (obj1) {
49371 ecode2 = SWIG_AsVal_int(obj1, &val2);
49372 if (!SWIG_IsOK(ecode2)) {
49373 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSpan" "', expected argument " "2"" of type '" "int""'");
49374 }
49375 arg2 = static_cast< int >(val2);
49376 }
49377 {
49378 PyThreadState* __tstate = wxPyBeginAllowThreads();
49379 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
49380 wxPyEndAllowThreads(__tstate);
49381 if (PyErr_Occurred()) SWIG_fail;
49382 }
49383 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_NEW | 0 );
49384 return resultobj;
49385 fail:
49386 return NULL;
49387 }
49388
49389
49390 SWIGINTERN PyObject *_wrap_delete_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49391 PyObject *resultobj = 0;
49392 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49393 void *argp1 = 0 ;
49394 int res1 = 0 ;
49395 PyObject *swig_obj[1] ;
49396
49397 if (!args) SWIG_fail;
49398 swig_obj[0] = args;
49399 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, SWIG_POINTER_DISOWN | 0 );
49400 if (!SWIG_IsOK(res1)) {
49401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSpan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49402 }
49403 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49404 {
49405 PyThreadState* __tstate = wxPyBeginAllowThreads();
49406 delete arg1;
49407
49408 wxPyEndAllowThreads(__tstate);
49409 if (PyErr_Occurred()) SWIG_fail;
49410 }
49411 resultobj = SWIG_Py_Void();
49412 return resultobj;
49413 fail:
49414 return NULL;
49415 }
49416
49417
49418 SWIGINTERN PyObject *_wrap_GBSpan_GetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49419 PyObject *resultobj = 0;
49420 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49421 int result;
49422 void *argp1 = 0 ;
49423 int res1 = 0 ;
49424 PyObject *swig_obj[1] ;
49425
49426 if (!args) SWIG_fail;
49427 swig_obj[0] = args;
49428 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49429 if (!SWIG_IsOK(res1)) {
49430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetRowspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
49431 }
49432 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49433 {
49434 PyThreadState* __tstate = wxPyBeginAllowThreads();
49435 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
49436 wxPyEndAllowThreads(__tstate);
49437 if (PyErr_Occurred()) SWIG_fail;
49438 }
49439 resultobj = SWIG_From_int(static_cast< int >(result));
49440 return resultobj;
49441 fail:
49442 return NULL;
49443 }
49444
49445
49446 SWIGINTERN PyObject *_wrap_GBSpan_GetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49447 PyObject *resultobj = 0;
49448 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49449 int result;
49450 void *argp1 = 0 ;
49451 int res1 = 0 ;
49452 PyObject *swig_obj[1] ;
49453
49454 if (!args) SWIG_fail;
49455 swig_obj[0] = args;
49456 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49457 if (!SWIG_IsOK(res1)) {
49458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetColspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
49459 }
49460 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49461 {
49462 PyThreadState* __tstate = wxPyBeginAllowThreads();
49463 result = (int)((wxGBSpan const *)arg1)->GetColspan();
49464 wxPyEndAllowThreads(__tstate);
49465 if (PyErr_Occurred()) SWIG_fail;
49466 }
49467 resultobj = SWIG_From_int(static_cast< int >(result));
49468 return resultobj;
49469 fail:
49470 return NULL;
49471 }
49472
49473
49474 SWIGINTERN PyObject *_wrap_GBSpan_SetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49475 PyObject *resultobj = 0;
49476 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49477 int arg2 ;
49478 void *argp1 = 0 ;
49479 int res1 = 0 ;
49480 int val2 ;
49481 int ecode2 = 0 ;
49482 PyObject * obj0 = 0 ;
49483 PyObject * obj1 = 0 ;
49484 char * kwnames[] = {
49485 (char *) "self",(char *) "rowspan", NULL
49486 };
49487
49488 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) SWIG_fail;
49489 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49490 if (!SWIG_IsOK(res1)) {
49491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetRowspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49492 }
49493 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49494 ecode2 = SWIG_AsVal_int(obj1, &val2);
49495 if (!SWIG_IsOK(ecode2)) {
49496 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetRowspan" "', expected argument " "2"" of type '" "int""'");
49497 }
49498 arg2 = static_cast< int >(val2);
49499 {
49500 PyThreadState* __tstate = wxPyBeginAllowThreads();
49501 (arg1)->SetRowspan(arg2);
49502 wxPyEndAllowThreads(__tstate);
49503 if (PyErr_Occurred()) SWIG_fail;
49504 }
49505 resultobj = SWIG_Py_Void();
49506 return resultobj;
49507 fail:
49508 return NULL;
49509 }
49510
49511
49512 SWIGINTERN PyObject *_wrap_GBSpan_SetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49513 PyObject *resultobj = 0;
49514 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49515 int arg2 ;
49516 void *argp1 = 0 ;
49517 int res1 = 0 ;
49518 int val2 ;
49519 int ecode2 = 0 ;
49520 PyObject * obj0 = 0 ;
49521 PyObject * obj1 = 0 ;
49522 char * kwnames[] = {
49523 (char *) "self",(char *) "colspan", NULL
49524 };
49525
49526 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) SWIG_fail;
49527 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49528 if (!SWIG_IsOK(res1)) {
49529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetColspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49530 }
49531 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49532 ecode2 = SWIG_AsVal_int(obj1, &val2);
49533 if (!SWIG_IsOK(ecode2)) {
49534 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetColspan" "', expected argument " "2"" of type '" "int""'");
49535 }
49536 arg2 = static_cast< int >(val2);
49537 {
49538 PyThreadState* __tstate = wxPyBeginAllowThreads();
49539 (arg1)->SetColspan(arg2);
49540 wxPyEndAllowThreads(__tstate);
49541 if (PyErr_Occurred()) SWIG_fail;
49542 }
49543 resultobj = SWIG_Py_Void();
49544 return resultobj;
49545 fail:
49546 return NULL;
49547 }
49548
49549
49550 SWIGINTERN PyObject *_wrap_GBSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49551 PyObject *resultobj = 0;
49552 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49553 PyObject *arg2 = (PyObject *) 0 ;
49554 bool result;
49555 void *argp1 = 0 ;
49556 int res1 = 0 ;
49557 PyObject * obj0 = 0 ;
49558 PyObject * obj1 = 0 ;
49559 char * kwnames[] = {
49560 (char *) "self",(char *) "other", NULL
49561 };
49562
49563 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
49564 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49565 if (!SWIG_IsOK(res1)) {
49566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___eq__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49567 }
49568 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49569 arg2 = obj1;
49570 {
49571 result = (bool)wxGBSpan___eq__(arg1,arg2);
49572 if (PyErr_Occurred()) SWIG_fail;
49573 }
49574 {
49575 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49576 }
49577 return resultobj;
49578 fail:
49579 return NULL;
49580 }
49581
49582
49583 SWIGINTERN PyObject *_wrap_GBSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49584 PyObject *resultobj = 0;
49585 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49586 PyObject *arg2 = (PyObject *) 0 ;
49587 bool result;
49588 void *argp1 = 0 ;
49589 int res1 = 0 ;
49590 PyObject * obj0 = 0 ;
49591 PyObject * obj1 = 0 ;
49592 char * kwnames[] = {
49593 (char *) "self",(char *) "other", NULL
49594 };
49595
49596 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
49597 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49598 if (!SWIG_IsOK(res1)) {
49599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___ne__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49600 }
49601 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49602 arg2 = obj1;
49603 {
49604 result = (bool)wxGBSpan___ne__(arg1,arg2);
49605 if (PyErr_Occurred()) SWIG_fail;
49606 }
49607 {
49608 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49609 }
49610 return resultobj;
49611 fail:
49612 return NULL;
49613 }
49614
49615
49616 SWIGINTERN PyObject *_wrap_GBSpan_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49617 PyObject *resultobj = 0;
49618 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49619 int arg2 = (int) 1 ;
49620 int arg3 = (int) 1 ;
49621 void *argp1 = 0 ;
49622 int res1 = 0 ;
49623 int val2 ;
49624 int ecode2 = 0 ;
49625 int val3 ;
49626 int ecode3 = 0 ;
49627 PyObject * obj0 = 0 ;
49628 PyObject * obj1 = 0 ;
49629 PyObject * obj2 = 0 ;
49630 char * kwnames[] = {
49631 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
49632 };
49633
49634 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49635 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49636 if (!SWIG_IsOK(res1)) {
49637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Set" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49638 }
49639 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49640 if (obj1) {
49641 ecode2 = SWIG_AsVal_int(obj1, &val2);
49642 if (!SWIG_IsOK(ecode2)) {
49643 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_Set" "', expected argument " "2"" of type '" "int""'");
49644 }
49645 arg2 = static_cast< int >(val2);
49646 }
49647 if (obj2) {
49648 ecode3 = SWIG_AsVal_int(obj2, &val3);
49649 if (!SWIG_IsOK(ecode3)) {
49650 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBSpan_Set" "', expected argument " "3"" of type '" "int""'");
49651 }
49652 arg3 = static_cast< int >(val3);
49653 }
49654 {
49655 PyThreadState* __tstate = wxPyBeginAllowThreads();
49656 wxGBSpan_Set(arg1,arg2,arg3);
49657 wxPyEndAllowThreads(__tstate);
49658 if (PyErr_Occurred()) SWIG_fail;
49659 }
49660 resultobj = SWIG_Py_Void();
49661 return resultobj;
49662 fail:
49663 return NULL;
49664 }
49665
49666
49667 SWIGINTERN PyObject *_wrap_GBSpan_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49668 PyObject *resultobj = 0;
49669 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49670 PyObject *result = 0 ;
49671 void *argp1 = 0 ;
49672 int res1 = 0 ;
49673 PyObject *swig_obj[1] ;
49674
49675 if (!args) SWIG_fail;
49676 swig_obj[0] = args;
49677 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49678 if (!SWIG_IsOK(res1)) {
49679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Get" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49680 }
49681 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49682 {
49683 PyThreadState* __tstate = wxPyBeginAllowThreads();
49684 result = (PyObject *)wxGBSpan_Get(arg1);
49685 wxPyEndAllowThreads(__tstate);
49686 if (PyErr_Occurred()) SWIG_fail;
49687 }
49688 resultobj = result;
49689 return resultobj;
49690 fail:
49691 return NULL;
49692 }
49693
49694
49695 SWIGINTERN PyObject *GBSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49696 PyObject *obj;
49697 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49698 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSpan, SWIG_NewClientData(obj));
49699 return SWIG_Py_Void();
49700 }
49701
49702 SWIGINTERN PyObject *GBSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49703 return SWIG_Python_InitShadowInstance(args);
49704 }
49705
49706 SWIGINTERN int DefaultSpan_set(PyObject *) {
49707 SWIG_Error(SWIG_AttributeError,"Variable DefaultSpan is read-only.");
49708 return 1;
49709 }
49710
49711
49712 SWIGINTERN PyObject *DefaultSpan_get(void) {
49713 PyObject *pyobj = 0;
49714
49715 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0 );
49716 return pyobj;
49717 }
49718
49719
49720 SWIGINTERN PyObject *_wrap_new_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49721 PyObject *resultobj = 0;
49722 wxGBSizerItem *result = 0 ;
49723
49724 if (!SWIG_Python_UnpackTuple(args,"new_GBSizerItem",0,0,0)) SWIG_fail;
49725 {
49726 PyThreadState* __tstate = wxPyBeginAllowThreads();
49727 result = (wxGBSizerItem *)new wxGBSizerItem();
49728 wxPyEndAllowThreads(__tstate);
49729 if (PyErr_Occurred()) SWIG_fail;
49730 }
49731 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_NEW | 0 );
49732 return resultobj;
49733 fail:
49734 return NULL;
49735 }
49736
49737
49738 SWIGINTERN PyObject *_wrap_delete_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49739 PyObject *resultobj = 0;
49740 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49741 void *argp1 = 0 ;
49742 int res1 = 0 ;
49743 PyObject *swig_obj[1] ;
49744
49745 if (!args) SWIG_fail;
49746 swig_obj[0] = args;
49747 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
49748 if (!SWIG_IsOK(res1)) {
49749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSizerItem" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49750 }
49751 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49752 {
49753 PyThreadState* __tstate = wxPyBeginAllowThreads();
49754 delete arg1;
49755
49756 wxPyEndAllowThreads(__tstate);
49757 if (PyErr_Occurred()) SWIG_fail;
49758 }
49759 resultobj = SWIG_Py_Void();
49760 return resultobj;
49761 fail:
49762 return NULL;
49763 }
49764
49765
49766 SWIGINTERN PyObject *_wrap_new_GBSizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49767 PyObject *resultobj = 0;
49768 wxWindow *arg1 = (wxWindow *) 0 ;
49769 wxGBPosition *arg2 = 0 ;
49770 wxGBSpan *arg3 = 0 ;
49771 int arg4 ;
49772 int arg5 ;
49773 PyObject *arg6 = (PyObject *) NULL ;
49774 wxGBSizerItem *result = 0 ;
49775 void *argp1 = 0 ;
49776 int res1 = 0 ;
49777 wxGBPosition temp2 ;
49778 wxGBSpan temp3 ;
49779 int val4 ;
49780 int ecode4 = 0 ;
49781 int val5 ;
49782 int ecode5 = 0 ;
49783 PyObject * obj0 = 0 ;
49784 PyObject * obj1 = 0 ;
49785 PyObject * obj2 = 0 ;
49786 PyObject * obj3 = 0 ;
49787 PyObject * obj4 = 0 ;
49788 PyObject * obj5 = 0 ;
49789 char * kwnames[] = {
49790 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49791 };
49792
49793 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49794 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
49795 if (!SWIG_IsOK(res1)) {
49796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
49797 }
49798 arg1 = reinterpret_cast< wxWindow * >(argp1);
49799 {
49800 arg2 = &temp2;
49801 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49802 }
49803 {
49804 arg3 = &temp3;
49805 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
49806 }
49807 ecode4 = SWIG_AsVal_int(obj3, &val4);
49808 if (!SWIG_IsOK(ecode4)) {
49809 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemWindow" "', expected argument " "4"" of type '" "int""'");
49810 }
49811 arg4 = static_cast< int >(val4);
49812 ecode5 = SWIG_AsVal_int(obj4, &val5);
49813 if (!SWIG_IsOK(ecode5)) {
49814 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemWindow" "', expected argument " "5"" of type '" "int""'");
49815 }
49816 arg5 = static_cast< int >(val5);
49817 if (obj5) {
49818 arg6 = obj5;
49819 }
49820 {
49821 PyThreadState* __tstate = wxPyBeginAllowThreads();
49822 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
49823 wxPyEndAllowThreads(__tstate);
49824 if (PyErr_Occurred()) SWIG_fail;
49825 }
49826 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49827 return resultobj;
49828 fail:
49829 return NULL;
49830 }
49831
49832
49833 SWIGINTERN PyObject *_wrap_new_GBSizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49834 PyObject *resultobj = 0;
49835 wxSizer *arg1 = (wxSizer *) 0 ;
49836 wxGBPosition *arg2 = 0 ;
49837 wxGBSpan *arg3 = 0 ;
49838 int arg4 ;
49839 int arg5 ;
49840 PyObject *arg6 = (PyObject *) NULL ;
49841 wxGBSizerItem *result = 0 ;
49842 int res1 = 0 ;
49843 wxGBPosition temp2 ;
49844 wxGBSpan temp3 ;
49845 int val4 ;
49846 int ecode4 = 0 ;
49847 int val5 ;
49848 int ecode5 = 0 ;
49849 PyObject * obj0 = 0 ;
49850 PyObject * obj1 = 0 ;
49851 PyObject * obj2 = 0 ;
49852 PyObject * obj3 = 0 ;
49853 PyObject * obj4 = 0 ;
49854 PyObject * obj5 = 0 ;
49855 char * kwnames[] = {
49856 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49857 };
49858
49859 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49860 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
49861 if (!SWIG_IsOK(res1)) {
49862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
49863 }
49864 {
49865 arg2 = &temp2;
49866 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49867 }
49868 {
49869 arg3 = &temp3;
49870 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
49871 }
49872 ecode4 = SWIG_AsVal_int(obj3, &val4);
49873 if (!SWIG_IsOK(ecode4)) {
49874 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemSizer" "', expected argument " "4"" of type '" "int""'");
49875 }
49876 arg4 = static_cast< int >(val4);
49877 ecode5 = SWIG_AsVal_int(obj4, &val5);
49878 if (!SWIG_IsOK(ecode5)) {
49879 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSizer" "', expected argument " "5"" of type '" "int""'");
49880 }
49881 arg5 = static_cast< int >(val5);
49882 if (obj5) {
49883 arg6 = obj5;
49884 }
49885 {
49886 PyThreadState* __tstate = wxPyBeginAllowThreads();
49887 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
49888 wxPyEndAllowThreads(__tstate);
49889 if (PyErr_Occurred()) SWIG_fail;
49890 }
49891 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49892 return resultobj;
49893 fail:
49894 return NULL;
49895 }
49896
49897
49898 SWIGINTERN PyObject *_wrap_new_GBSizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49899 PyObject *resultobj = 0;
49900 int arg1 ;
49901 int arg2 ;
49902 wxGBPosition *arg3 = 0 ;
49903 wxGBSpan *arg4 = 0 ;
49904 int arg5 ;
49905 int arg6 ;
49906 PyObject *arg7 = (PyObject *) NULL ;
49907 wxGBSizerItem *result = 0 ;
49908 int val1 ;
49909 int ecode1 = 0 ;
49910 int val2 ;
49911 int ecode2 = 0 ;
49912 wxGBPosition temp3 ;
49913 wxGBSpan temp4 ;
49914 int val5 ;
49915 int ecode5 = 0 ;
49916 int val6 ;
49917 int ecode6 = 0 ;
49918 PyObject * obj0 = 0 ;
49919 PyObject * obj1 = 0 ;
49920 PyObject * obj2 = 0 ;
49921 PyObject * obj3 = 0 ;
49922 PyObject * obj4 = 0 ;
49923 PyObject * obj5 = 0 ;
49924 PyObject * obj6 = 0 ;
49925 char * kwnames[] = {
49926 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49927 };
49928
49929 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
49930 ecode1 = SWIG_AsVal_int(obj0, &val1);
49931 if (!SWIG_IsOK(ecode1)) {
49932 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
49933 }
49934 arg1 = static_cast< int >(val1);
49935 ecode2 = SWIG_AsVal_int(obj1, &val2);
49936 if (!SWIG_IsOK(ecode2)) {
49937 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
49938 }
49939 arg2 = static_cast< int >(val2);
49940 {
49941 arg3 = &temp3;
49942 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
49943 }
49944 {
49945 arg4 = &temp4;
49946 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
49947 }
49948 ecode5 = SWIG_AsVal_int(obj4, &val5);
49949 if (!SWIG_IsOK(ecode5)) {
49950 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
49951 }
49952 arg5 = static_cast< int >(val5);
49953 ecode6 = SWIG_AsVal_int(obj5, &val6);
49954 if (!SWIG_IsOK(ecode6)) {
49955 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GBSizerItemSpacer" "', expected argument " "6"" of type '" "int""'");
49956 }
49957 arg6 = static_cast< int >(val6);
49958 if (obj6) {
49959 arg7 = obj6;
49960 }
49961 {
49962 PyThreadState* __tstate = wxPyBeginAllowThreads();
49963 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
49964 wxPyEndAllowThreads(__tstate);
49965 if (PyErr_Occurred()) SWIG_fail;
49966 }
49967 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49968 return resultobj;
49969 fail:
49970 return NULL;
49971 }
49972
49973
49974 SWIGINTERN PyObject *_wrap_GBSizerItem_GetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49975 PyObject *resultobj = 0;
49976 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49977 wxGBPosition result;
49978 void *argp1 = 0 ;
49979 int res1 = 0 ;
49980 PyObject *swig_obj[1] ;
49981
49982 if (!args) SWIG_fail;
49983 swig_obj[0] = args;
49984 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49985 if (!SWIG_IsOK(res1)) {
49986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetPos" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
49987 }
49988 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49989 {
49990 PyThreadState* __tstate = wxPyBeginAllowThreads();
49991 result = ((wxGBSizerItem const *)arg1)->GetPos();
49992 wxPyEndAllowThreads(__tstate);
49993 if (PyErr_Occurred()) SWIG_fail;
49994 }
49995 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
49996 return resultobj;
49997 fail:
49998 return NULL;
49999 }
50000
50001
50002 SWIGINTERN PyObject *_wrap_GBSizerItem_GetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50003 PyObject *resultobj = 0;
50004 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50005 wxGBSpan result;
50006 void *argp1 = 0 ;
50007 int res1 = 0 ;
50008 PyObject *swig_obj[1] ;
50009
50010 if (!args) SWIG_fail;
50011 swig_obj[0] = args;
50012 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50013 if (!SWIG_IsOK(res1)) {
50014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
50015 }
50016 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50017 {
50018 PyThreadState* __tstate = wxPyBeginAllowThreads();
50019 result = ((wxGBSizerItem const *)arg1)->GetSpan();
50020 wxPyEndAllowThreads(__tstate);
50021 if (PyErr_Occurred()) SWIG_fail;
50022 }
50023 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50024 return resultobj;
50025 fail:
50026 return NULL;
50027 }
50028
50029
50030 SWIGINTERN PyObject *_wrap_GBSizerItem_SetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50031 PyObject *resultobj = 0;
50032 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50033 wxGBPosition *arg2 = 0 ;
50034 bool result;
50035 void *argp1 = 0 ;
50036 int res1 = 0 ;
50037 wxGBPosition temp2 ;
50038 PyObject * obj0 = 0 ;
50039 PyObject * obj1 = 0 ;
50040 char * kwnames[] = {
50041 (char *) "self",(char *) "pos", NULL
50042 };
50043
50044 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) SWIG_fail;
50045 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50046 if (!SWIG_IsOK(res1)) {
50047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50048 }
50049 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50050 {
50051 arg2 = &temp2;
50052 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50053 }
50054 {
50055 PyThreadState* __tstate = wxPyBeginAllowThreads();
50056 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
50057 wxPyEndAllowThreads(__tstate);
50058 if (PyErr_Occurred()) SWIG_fail;
50059 }
50060 {
50061 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50062 }
50063 return resultobj;
50064 fail:
50065 return NULL;
50066 }
50067
50068
50069 SWIGINTERN PyObject *_wrap_GBSizerItem_SetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50070 PyObject *resultobj = 0;
50071 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50072 wxGBSpan *arg2 = 0 ;
50073 bool result;
50074 void *argp1 = 0 ;
50075 int res1 = 0 ;
50076 wxGBSpan temp2 ;
50077 PyObject * obj0 = 0 ;
50078 PyObject * obj1 = 0 ;
50079 char * kwnames[] = {
50080 (char *) "self",(char *) "span", NULL
50081 };
50082
50083 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) SWIG_fail;
50084 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50085 if (!SWIG_IsOK(res1)) {
50086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50087 }
50088 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50089 {
50090 arg2 = &temp2;
50091 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
50092 }
50093 {
50094 PyThreadState* __tstate = wxPyBeginAllowThreads();
50095 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
50096 wxPyEndAllowThreads(__tstate);
50097 if (PyErr_Occurred()) SWIG_fail;
50098 }
50099 {
50100 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50101 }
50102 return resultobj;
50103 fail:
50104 return NULL;
50105 }
50106
50107
50108 SWIGINTERN PyObject *_wrap_GBSizerItem_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50109 PyObject *resultobj = 0;
50110 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50111 wxGBSizerItem *arg2 = 0 ;
50112 bool result;
50113 void *argp1 = 0 ;
50114 int res1 = 0 ;
50115 void *argp2 = 0 ;
50116 int res2 = 0 ;
50117 PyObject * obj0 = 0 ;
50118 PyObject * obj1 = 0 ;
50119 char * kwnames[] = {
50120 (char *) "self",(char *) "other", NULL
50121 };
50122
50123 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
50124 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50125 if (!SWIG_IsOK(res1)) {
50126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_Intersects" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50127 }
50128 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50129 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGBSizerItem, 0 | 0);
50130 if (!SWIG_IsOK(res2)) {
50131 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
50132 }
50133 if (!argp2) {
50134 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
50135 }
50136 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
50137 {
50138 PyThreadState* __tstate = wxPyBeginAllowThreads();
50139 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
50140 wxPyEndAllowThreads(__tstate);
50141 if (PyErr_Occurred()) SWIG_fail;
50142 }
50143 {
50144 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50145 }
50146 return resultobj;
50147 fail:
50148 return NULL;
50149 }
50150
50151
50152 SWIGINTERN PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50153 PyObject *resultobj = 0;
50154 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50155 wxGBPosition *arg2 = 0 ;
50156 wxGBSpan *arg3 = 0 ;
50157 bool result;
50158 void *argp1 = 0 ;
50159 int res1 = 0 ;
50160 wxGBPosition temp2 ;
50161 wxGBSpan temp3 ;
50162 PyObject * obj0 = 0 ;
50163 PyObject * obj1 = 0 ;
50164 PyObject * obj2 = 0 ;
50165 char * kwnames[] = {
50166 (char *) "self",(char *) "pos",(char *) "span", NULL
50167 };
50168
50169 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50170 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50171 if (!SWIG_IsOK(res1)) {
50172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_IntersectsPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50173 }
50174 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50175 {
50176 arg2 = &temp2;
50177 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50178 }
50179 {
50180 arg3 = &temp3;
50181 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
50182 }
50183 {
50184 PyThreadState* __tstate = wxPyBeginAllowThreads();
50185 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
50186 wxPyEndAllowThreads(__tstate);
50187 if (PyErr_Occurred()) SWIG_fail;
50188 }
50189 {
50190 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50191 }
50192 return resultobj;
50193 fail:
50194 return NULL;
50195 }
50196
50197
50198 SWIGINTERN PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50199 PyObject *resultobj = 0;
50200 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50201 wxGBPosition result;
50202 void *argp1 = 0 ;
50203 int res1 = 0 ;
50204 PyObject *swig_obj[1] ;
50205
50206 if (!args) SWIG_fail;
50207 swig_obj[0] = args;
50208 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50209 if (!SWIG_IsOK(res1)) {
50210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetEndPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50211 }
50212 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50213 {
50214 PyThreadState* __tstate = wxPyBeginAllowThreads();
50215 result = wxGBSizerItem_GetEndPos(arg1);
50216 wxPyEndAllowThreads(__tstate);
50217 if (PyErr_Occurred()) SWIG_fail;
50218 }
50219 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50220 return resultobj;
50221 fail:
50222 return NULL;
50223 }
50224
50225
50226 SWIGINTERN PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50227 PyObject *resultobj = 0;
50228 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50229 wxGridBagSizer *result = 0 ;
50230 void *argp1 = 0 ;
50231 int res1 = 0 ;
50232 PyObject *swig_obj[1] ;
50233
50234 if (!args) SWIG_fail;
50235 swig_obj[0] = args;
50236 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50237 if (!SWIG_IsOK(res1)) {
50238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
50239 }
50240 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50241 {
50242 PyThreadState* __tstate = wxPyBeginAllowThreads();
50243 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
50244 wxPyEndAllowThreads(__tstate);
50245 if (PyErr_Occurred()) SWIG_fail;
50246 }
50247 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50248 return resultobj;
50249 fail:
50250 return NULL;
50251 }
50252
50253
50254 SWIGINTERN PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50255 PyObject *resultobj = 0;
50256 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50257 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
50258 void *argp1 = 0 ;
50259 int res1 = 0 ;
50260 void *argp2 = 0 ;
50261 int res2 = 0 ;
50262 PyObject * obj0 = 0 ;
50263 PyObject * obj1 = 0 ;
50264 char * kwnames[] = {
50265 (char *) "self",(char *) "sizer", NULL
50266 };
50267
50268 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) SWIG_fail;
50269 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50270 if (!SWIG_IsOK(res1)) {
50271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50272 }
50273 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50274 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50275 if (!SWIG_IsOK(res2)) {
50276 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "2"" of type '" "wxGridBagSizer *""'");
50277 }
50278 arg2 = reinterpret_cast< wxGridBagSizer * >(argp2);
50279 {
50280 PyThreadState* __tstate = wxPyBeginAllowThreads();
50281 (arg1)->SetGBSizer(arg2);
50282 wxPyEndAllowThreads(__tstate);
50283 if (PyErr_Occurred()) SWIG_fail;
50284 }
50285 resultobj = SWIG_Py_Void();
50286 return resultobj;
50287 fail:
50288 return NULL;
50289 }
50290
50291
50292 SWIGINTERN PyObject *GBSizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50293 PyObject *obj;
50294 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
50295 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSizerItem, SWIG_NewClientData(obj));
50296 return SWIG_Py_Void();
50297 }
50298
50299 SWIGINTERN PyObject *GBSizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50300 return SWIG_Python_InitShadowInstance(args);
50301 }
50302
50303 SWIGINTERN PyObject *_wrap_new_GridBagSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50304 PyObject *resultobj = 0;
50305 int arg1 = (int) 0 ;
50306 int arg2 = (int) 0 ;
50307 wxGridBagSizer *result = 0 ;
50308 int val1 ;
50309 int ecode1 = 0 ;
50310 int val2 ;
50311 int ecode2 = 0 ;
50312 PyObject * obj0 = 0 ;
50313 PyObject * obj1 = 0 ;
50314 char * kwnames[] = {
50315 (char *) "vgap",(char *) "hgap", NULL
50316 };
50317
50318 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) SWIG_fail;
50319 if (obj0) {
50320 ecode1 = SWIG_AsVal_int(obj0, &val1);
50321 if (!SWIG_IsOK(ecode1)) {
50322 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridBagSizer" "', expected argument " "1"" of type '" "int""'");
50323 }
50324 arg1 = static_cast< int >(val1);
50325 }
50326 if (obj1) {
50327 ecode2 = SWIG_AsVal_int(obj1, &val2);
50328 if (!SWIG_IsOK(ecode2)) {
50329 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridBagSizer" "', expected argument " "2"" of type '" "int""'");
50330 }
50331 arg2 = static_cast< int >(val2);
50332 }
50333 {
50334 PyThreadState* __tstate = wxPyBeginAllowThreads();
50335 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
50336 wxPyEndAllowThreads(__tstate);
50337 if (PyErr_Occurred()) SWIG_fail;
50338 }
50339 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_NEW | 0 );
50340 return resultobj;
50341 fail:
50342 return NULL;
50343 }
50344
50345
50346 SWIGINTERN PyObject *_wrap_GridBagSizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50347 PyObject *resultobj = 0;
50348 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50349 PyObject *arg2 = (PyObject *) 0 ;
50350 wxGBPosition *arg3 = 0 ;
50351 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
50352 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
50353 int arg5 = (int) 0 ;
50354 int arg6 = (int) 0 ;
50355 PyObject *arg7 = (PyObject *) NULL ;
50356 wxGBSizerItem *result = 0 ;
50357 void *argp1 = 0 ;
50358 int res1 = 0 ;
50359 wxGBPosition temp3 ;
50360 wxGBSpan temp4 ;
50361 int val5 ;
50362 int ecode5 = 0 ;
50363 int val6 ;
50364 int ecode6 = 0 ;
50365 PyObject * obj0 = 0 ;
50366 PyObject * obj1 = 0 ;
50367 PyObject * obj2 = 0 ;
50368 PyObject * obj3 = 0 ;
50369 PyObject * obj4 = 0 ;
50370 PyObject * obj5 = 0 ;
50371 PyObject * obj6 = 0 ;
50372 char * kwnames[] = {
50373 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
50374 };
50375
50376 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
50377 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50378 if (!SWIG_IsOK(res1)) {
50379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_Add" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50380 }
50381 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50382 arg2 = obj1;
50383 {
50384 arg3 = &temp3;
50385 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
50386 }
50387 if (obj3) {
50388 {
50389 arg4 = &temp4;
50390 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
50391 }
50392 }
50393 if (obj4) {
50394 ecode5 = SWIG_AsVal_int(obj4, &val5);
50395 if (!SWIG_IsOK(ecode5)) {
50396 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridBagSizer_Add" "', expected argument " "5"" of type '" "int""'");
50397 }
50398 arg5 = static_cast< int >(val5);
50399 }
50400 if (obj5) {
50401 ecode6 = SWIG_AsVal_int(obj5, &val6);
50402 if (!SWIG_IsOK(ecode6)) {
50403 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridBagSizer_Add" "', expected argument " "6"" of type '" "int""'");
50404 }
50405 arg6 = static_cast< int >(val6);
50406 }
50407 if (obj6) {
50408 arg7 = obj6;
50409 }
50410 {
50411 PyThreadState* __tstate = wxPyBeginAllowThreads();
50412 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
50413 wxPyEndAllowThreads(__tstate);
50414 if (PyErr_Occurred()) SWIG_fail;
50415 }
50416 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50417 return resultobj;
50418 fail:
50419 return NULL;
50420 }
50421
50422
50423 SWIGINTERN PyObject *_wrap_GridBagSizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50424 PyObject *resultobj = 0;
50425 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50426 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
50427 wxGBSizerItem *result = 0 ;
50428 void *argp1 = 0 ;
50429 int res1 = 0 ;
50430 int res2 = 0 ;
50431 PyObject * obj0 = 0 ;
50432 PyObject * obj1 = 0 ;
50433 char * kwnames[] = {
50434 (char *) "self",(char *) "item", NULL
50435 };
50436
50437 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
50438 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50439 if (!SWIG_IsOK(res1)) {
50440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_AddItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50441 }
50442 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50443 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
50444 if (!SWIG_IsOK(res2)) {
50445 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_AddItem" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
50446 }
50447 {
50448 PyThreadState* __tstate = wxPyBeginAllowThreads();
50449 result = (wxGBSizerItem *)(arg1)->Add(arg2);
50450 wxPyEndAllowThreads(__tstate);
50451 if (PyErr_Occurred()) SWIG_fail;
50452 }
50453 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50454 return resultobj;
50455 fail:
50456 return NULL;
50457 }
50458
50459
50460 SWIGINTERN PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50461 PyObject *resultobj = 0;
50462 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50463 int arg2 ;
50464 int arg3 ;
50465 wxSize result;
50466 void *argp1 = 0 ;
50467 int res1 = 0 ;
50468 int val2 ;
50469 int ecode2 = 0 ;
50470 int val3 ;
50471 int ecode3 = 0 ;
50472 PyObject * obj0 = 0 ;
50473 PyObject * obj1 = 0 ;
50474 PyObject * obj2 = 0 ;
50475 char * kwnames[] = {
50476 (char *) "self",(char *) "row",(char *) "col", NULL
50477 };
50478
50479 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50480 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50481 if (!SWIG_IsOK(res1)) {
50482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
50483 }
50484 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50485 ecode2 = SWIG_AsVal_int(obj1, &val2);
50486 if (!SWIG_IsOK(ecode2)) {
50487 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "2"" of type '" "int""'");
50488 }
50489 arg2 = static_cast< int >(val2);
50490 ecode3 = SWIG_AsVal_int(obj2, &val3);
50491 if (!SWIG_IsOK(ecode3)) {
50492 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "3"" of type '" "int""'");
50493 }
50494 arg3 = static_cast< int >(val3);
50495 {
50496 PyThreadState* __tstate = wxPyBeginAllowThreads();
50497 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
50498 wxPyEndAllowThreads(__tstate);
50499 if (PyErr_Occurred()) SWIG_fail;
50500 }
50501 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50502 return resultobj;
50503 fail:
50504 return NULL;
50505 }
50506
50507
50508 SWIGINTERN PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50509 PyObject *resultobj = 0;
50510 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50511 wxSize result;
50512 void *argp1 = 0 ;
50513 int res1 = 0 ;
50514 PyObject *swig_obj[1] ;
50515
50516 if (!args) SWIG_fail;
50517 swig_obj[0] = args;
50518 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50519 if (!SWIG_IsOK(res1)) {
50520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
50521 }
50522 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50523 {
50524 PyThreadState* __tstate = wxPyBeginAllowThreads();
50525 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
50526 wxPyEndAllowThreads(__tstate);
50527 if (PyErr_Occurred()) SWIG_fail;
50528 }
50529 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50530 return resultobj;
50531 fail:
50532 return NULL;
50533 }
50534
50535
50536 SWIGINTERN PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50537 PyObject *resultobj = 0;
50538 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50539 wxSize *arg2 = 0 ;
50540 void *argp1 = 0 ;
50541 int res1 = 0 ;
50542 wxSize temp2 ;
50543 PyObject * obj0 = 0 ;
50544 PyObject * obj1 = 0 ;
50545 char * kwnames[] = {
50546 (char *) "self",(char *) "sz", NULL
50547 };
50548
50549 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) SWIG_fail;
50550 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50551 if (!SWIG_IsOK(res1)) {
50552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50553 }
50554 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50555 {
50556 arg2 = &temp2;
50557 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
50558 }
50559 {
50560 PyThreadState* __tstate = wxPyBeginAllowThreads();
50561 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
50562 wxPyEndAllowThreads(__tstate);
50563 if (PyErr_Occurred()) SWIG_fail;
50564 }
50565 resultobj = SWIG_Py_Void();
50566 return resultobj;
50567 fail:
50568 return NULL;
50569 }
50570
50571
50572 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50573 PyObject *resultobj = 0;
50574 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50575 wxWindow *arg2 = (wxWindow *) 0 ;
50576 wxGBPosition result;
50577 void *argp1 = 0 ;
50578 int res1 = 0 ;
50579 void *argp2 = 0 ;
50580 int res2 = 0 ;
50581
50582 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50583 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50584 if (!SWIG_IsOK(res1)) {
50585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50586 }
50587 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50588 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50589 if (!SWIG_IsOK(res2)) {
50590 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
50591 }
50592 arg2 = reinterpret_cast< wxWindow * >(argp2);
50593 {
50594 PyThreadState* __tstate = wxPyBeginAllowThreads();
50595 result = (arg1)->GetItemPosition(arg2);
50596 wxPyEndAllowThreads(__tstate);
50597 if (PyErr_Occurred()) SWIG_fail;
50598 }
50599 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50600 return resultobj;
50601 fail:
50602 return NULL;
50603 }
50604
50605
50606 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50607 PyObject *resultobj = 0;
50608 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50609 wxSizer *arg2 = (wxSizer *) 0 ;
50610 wxGBPosition result;
50611 void *argp1 = 0 ;
50612 int res1 = 0 ;
50613 void *argp2 = 0 ;
50614 int res2 = 0 ;
50615
50616 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50617 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50618 if (!SWIG_IsOK(res1)) {
50619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50620 }
50621 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50622 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50623 if (!SWIG_IsOK(res2)) {
50624 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
50625 }
50626 arg2 = reinterpret_cast< wxSizer * >(argp2);
50627 {
50628 PyThreadState* __tstate = wxPyBeginAllowThreads();
50629 result = (arg1)->GetItemPosition(arg2);
50630 wxPyEndAllowThreads(__tstate);
50631 if (PyErr_Occurred()) SWIG_fail;
50632 }
50633 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50634 return resultobj;
50635 fail:
50636 return NULL;
50637 }
50638
50639
50640 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50641 PyObject *resultobj = 0;
50642 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50643 size_t arg2 ;
50644 wxGBPosition result;
50645 void *argp1 = 0 ;
50646 int res1 = 0 ;
50647 size_t val2 ;
50648 int ecode2 = 0 ;
50649
50650 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50651 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50652 if (!SWIG_IsOK(res1)) {
50653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50654 }
50655 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50656 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50657 if (!SWIG_IsOK(ecode2)) {
50658 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
50659 }
50660 arg2 = static_cast< size_t >(val2);
50661 {
50662 PyThreadState* __tstate = wxPyBeginAllowThreads();
50663 result = (arg1)->GetItemPosition(arg2);
50664 wxPyEndAllowThreads(__tstate);
50665 if (PyErr_Occurred()) SWIG_fail;
50666 }
50667 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50668 return resultobj;
50669 fail:
50670 return NULL;
50671 }
50672
50673
50674 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
50675 int argc;
50676 PyObject *argv[3];
50677
50678 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemPosition",0,2,argv))) SWIG_fail;
50679 --argc;
50680 if (argc == 2) {
50681 int _v = 0;
50682 {
50683 void *vptr = 0;
50684 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50685 _v = SWIG_CheckState(res);
50686 }
50687 if (!_v) goto check_1;
50688 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self, argc, argv);
50689 }
50690 check_1:
50691
50692 if (argc == 2) {
50693 int _v = 0;
50694 {
50695 void *vptr = 0;
50696 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50697 _v = SWIG_CheckState(res);
50698 }
50699 if (!_v) goto check_2;
50700 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self, argc, argv);
50701 }
50702 check_2:
50703
50704 if (argc == 2) {
50705 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self, argc, argv);
50706 }
50707
50708 fail:
50709 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
50710 return NULL;
50711 }
50712
50713
50714 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50715 PyObject *resultobj = 0;
50716 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50717 wxWindow *arg2 = (wxWindow *) 0 ;
50718 wxGBPosition *arg3 = 0 ;
50719 bool result;
50720 void *argp1 = 0 ;
50721 int res1 = 0 ;
50722 void *argp2 = 0 ;
50723 int res2 = 0 ;
50724 wxGBPosition temp3 ;
50725
50726 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50727 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50728 if (!SWIG_IsOK(res1)) {
50729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50730 }
50731 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50732 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50733 if (!SWIG_IsOK(res2)) {
50734 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
50735 }
50736 arg2 = reinterpret_cast< wxWindow * >(argp2);
50737 {
50738 arg3 = &temp3;
50739 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50740 }
50741 {
50742 PyThreadState* __tstate = wxPyBeginAllowThreads();
50743 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50744 wxPyEndAllowThreads(__tstate);
50745 if (PyErr_Occurred()) SWIG_fail;
50746 }
50747 {
50748 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50749 }
50750 return resultobj;
50751 fail:
50752 return NULL;
50753 }
50754
50755
50756 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50757 PyObject *resultobj = 0;
50758 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50759 wxSizer *arg2 = (wxSizer *) 0 ;
50760 wxGBPosition *arg3 = 0 ;
50761 bool result;
50762 void *argp1 = 0 ;
50763 int res1 = 0 ;
50764 void *argp2 = 0 ;
50765 int res2 = 0 ;
50766 wxGBPosition temp3 ;
50767
50768 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50769 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50770 if (!SWIG_IsOK(res1)) {
50771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50772 }
50773 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50774 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50775 if (!SWIG_IsOK(res2)) {
50776 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
50777 }
50778 arg2 = reinterpret_cast< wxSizer * >(argp2);
50779 {
50780 arg3 = &temp3;
50781 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50782 }
50783 {
50784 PyThreadState* __tstate = wxPyBeginAllowThreads();
50785 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50786 wxPyEndAllowThreads(__tstate);
50787 if (PyErr_Occurred()) SWIG_fail;
50788 }
50789 {
50790 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50791 }
50792 return resultobj;
50793 fail:
50794 return NULL;
50795 }
50796
50797
50798 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50799 PyObject *resultobj = 0;
50800 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50801 size_t arg2 ;
50802 wxGBPosition *arg3 = 0 ;
50803 bool result;
50804 void *argp1 = 0 ;
50805 int res1 = 0 ;
50806 size_t val2 ;
50807 int ecode2 = 0 ;
50808 wxGBPosition temp3 ;
50809
50810 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50811 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50812 if (!SWIG_IsOK(res1)) {
50813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50814 }
50815 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50816 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50817 if (!SWIG_IsOK(ecode2)) {
50818 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
50819 }
50820 arg2 = static_cast< size_t >(val2);
50821 {
50822 arg3 = &temp3;
50823 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50824 }
50825 {
50826 PyThreadState* __tstate = wxPyBeginAllowThreads();
50827 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50828 wxPyEndAllowThreads(__tstate);
50829 if (PyErr_Occurred()) SWIG_fail;
50830 }
50831 {
50832 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50833 }
50834 return resultobj;
50835 fail:
50836 return NULL;
50837 }
50838
50839
50840 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
50841 int argc;
50842 PyObject *argv[4];
50843
50844 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemPosition",0,3,argv))) SWIG_fail;
50845 --argc;
50846 if (argc == 3) {
50847 int _v = 0;
50848 {
50849 void *vptr = 0;
50850 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50851 _v = SWIG_CheckState(res);
50852 }
50853 if (!_v) goto check_1;
50854 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self, argc, argv);
50855 }
50856 check_1:
50857
50858 if (argc == 3) {
50859 int _v = 0;
50860 {
50861 void *vptr = 0;
50862 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50863 _v = SWIG_CheckState(res);
50864 }
50865 if (!_v) goto check_2;
50866 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self, argc, argv);
50867 }
50868 check_2:
50869
50870 if (argc == 3) {
50871 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self, argc, argv);
50872 }
50873
50874 fail:
50875 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
50876 return NULL;
50877 }
50878
50879
50880 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50881 PyObject *resultobj = 0;
50882 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50883 wxWindow *arg2 = (wxWindow *) 0 ;
50884 wxGBSpan result;
50885 void *argp1 = 0 ;
50886 int res1 = 0 ;
50887 void *argp2 = 0 ;
50888 int res2 = 0 ;
50889
50890 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50891 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50892 if (!SWIG_IsOK(res1)) {
50893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50894 }
50895 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50896 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50897 if (!SWIG_IsOK(res2)) {
50898 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
50899 }
50900 arg2 = reinterpret_cast< wxWindow * >(argp2);
50901 {
50902 PyThreadState* __tstate = wxPyBeginAllowThreads();
50903 result = (arg1)->GetItemSpan(arg2);
50904 wxPyEndAllowThreads(__tstate);
50905 if (PyErr_Occurred()) SWIG_fail;
50906 }
50907 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50908 return resultobj;
50909 fail:
50910 return NULL;
50911 }
50912
50913
50914 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50915 PyObject *resultobj = 0;
50916 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50917 wxSizer *arg2 = (wxSizer *) 0 ;
50918 wxGBSpan result;
50919 void *argp1 = 0 ;
50920 int res1 = 0 ;
50921 void *argp2 = 0 ;
50922 int res2 = 0 ;
50923
50924 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50925 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50926 if (!SWIG_IsOK(res1)) {
50927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50928 }
50929 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50930 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50931 if (!SWIG_IsOK(res2)) {
50932 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
50933 }
50934 arg2 = reinterpret_cast< wxSizer * >(argp2);
50935 {
50936 PyThreadState* __tstate = wxPyBeginAllowThreads();
50937 result = (arg1)->GetItemSpan(arg2);
50938 wxPyEndAllowThreads(__tstate);
50939 if (PyErr_Occurred()) SWIG_fail;
50940 }
50941 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50942 return resultobj;
50943 fail:
50944 return NULL;
50945 }
50946
50947
50948 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50949 PyObject *resultobj = 0;
50950 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50951 size_t arg2 ;
50952 wxGBSpan result;
50953 void *argp1 = 0 ;
50954 int res1 = 0 ;
50955 size_t val2 ;
50956 int ecode2 = 0 ;
50957
50958 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50959 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50960 if (!SWIG_IsOK(res1)) {
50961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50962 }
50963 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50964 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50965 if (!SWIG_IsOK(ecode2)) {
50966 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
50967 }
50968 arg2 = static_cast< size_t >(val2);
50969 {
50970 PyThreadState* __tstate = wxPyBeginAllowThreads();
50971 result = (arg1)->GetItemSpan(arg2);
50972 wxPyEndAllowThreads(__tstate);
50973 if (PyErr_Occurred()) SWIG_fail;
50974 }
50975 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50976 return resultobj;
50977 fail:
50978 return NULL;
50979 }
50980
50981
50982 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
50983 int argc;
50984 PyObject *argv[3];
50985
50986 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemSpan",0,2,argv))) SWIG_fail;
50987 --argc;
50988 if (argc == 2) {
50989 int _v = 0;
50990 {
50991 void *vptr = 0;
50992 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50993 _v = SWIG_CheckState(res);
50994 }
50995 if (!_v) goto check_1;
50996 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self, argc, argv);
50997 }
50998 check_1:
50999
51000 if (argc == 2) {
51001 int _v = 0;
51002 {
51003 void *vptr = 0;
51004 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
51005 _v = SWIG_CheckState(res);
51006 }
51007 if (!_v) goto check_2;
51008 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self, argc, argv);
51009 }
51010 check_2:
51011
51012 if (argc == 2) {
51013 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self, argc, argv);
51014 }
51015
51016 fail:
51017 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
51018 return NULL;
51019 }
51020
51021
51022 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51023 PyObject *resultobj = 0;
51024 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51025 wxWindow *arg2 = (wxWindow *) 0 ;
51026 wxGBSpan *arg3 = 0 ;
51027 bool result;
51028 void *argp1 = 0 ;
51029 int res1 = 0 ;
51030 void *argp2 = 0 ;
51031 int res2 = 0 ;
51032 wxGBSpan temp3 ;
51033
51034 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51035 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51036 if (!SWIG_IsOK(res1)) {
51037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51038 }
51039 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51040 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51041 if (!SWIG_IsOK(res2)) {
51042 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
51043 }
51044 arg2 = reinterpret_cast< wxWindow * >(argp2);
51045 {
51046 arg3 = &temp3;
51047 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
51048 }
51049 {
51050 PyThreadState* __tstate = wxPyBeginAllowThreads();
51051 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
51052 wxPyEndAllowThreads(__tstate);
51053 if (PyErr_Occurred()) SWIG_fail;
51054 }
51055 {
51056 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51057 }
51058 return resultobj;
51059 fail:
51060 return NULL;
51061 }
51062
51063
51064 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51065 PyObject *resultobj = 0;
51066 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51067 wxSizer *arg2 = (wxSizer *) 0 ;
51068 wxGBSpan *arg3 = 0 ;
51069 bool result;
51070 void *argp1 = 0 ;
51071 int res1 = 0 ;
51072 void *argp2 = 0 ;
51073 int res2 = 0 ;
51074 wxGBSpan temp3 ;
51075
51076 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51077 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51078 if (!SWIG_IsOK(res1)) {
51079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51080 }
51081 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51082 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
51083 if (!SWIG_IsOK(res2)) {
51084 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
51085 }
51086 arg2 = reinterpret_cast< wxSizer * >(argp2);
51087 {
51088 arg3 = &temp3;
51089 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
51090 }
51091 {
51092 PyThreadState* __tstate = wxPyBeginAllowThreads();
51093 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
51094 wxPyEndAllowThreads(__tstate);
51095 if (PyErr_Occurred()) SWIG_fail;
51096 }
51097 {
51098 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51099 }
51100 return resultobj;
51101 fail:
51102 return NULL;
51103 }
51104
51105
51106 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51107 PyObject *resultobj = 0;
51108 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51109 size_t arg2 ;
51110 wxGBSpan *arg3 = 0 ;
51111 bool result;
51112 void *argp1 = 0 ;
51113 int res1 = 0 ;
51114 size_t val2 ;
51115 int ecode2 = 0 ;
51116 wxGBSpan temp3 ;
51117
51118 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51119 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51120 if (!SWIG_IsOK(res1)) {
51121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51122 }
51123 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51124 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
51125 if (!SWIG_IsOK(ecode2)) {
51126 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
51127 }
51128 arg2 = static_cast< size_t >(val2);
51129 {
51130 arg3 = &temp3;
51131 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
51132 }
51133 {
51134 PyThreadState* __tstate = wxPyBeginAllowThreads();
51135 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
51136 wxPyEndAllowThreads(__tstate);
51137 if (PyErr_Occurred()) SWIG_fail;
51138 }
51139 {
51140 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51141 }
51142 return resultobj;
51143 fail:
51144 return NULL;
51145 }
51146
51147
51148 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
51149 int argc;
51150 PyObject *argv[4];
51151
51152 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemSpan",0,3,argv))) SWIG_fail;
51153 --argc;
51154 if (argc == 3) {
51155 int _v = 0;
51156 {
51157 void *vptr = 0;
51158 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
51159 _v = SWIG_CheckState(res);
51160 }
51161 if (!_v) goto check_1;
51162 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self, argc, argv);
51163 }
51164 check_1:
51165
51166 if (argc == 3) {
51167 int _v = 0;
51168 {
51169 void *vptr = 0;
51170 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
51171 _v = SWIG_CheckState(res);
51172 }
51173 if (!_v) goto check_2;
51174 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self, argc, argv);
51175 }
51176 check_2:
51177
51178 if (argc == 3) {
51179 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self, argc, argv);
51180 }
51181
51182 fail:
51183 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
51184 return NULL;
51185 }
51186
51187
51188 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51189 PyObject *resultobj = 0;
51190 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51191 wxWindow *arg2 = (wxWindow *) 0 ;
51192 wxGBSizerItem *result = 0 ;
51193 void *argp1 = 0 ;
51194 int res1 = 0 ;
51195 void *argp2 = 0 ;
51196 int res2 = 0 ;
51197
51198 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51199 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51200 if (!SWIG_IsOK(res1)) {
51201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51202 }
51203 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51204 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51205 if (!SWIG_IsOK(res2)) {
51206 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxWindow *""'");
51207 }
51208 arg2 = reinterpret_cast< wxWindow * >(argp2);
51209 {
51210 PyThreadState* __tstate = wxPyBeginAllowThreads();
51211 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
51212 wxPyEndAllowThreads(__tstate);
51213 if (PyErr_Occurred()) SWIG_fail;
51214 }
51215 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51216 return resultobj;
51217 fail:
51218 return NULL;
51219 }
51220
51221
51222 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51223 PyObject *resultobj = 0;
51224 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51225 wxSizer *arg2 = (wxSizer *) 0 ;
51226 wxGBSizerItem *result = 0 ;
51227 void *argp1 = 0 ;
51228 int res1 = 0 ;
51229 void *argp2 = 0 ;
51230 int res2 = 0 ;
51231
51232 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51233 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51234 if (!SWIG_IsOK(res1)) {
51235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51236 }
51237 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51238 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
51239 if (!SWIG_IsOK(res2)) {
51240 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxSizer *""'");
51241 }
51242 arg2 = reinterpret_cast< wxSizer * >(argp2);
51243 {
51244 PyThreadState* __tstate = wxPyBeginAllowThreads();
51245 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
51246 wxPyEndAllowThreads(__tstate);
51247 if (PyErr_Occurred()) SWIG_fail;
51248 }
51249 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51250 return resultobj;
51251 fail:
51252 return NULL;
51253 }
51254
51255
51256 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
51257 int argc;
51258 PyObject *argv[3];
51259
51260 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_FindItem",0,2,argv))) SWIG_fail;
51261 --argc;
51262 if (argc == 2) {
51263 int _v = 0;
51264 {
51265 void *vptr = 0;
51266 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
51267 _v = SWIG_CheckState(res);
51268 }
51269 if (!_v) goto check_1;
51270 return _wrap_GridBagSizer_FindItem__SWIG_0(self, argc, argv);
51271 }
51272 check_1:
51273
51274 if (argc == 2) {
51275 return _wrap_GridBagSizer_FindItem__SWIG_1(self, argc, argv);
51276 }
51277
51278 fail:
51279 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
51280 return NULL;
51281 }
51282
51283
51284 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51285 PyObject *resultobj = 0;
51286 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51287 wxGBPosition *arg2 = 0 ;
51288 wxGBSizerItem *result = 0 ;
51289 void *argp1 = 0 ;
51290 int res1 = 0 ;
51291 wxGBPosition temp2 ;
51292 PyObject * obj0 = 0 ;
51293 PyObject * obj1 = 0 ;
51294 char * kwnames[] = {
51295 (char *) "self",(char *) "pos", NULL
51296 };
51297
51298 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) SWIG_fail;
51299 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51300 if (!SWIG_IsOK(res1)) {
51301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51302 }
51303 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51304 {
51305 arg2 = &temp2;
51306 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51307 }
51308 {
51309 PyThreadState* __tstate = wxPyBeginAllowThreads();
51310 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
51311 wxPyEndAllowThreads(__tstate);
51312 if (PyErr_Occurred()) SWIG_fail;
51313 }
51314 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51315 return resultobj;
51316 fail:
51317 return NULL;
51318 }
51319
51320
51321 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51322 PyObject *resultobj = 0;
51323 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51324 wxPoint *arg2 = 0 ;
51325 wxGBSizerItem *result = 0 ;
51326 void *argp1 = 0 ;
51327 int res1 = 0 ;
51328 wxPoint temp2 ;
51329 PyObject * obj0 = 0 ;
51330 PyObject * obj1 = 0 ;
51331 char * kwnames[] = {
51332 (char *) "self",(char *) "pt", NULL
51333 };
51334
51335 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) SWIG_fail;
51336 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51337 if (!SWIG_IsOK(res1)) {
51338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPoint" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51339 }
51340 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51341 {
51342 arg2 = &temp2;
51343 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
51344 }
51345 {
51346 PyThreadState* __tstate = wxPyBeginAllowThreads();
51347 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
51348 wxPyEndAllowThreads(__tstate);
51349 if (PyErr_Occurred()) SWIG_fail;
51350 }
51351 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51352 return resultobj;
51353 fail:
51354 return NULL;
51355 }
51356
51357
51358 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51359 PyObject *resultobj = 0;
51360 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51361 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
51362 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
51363 bool result;
51364 void *argp1 = 0 ;
51365 int res1 = 0 ;
51366 void *argp2 = 0 ;
51367 int res2 = 0 ;
51368 void *argp3 = 0 ;
51369 int res3 = 0 ;
51370 PyObject * obj0 = 0 ;
51371 PyObject * obj1 = 0 ;
51372 PyObject * obj2 = 0 ;
51373 char * kwnames[] = {
51374 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
51375 };
51376
51377 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51378 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51379 if (!SWIG_IsOK(res1)) {
51380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51381 }
51382 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51383 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51384 if (!SWIG_IsOK(res2)) {
51385 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
51386 }
51387 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
51388 if (obj2) {
51389 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51390 if (!SWIG_IsOK(res3)) {
51391 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "3"" of type '" "wxGBSizerItem *""'");
51392 }
51393 arg3 = reinterpret_cast< wxGBSizerItem * >(argp3);
51394 }
51395 {
51396 PyThreadState* __tstate = wxPyBeginAllowThreads();
51397 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
51398 wxPyEndAllowThreads(__tstate);
51399 if (PyErr_Occurred()) SWIG_fail;
51400 }
51401 {
51402 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51403 }
51404 return resultobj;
51405 fail:
51406 return NULL;
51407 }
51408
51409
51410 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51411 PyObject *resultobj = 0;
51412 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51413 wxGBPosition *arg2 = 0 ;
51414 wxGBSpan *arg3 = 0 ;
51415 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
51416 bool result;
51417 void *argp1 = 0 ;
51418 int res1 = 0 ;
51419 wxGBPosition temp2 ;
51420 wxGBSpan temp3 ;
51421 void *argp4 = 0 ;
51422 int res4 = 0 ;
51423 PyObject * obj0 = 0 ;
51424 PyObject * obj1 = 0 ;
51425 PyObject * obj2 = 0 ;
51426 PyObject * obj3 = 0 ;
51427 char * kwnames[] = {
51428 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
51429 };
51430
51431 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51432 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51433 if (!SWIG_IsOK(res1)) {
51434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51435 }
51436 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51437 {
51438 arg2 = &temp2;
51439 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51440 }
51441 {
51442 arg3 = &temp3;
51443 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
51444 }
51445 if (obj3) {
51446 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51447 if (!SWIG_IsOK(res4)) {
51448 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "4"" of type '" "wxGBSizerItem *""'");
51449 }
51450 arg4 = reinterpret_cast< wxGBSizerItem * >(argp4);
51451 }
51452 {
51453 PyThreadState* __tstate = wxPyBeginAllowThreads();
51454 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
51455 wxPyEndAllowThreads(__tstate);
51456 if (PyErr_Occurred()) SWIG_fail;
51457 }
51458 {
51459 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51460 }
51461 return resultobj;
51462 fail:
51463 return NULL;
51464 }
51465
51466
51467 SWIGINTERN PyObject *GridBagSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51468 PyObject *obj;
51469 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51470 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridBagSizer, SWIG_NewClientData(obj));
51471 return SWIG_Py_Void();
51472 }
51473
51474 SWIGINTERN PyObject *GridBagSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51475 return SWIG_Python_InitShadowInstance(args);
51476 }
51477
51478 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51479 PyObject *resultobj = 0;
51480 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51481 wxRelationship arg2 ;
51482 wxWindow *arg3 = (wxWindow *) 0 ;
51483 wxEdge arg4 ;
51484 int arg5 = (int) 0 ;
51485 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
51486 void *argp1 = 0 ;
51487 int res1 = 0 ;
51488 int val2 ;
51489 int ecode2 = 0 ;
51490 void *argp3 = 0 ;
51491 int res3 = 0 ;
51492 int val4 ;
51493 int ecode4 = 0 ;
51494 int val5 ;
51495 int ecode5 = 0 ;
51496 int val6 ;
51497 int ecode6 = 0 ;
51498 PyObject * obj0 = 0 ;
51499 PyObject * obj1 = 0 ;
51500 PyObject * obj2 = 0 ;
51501 PyObject * obj3 = 0 ;
51502 PyObject * obj4 = 0 ;
51503 PyObject * obj5 = 0 ;
51504 char * kwnames[] = {
51505 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
51506 };
51507
51508 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
51509 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51510 if (!SWIG_IsOK(res1)) {
51511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51512 }
51513 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51514 ecode2 = SWIG_AsVal_int(obj1, &val2);
51515 if (!SWIG_IsOK(ecode2)) {
51516 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "2"" of type '" "wxRelationship""'");
51517 }
51518 arg2 = static_cast< wxRelationship >(val2);
51519 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
51520 if (!SWIG_IsOK(res3)) {
51521 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "3"" of type '" "wxWindow *""'");
51522 }
51523 arg3 = reinterpret_cast< wxWindow * >(argp3);
51524 ecode4 = SWIG_AsVal_int(obj3, &val4);
51525 if (!SWIG_IsOK(ecode4)) {
51526 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "4"" of type '" "wxEdge""'");
51527 }
51528 arg4 = static_cast< wxEdge >(val4);
51529 if (obj4) {
51530 ecode5 = SWIG_AsVal_int(obj4, &val5);
51531 if (!SWIG_IsOK(ecode5)) {
51532 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "5"" of type '" "int""'");
51533 }
51534 arg5 = static_cast< int >(val5);
51535 }
51536 if (obj5) {
51537 ecode6 = SWIG_AsVal_int(obj5, &val6);
51538 if (!SWIG_IsOK(ecode6)) {
51539 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "6"" of type '" "int""'");
51540 }
51541 arg6 = static_cast< int >(val6);
51542 }
51543 {
51544 PyThreadState* __tstate = wxPyBeginAllowThreads();
51545 (arg1)->Set(arg2,arg3,arg4,arg5,arg6);
51546 wxPyEndAllowThreads(__tstate);
51547 if (PyErr_Occurred()) SWIG_fail;
51548 }
51549 resultobj = SWIG_Py_Void();
51550 return resultobj;
51551 fail:
51552 return NULL;
51553 }
51554
51555
51556 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51557 PyObject *resultobj = 0;
51558 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51559 wxWindow *arg2 = (wxWindow *) 0 ;
51560 int arg3 = (int) 0 ;
51561 void *argp1 = 0 ;
51562 int res1 = 0 ;
51563 void *argp2 = 0 ;
51564 int res2 = 0 ;
51565 int val3 ;
51566 int ecode3 = 0 ;
51567 PyObject * obj0 = 0 ;
51568 PyObject * obj1 = 0 ;
51569 PyObject * obj2 = 0 ;
51570 char * kwnames[] = {
51571 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51572 };
51573
51574 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51575 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51576 if (!SWIG_IsOK(res1)) {
51577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51578 }
51579 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51580 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51581 if (!SWIG_IsOK(res2)) {
51582 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51583 }
51584 arg2 = reinterpret_cast< wxWindow * >(argp2);
51585 if (obj2) {
51586 ecode3 = SWIG_AsVal_int(obj2, &val3);
51587 if (!SWIG_IsOK(ecode3)) {
51588 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "3"" of type '" "int""'");
51589 }
51590 arg3 = static_cast< int >(val3);
51591 }
51592 {
51593 PyThreadState* __tstate = wxPyBeginAllowThreads();
51594 (arg1)->LeftOf(arg2,arg3);
51595 wxPyEndAllowThreads(__tstate);
51596 if (PyErr_Occurred()) SWIG_fail;
51597 }
51598 resultobj = SWIG_Py_Void();
51599 return resultobj;
51600 fail:
51601 return NULL;
51602 }
51603
51604
51605 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51606 PyObject *resultobj = 0;
51607 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51608 wxWindow *arg2 = (wxWindow *) 0 ;
51609 int arg3 = (int) 0 ;
51610 void *argp1 = 0 ;
51611 int res1 = 0 ;
51612 void *argp2 = 0 ;
51613 int res2 = 0 ;
51614 int val3 ;
51615 int ecode3 = 0 ;
51616 PyObject * obj0 = 0 ;
51617 PyObject * obj1 = 0 ;
51618 PyObject * obj2 = 0 ;
51619 char * kwnames[] = {
51620 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51621 };
51622
51623 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51624 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51625 if (!SWIG_IsOK(res1)) {
51626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51627 }
51628 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51629 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51630 if (!SWIG_IsOK(res2)) {
51631 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51632 }
51633 arg2 = reinterpret_cast< wxWindow * >(argp2);
51634 if (obj2) {
51635 ecode3 = SWIG_AsVal_int(obj2, &val3);
51636 if (!SWIG_IsOK(ecode3)) {
51637 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "3"" of type '" "int""'");
51638 }
51639 arg3 = static_cast< int >(val3);
51640 }
51641 {
51642 PyThreadState* __tstate = wxPyBeginAllowThreads();
51643 (arg1)->RightOf(arg2,arg3);
51644 wxPyEndAllowThreads(__tstate);
51645 if (PyErr_Occurred()) SWIG_fail;
51646 }
51647 resultobj = SWIG_Py_Void();
51648 return resultobj;
51649 fail:
51650 return NULL;
51651 }
51652
51653
51654 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51655 PyObject *resultobj = 0;
51656 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51657 wxWindow *arg2 = (wxWindow *) 0 ;
51658 int arg3 = (int) 0 ;
51659 void *argp1 = 0 ;
51660 int res1 = 0 ;
51661 void *argp2 = 0 ;
51662 int res2 = 0 ;
51663 int val3 ;
51664 int ecode3 = 0 ;
51665 PyObject * obj0 = 0 ;
51666 PyObject * obj1 = 0 ;
51667 PyObject * obj2 = 0 ;
51668 char * kwnames[] = {
51669 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51670 };
51671
51672 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51673 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51674 if (!SWIG_IsOK(res1)) {
51675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51676 }
51677 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51678 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51679 if (!SWIG_IsOK(res2)) {
51680 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "2"" of type '" "wxWindow *""'");
51681 }
51682 arg2 = reinterpret_cast< wxWindow * >(argp2);
51683 if (obj2) {
51684 ecode3 = SWIG_AsVal_int(obj2, &val3);
51685 if (!SWIG_IsOK(ecode3)) {
51686 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "3"" of type '" "int""'");
51687 }
51688 arg3 = static_cast< int >(val3);
51689 }
51690 {
51691 PyThreadState* __tstate = wxPyBeginAllowThreads();
51692 (arg1)->Above(arg2,arg3);
51693 wxPyEndAllowThreads(__tstate);
51694 if (PyErr_Occurred()) SWIG_fail;
51695 }
51696 resultobj = SWIG_Py_Void();
51697 return resultobj;
51698 fail:
51699 return NULL;
51700 }
51701
51702
51703 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51704 PyObject *resultobj = 0;
51705 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51706 wxWindow *arg2 = (wxWindow *) 0 ;
51707 int arg3 = (int) 0 ;
51708 void *argp1 = 0 ;
51709 int res1 = 0 ;
51710 void *argp2 = 0 ;
51711 int res2 = 0 ;
51712 int val3 ;
51713 int ecode3 = 0 ;
51714 PyObject * obj0 = 0 ;
51715 PyObject * obj1 = 0 ;
51716 PyObject * obj2 = 0 ;
51717 char * kwnames[] = {
51718 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51719 };
51720
51721 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51722 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51723 if (!SWIG_IsOK(res1)) {
51724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51725 }
51726 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51727 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51728 if (!SWIG_IsOK(res2)) {
51729 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "2"" of type '" "wxWindow *""'");
51730 }
51731 arg2 = reinterpret_cast< wxWindow * >(argp2);
51732 if (obj2) {
51733 ecode3 = SWIG_AsVal_int(obj2, &val3);
51734 if (!SWIG_IsOK(ecode3)) {
51735 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "3"" of type '" "int""'");
51736 }
51737 arg3 = static_cast< int >(val3);
51738 }
51739 {
51740 PyThreadState* __tstate = wxPyBeginAllowThreads();
51741 (arg1)->Below(arg2,arg3);
51742 wxPyEndAllowThreads(__tstate);
51743 if (PyErr_Occurred()) SWIG_fail;
51744 }
51745 resultobj = SWIG_Py_Void();
51746 return resultobj;
51747 fail:
51748 return NULL;
51749 }
51750
51751
51752 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51753 PyObject *resultobj = 0;
51754 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51755 wxWindow *arg2 = (wxWindow *) 0 ;
51756 wxEdge arg3 ;
51757 int arg4 = (int) 0 ;
51758 void *argp1 = 0 ;
51759 int res1 = 0 ;
51760 void *argp2 = 0 ;
51761 int res2 = 0 ;
51762 int val3 ;
51763 int ecode3 = 0 ;
51764 int val4 ;
51765 int ecode4 = 0 ;
51766 PyObject * obj0 = 0 ;
51767 PyObject * obj1 = 0 ;
51768 PyObject * obj2 = 0 ;
51769 PyObject * obj3 = 0 ;
51770 char * kwnames[] = {
51771 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
51772 };
51773
51774 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51775 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51776 if (!SWIG_IsOK(res1)) {
51777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51778 }
51779 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51780 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51781 if (!SWIG_IsOK(res2)) {
51782 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "2"" of type '" "wxWindow *""'");
51783 }
51784 arg2 = reinterpret_cast< wxWindow * >(argp2);
51785 ecode3 = SWIG_AsVal_int(obj2, &val3);
51786 if (!SWIG_IsOK(ecode3)) {
51787 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "3"" of type '" "wxEdge""'");
51788 }
51789 arg3 = static_cast< wxEdge >(val3);
51790 if (obj3) {
51791 ecode4 = SWIG_AsVal_int(obj3, &val4);
51792 if (!SWIG_IsOK(ecode4)) {
51793 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "4"" of type '" "int""'");
51794 }
51795 arg4 = static_cast< int >(val4);
51796 }
51797 {
51798 PyThreadState* __tstate = wxPyBeginAllowThreads();
51799 (arg1)->SameAs(arg2,arg3,arg4);
51800 wxPyEndAllowThreads(__tstate);
51801 if (PyErr_Occurred()) SWIG_fail;
51802 }
51803 resultobj = SWIG_Py_Void();
51804 return resultobj;
51805 fail:
51806 return NULL;
51807 }
51808
51809
51810 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51811 PyObject *resultobj = 0;
51812 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51813 wxWindow *arg2 = (wxWindow *) 0 ;
51814 wxEdge arg3 ;
51815 int arg4 ;
51816 void *argp1 = 0 ;
51817 int res1 = 0 ;
51818 void *argp2 = 0 ;
51819 int res2 = 0 ;
51820 int val3 ;
51821 int ecode3 = 0 ;
51822 int val4 ;
51823 int ecode4 = 0 ;
51824 PyObject * obj0 = 0 ;
51825 PyObject * obj1 = 0 ;
51826 PyObject * obj2 = 0 ;
51827 PyObject * obj3 = 0 ;
51828 char * kwnames[] = {
51829 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
51830 };
51831
51832 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51833 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51834 if (!SWIG_IsOK(res1)) {
51835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51836 }
51837 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51838 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51839 if (!SWIG_IsOK(res2)) {
51840 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51841 }
51842 arg2 = reinterpret_cast< wxWindow * >(argp2);
51843 ecode3 = SWIG_AsVal_int(obj2, &val3);
51844 if (!SWIG_IsOK(ecode3)) {
51845 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "3"" of type '" "wxEdge""'");
51846 }
51847 arg3 = static_cast< wxEdge >(val3);
51848 ecode4 = SWIG_AsVal_int(obj3, &val4);
51849 if (!SWIG_IsOK(ecode4)) {
51850 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "4"" of type '" "int""'");
51851 }
51852 arg4 = static_cast< int >(val4);
51853 {
51854 PyThreadState* __tstate = wxPyBeginAllowThreads();
51855 (arg1)->PercentOf(arg2,arg3,arg4);
51856 wxPyEndAllowThreads(__tstate);
51857 if (PyErr_Occurred()) SWIG_fail;
51858 }
51859 resultobj = SWIG_Py_Void();
51860 return resultobj;
51861 fail:
51862 return NULL;
51863 }
51864
51865
51866 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51867 PyObject *resultobj = 0;
51868 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51869 int arg2 ;
51870 void *argp1 = 0 ;
51871 int res1 = 0 ;
51872 int val2 ;
51873 int ecode2 = 0 ;
51874 PyObject * obj0 = 0 ;
51875 PyObject * obj1 = 0 ;
51876 char * kwnames[] = {
51877 (char *) "self",(char *) "val", NULL
51878 };
51879
51880 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) SWIG_fail;
51881 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51882 if (!SWIG_IsOK(res1)) {
51883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51884 }
51885 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51886 ecode2 = SWIG_AsVal_int(obj1, &val2);
51887 if (!SWIG_IsOK(ecode2)) {
51888 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "2"" of type '" "int""'");
51889 }
51890 arg2 = static_cast< int >(val2);
51891 {
51892 PyThreadState* __tstate = wxPyBeginAllowThreads();
51893 (arg1)->Absolute(arg2);
51894 wxPyEndAllowThreads(__tstate);
51895 if (PyErr_Occurred()) SWIG_fail;
51896 }
51897 resultobj = SWIG_Py_Void();
51898 return resultobj;
51899 fail:
51900 return NULL;
51901 }
51902
51903
51904 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51905 PyObject *resultobj = 0;
51906 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51907 void *argp1 = 0 ;
51908 int res1 = 0 ;
51909 PyObject *swig_obj[1] ;
51910
51911 if (!args) SWIG_fail;
51912 swig_obj[0] = args;
51913 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51914 if (!SWIG_IsOK(res1)) {
51915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Unconstrained" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51916 }
51917 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51918 {
51919 PyThreadState* __tstate = wxPyBeginAllowThreads();
51920 (arg1)->Unconstrained();
51921 wxPyEndAllowThreads(__tstate);
51922 if (PyErr_Occurred()) SWIG_fail;
51923 }
51924 resultobj = SWIG_Py_Void();
51925 return resultobj;
51926 fail:
51927 return NULL;
51928 }
51929
51930
51931 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51932 PyObject *resultobj = 0;
51933 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51934 void *argp1 = 0 ;
51935 int res1 = 0 ;
51936 PyObject *swig_obj[1] ;
51937
51938 if (!args) SWIG_fail;
51939 swig_obj[0] = args;
51940 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51941 if (!SWIG_IsOK(res1)) {
51942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_AsIs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51943 }
51944 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51945 {
51946 PyThreadState* __tstate = wxPyBeginAllowThreads();
51947 (arg1)->AsIs();
51948 wxPyEndAllowThreads(__tstate);
51949 if (PyErr_Occurred()) SWIG_fail;
51950 }
51951 resultobj = SWIG_Py_Void();
51952 return resultobj;
51953 fail:
51954 return NULL;
51955 }
51956
51957
51958 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51959 PyObject *resultobj = 0;
51960 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51961 wxWindow *result = 0 ;
51962 void *argp1 = 0 ;
51963 int res1 = 0 ;
51964 PyObject *swig_obj[1] ;
51965
51966 if (!args) SWIG_fail;
51967 swig_obj[0] = args;
51968 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51969 if (!SWIG_IsOK(res1)) {
51970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherWindow" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51971 }
51972 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51973 {
51974 PyThreadState* __tstate = wxPyBeginAllowThreads();
51975 result = (wxWindow *)(arg1)->GetOtherWindow();
51976 wxPyEndAllowThreads(__tstate);
51977 if (PyErr_Occurred()) SWIG_fail;
51978 }
51979 {
51980 resultobj = wxPyMake_wxObject(result, 0);
51981 }
51982 return resultobj;
51983 fail:
51984 return NULL;
51985 }
51986
51987
51988 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51989 PyObject *resultobj = 0;
51990 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51991 wxEdge result;
51992 void *argp1 = 0 ;
51993 int res1 = 0 ;
51994 PyObject *swig_obj[1] ;
51995
51996 if (!args) SWIG_fail;
51997 swig_obj[0] = args;
51998 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51999 if (!SWIG_IsOK(res1)) {
52000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMyEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52001 }
52002 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52003 {
52004 PyThreadState* __tstate = wxPyBeginAllowThreads();
52005 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
52006 wxPyEndAllowThreads(__tstate);
52007 if (PyErr_Occurred()) SWIG_fail;
52008 }
52009 resultobj = SWIG_From_int(static_cast< int >(result));
52010 return resultobj;
52011 fail:
52012 return NULL;
52013 }
52014
52015
52016 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52017 PyObject *resultobj = 0;
52018 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52019 wxEdge arg2 ;
52020 void *argp1 = 0 ;
52021 int res1 = 0 ;
52022 int val2 ;
52023 int ecode2 = 0 ;
52024 PyObject * obj0 = 0 ;
52025 PyObject * obj1 = 0 ;
52026 char * kwnames[] = {
52027 (char *) "self",(char *) "which", NULL
52028 };
52029
52030 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) SWIG_fail;
52031 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52032 if (!SWIG_IsOK(res1)) {
52033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52034 }
52035 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52036 ecode2 = SWIG_AsVal_int(obj1, &val2);
52037 if (!SWIG_IsOK(ecode2)) {
52038 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
52039 }
52040 arg2 = static_cast< wxEdge >(val2);
52041 {
52042 PyThreadState* __tstate = wxPyBeginAllowThreads();
52043 (arg1)->SetEdge(arg2);
52044 wxPyEndAllowThreads(__tstate);
52045 if (PyErr_Occurred()) SWIG_fail;
52046 }
52047 resultobj = SWIG_Py_Void();
52048 return resultobj;
52049 fail:
52050 return NULL;
52051 }
52052
52053
52054 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52055 PyObject *resultobj = 0;
52056 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52057 int arg2 ;
52058 void *argp1 = 0 ;
52059 int res1 = 0 ;
52060 int val2 ;
52061 int ecode2 = 0 ;
52062 PyObject * obj0 = 0 ;
52063 PyObject * obj1 = 0 ;
52064 char * kwnames[] = {
52065 (char *) "self",(char *) "v", NULL
52066 };
52067
52068 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
52069 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52070 if (!SWIG_IsOK(res1)) {
52071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52072 }
52073 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52074 ecode2 = SWIG_AsVal_int(obj1, &val2);
52075 if (!SWIG_IsOK(ecode2)) {
52076 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "2"" of type '" "int""'");
52077 }
52078 arg2 = static_cast< int >(val2);
52079 {
52080 PyThreadState* __tstate = wxPyBeginAllowThreads();
52081 (arg1)->SetValue(arg2);
52082 wxPyEndAllowThreads(__tstate);
52083 if (PyErr_Occurred()) SWIG_fail;
52084 }
52085 resultobj = SWIG_Py_Void();
52086 return resultobj;
52087 fail:
52088 return NULL;
52089 }
52090
52091
52092 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52093 PyObject *resultobj = 0;
52094 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52095 int result;
52096 void *argp1 = 0 ;
52097 int res1 = 0 ;
52098 PyObject *swig_obj[1] ;
52099
52100 if (!args) SWIG_fail;
52101 swig_obj[0] = args;
52102 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52103 if (!SWIG_IsOK(res1)) {
52104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52105 }
52106 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52107 {
52108 PyThreadState* __tstate = wxPyBeginAllowThreads();
52109 result = (int)(arg1)->GetMargin();
52110 wxPyEndAllowThreads(__tstate);
52111 if (PyErr_Occurred()) SWIG_fail;
52112 }
52113 resultobj = SWIG_From_int(static_cast< int >(result));
52114 return resultobj;
52115 fail:
52116 return NULL;
52117 }
52118
52119
52120 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52121 PyObject *resultobj = 0;
52122 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52123 int arg2 ;
52124 void *argp1 = 0 ;
52125 int res1 = 0 ;
52126 int val2 ;
52127 int ecode2 = 0 ;
52128 PyObject * obj0 = 0 ;
52129 PyObject * obj1 = 0 ;
52130 char * kwnames[] = {
52131 (char *) "self",(char *) "m", NULL
52132 };
52133
52134 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) SWIG_fail;
52135 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52136 if (!SWIG_IsOK(res1)) {
52137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52138 }
52139 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52140 ecode2 = SWIG_AsVal_int(obj1, &val2);
52141 if (!SWIG_IsOK(ecode2)) {
52142 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "2"" of type '" "int""'");
52143 }
52144 arg2 = static_cast< int >(val2);
52145 {
52146 PyThreadState* __tstate = wxPyBeginAllowThreads();
52147 (arg1)->SetMargin(arg2);
52148 wxPyEndAllowThreads(__tstate);
52149 if (PyErr_Occurred()) SWIG_fail;
52150 }
52151 resultobj = SWIG_Py_Void();
52152 return resultobj;
52153 fail:
52154 return NULL;
52155 }
52156
52157
52158 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52159 PyObject *resultobj = 0;
52160 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52161 int result;
52162 void *argp1 = 0 ;
52163 int res1 = 0 ;
52164 PyObject *swig_obj[1] ;
52165
52166 if (!args) SWIG_fail;
52167 swig_obj[0] = args;
52168 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52169 if (!SWIG_IsOK(res1)) {
52170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52171 }
52172 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52173 {
52174 PyThreadState* __tstate = wxPyBeginAllowThreads();
52175 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
52176 wxPyEndAllowThreads(__tstate);
52177 if (PyErr_Occurred()) SWIG_fail;
52178 }
52179 resultobj = SWIG_From_int(static_cast< int >(result));
52180 return resultobj;
52181 fail:
52182 return NULL;
52183 }
52184
52185
52186 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52187 PyObject *resultobj = 0;
52188 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52189 int result;
52190 void *argp1 = 0 ;
52191 int res1 = 0 ;
52192 PyObject *swig_obj[1] ;
52193
52194 if (!args) SWIG_fail;
52195 swig_obj[0] = args;
52196 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52197 if (!SWIG_IsOK(res1)) {
52198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetPercent" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52199 }
52200 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52201 {
52202 PyThreadState* __tstate = wxPyBeginAllowThreads();
52203 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
52204 wxPyEndAllowThreads(__tstate);
52205 if (PyErr_Occurred()) SWIG_fail;
52206 }
52207 resultobj = SWIG_From_int(static_cast< int >(result));
52208 return resultobj;
52209 fail:
52210 return NULL;
52211 }
52212
52213
52214 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52215 PyObject *resultobj = 0;
52216 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52217 int result;
52218 void *argp1 = 0 ;
52219 int res1 = 0 ;
52220 PyObject *swig_obj[1] ;
52221
52222 if (!args) SWIG_fail;
52223 swig_obj[0] = args;
52224 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52225 if (!SWIG_IsOK(res1)) {
52226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52227 }
52228 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52229 {
52230 PyThreadState* __tstate = wxPyBeginAllowThreads();
52231 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
52232 wxPyEndAllowThreads(__tstate);
52233 if (PyErr_Occurred()) SWIG_fail;
52234 }
52235 resultobj = SWIG_From_int(static_cast< int >(result));
52236 return resultobj;
52237 fail:
52238 return NULL;
52239 }
52240
52241
52242 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52243 PyObject *resultobj = 0;
52244 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52245 bool result;
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_wxIndividualLayoutConstraint, 0 | 0 );
52253 if (!SWIG_IsOK(res1)) {
52254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52255 }
52256 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52257 {
52258 PyThreadState* __tstate = wxPyBeginAllowThreads();
52259 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
52260 wxPyEndAllowThreads(__tstate);
52261 if (PyErr_Occurred()) SWIG_fail;
52262 }
52263 {
52264 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52265 }
52266 return resultobj;
52267 fail:
52268 return NULL;
52269 }
52270
52271
52272 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52273 PyObject *resultobj = 0;
52274 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52275 bool arg2 ;
52276 void *argp1 = 0 ;
52277 int res1 = 0 ;
52278 bool val2 ;
52279 int ecode2 = 0 ;
52280 PyObject * obj0 = 0 ;
52281 PyObject * obj1 = 0 ;
52282 char * kwnames[] = {
52283 (char *) "self",(char *) "d", NULL
52284 };
52285
52286 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) SWIG_fail;
52287 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52288 if (!SWIG_IsOK(res1)) {
52289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52290 }
52291 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52292 ecode2 = SWIG_AsVal_bool(obj1, &val2);
52293 if (!SWIG_IsOK(ecode2)) {
52294 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "2"" of type '" "bool""'");
52295 }
52296 arg2 = static_cast< bool >(val2);
52297 {
52298 PyThreadState* __tstate = wxPyBeginAllowThreads();
52299 (arg1)->SetDone(arg2);
52300 wxPyEndAllowThreads(__tstate);
52301 if (PyErr_Occurred()) SWIG_fail;
52302 }
52303 resultobj = SWIG_Py_Void();
52304 return resultobj;
52305 fail:
52306 return NULL;
52307 }
52308
52309
52310 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52311 PyObject *resultobj = 0;
52312 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52313 wxRelationship result;
52314 void *argp1 = 0 ;
52315 int res1 = 0 ;
52316 PyObject *swig_obj[1] ;
52317
52318 if (!args) SWIG_fail;
52319 swig_obj[0] = args;
52320 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52321 if (!SWIG_IsOK(res1)) {
52322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52323 }
52324 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52325 {
52326 PyThreadState* __tstate = wxPyBeginAllowThreads();
52327 result = (wxRelationship)(arg1)->GetRelationship();
52328 wxPyEndAllowThreads(__tstate);
52329 if (PyErr_Occurred()) SWIG_fail;
52330 }
52331 resultobj = SWIG_From_int(static_cast< int >(result));
52332 return resultobj;
52333 fail:
52334 return NULL;
52335 }
52336
52337
52338 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52339 PyObject *resultobj = 0;
52340 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52341 wxRelationship arg2 ;
52342 void *argp1 = 0 ;
52343 int res1 = 0 ;
52344 int val2 ;
52345 int ecode2 = 0 ;
52346 PyObject * obj0 = 0 ;
52347 PyObject * obj1 = 0 ;
52348 char * kwnames[] = {
52349 (char *) "self",(char *) "r", NULL
52350 };
52351
52352 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) SWIG_fail;
52353 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52354 if (!SWIG_IsOK(res1)) {
52355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52356 }
52357 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52358 ecode2 = SWIG_AsVal_int(obj1, &val2);
52359 if (!SWIG_IsOK(ecode2)) {
52360 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "2"" of type '" "wxRelationship""'");
52361 }
52362 arg2 = static_cast< wxRelationship >(val2);
52363 {
52364 PyThreadState* __tstate = wxPyBeginAllowThreads();
52365 (arg1)->SetRelationship(arg2);
52366 wxPyEndAllowThreads(__tstate);
52367 if (PyErr_Occurred()) SWIG_fail;
52368 }
52369 resultobj = SWIG_Py_Void();
52370 return resultobj;
52371 fail:
52372 return NULL;
52373 }
52374
52375
52376 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52377 PyObject *resultobj = 0;
52378 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52379 wxWindow *arg2 = (wxWindow *) 0 ;
52380 bool result;
52381 void *argp1 = 0 ;
52382 int res1 = 0 ;
52383 void *argp2 = 0 ;
52384 int res2 = 0 ;
52385 PyObject * obj0 = 0 ;
52386 PyObject * obj1 = 0 ;
52387 char * kwnames[] = {
52388 (char *) "self",(char *) "otherW", NULL
52389 };
52390
52391 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) SWIG_fail;
52392 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52393 if (!SWIG_IsOK(res1)) {
52394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52395 }
52396 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52397 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52398 if (!SWIG_IsOK(res2)) {
52399 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "2"" of type '" "wxWindow *""'");
52400 }
52401 arg2 = reinterpret_cast< wxWindow * >(argp2);
52402 {
52403 PyThreadState* __tstate = wxPyBeginAllowThreads();
52404 result = (bool)(arg1)->ResetIfWin(arg2);
52405 wxPyEndAllowThreads(__tstate);
52406 if (PyErr_Occurred()) SWIG_fail;
52407 }
52408 {
52409 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52410 }
52411 return resultobj;
52412 fail:
52413 return NULL;
52414 }
52415
52416
52417 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52418 PyObject *resultobj = 0;
52419 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52420 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
52421 wxWindow *arg3 = (wxWindow *) 0 ;
52422 bool result;
52423 void *argp1 = 0 ;
52424 int res1 = 0 ;
52425 void *argp2 = 0 ;
52426 int res2 = 0 ;
52427 void *argp3 = 0 ;
52428 int res3 = 0 ;
52429 PyObject * obj0 = 0 ;
52430 PyObject * obj1 = 0 ;
52431 PyObject * obj2 = 0 ;
52432 char * kwnames[] = {
52433 (char *) "self",(char *) "constraints",(char *) "win", NULL
52434 };
52435
52436 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52437 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52438 if (!SWIG_IsOK(res1)) {
52439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52440 }
52441 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52442 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52443 if (!SWIG_IsOK(res2)) {
52444 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
52445 }
52446 arg2 = reinterpret_cast< wxLayoutConstraints * >(argp2);
52447 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
52448 if (!SWIG_IsOK(res3)) {
52449 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "3"" of type '" "wxWindow *""'");
52450 }
52451 arg3 = reinterpret_cast< wxWindow * >(argp3);
52452 {
52453 PyThreadState* __tstate = wxPyBeginAllowThreads();
52454 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
52455 wxPyEndAllowThreads(__tstate);
52456 if (PyErr_Occurred()) SWIG_fail;
52457 }
52458 {
52459 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52460 }
52461 return resultobj;
52462 fail:
52463 return NULL;
52464 }
52465
52466
52467 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52468 PyObject *resultobj = 0;
52469 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52470 wxEdge arg2 ;
52471 wxWindow *arg3 = (wxWindow *) 0 ;
52472 wxWindow *arg4 = (wxWindow *) 0 ;
52473 int result;
52474 void *argp1 = 0 ;
52475 int res1 = 0 ;
52476 int val2 ;
52477 int ecode2 = 0 ;
52478 void *argp3 = 0 ;
52479 int res3 = 0 ;
52480 void *argp4 = 0 ;
52481 int res4 = 0 ;
52482 PyObject * obj0 = 0 ;
52483 PyObject * obj1 = 0 ;
52484 PyObject * obj2 = 0 ;
52485 PyObject * obj3 = 0 ;
52486 char * kwnames[] = {
52487 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
52488 };
52489
52490 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52491 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52492 if (!SWIG_IsOK(res1)) {
52493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52494 }
52495 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52496 ecode2 = SWIG_AsVal_int(obj1, &val2);
52497 if (!SWIG_IsOK(ecode2)) {
52498 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
52499 }
52500 arg2 = static_cast< wxEdge >(val2);
52501 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
52502 if (!SWIG_IsOK(res3)) {
52503 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "3"" of type '" "wxWindow *""'");
52504 }
52505 arg3 = reinterpret_cast< wxWindow * >(argp3);
52506 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
52507 if (!SWIG_IsOK(res4)) {
52508 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "4"" of type '" "wxWindow *""'");
52509 }
52510 arg4 = reinterpret_cast< wxWindow * >(argp4);
52511 {
52512 PyThreadState* __tstate = wxPyBeginAllowThreads();
52513 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge(arg2,arg3,arg4);
52514 wxPyEndAllowThreads(__tstate);
52515 if (PyErr_Occurred()) SWIG_fail;
52516 }
52517 resultobj = SWIG_From_int(static_cast< int >(result));
52518 return resultobj;
52519 fail:
52520 return NULL;
52521 }
52522
52523
52524 SWIGINTERN PyObject *IndividualLayoutConstraint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52525 PyObject *obj;
52526 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52527 SWIG_TypeNewClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_NewClientData(obj));
52528 return SWIG_Py_Void();
52529 }
52530
52531 SWIGINTERN PyObject *_wrap_LayoutConstraints_left_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52532 PyObject *resultobj = 0;
52533 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52534 wxIndividualLayoutConstraint *result = 0 ;
52535 void *argp1 = 0 ;
52536 int res1 = 0 ;
52537 PyObject *swig_obj[1] ;
52538
52539 if (!args) SWIG_fail;
52540 swig_obj[0] = args;
52541 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52542 if (!SWIG_IsOK(res1)) {
52543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_left_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52544 }
52545 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52546 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
52547 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52548 return resultobj;
52549 fail:
52550 return NULL;
52551 }
52552
52553
52554 SWIGINTERN PyObject *_wrap_LayoutConstraints_top_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52555 PyObject *resultobj = 0;
52556 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52557 wxIndividualLayoutConstraint *result = 0 ;
52558 void *argp1 = 0 ;
52559 int res1 = 0 ;
52560 PyObject *swig_obj[1] ;
52561
52562 if (!args) SWIG_fail;
52563 swig_obj[0] = args;
52564 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52565 if (!SWIG_IsOK(res1)) {
52566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_top_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52567 }
52568 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52569 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
52570 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52571 return resultobj;
52572 fail:
52573 return NULL;
52574 }
52575
52576
52577 SWIGINTERN PyObject *_wrap_LayoutConstraints_right_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52578 PyObject *resultobj = 0;
52579 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52580 wxIndividualLayoutConstraint *result = 0 ;
52581 void *argp1 = 0 ;
52582 int res1 = 0 ;
52583 PyObject *swig_obj[1] ;
52584
52585 if (!args) SWIG_fail;
52586 swig_obj[0] = args;
52587 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52588 if (!SWIG_IsOK(res1)) {
52589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_right_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52590 }
52591 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52592 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
52593 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52594 return resultobj;
52595 fail:
52596 return NULL;
52597 }
52598
52599
52600 SWIGINTERN PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52601 PyObject *resultobj = 0;
52602 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52603 wxIndividualLayoutConstraint *result = 0 ;
52604 void *argp1 = 0 ;
52605 int res1 = 0 ;
52606 PyObject *swig_obj[1] ;
52607
52608 if (!args) SWIG_fail;
52609 swig_obj[0] = args;
52610 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52611 if (!SWIG_IsOK(res1)) {
52612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_bottom_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52613 }
52614 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52615 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
52616 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52617 return resultobj;
52618 fail:
52619 return NULL;
52620 }
52621
52622
52623 SWIGINTERN PyObject *_wrap_LayoutConstraints_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52624 PyObject *resultobj = 0;
52625 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52626 wxIndividualLayoutConstraint *result = 0 ;
52627 void *argp1 = 0 ;
52628 int res1 = 0 ;
52629 PyObject *swig_obj[1] ;
52630
52631 if (!args) SWIG_fail;
52632 swig_obj[0] = args;
52633 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52634 if (!SWIG_IsOK(res1)) {
52635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_width_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52636 }
52637 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52638 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
52639 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52640 return resultobj;
52641 fail:
52642 return NULL;
52643 }
52644
52645
52646 SWIGINTERN PyObject *_wrap_LayoutConstraints_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52647 PyObject *resultobj = 0;
52648 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52649 wxIndividualLayoutConstraint *result = 0 ;
52650 void *argp1 = 0 ;
52651 int res1 = 0 ;
52652 PyObject *swig_obj[1] ;
52653
52654 if (!args) SWIG_fail;
52655 swig_obj[0] = args;
52656 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52657 if (!SWIG_IsOK(res1)) {
52658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_height_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52659 }
52660 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52661 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
52662 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52663 return resultobj;
52664 fail:
52665 return NULL;
52666 }
52667
52668
52669 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52670 PyObject *resultobj = 0;
52671 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52672 wxIndividualLayoutConstraint *result = 0 ;
52673 void *argp1 = 0 ;
52674 int res1 = 0 ;
52675 PyObject *swig_obj[1] ;
52676
52677 if (!args) SWIG_fail;
52678 swig_obj[0] = args;
52679 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52680 if (!SWIG_IsOK(res1)) {
52681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreX_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52682 }
52683 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52684 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
52685 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52686 return resultobj;
52687 fail:
52688 return NULL;
52689 }
52690
52691
52692 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52693 PyObject *resultobj = 0;
52694 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52695 wxIndividualLayoutConstraint *result = 0 ;
52696 void *argp1 = 0 ;
52697 int res1 = 0 ;
52698 PyObject *swig_obj[1] ;
52699
52700 if (!args) SWIG_fail;
52701 swig_obj[0] = args;
52702 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52703 if (!SWIG_IsOK(res1)) {
52704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreY_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52705 }
52706 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52707 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
52708 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52709 return resultobj;
52710 fail:
52711 return NULL;
52712 }
52713
52714
52715 SWIGINTERN PyObject *_wrap_new_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52716 PyObject *resultobj = 0;
52717 wxLayoutConstraints *result = 0 ;
52718
52719 if (!SWIG_Python_UnpackTuple(args,"new_LayoutConstraints",0,0,0)) SWIG_fail;
52720 {
52721 PyThreadState* __tstate = wxPyBeginAllowThreads();
52722 result = (wxLayoutConstraints *)new wxLayoutConstraints();
52723 wxPyEndAllowThreads(__tstate);
52724 if (PyErr_Occurred()) SWIG_fail;
52725 }
52726 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_NEW | 0 );
52727 return resultobj;
52728 fail:
52729 return NULL;
52730 }
52731
52732
52733 SWIGINTERN PyObject *_wrap_delete_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52734 PyObject *resultobj = 0;
52735 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52736 void *argp1 = 0 ;
52737 int res1 = 0 ;
52738 PyObject *swig_obj[1] ;
52739
52740 if (!args) SWIG_fail;
52741 swig_obj[0] = args;
52742 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
52743 if (!SWIG_IsOK(res1)) {
52744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LayoutConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52745 }
52746 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52747 {
52748 PyThreadState* __tstate = wxPyBeginAllowThreads();
52749 delete arg1;
52750
52751 wxPyEndAllowThreads(__tstate);
52752 if (PyErr_Occurred()) SWIG_fail;
52753 }
52754 resultobj = SWIG_Py_Void();
52755 return resultobj;
52756 fail:
52757 return NULL;
52758 }
52759
52760
52761 SWIGINTERN PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52762 PyObject *resultobj = 0;
52763 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52764 wxWindow *arg2 = (wxWindow *) 0 ;
52765 int *arg3 = (int *) 0 ;
52766 bool result;
52767 void *argp1 = 0 ;
52768 int res1 = 0 ;
52769 void *argp2 = 0 ;
52770 int res2 = 0 ;
52771 int temp3 ;
52772 int res3 = SWIG_TMPOBJ ;
52773 PyObject * obj0 = 0 ;
52774 PyObject * obj1 = 0 ;
52775 char * kwnames[] = {
52776 (char *) "self",(char *) "win", NULL
52777 };
52778
52779 arg3 = &temp3;
52780 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
52781 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52782 if (!SWIG_IsOK(res1)) {
52783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52784 }
52785 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52786 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52787 if (!SWIG_IsOK(res2)) {
52788 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "2"" of type '" "wxWindow *""'");
52789 }
52790 arg2 = reinterpret_cast< wxWindow * >(argp2);
52791 {
52792 PyThreadState* __tstate = wxPyBeginAllowThreads();
52793 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
52794 wxPyEndAllowThreads(__tstate);
52795 if (PyErr_Occurred()) SWIG_fail;
52796 }
52797 {
52798 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52799 }
52800 if (SWIG_IsTmpObj(res3)) {
52801 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
52802 } else {
52803 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
52804 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
52805 }
52806 return resultobj;
52807 fail:
52808 return NULL;
52809 }
52810
52811
52812 SWIGINTERN PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52813 PyObject *resultobj = 0;
52814 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52815 bool result;
52816 void *argp1 = 0 ;
52817 int res1 = 0 ;
52818 PyObject *swig_obj[1] ;
52819
52820 if (!args) SWIG_fail;
52821 swig_obj[0] = args;
52822 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52823 if (!SWIG_IsOK(res1)) {
52824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_AreSatisfied" "', expected argument " "1"" of type '" "wxLayoutConstraints const *""'");
52825 }
52826 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52827 {
52828 PyThreadState* __tstate = wxPyBeginAllowThreads();
52829 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
52830 wxPyEndAllowThreads(__tstate);
52831 if (PyErr_Occurred()) SWIG_fail;
52832 }
52833 {
52834 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52835 }
52836 return resultobj;
52837 fail:
52838 return NULL;
52839 }
52840
52841
52842 SWIGINTERN PyObject *LayoutConstraints_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52843 PyObject *obj;
52844 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52845 SWIG_TypeNewClientData(SWIGTYPE_p_wxLayoutConstraints, SWIG_NewClientData(obj));
52846 return SWIG_Py_Void();
52847 }
52848
52849 SWIGINTERN PyObject *LayoutConstraints_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52850 return SWIG_Python_InitShadowInstance(args);
52851 }
52852
52853 static PyMethodDef SwigMethods[] = {
52854 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
52855 { (char *)"Object_GetClassName", (PyCFunction)_wrap_Object_GetClassName, METH_O, NULL},
52856 { (char *)"Object_Destroy", (PyCFunction)_wrap_Object_Destroy, METH_O, NULL},
52857 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
52858 { (char *)"Size_width_set", _wrap_Size_width_set, METH_VARARGS, NULL},
52859 { (char *)"Size_width_get", (PyCFunction)_wrap_Size_width_get, METH_O, NULL},
52860 { (char *)"Size_height_set", _wrap_Size_height_set, METH_VARARGS, NULL},
52861 { (char *)"Size_height_get", (PyCFunction)_wrap_Size_height_get, METH_O, NULL},
52862 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
52863 { (char *)"delete_Size", (PyCFunction)_wrap_delete_Size, METH_O, NULL},
52864 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52865 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52866 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52867 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52868 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
52869 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
52870 { (char *)"Size_Scale", (PyCFunction) _wrap_Size_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
52871 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52872 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
52873 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
52874 { (char *)"Size_GetWidth", (PyCFunction)_wrap_Size_GetWidth, METH_O, NULL},
52875 { (char *)"Size_GetHeight", (PyCFunction)_wrap_Size_GetHeight, METH_O, NULL},
52876 { (char *)"Size_IsFullySpecified", (PyCFunction)_wrap_Size_IsFullySpecified, METH_O, NULL},
52877 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
52878 { (char *)"Size_Get", (PyCFunction)_wrap_Size_Get, METH_O, NULL},
52879 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
52880 { (char *)"Size_swiginit", Size_swiginit, METH_VARARGS, NULL},
52881 { (char *)"RealPoint_x_set", _wrap_RealPoint_x_set, METH_VARARGS, NULL},
52882 { (char *)"RealPoint_x_get", (PyCFunction)_wrap_RealPoint_x_get, METH_O, NULL},
52883 { (char *)"RealPoint_y_set", _wrap_RealPoint_y_set, METH_VARARGS, NULL},
52884 { (char *)"RealPoint_y_get", (PyCFunction)_wrap_RealPoint_y_get, METH_O, NULL},
52885 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
52886 { (char *)"delete_RealPoint", (PyCFunction)_wrap_delete_RealPoint, METH_O, NULL},
52887 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52888 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52889 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52890 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52891 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52892 { (char *)"RealPoint_Get", (PyCFunction)_wrap_RealPoint_Get, METH_O, NULL},
52893 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
52894 { (char *)"RealPoint_swiginit", RealPoint_swiginit, METH_VARARGS, NULL},
52895 { (char *)"Point_x_set", _wrap_Point_x_set, METH_VARARGS, NULL},
52896 { (char *)"Point_x_get", (PyCFunction)_wrap_Point_x_get, METH_O, NULL},
52897 { (char *)"Point_y_set", _wrap_Point_y_set, METH_VARARGS, NULL},
52898 { (char *)"Point_y_get", (PyCFunction)_wrap_Point_y_get, METH_O, NULL},
52899 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
52900 { (char *)"delete_Point", (PyCFunction)_wrap_delete_Point, METH_O, NULL},
52901 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52902 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52903 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52904 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52905 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52906 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
52907 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52908 { (char *)"Point_Get", (PyCFunction)_wrap_Point_Get, METH_O, NULL},
52909 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
52910 { (char *)"Point_swiginit", Point_swiginit, METH_VARARGS, NULL},
52911 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
52912 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
52913 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
52914 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
52915 { (char *)"delete_Rect", (PyCFunction)_wrap_delete_Rect, METH_O, NULL},
52916 { (char *)"Rect_GetX", (PyCFunction)_wrap_Rect_GetX, METH_O, NULL},
52917 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
52918 { (char *)"Rect_GetY", (PyCFunction)_wrap_Rect_GetY, METH_O, NULL},
52919 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
52920 { (char *)"Rect_GetWidth", (PyCFunction)_wrap_Rect_GetWidth, METH_O, NULL},
52921 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
52922 { (char *)"Rect_GetHeight", (PyCFunction)_wrap_Rect_GetHeight, METH_O, NULL},
52923 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
52924 { (char *)"Rect_GetPosition", (PyCFunction)_wrap_Rect_GetPosition, METH_O, NULL},
52925 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
52926 { (char *)"Rect_GetSize", (PyCFunction)_wrap_Rect_GetSize, METH_O, NULL},
52927 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
52928 { (char *)"Rect_IsEmpty", (PyCFunction)_wrap_Rect_IsEmpty, METH_O, NULL},
52929 { (char *)"Rect_GetTopLeft", (PyCFunction)_wrap_Rect_GetTopLeft, METH_O, NULL},
52930 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
52931 { (char *)"Rect_GetBottomRight", (PyCFunction)_wrap_Rect_GetBottomRight, METH_O, NULL},
52932 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
52933 { (char *)"Rect_GetLeft", (PyCFunction)_wrap_Rect_GetLeft, METH_O, NULL},
52934 { (char *)"Rect_GetTop", (PyCFunction)_wrap_Rect_GetTop, METH_O, NULL},
52935 { (char *)"Rect_GetBottom", (PyCFunction)_wrap_Rect_GetBottom, METH_O, NULL},
52936 { (char *)"Rect_GetRight", (PyCFunction)_wrap_Rect_GetRight, METH_O, NULL},
52937 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
52938 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
52939 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
52940 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
52941 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
52942 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
52943 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
52944 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
52945 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
52946 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
52947 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52948 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52949 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52950 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52951 { (char *)"Rect_InsideXY", (PyCFunction) _wrap_Rect_InsideXY, METH_VARARGS | METH_KEYWORDS, NULL},
52952 { (char *)"Rect_Inside", (PyCFunction) _wrap_Rect_Inside, METH_VARARGS | METH_KEYWORDS, NULL},
52953 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
52954 { (char *)"Rect_CenterIn", (PyCFunction) _wrap_Rect_CenterIn, METH_VARARGS | METH_KEYWORDS, NULL},
52955 { (char *)"Rect_x_set", _wrap_Rect_x_set, METH_VARARGS, NULL},
52956 { (char *)"Rect_x_get", (PyCFunction)_wrap_Rect_x_get, METH_O, NULL},
52957 { (char *)"Rect_y_set", _wrap_Rect_y_set, METH_VARARGS, NULL},
52958 { (char *)"Rect_y_get", (PyCFunction)_wrap_Rect_y_get, METH_O, NULL},
52959 { (char *)"Rect_width_set", _wrap_Rect_width_set, METH_VARARGS, NULL},
52960 { (char *)"Rect_width_get", (PyCFunction)_wrap_Rect_width_get, METH_O, NULL},
52961 { (char *)"Rect_height_set", _wrap_Rect_height_set, METH_VARARGS, NULL},
52962 { (char *)"Rect_height_get", (PyCFunction)_wrap_Rect_height_get, METH_O, NULL},
52963 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52964 { (char *)"Rect_Get", (PyCFunction)_wrap_Rect_Get, METH_O, NULL},
52965 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
52966 { (char *)"Rect_swiginit", Rect_swiginit, METH_VARARGS, NULL},
52967 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
52968 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
52969 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
52970 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
52971 { (char *)"Point2D_GetFloor", (PyCFunction)_wrap_Point2D_GetFloor, METH_O, NULL},
52972 { (char *)"Point2D_GetRounded", (PyCFunction)_wrap_Point2D_GetRounded, METH_O, NULL},
52973 { (char *)"Point2D_GetVectorLength", (PyCFunction)_wrap_Point2D_GetVectorLength, METH_O, NULL},
52974 { (char *)"Point2D_GetVectorAngle", (PyCFunction)_wrap_Point2D_GetVectorAngle, METH_O, NULL},
52975 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
52976 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
52977 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
52978 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
52979 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
52980 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
52981 { (char *)"Point2D___neg__", (PyCFunction)_wrap_Point2D___neg__, METH_O, NULL},
52982 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52983 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
52984 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
52985 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
52986 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52987 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52988 { (char *)"Point2D_x_set", _wrap_Point2D_x_set, METH_VARARGS, NULL},
52989 { (char *)"Point2D_x_get", (PyCFunction)_wrap_Point2D_x_get, METH_O, NULL},
52990 { (char *)"Point2D_y_set", _wrap_Point2D_y_set, METH_VARARGS, NULL},
52991 { (char *)"Point2D_y_get", (PyCFunction)_wrap_Point2D_y_get, METH_O, NULL},
52992 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52993 { (char *)"Point2D_Get", (PyCFunction)_wrap_Point2D_Get, METH_O, NULL},
52994 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
52995 { (char *)"Point2D_swiginit", Point2D_swiginit, METH_VARARGS, NULL},
52996 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
52997 { (char *)"delete_InputStream", (PyCFunction)_wrap_delete_InputStream, METH_O, NULL},
52998 { (char *)"InputStream_close", (PyCFunction)_wrap_InputStream_close, METH_O, NULL},
52999 { (char *)"InputStream_flush", (PyCFunction)_wrap_InputStream_flush, METH_O, NULL},
53000 { (char *)"InputStream_eof", (PyCFunction)_wrap_InputStream_eof, METH_O, NULL},
53001 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
53002 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
53003 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
53004 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
53005 { (char *)"InputStream_tell", (PyCFunction)_wrap_InputStream_tell, METH_O, NULL},
53006 { (char *)"InputStream_Peek", (PyCFunction)_wrap_InputStream_Peek, METH_O, NULL},
53007 { (char *)"InputStream_GetC", (PyCFunction)_wrap_InputStream_GetC, METH_O, NULL},
53008 { (char *)"InputStream_LastRead", (PyCFunction)_wrap_InputStream_LastRead, METH_O, NULL},
53009 { (char *)"InputStream_CanRead", (PyCFunction)_wrap_InputStream_CanRead, METH_O, NULL},
53010 { (char *)"InputStream_Eof", (PyCFunction)_wrap_InputStream_Eof, METH_O, NULL},
53011 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
53012 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
53013 { (char *)"InputStream_TellI", (PyCFunction)_wrap_InputStream_TellI, METH_O, NULL},
53014 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
53015 { (char *)"InputStream_swiginit", InputStream_swiginit, METH_VARARGS, NULL},
53016 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
53017 { (char *)"OutputStream_LastWrite", (PyCFunction)_wrap_OutputStream_LastWrite, METH_O, NULL},
53018 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
53019 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
53020 { (char *)"delete_FSFile", (PyCFunction)_wrap_delete_FSFile, METH_O, NULL},
53021 { (char *)"FSFile_GetStream", (PyCFunction)_wrap_FSFile_GetStream, METH_O, NULL},
53022 { (char *)"FSFile_GetMimeType", (PyCFunction)_wrap_FSFile_GetMimeType, METH_O, NULL},
53023 { (char *)"FSFile_GetLocation", (PyCFunction)_wrap_FSFile_GetLocation, METH_O, NULL},
53024 { (char *)"FSFile_GetAnchor", (PyCFunction)_wrap_FSFile_GetAnchor, METH_O, NULL},
53025 { (char *)"FSFile_GetModificationTime", (PyCFunction)_wrap_FSFile_GetModificationTime, METH_O, NULL},
53026 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
53027 { (char *)"FSFile_swiginit", FSFile_swiginit, METH_VARARGS, NULL},
53028 { (char *)"delete_CPPFileSystemHandler", (PyCFunction)_wrap_delete_CPPFileSystemHandler, METH_O, NULL},
53029 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
53030 { (char *)"new_FileSystemHandler", (PyCFunction)_wrap_new_FileSystemHandler, METH_NOARGS, NULL},
53031 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53032 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
53033 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53034 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
53035 { (char *)"FileSystemHandler_FindNext", (PyCFunction)_wrap_FileSystemHandler_FindNext, METH_O, NULL},
53036 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
53037 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
53038 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
53039 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
53040 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
53041 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
53042 { (char *)"FileSystemHandler_swiginit", FileSystemHandler_swiginit, METH_VARARGS, NULL},
53043 { (char *)"new_FileSystem", (PyCFunction)_wrap_new_FileSystem, METH_NOARGS, NULL},
53044 { (char *)"delete_FileSystem", (PyCFunction)_wrap_delete_FileSystem, METH_O, NULL},
53045 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
53046 { (char *)"FileSystem_GetPath", (PyCFunction)_wrap_FileSystem_GetPath, METH_O, NULL},
53047 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53048 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
53049 { (char *)"FileSystem_FindNext", (PyCFunction)_wrap_FileSystem_FindNext, METH_O, NULL},
53050 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53051 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction)_wrap_FileSystem_CleanUpHandlers, METH_NOARGS, NULL},
53052 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
53053 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
53054 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
53055 { (char *)"FileSystem_swiginit", FileSystem_swiginit, METH_VARARGS, NULL},
53056 { (char *)"new_InternetFSHandler", (PyCFunction)_wrap_new_InternetFSHandler, METH_NOARGS, NULL},
53057 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
53058 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53059 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
53060 { (char *)"InternetFSHandler_swiginit", InternetFSHandler_swiginit, METH_VARARGS, NULL},
53061 { (char *)"new_ZipFSHandler", (PyCFunction)_wrap_new_ZipFSHandler, METH_NOARGS, NULL},
53062 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
53063 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53064 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
53065 { (char *)"ZipFSHandler_FindNext", (PyCFunction)_wrap_ZipFSHandler_FindNext, METH_O, NULL},
53066 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
53067 { (char *)"ZipFSHandler_swiginit", ZipFSHandler_swiginit, METH_VARARGS, NULL},
53068 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
53069 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53070 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
53071 { (char *)"new_MemoryFSHandler", (PyCFunction)_wrap_new_MemoryFSHandler, METH_NOARGS, NULL},
53072 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
53073 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
53074 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53075 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
53076 { (char *)"MemoryFSHandler_FindNext", (PyCFunction)_wrap_MemoryFSHandler_FindNext, METH_O, NULL},
53077 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
53078 { (char *)"MemoryFSHandler_swiginit", MemoryFSHandler_swiginit, METH_VARARGS, NULL},
53079 { (char *)"ImageHandler_GetName", (PyCFunction)_wrap_ImageHandler_GetName, METH_O, NULL},
53080 { (char *)"ImageHandler_GetExtension", (PyCFunction)_wrap_ImageHandler_GetExtension, METH_O, NULL},
53081 { (char *)"ImageHandler_GetType", (PyCFunction)_wrap_ImageHandler_GetType, METH_O, NULL},
53082 { (char *)"ImageHandler_GetMimeType", (PyCFunction)_wrap_ImageHandler_GetMimeType, METH_O, NULL},
53083 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
53084 { (char *)"ImageHandler_CanReadStream", (PyCFunction) _wrap_ImageHandler_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
53085 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
53086 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
53087 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
53088 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
53089 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
53090 { (char *)"new_PyImageHandler", (PyCFunction)_wrap_new_PyImageHandler, METH_NOARGS, NULL},
53091 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53092 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
53093 { (char *)"PyImageHandler_swiginit", PyImageHandler_swiginit, METH_VARARGS, NULL},
53094 { (char *)"new_ImageHistogram", (PyCFunction)_wrap_new_ImageHistogram, METH_NOARGS, NULL},
53095 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
53096 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
53097 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
53098 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
53099 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
53100 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
53101 { (char *)"ImageHistogram_swiginit", ImageHistogram_swiginit, METH_VARARGS, NULL},
53102 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
53103 { (char *)"Image_RGBValue_red_set", _wrap_Image_RGBValue_red_set, METH_VARARGS, NULL},
53104 { (char *)"Image_RGBValue_red_get", (PyCFunction)_wrap_Image_RGBValue_red_get, METH_O, NULL},
53105 { (char *)"Image_RGBValue_green_set", _wrap_Image_RGBValue_green_set, METH_VARARGS, NULL},
53106 { (char *)"Image_RGBValue_green_get", (PyCFunction)_wrap_Image_RGBValue_green_get, METH_O, NULL},
53107 { (char *)"Image_RGBValue_blue_set", _wrap_Image_RGBValue_blue_set, METH_VARARGS, NULL},
53108 { (char *)"Image_RGBValue_blue_get", (PyCFunction)_wrap_Image_RGBValue_blue_get, METH_O, NULL},
53109 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
53110 { (char *)"Image_RGBValue_swiginit", Image_RGBValue_swiginit, METH_VARARGS, NULL},
53111 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
53112 { (char *)"Image_HSVValue_hue_set", _wrap_Image_HSVValue_hue_set, METH_VARARGS, NULL},
53113 { (char *)"Image_HSVValue_hue_get", (PyCFunction)_wrap_Image_HSVValue_hue_get, METH_O, NULL},
53114 { (char *)"Image_HSVValue_saturation_set", _wrap_Image_HSVValue_saturation_set, METH_VARARGS, NULL},
53115 { (char *)"Image_HSVValue_saturation_get", (PyCFunction)_wrap_Image_HSVValue_saturation_get, METH_O, NULL},
53116 { (char *)"Image_HSVValue_value_set", _wrap_Image_HSVValue_value_set, METH_VARARGS, NULL},
53117 { (char *)"Image_HSVValue_value_get", (PyCFunction)_wrap_Image_HSVValue_value_get, METH_O, NULL},
53118 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
53119 { (char *)"Image_HSVValue_swiginit", Image_HSVValue_swiginit, METH_VARARGS, NULL},
53120 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
53121 { (char *)"delete_Image", (PyCFunction)_wrap_delete_Image, METH_O, NULL},
53122 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
53123 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
53124 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
53125 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
53126 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53127 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
53128 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
53129 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
53130 { (char *)"Image_Destroy", (PyCFunction)_wrap_Image_Destroy, METH_O, NULL},
53131 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
53132 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
53133 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
53134 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
53135 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
53136 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
53137 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
53138 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
53139 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
53140 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
53141 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
53142 { (char *)"Image_HasAlpha", (PyCFunction)_wrap_Image_HasAlpha, METH_O, NULL},
53143 { (char *)"Image_InitAlpha", (PyCFunction)_wrap_Image_InitAlpha, METH_O, NULL},
53144 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
53145 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
53146 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
53147 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
53148 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
53149 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
53150 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
53151 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
53152 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
53153 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
53154 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
53155 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
53156 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
53157 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
53158 { (char *)"Image_Ok", (PyCFunction)_wrap_Image_Ok, METH_O, NULL},
53159 { (char *)"Image_GetWidth", (PyCFunction)_wrap_Image_GetWidth, METH_O, NULL},
53160 { (char *)"Image_GetHeight", (PyCFunction)_wrap_Image_GetHeight, METH_O, NULL},
53161 { (char *)"Image_GetSize", (PyCFunction)_wrap_Image_GetSize, METH_O, NULL},
53162 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
53163 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
53164 { (char *)"Image_Copy", (PyCFunction)_wrap_Image_Copy, METH_O, NULL},
53165 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
53166 { (char *)"Image_GetData", (PyCFunction)_wrap_Image_GetData, METH_O, NULL},
53167 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
53168 { (char *)"Image_GetDataBuffer", (PyCFunction)_wrap_Image_GetDataBuffer, METH_O, NULL},
53169 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
53170 { (char *)"Image_GetAlphaData", (PyCFunction)_wrap_Image_GetAlphaData, METH_O, NULL},
53171 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
53172 { (char *)"Image_GetAlphaBuffer", (PyCFunction)_wrap_Image_GetAlphaBuffer, METH_O, NULL},
53173 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
53174 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
53175 { (char *)"Image_GetOrFindMaskColour", (PyCFunction)_wrap_Image_GetOrFindMaskColour, METH_O, NULL},
53176 { (char *)"Image_GetMaskRed", (PyCFunction)_wrap_Image_GetMaskRed, METH_O, NULL},
53177 { (char *)"Image_GetMaskGreen", (PyCFunction)_wrap_Image_GetMaskGreen, METH_O, NULL},
53178 { (char *)"Image_GetMaskBlue", (PyCFunction)_wrap_Image_GetMaskBlue, METH_O, NULL},
53179 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
53180 { (char *)"Image_HasMask", (PyCFunction)_wrap_Image_HasMask, METH_O, NULL},
53181 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
53182 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
53183 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
53184 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
53185 { (char *)"Image_ConvertToGreyscale", (PyCFunction) _wrap_Image_ConvertToGreyscale, METH_VARARGS | METH_KEYWORDS, NULL},
53186 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
53187 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
53188 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
53189 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
53190 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
53191 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
53192 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
53193 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
53194 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53195 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53196 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53197 { (char *)"Image_GetHandlers", (PyCFunction)_wrap_Image_GetHandlers, METH_NOARGS, NULL},
53198 { (char *)"Image_GetImageExtWildcard", (PyCFunction)_wrap_Image_GetImageExtWildcard, METH_NOARGS, NULL},
53199 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53200 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53201 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
53202 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
53203 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
53204 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
53205 { (char *)"Image_swiginit", Image_swiginit, METH_VARARGS, NULL},
53206 { (char *)"new_BMPHandler", (PyCFunction)_wrap_new_BMPHandler, METH_NOARGS, NULL},
53207 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
53208 { (char *)"BMPHandler_swiginit", BMPHandler_swiginit, METH_VARARGS, NULL},
53209 { (char *)"new_ICOHandler", (PyCFunction)_wrap_new_ICOHandler, METH_NOARGS, NULL},
53210 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
53211 { (char *)"ICOHandler_swiginit", ICOHandler_swiginit, METH_VARARGS, NULL},
53212 { (char *)"new_CURHandler", (PyCFunction)_wrap_new_CURHandler, METH_NOARGS, NULL},
53213 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
53214 { (char *)"CURHandler_swiginit", CURHandler_swiginit, METH_VARARGS, NULL},
53215 { (char *)"new_ANIHandler", (PyCFunction)_wrap_new_ANIHandler, METH_NOARGS, NULL},
53216 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
53217 { (char *)"ANIHandler_swiginit", ANIHandler_swiginit, METH_VARARGS, NULL},
53218 { (char *)"new_PNGHandler", (PyCFunction)_wrap_new_PNGHandler, METH_NOARGS, NULL},
53219 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
53220 { (char *)"PNGHandler_swiginit", PNGHandler_swiginit, METH_VARARGS, NULL},
53221 { (char *)"new_GIFHandler", (PyCFunction)_wrap_new_GIFHandler, METH_NOARGS, NULL},
53222 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
53223 { (char *)"GIFHandler_swiginit", GIFHandler_swiginit, METH_VARARGS, NULL},
53224 { (char *)"new_PCXHandler", (PyCFunction)_wrap_new_PCXHandler, METH_NOARGS, NULL},
53225 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
53226 { (char *)"PCXHandler_swiginit", PCXHandler_swiginit, METH_VARARGS, NULL},
53227 { (char *)"new_JPEGHandler", (PyCFunction)_wrap_new_JPEGHandler, METH_NOARGS, NULL},
53228 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
53229 { (char *)"JPEGHandler_swiginit", JPEGHandler_swiginit, METH_VARARGS, NULL},
53230 { (char *)"new_PNMHandler", (PyCFunction)_wrap_new_PNMHandler, METH_NOARGS, NULL},
53231 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
53232 { (char *)"PNMHandler_swiginit", PNMHandler_swiginit, METH_VARARGS, NULL},
53233 { (char *)"new_XPMHandler", (PyCFunction)_wrap_new_XPMHandler, METH_NOARGS, NULL},
53234 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
53235 { (char *)"XPMHandler_swiginit", XPMHandler_swiginit, METH_VARARGS, NULL},
53236 { (char *)"new_TIFFHandler", (PyCFunction)_wrap_new_TIFFHandler, METH_NOARGS, NULL},
53237 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
53238 { (char *)"TIFFHandler_swiginit", TIFFHandler_swiginit, METH_VARARGS, NULL},
53239 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
53240 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
53241 { (char *)"new_EvtHandler", (PyCFunction)_wrap_new_EvtHandler, METH_NOARGS, NULL},
53242 { (char *)"EvtHandler_GetNextHandler", (PyCFunction)_wrap_EvtHandler_GetNextHandler, METH_O, NULL},
53243 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction)_wrap_EvtHandler_GetPreviousHandler, METH_O, NULL},
53244 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53245 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53246 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction)_wrap_EvtHandler_GetEvtHandlerEnabled, METH_O, NULL},
53247 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53248 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53249 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53250 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction)_wrap_EvtHandler_ProcessPendingEvents, METH_O, NULL},
53251 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
53252 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
53253 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53254 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
53255 { (char *)"EvtHandler_swiginit", EvtHandler_swiginit, METH_VARARGS, NULL},
53256 { (char *)"NewEventType", (PyCFunction)_wrap_NewEventType, METH_NOARGS, NULL},
53257 { (char *)"delete_Event", (PyCFunction)_wrap_delete_Event, METH_O, NULL},
53258 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
53259 { (char *)"Event_GetEventType", (PyCFunction)_wrap_Event_GetEventType, METH_O, NULL},
53260 { (char *)"Event_GetEventObject", (PyCFunction)_wrap_Event_GetEventObject, METH_O, NULL},
53261 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
53262 { (char *)"Event_GetTimestamp", (PyCFunction)_wrap_Event_GetTimestamp, METH_O, NULL},
53263 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
53264 { (char *)"Event_GetId", (PyCFunction)_wrap_Event_GetId, METH_O, NULL},
53265 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53266 { (char *)"Event_IsCommandEvent", (PyCFunction)_wrap_Event_IsCommandEvent, METH_O, NULL},
53267 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
53268 { (char *)"Event_GetSkipped", (PyCFunction)_wrap_Event_GetSkipped, METH_O, NULL},
53269 { (char *)"Event_ShouldPropagate", (PyCFunction)_wrap_Event_ShouldPropagate, METH_O, NULL},
53270 { (char *)"Event_StopPropagation", (PyCFunction)_wrap_Event_StopPropagation, METH_O, NULL},
53271 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
53272 { (char *)"Event_Clone", (PyCFunction)_wrap_Event_Clone, METH_O, NULL},
53273 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
53274 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
53275 { (char *)"delete_PropagationDisabler", (PyCFunction)_wrap_delete_PropagationDisabler, METH_O, NULL},
53276 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
53277 { (char *)"PropagationDisabler_swiginit", PropagationDisabler_swiginit, METH_VARARGS, NULL},
53278 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
53279 { (char *)"delete_PropagateOnce", (PyCFunction)_wrap_delete_PropagateOnce, METH_O, NULL},
53280 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
53281 { (char *)"PropagateOnce_swiginit", PropagateOnce_swiginit, METH_VARARGS, NULL},
53282 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53283 { (char *)"CommandEvent_GetSelection", (PyCFunction)_wrap_CommandEvent_GetSelection, METH_O, NULL},
53284 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
53285 { (char *)"CommandEvent_GetString", (PyCFunction)_wrap_CommandEvent_GetString, METH_O, NULL},
53286 { (char *)"CommandEvent_IsChecked", (PyCFunction)_wrap_CommandEvent_IsChecked, METH_O, NULL},
53287 { (char *)"CommandEvent_IsSelection", (PyCFunction)_wrap_CommandEvent_IsSelection, METH_O, NULL},
53288 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
53289 { (char *)"CommandEvent_GetExtraLong", (PyCFunction)_wrap_CommandEvent_GetExtraLong, METH_O, NULL},
53290 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
53291 { (char *)"CommandEvent_GetInt", (PyCFunction)_wrap_CommandEvent_GetInt, METH_O, NULL},
53292 { (char *)"CommandEvent_GetClientData", (PyCFunction)_wrap_CommandEvent_GetClientData, METH_O, NULL},
53293 { (char *)"CommandEvent_SetClientData", (PyCFunction) _wrap_CommandEvent_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
53294 { (char *)"CommandEvent_Clone", (PyCFunction)_wrap_CommandEvent_Clone, METH_O, NULL},
53295 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
53296 { (char *)"CommandEvent_swiginit", CommandEvent_swiginit, METH_VARARGS, NULL},
53297 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53298 { (char *)"NotifyEvent_Veto", (PyCFunction)_wrap_NotifyEvent_Veto, METH_O, NULL},
53299 { (char *)"NotifyEvent_Allow", (PyCFunction)_wrap_NotifyEvent_Allow, METH_O, NULL},
53300 { (char *)"NotifyEvent_IsAllowed", (PyCFunction)_wrap_NotifyEvent_IsAllowed, METH_O, NULL},
53301 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
53302 { (char *)"NotifyEvent_swiginit", NotifyEvent_swiginit, METH_VARARGS, NULL},
53303 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53304 { (char *)"ScrollEvent_GetOrientation", (PyCFunction)_wrap_ScrollEvent_GetOrientation, METH_O, NULL},
53305 { (char *)"ScrollEvent_GetPosition", (PyCFunction)_wrap_ScrollEvent_GetPosition, METH_O, NULL},
53306 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
53307 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53308 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
53309 { (char *)"ScrollEvent_swiginit", ScrollEvent_swiginit, METH_VARARGS, NULL},
53310 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53311 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction)_wrap_ScrollWinEvent_GetOrientation, METH_O, NULL},
53312 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction)_wrap_ScrollWinEvent_GetPosition, METH_O, NULL},
53313 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
53314 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53315 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
53316 { (char *)"ScrollWinEvent_swiginit", ScrollWinEvent_swiginit, METH_VARARGS, NULL},
53317 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53318 { (char *)"MouseEvent_IsButton", (PyCFunction)_wrap_MouseEvent_IsButton, METH_O, NULL},
53319 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
53320 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
53321 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
53322 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
53323 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
53324 { (char *)"MouseEvent_GetButton", (PyCFunction)_wrap_MouseEvent_GetButton, METH_O, NULL},
53325 { (char *)"MouseEvent_ControlDown", (PyCFunction)_wrap_MouseEvent_ControlDown, METH_O, NULL},
53326 { (char *)"MouseEvent_MetaDown", (PyCFunction)_wrap_MouseEvent_MetaDown, METH_O, NULL},
53327 { (char *)"MouseEvent_AltDown", (PyCFunction)_wrap_MouseEvent_AltDown, METH_O, NULL},
53328 { (char *)"MouseEvent_ShiftDown", (PyCFunction)_wrap_MouseEvent_ShiftDown, METH_O, NULL},
53329 { (char *)"MouseEvent_CmdDown", (PyCFunction)_wrap_MouseEvent_CmdDown, METH_O, NULL},
53330 { (char *)"MouseEvent_LeftDown", (PyCFunction)_wrap_MouseEvent_LeftDown, METH_O, NULL},
53331 { (char *)"MouseEvent_MiddleDown", (PyCFunction)_wrap_MouseEvent_MiddleDown, METH_O, NULL},
53332 { (char *)"MouseEvent_RightDown", (PyCFunction)_wrap_MouseEvent_RightDown, METH_O, NULL},
53333 { (char *)"MouseEvent_LeftUp", (PyCFunction)_wrap_MouseEvent_LeftUp, METH_O, NULL},
53334 { (char *)"MouseEvent_MiddleUp", (PyCFunction)_wrap_MouseEvent_MiddleUp, METH_O, NULL},
53335 { (char *)"MouseEvent_RightUp", (PyCFunction)_wrap_MouseEvent_RightUp, METH_O, NULL},
53336 { (char *)"MouseEvent_LeftDClick", (PyCFunction)_wrap_MouseEvent_LeftDClick, METH_O, NULL},
53337 { (char *)"MouseEvent_MiddleDClick", (PyCFunction)_wrap_MouseEvent_MiddleDClick, METH_O, NULL},
53338 { (char *)"MouseEvent_RightDClick", (PyCFunction)_wrap_MouseEvent_RightDClick, METH_O, NULL},
53339 { (char *)"MouseEvent_LeftIsDown", (PyCFunction)_wrap_MouseEvent_LeftIsDown, METH_O, NULL},
53340 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction)_wrap_MouseEvent_MiddleIsDown, METH_O, NULL},
53341 { (char *)"MouseEvent_RightIsDown", (PyCFunction)_wrap_MouseEvent_RightIsDown, METH_O, NULL},
53342 { (char *)"MouseEvent_Dragging", (PyCFunction)_wrap_MouseEvent_Dragging, METH_O, NULL},
53343 { (char *)"MouseEvent_Moving", (PyCFunction)_wrap_MouseEvent_Moving, METH_O, NULL},
53344 { (char *)"MouseEvent_Entering", (PyCFunction)_wrap_MouseEvent_Entering, METH_O, NULL},
53345 { (char *)"MouseEvent_Leaving", (PyCFunction)_wrap_MouseEvent_Leaving, METH_O, NULL},
53346 { (char *)"MouseEvent_GetPosition", (PyCFunction)_wrap_MouseEvent_GetPosition, METH_O, NULL},
53347 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction)_wrap_MouseEvent_GetPositionTuple, METH_O, NULL},
53348 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53349 { (char *)"MouseEvent_GetX", (PyCFunction)_wrap_MouseEvent_GetX, METH_O, NULL},
53350 { (char *)"MouseEvent_GetY", (PyCFunction)_wrap_MouseEvent_GetY, METH_O, NULL},
53351 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction)_wrap_MouseEvent_GetWheelRotation, METH_O, NULL},
53352 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction)_wrap_MouseEvent_GetWheelDelta, METH_O, NULL},
53353 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction)_wrap_MouseEvent_GetLinesPerAction, METH_O, NULL},
53354 { (char *)"MouseEvent_IsPageScroll", (PyCFunction)_wrap_MouseEvent_IsPageScroll, METH_O, NULL},
53355 { (char *)"MouseEvent_m_x_set", _wrap_MouseEvent_m_x_set, METH_VARARGS, NULL},
53356 { (char *)"MouseEvent_m_x_get", (PyCFunction)_wrap_MouseEvent_m_x_get, METH_O, NULL},
53357 { (char *)"MouseEvent_m_y_set", _wrap_MouseEvent_m_y_set, METH_VARARGS, NULL},
53358 { (char *)"MouseEvent_m_y_get", (PyCFunction)_wrap_MouseEvent_m_y_get, METH_O, NULL},
53359 { (char *)"MouseEvent_m_leftDown_set", _wrap_MouseEvent_m_leftDown_set, METH_VARARGS, NULL},
53360 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction)_wrap_MouseEvent_m_leftDown_get, METH_O, NULL},
53361 { (char *)"MouseEvent_m_middleDown_set", _wrap_MouseEvent_m_middleDown_set, METH_VARARGS, NULL},
53362 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction)_wrap_MouseEvent_m_middleDown_get, METH_O, NULL},
53363 { (char *)"MouseEvent_m_rightDown_set", _wrap_MouseEvent_m_rightDown_set, METH_VARARGS, NULL},
53364 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction)_wrap_MouseEvent_m_rightDown_get, METH_O, NULL},
53365 { (char *)"MouseEvent_m_controlDown_set", _wrap_MouseEvent_m_controlDown_set, METH_VARARGS, NULL},
53366 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction)_wrap_MouseEvent_m_controlDown_get, METH_O, NULL},
53367 { (char *)"MouseEvent_m_shiftDown_set", _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS, NULL},
53368 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction)_wrap_MouseEvent_m_shiftDown_get, METH_O, NULL},
53369 { (char *)"MouseEvent_m_altDown_set", _wrap_MouseEvent_m_altDown_set, METH_VARARGS, NULL},
53370 { (char *)"MouseEvent_m_altDown_get", (PyCFunction)_wrap_MouseEvent_m_altDown_get, METH_O, NULL},
53371 { (char *)"MouseEvent_m_metaDown_set", _wrap_MouseEvent_m_metaDown_set, METH_VARARGS, NULL},
53372 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction)_wrap_MouseEvent_m_metaDown_get, METH_O, NULL},
53373 { (char *)"MouseEvent_m_wheelRotation_set", _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS, NULL},
53374 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction)_wrap_MouseEvent_m_wheelRotation_get, METH_O, NULL},
53375 { (char *)"MouseEvent_m_wheelDelta_set", _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS, NULL},
53376 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction)_wrap_MouseEvent_m_wheelDelta_get, METH_O, NULL},
53377 { (char *)"MouseEvent_m_linesPerAction_set", _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS, NULL},
53378 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction)_wrap_MouseEvent_m_linesPerAction_get, METH_O, NULL},
53379 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
53380 { (char *)"MouseEvent_swiginit", MouseEvent_swiginit, METH_VARARGS, NULL},
53381 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53382 { (char *)"SetCursorEvent_GetX", (PyCFunction)_wrap_SetCursorEvent_GetX, METH_O, NULL},
53383 { (char *)"SetCursorEvent_GetY", (PyCFunction)_wrap_SetCursorEvent_GetY, METH_O, NULL},
53384 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
53385 { (char *)"SetCursorEvent_GetCursor", (PyCFunction)_wrap_SetCursorEvent_GetCursor, METH_O, NULL},
53386 { (char *)"SetCursorEvent_HasCursor", (PyCFunction)_wrap_SetCursorEvent_HasCursor, METH_O, NULL},
53387 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
53388 { (char *)"SetCursorEvent_swiginit", SetCursorEvent_swiginit, METH_VARARGS, NULL},
53389 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53390 { (char *)"KeyEvent_GetModifiers", (PyCFunction)_wrap_KeyEvent_GetModifiers, METH_O, NULL},
53391 { (char *)"KeyEvent_ControlDown", (PyCFunction)_wrap_KeyEvent_ControlDown, METH_O, NULL},
53392 { (char *)"KeyEvent_MetaDown", (PyCFunction)_wrap_KeyEvent_MetaDown, METH_O, NULL},
53393 { (char *)"KeyEvent_AltDown", (PyCFunction)_wrap_KeyEvent_AltDown, METH_O, NULL},
53394 { (char *)"KeyEvent_ShiftDown", (PyCFunction)_wrap_KeyEvent_ShiftDown, METH_O, NULL},
53395 { (char *)"KeyEvent_CmdDown", (PyCFunction)_wrap_KeyEvent_CmdDown, METH_O, NULL},
53396 { (char *)"KeyEvent_HasModifiers", (PyCFunction)_wrap_KeyEvent_HasModifiers, METH_O, NULL},
53397 { (char *)"KeyEvent_GetKeyCode", (PyCFunction)_wrap_KeyEvent_GetKeyCode, METH_O, NULL},
53398 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction)_wrap_KeyEvent_GetUnicodeKey, METH_O, NULL},
53399 { (char *)"KeyEvent_SetUnicodeKey", (PyCFunction) _wrap_KeyEvent_SetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
53400 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction)_wrap_KeyEvent_GetRawKeyCode, METH_O, NULL},
53401 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction)_wrap_KeyEvent_GetRawKeyFlags, METH_O, NULL},
53402 { (char *)"KeyEvent_GetPosition", (PyCFunction)_wrap_KeyEvent_GetPosition, METH_O, NULL},
53403 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction)_wrap_KeyEvent_GetPositionTuple, METH_O, NULL},
53404 { (char *)"KeyEvent_GetX", (PyCFunction)_wrap_KeyEvent_GetX, METH_O, NULL},
53405 { (char *)"KeyEvent_GetY", (PyCFunction)_wrap_KeyEvent_GetY, METH_O, NULL},
53406 { (char *)"KeyEvent_m_x_set", _wrap_KeyEvent_m_x_set, METH_VARARGS, NULL},
53407 { (char *)"KeyEvent_m_x_get", (PyCFunction)_wrap_KeyEvent_m_x_get, METH_O, NULL},
53408 { (char *)"KeyEvent_m_y_set", _wrap_KeyEvent_m_y_set, METH_VARARGS, NULL},
53409 { (char *)"KeyEvent_m_y_get", (PyCFunction)_wrap_KeyEvent_m_y_get, METH_O, NULL},
53410 { (char *)"KeyEvent_m_keyCode_set", _wrap_KeyEvent_m_keyCode_set, METH_VARARGS, NULL},
53411 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction)_wrap_KeyEvent_m_keyCode_get, METH_O, NULL},
53412 { (char *)"KeyEvent_m_controlDown_set", _wrap_KeyEvent_m_controlDown_set, METH_VARARGS, NULL},
53413 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction)_wrap_KeyEvent_m_controlDown_get, METH_O, NULL},
53414 { (char *)"KeyEvent_m_shiftDown_set", _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS, NULL},
53415 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction)_wrap_KeyEvent_m_shiftDown_get, METH_O, NULL},
53416 { (char *)"KeyEvent_m_altDown_set", _wrap_KeyEvent_m_altDown_set, METH_VARARGS, NULL},
53417 { (char *)"KeyEvent_m_altDown_get", (PyCFunction)_wrap_KeyEvent_m_altDown_get, METH_O, NULL},
53418 { (char *)"KeyEvent_m_metaDown_set", _wrap_KeyEvent_m_metaDown_set, METH_VARARGS, NULL},
53419 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction)_wrap_KeyEvent_m_metaDown_get, METH_O, NULL},
53420 { (char *)"KeyEvent_m_scanCode_set", _wrap_KeyEvent_m_scanCode_set, METH_VARARGS, NULL},
53421 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction)_wrap_KeyEvent_m_scanCode_get, METH_O, NULL},
53422 { (char *)"KeyEvent_m_rawCode_set", _wrap_KeyEvent_m_rawCode_set, METH_VARARGS, NULL},
53423 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction)_wrap_KeyEvent_m_rawCode_get, METH_O, NULL},
53424 { (char *)"KeyEvent_m_rawFlags_set", _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS, NULL},
53425 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction)_wrap_KeyEvent_m_rawFlags_get, METH_O, NULL},
53426 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
53427 { (char *)"KeyEvent_swiginit", KeyEvent_swiginit, METH_VARARGS, NULL},
53428 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53429 { (char *)"SizeEvent_GetSize", (PyCFunction)_wrap_SizeEvent_GetSize, METH_O, NULL},
53430 { (char *)"SizeEvent_GetRect", (PyCFunction)_wrap_SizeEvent_GetRect, METH_O, NULL},
53431 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53432 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
53433 { (char *)"SizeEvent_m_size_set", _wrap_SizeEvent_m_size_set, METH_VARARGS, NULL},
53434 { (char *)"SizeEvent_m_size_get", (PyCFunction)_wrap_SizeEvent_m_size_get, METH_O, NULL},
53435 { (char *)"SizeEvent_m_rect_set", _wrap_SizeEvent_m_rect_set, METH_VARARGS, NULL},
53436 { (char *)"SizeEvent_m_rect_get", (PyCFunction)_wrap_SizeEvent_m_rect_get, METH_O, NULL},
53437 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
53438 { (char *)"SizeEvent_swiginit", SizeEvent_swiginit, METH_VARARGS, NULL},
53439 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53440 { (char *)"MoveEvent_GetPosition", (PyCFunction)_wrap_MoveEvent_GetPosition, METH_O, NULL},
53441 { (char *)"MoveEvent_GetRect", (PyCFunction)_wrap_MoveEvent_GetRect, METH_O, NULL},
53442 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53443 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53444 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
53445 { (char *)"MoveEvent_swiginit", MoveEvent_swiginit, METH_VARARGS, NULL},
53446 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53447 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
53448 { (char *)"PaintEvent_swiginit", PaintEvent_swiginit, METH_VARARGS, NULL},
53449 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53450 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
53451 { (char *)"NcPaintEvent_swiginit", NcPaintEvent_swiginit, METH_VARARGS, NULL},
53452 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53453 { (char *)"EraseEvent_GetDC", (PyCFunction)_wrap_EraseEvent_GetDC, METH_O, NULL},
53454 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
53455 { (char *)"EraseEvent_swiginit", EraseEvent_swiginit, METH_VARARGS, NULL},
53456 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53457 { (char *)"FocusEvent_GetWindow", (PyCFunction)_wrap_FocusEvent_GetWindow, METH_O, NULL},
53458 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53459 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
53460 { (char *)"FocusEvent_swiginit", FocusEvent_swiginit, METH_VARARGS, NULL},
53461 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53462 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction)_wrap_ChildFocusEvent_GetWindow, METH_O, NULL},
53463 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
53464 { (char *)"ChildFocusEvent_swiginit", ChildFocusEvent_swiginit, METH_VARARGS, NULL},
53465 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53466 { (char *)"ActivateEvent_GetActive", (PyCFunction)_wrap_ActivateEvent_GetActive, METH_O, NULL},
53467 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
53468 { (char *)"ActivateEvent_swiginit", ActivateEvent_swiginit, METH_VARARGS, NULL},
53469 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53470 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
53471 { (char *)"InitDialogEvent_swiginit", InitDialogEvent_swiginit, METH_VARARGS, NULL},
53472 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53473 { (char *)"MenuEvent_GetMenuId", (PyCFunction)_wrap_MenuEvent_GetMenuId, METH_O, NULL},
53474 { (char *)"MenuEvent_IsPopup", (PyCFunction)_wrap_MenuEvent_IsPopup, METH_O, NULL},
53475 { (char *)"MenuEvent_GetMenu", (PyCFunction)_wrap_MenuEvent_GetMenu, METH_O, NULL},
53476 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
53477 { (char *)"MenuEvent_swiginit", MenuEvent_swiginit, METH_VARARGS, NULL},
53478 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53479 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
53480 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction)_wrap_CloseEvent_GetLoggingOff, METH_O, NULL},
53481 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
53482 { (char *)"CloseEvent_GetVeto", (PyCFunction)_wrap_CloseEvent_GetVeto, METH_O, NULL},
53483 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
53484 { (char *)"CloseEvent_CanVeto", (PyCFunction)_wrap_CloseEvent_CanVeto, METH_O, NULL},
53485 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
53486 { (char *)"CloseEvent_swiginit", CloseEvent_swiginit, METH_VARARGS, NULL},
53487 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53488 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
53489 { (char *)"ShowEvent_GetShow", (PyCFunction)_wrap_ShowEvent_GetShow, METH_O, NULL},
53490 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
53491 { (char *)"ShowEvent_swiginit", ShowEvent_swiginit, METH_VARARGS, NULL},
53492 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53493 { (char *)"IconizeEvent_Iconized", (PyCFunction)_wrap_IconizeEvent_Iconized, METH_O, NULL},
53494 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
53495 { (char *)"IconizeEvent_swiginit", IconizeEvent_swiginit, METH_VARARGS, NULL},
53496 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53497 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
53498 { (char *)"MaximizeEvent_swiginit", MaximizeEvent_swiginit, METH_VARARGS, NULL},
53499 { (char *)"DropFilesEvent_GetPosition", (PyCFunction)_wrap_DropFilesEvent_GetPosition, METH_O, NULL},
53500 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction)_wrap_DropFilesEvent_GetNumberOfFiles, METH_O, NULL},
53501 { (char *)"DropFilesEvent_GetFiles", (PyCFunction)_wrap_DropFilesEvent_GetFiles, METH_O, NULL},
53502 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
53503 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53504 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetChecked, METH_O, NULL},
53505 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetEnabled, METH_O, NULL},
53506 { (char *)"UpdateUIEvent_GetShown", (PyCFunction)_wrap_UpdateUIEvent_GetShown, METH_O, NULL},
53507 { (char *)"UpdateUIEvent_GetText", (PyCFunction)_wrap_UpdateUIEvent_GetText, METH_O, NULL},
53508 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction)_wrap_UpdateUIEvent_GetSetText, METH_O, NULL},
53509 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetSetChecked, METH_O, NULL},
53510 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetSetEnabled, METH_O, NULL},
53511 { (char *)"UpdateUIEvent_GetSetShown", (PyCFunction)_wrap_UpdateUIEvent_GetSetShown, METH_O, NULL},
53512 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53513 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53514 { (char *)"UpdateUIEvent_Show", (PyCFunction) _wrap_UpdateUIEvent_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53515 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
53516 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
53517 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction)_wrap_UpdateUIEvent_GetUpdateInterval, METH_NOARGS, NULL},
53518 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
53519 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction)_wrap_UpdateUIEvent_ResetUpdateTime, METH_NOARGS, NULL},
53520 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
53521 { (char *)"UpdateUIEvent_GetMode", (PyCFunction)_wrap_UpdateUIEvent_GetMode, METH_NOARGS, NULL},
53522 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
53523 { (char *)"UpdateUIEvent_swiginit", UpdateUIEvent_swiginit, METH_VARARGS, NULL},
53524 { (char *)"new_SysColourChangedEvent", (PyCFunction)_wrap_new_SysColourChangedEvent, METH_NOARGS, NULL},
53525 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
53526 { (char *)"SysColourChangedEvent_swiginit", SysColourChangedEvent_swiginit, METH_VARARGS, NULL},
53527 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53528 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction)_wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_O, NULL},
53529 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
53530 { (char *)"MouseCaptureChangedEvent_swiginit", MouseCaptureChangedEvent_swiginit, METH_VARARGS, NULL},
53531 { (char *)"new_MouseCaptureLostEvent", (PyCFunction) _wrap_new_MouseCaptureLostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53532 { (char *)"MouseCaptureLostEvent_swigregister", MouseCaptureLostEvent_swigregister, METH_VARARGS, NULL},
53533 { (char *)"MouseCaptureLostEvent_swiginit", MouseCaptureLostEvent_swiginit, METH_VARARGS, NULL},
53534 { (char *)"new_DisplayChangedEvent", (PyCFunction)_wrap_new_DisplayChangedEvent, METH_NOARGS, NULL},
53535 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
53536 { (char *)"DisplayChangedEvent_swiginit", DisplayChangedEvent_swiginit, METH_VARARGS, NULL},
53537 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53538 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53539 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction)_wrap_PaletteChangedEvent_GetChangedWindow, METH_O, NULL},
53540 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
53541 { (char *)"PaletteChangedEvent_swiginit", PaletteChangedEvent_swiginit, METH_VARARGS, NULL},
53542 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53543 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
53544 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction)_wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_O, NULL},
53545 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
53546 { (char *)"QueryNewPaletteEvent_swiginit", QueryNewPaletteEvent_swiginit, METH_VARARGS, NULL},
53547 { (char *)"new_NavigationKeyEvent", (PyCFunction)_wrap_new_NavigationKeyEvent, METH_NOARGS, NULL},
53548 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction)_wrap_NavigationKeyEvent_GetDirection, METH_O, NULL},
53549 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
53550 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction)_wrap_NavigationKeyEvent_IsWindowChange, METH_O, NULL},
53551 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
53552 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction)_wrap_NavigationKeyEvent_IsFromTab, METH_O, NULL},
53553 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
53554 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
53555 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction)_wrap_NavigationKeyEvent_GetCurrentFocus, METH_O, NULL},
53556 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
53557 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
53558 { (char *)"NavigationKeyEvent_swiginit", NavigationKeyEvent_swiginit, METH_VARARGS, NULL},
53559 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53560 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction)_wrap_WindowCreateEvent_GetWindow, METH_O, NULL},
53561 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
53562 { (char *)"WindowCreateEvent_swiginit", WindowCreateEvent_swiginit, METH_VARARGS, NULL},
53563 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53564 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction)_wrap_WindowDestroyEvent_GetWindow, METH_O, NULL},
53565 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
53566 { (char *)"WindowDestroyEvent_swiginit", WindowDestroyEvent_swiginit, METH_VARARGS, NULL},
53567 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53568 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction)_wrap_ContextMenuEvent_GetPosition, METH_O, NULL},
53569 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53570 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
53571 { (char *)"ContextMenuEvent_swiginit", ContextMenuEvent_swiginit, METH_VARARGS, NULL},
53572 { (char *)"new_IdleEvent", (PyCFunction)_wrap_new_IdleEvent, METH_NOARGS, NULL},
53573 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
53574 { (char *)"IdleEvent_MoreRequested", (PyCFunction)_wrap_IdleEvent_MoreRequested, METH_O, NULL},
53575 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
53576 { (char *)"IdleEvent_GetMode", (PyCFunction)_wrap_IdleEvent_GetMode, METH_NOARGS, NULL},
53577 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
53578 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
53579 { (char *)"IdleEvent_swiginit", IdleEvent_swiginit, METH_VARARGS, NULL},
53580 { (char *)"new_ClipboardTextEvent", (PyCFunction) _wrap_new_ClipboardTextEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53581 { (char *)"ClipboardTextEvent_swigregister", ClipboardTextEvent_swigregister, METH_VARARGS, NULL},
53582 { (char *)"ClipboardTextEvent_swiginit", ClipboardTextEvent_swiginit, METH_VARARGS, NULL},
53583 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53584 { (char *)"delete_PyEvent", (PyCFunction)_wrap_delete_PyEvent, METH_O, NULL},
53585 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53586 { (char *)"PyEvent__GetSelf", (PyCFunction)_wrap_PyEvent__GetSelf, METH_O, NULL},
53587 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
53588 { (char *)"PyEvent_swiginit", PyEvent_swiginit, METH_VARARGS, NULL},
53589 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53590 { (char *)"delete_PyCommandEvent", (PyCFunction)_wrap_delete_PyCommandEvent, METH_O, NULL},
53591 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53592 { (char *)"PyCommandEvent__GetSelf", (PyCFunction)_wrap_PyCommandEvent__GetSelf, METH_O, NULL},
53593 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
53594 { (char *)"PyCommandEvent_swiginit", PyCommandEvent_swiginit, METH_VARARGS, NULL},
53595 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53596 { (char *)"DateEvent_GetDate", (PyCFunction)_wrap_DateEvent_GetDate, METH_O, NULL},
53597 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
53598 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
53599 { (char *)"DateEvent_swiginit", DateEvent_swiginit, METH_VARARGS, NULL},
53600 { (char *)"new_PyApp", (PyCFunction)_wrap_new_PyApp, METH_NOARGS, NULL},
53601 { (char *)"delete_PyApp", (PyCFunction)_wrap_delete_PyApp, METH_O, NULL},
53602 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53603 { (char *)"PyApp_GetAppName", (PyCFunction)_wrap_PyApp_GetAppName, METH_O, NULL},
53604 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
53605 { (char *)"PyApp_GetClassName", (PyCFunction)_wrap_PyApp_GetClassName, METH_O, NULL},
53606 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
53607 { (char *)"PyApp_GetVendorName", (PyCFunction)_wrap_PyApp_GetVendorName, METH_O, NULL},
53608 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
53609 { (char *)"PyApp_GetTraits", (PyCFunction)_wrap_PyApp_GetTraits, METH_O, NULL},
53610 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction)_wrap_PyApp_ProcessPendingEvents, METH_O, NULL},
53611 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
53612 { (char *)"PyApp_WakeUpIdle", (PyCFunction)_wrap_PyApp_WakeUpIdle, METH_O, NULL},
53613 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction)_wrap_PyApp_IsMainLoopRunning, METH_NOARGS, NULL},
53614 { (char *)"PyApp_MainLoop", (PyCFunction)_wrap_PyApp_MainLoop, METH_O, NULL},
53615 { (char *)"PyApp_Exit", (PyCFunction)_wrap_PyApp_Exit, METH_O, NULL},
53616 { (char *)"PyApp_ExitMainLoop", (PyCFunction)_wrap_PyApp_ExitMainLoop, METH_O, NULL},
53617 { (char *)"PyApp_Pending", (PyCFunction)_wrap_PyApp_Pending, METH_O, NULL},
53618 { (char *)"PyApp_Dispatch", (PyCFunction)_wrap_PyApp_Dispatch, METH_O, NULL},
53619 { (char *)"PyApp_ProcessIdle", (PyCFunction)_wrap_PyApp_ProcessIdle, METH_O, NULL},
53620 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
53621 { (char *)"PyApp_IsActive", (PyCFunction)_wrap_PyApp_IsActive, METH_O, NULL},
53622 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53623 { (char *)"PyApp_GetTopWindow", (PyCFunction)_wrap_PyApp_GetTopWindow, METH_O, NULL},
53624 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
53625 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction)_wrap_PyApp_GetExitOnFrameDelete, METH_O, NULL},
53626 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
53627 { (char *)"PyApp_GetUseBestVisual", (PyCFunction)_wrap_PyApp_GetUseBestVisual, METH_O, NULL},
53628 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
53629 { (char *)"PyApp_GetPrintMode", (PyCFunction)_wrap_PyApp_GetPrintMode, METH_O, NULL},
53630 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
53631 { (char *)"PyApp_GetAssertMode", (PyCFunction)_wrap_PyApp_GetAssertMode, METH_O, NULL},
53632 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction)_wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_NOARGS, NULL},
53633 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction)_wrap_PyApp_GetMacAboutMenuItemId, METH_NOARGS, NULL},
53634 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction)_wrap_PyApp_GetMacPreferencesMenuItemId, METH_NOARGS, NULL},
53635 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction)_wrap_PyApp_GetMacExitMenuItemId, METH_NOARGS, NULL},
53636 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction)_wrap_PyApp_GetMacHelpMenuTitleName, METH_NOARGS, NULL},
53637 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
53638 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53639 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53640 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53641 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
53642 { (char *)"PyApp__BootstrapApp", (PyCFunction)_wrap_PyApp__BootstrapApp, METH_O, NULL},
53643 { (char *)"PyApp_GetComCtl32Version", (PyCFunction)_wrap_PyApp_GetComCtl32Version, METH_NOARGS, NULL},
53644 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
53645 { (char *)"PyApp_swiginit", PyApp_swiginit, METH_VARARGS, NULL},
53646 { (char *)"Exit", (PyCFunction)_wrap_Exit, METH_NOARGS, NULL},
53647 { (char *)"Yield", (PyCFunction)_wrap_Yield, METH_NOARGS, NULL},
53648 { (char *)"YieldIfNeeded", (PyCFunction)_wrap_YieldIfNeeded, METH_NOARGS, NULL},
53649 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
53650 { (char *)"WakeUpIdle", (PyCFunction)_wrap_WakeUpIdle, METH_NOARGS, NULL},
53651 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53652 { (char *)"App_CleanUp", (PyCFunction)_wrap_App_CleanUp, METH_NOARGS, NULL},
53653 { (char *)"GetApp", (PyCFunction)_wrap_GetApp, METH_NOARGS, NULL},
53654 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
53655 { (char *)"GetDefaultPyEncoding", (PyCFunction)_wrap_GetDefaultPyEncoding, METH_NOARGS, NULL},
53656 { (char *)"new_EventLoop", (PyCFunction)_wrap_new_EventLoop, METH_NOARGS, NULL},
53657 { (char *)"delete_EventLoop", (PyCFunction)_wrap_delete_EventLoop, METH_O, NULL},
53658 { (char *)"EventLoop_Run", (PyCFunction)_wrap_EventLoop_Run, METH_O, NULL},
53659 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
53660 { (char *)"EventLoop_Pending", (PyCFunction)_wrap_EventLoop_Pending, METH_O, NULL},
53661 { (char *)"EventLoop_Dispatch", (PyCFunction)_wrap_EventLoop_Dispatch, METH_O, NULL},
53662 { (char *)"EventLoop_IsRunning", (PyCFunction)_wrap_EventLoop_IsRunning, METH_O, NULL},
53663 { (char *)"EventLoop_GetActive", (PyCFunction)_wrap_EventLoop_GetActive, METH_NOARGS, NULL},
53664 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
53665 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
53666 { (char *)"EventLoop_swiginit", EventLoop_swiginit, METH_VARARGS, NULL},
53667 { (char *)"new_EventLoopActivator", (PyCFunction) _wrap_new_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
53668 { (char *)"delete_EventLoopActivator", (PyCFunction)_wrap_delete_EventLoopActivator, METH_O, NULL},
53669 { (char *)"EventLoopActivator_swigregister", EventLoopActivator_swigregister, METH_VARARGS, NULL},
53670 { (char *)"EventLoopActivator_swiginit", EventLoopActivator_swiginit, METH_VARARGS, NULL},
53671 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
53672 { (char *)"delete_AcceleratorEntry", (PyCFunction)_wrap_delete_AcceleratorEntry, METH_O, NULL},
53673 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53674 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction)_wrap_AcceleratorEntry_GetFlags, METH_O, NULL},
53675 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction)_wrap_AcceleratorEntry_GetKeyCode, METH_O, NULL},
53676 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction)_wrap_AcceleratorEntry_GetCommand, METH_O, NULL},
53677 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
53678 { (char *)"AcceleratorEntry_swiginit", AcceleratorEntry_swiginit, METH_VARARGS, NULL},
53679 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
53680 { (char *)"delete_AcceleratorTable", (PyCFunction)_wrap_delete_AcceleratorTable, METH_O, NULL},
53681 { (char *)"AcceleratorTable_Ok", (PyCFunction)_wrap_AcceleratorTable_Ok, METH_O, NULL},
53682 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
53683 { (char *)"AcceleratorTable_swiginit", AcceleratorTable_swiginit, METH_VARARGS, NULL},
53684 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
53685 { (char *)"new_VisualAttributes", (PyCFunction)_wrap_new_VisualAttributes, METH_NOARGS, NULL},
53686 { (char *)"delete_VisualAttributes", (PyCFunction)_wrap_delete_VisualAttributes, METH_O, NULL},
53687 { (char *)"VisualAttributes_font_set", _wrap_VisualAttributes_font_set, METH_VARARGS, NULL},
53688 { (char *)"VisualAttributes_font_get", (PyCFunction)_wrap_VisualAttributes_font_get, METH_O, NULL},
53689 { (char *)"VisualAttributes_colFg_set", _wrap_VisualAttributes_colFg_set, METH_VARARGS, NULL},
53690 { (char *)"VisualAttributes_colFg_get", (PyCFunction)_wrap_VisualAttributes_colFg_get, METH_O, NULL},
53691 { (char *)"VisualAttributes_colBg_set", _wrap_VisualAttributes_colBg_set, METH_VARARGS, NULL},
53692 { (char *)"VisualAttributes_colBg_get", (PyCFunction)_wrap_VisualAttributes_colBg_get, METH_O, NULL},
53693 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
53694 { (char *)"VisualAttributes_swiginit", VisualAttributes_swiginit, METH_VARARGS, NULL},
53695 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
53696 { (char *)"new_PreWindow", (PyCFunction)_wrap_new_PreWindow, METH_NOARGS, NULL},
53697 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
53698 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
53699 { (char *)"Window_Destroy", (PyCFunction)_wrap_Window_Destroy, METH_O, NULL},
53700 { (char *)"Window_DestroyChildren", (PyCFunction)_wrap_Window_DestroyChildren, METH_O, NULL},
53701 { (char *)"Window_IsBeingDeleted", (PyCFunction)_wrap_Window_IsBeingDeleted, METH_O, NULL},
53702 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53703 { (char *)"Window_GetLabel", (PyCFunction)_wrap_Window_GetLabel, METH_O, NULL},
53704 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
53705 { (char *)"Window_GetName", (PyCFunction)_wrap_Window_GetName, METH_O, NULL},
53706 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
53707 { (char *)"Window_GetWindowVariant", (PyCFunction)_wrap_Window_GetWindowVariant, METH_O, NULL},
53708 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53709 { (char *)"Window_GetId", (PyCFunction)_wrap_Window_GetId, METH_O, NULL},
53710 { (char *)"Window_NewControlId", (PyCFunction)_wrap_Window_NewControlId, METH_NOARGS, NULL},
53711 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
53712 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
53713 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
53714 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
53715 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53716 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53717 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
53718 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
53719 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
53720 { (char *)"Window_Raise", (PyCFunction)_wrap_Window_Raise, METH_O, NULL},
53721 { (char *)"Window_Lower", (PyCFunction)_wrap_Window_Lower, METH_O, NULL},
53722 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
53723 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53724 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
53725 { (char *)"Window_GetPosition", (PyCFunction)_wrap_Window_GetPosition, METH_O, NULL},
53726 { (char *)"Window_GetPositionTuple", (PyCFunction)_wrap_Window_GetPositionTuple, METH_O, NULL},
53727 { (char *)"Window_GetScreenPosition", (PyCFunction)_wrap_Window_GetScreenPosition, METH_O, NULL},
53728 { (char *)"Window_GetScreenPositionTuple", (PyCFunction)_wrap_Window_GetScreenPositionTuple, METH_O, NULL},
53729 { (char *)"Window_GetScreenRect", (PyCFunction)_wrap_Window_GetScreenRect, METH_O, NULL},
53730 { (char *)"Window_GetSize", (PyCFunction)_wrap_Window_GetSize, METH_O, NULL},
53731 { (char *)"Window_GetSizeTuple", (PyCFunction)_wrap_Window_GetSizeTuple, METH_O, NULL},
53732 { (char *)"Window_GetRect", (PyCFunction)_wrap_Window_GetRect, METH_O, NULL},
53733 { (char *)"Window_GetClientSize", (PyCFunction)_wrap_Window_GetClientSize, METH_O, NULL},
53734 { (char *)"Window_GetClientSizeTuple", (PyCFunction)_wrap_Window_GetClientSizeTuple, METH_O, NULL},
53735 { (char *)"Window_GetClientAreaOrigin", (PyCFunction)_wrap_Window_GetClientAreaOrigin, METH_O, NULL},
53736 { (char *)"Window_GetClientRect", (PyCFunction)_wrap_Window_GetClientRect, METH_O, NULL},
53737 { (char *)"Window_GetBestSize", (PyCFunction)_wrap_Window_GetBestSize, METH_O, NULL},
53738 { (char *)"Window_GetBestSizeTuple", (PyCFunction)_wrap_Window_GetBestSizeTuple, METH_O, NULL},
53739 { (char *)"Window_InvalidateBestSize", (PyCFunction)_wrap_Window_InvalidateBestSize, METH_O, NULL},
53740 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
53741 { (char *)"Window_GetBestFittingSize", (PyCFunction)_wrap_Window_GetBestFittingSize, METH_O, NULL},
53742 { (char *)"Window_GetAdjustedBestSize", (PyCFunction)_wrap_Window_GetAdjustedBestSize, METH_O, NULL},
53743 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
53744 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
53745 { (char *)"Window_Fit", (PyCFunction)_wrap_Window_Fit, METH_O, NULL},
53746 { (char *)"Window_FitInside", (PyCFunction)_wrap_Window_FitInside, METH_O, NULL},
53747 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53748 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
53749 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53750 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
53751 { (char *)"Window_GetMaxSize", (PyCFunction)_wrap_Window_GetMaxSize, METH_O, NULL},
53752 { (char *)"Window_GetMinSize", (PyCFunction)_wrap_Window_GetMinSize, METH_O, NULL},
53753 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
53754 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
53755 { (char *)"Window_GetMinWidth", (PyCFunction)_wrap_Window_GetMinWidth, METH_O, NULL},
53756 { (char *)"Window_GetMinHeight", (PyCFunction)_wrap_Window_GetMinHeight, METH_O, NULL},
53757 { (char *)"Window_GetMaxWidth", (PyCFunction)_wrap_Window_GetMaxWidth, METH_O, NULL},
53758 { (char *)"Window_GetMaxHeight", (PyCFunction)_wrap_Window_GetMaxHeight, METH_O, NULL},
53759 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
53760 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53761 { (char *)"Window_GetVirtualSize", (PyCFunction)_wrap_Window_GetVirtualSize, METH_O, NULL},
53762 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction)_wrap_Window_GetVirtualSizeTuple, METH_O, NULL},
53763 { (char *)"Window_GetBestVirtualSize", (PyCFunction)_wrap_Window_GetBestVirtualSize, METH_O, NULL},
53764 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53765 { (char *)"Window_Hide", (PyCFunction)_wrap_Window_Hide, METH_O, NULL},
53766 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53767 { (char *)"Window_Disable", (PyCFunction)_wrap_Window_Disable, METH_O, NULL},
53768 { (char *)"Window_IsShown", (PyCFunction)_wrap_Window_IsShown, METH_O, NULL},
53769 { (char *)"Window_IsEnabled", (PyCFunction)_wrap_Window_IsEnabled, METH_O, NULL},
53770 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53771 { (char *)"Window_GetWindowStyleFlag", (PyCFunction)_wrap_Window_GetWindowStyleFlag, METH_O, NULL},
53772 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53773 { (char *)"Window_IsRetained", (PyCFunction)_wrap_Window_IsRetained, METH_O, NULL},
53774 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
53775 { (char *)"Window_GetExtraStyle", (PyCFunction)_wrap_Window_GetExtraStyle, METH_O, NULL},
53776 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
53777 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53778 { (char *)"Window_GetThemeEnabled", (PyCFunction)_wrap_Window_GetThemeEnabled, METH_O, NULL},
53779 { (char *)"Window_SetFocus", (PyCFunction)_wrap_Window_SetFocus, METH_O, NULL},
53780 { (char *)"Window_SetFocusFromKbd", (PyCFunction)_wrap_Window_SetFocusFromKbd, METH_O, NULL},
53781 { (char *)"Window_FindFocus", (PyCFunction)_wrap_Window_FindFocus, METH_NOARGS, NULL},
53782 { (char *)"Window_AcceptsFocus", (PyCFunction)_wrap_Window_AcceptsFocus, METH_O, NULL},
53783 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction)_wrap_Window_AcceptsFocusFromKeyboard, METH_O, NULL},
53784 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
53785 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
53786 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
53787 { (char *)"Window_GetChildren", (PyCFunction)_wrap_Window_GetChildren, METH_O, NULL},
53788 { (char *)"Window_GetParent", (PyCFunction)_wrap_Window_GetParent, METH_O, NULL},
53789 { (char *)"Window_GetGrandParent", (PyCFunction)_wrap_Window_GetGrandParent, METH_O, NULL},
53790 { (char *)"Window_IsTopLevel", (PyCFunction)_wrap_Window_IsTopLevel, METH_O, NULL},
53791 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
53792 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
53793 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
53794 { (char *)"Window_SetDoubleBuffered", (PyCFunction) _wrap_Window_SetDoubleBuffered, METH_VARARGS | METH_KEYWORDS, NULL},
53795 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
53796 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
53797 { (char *)"Window_GetEventHandler", (PyCFunction)_wrap_Window_GetEventHandler, METH_O, NULL},
53798 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53799 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53800 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53801 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53802 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
53803 { (char *)"Window_GetValidator", (PyCFunction)_wrap_Window_GetValidator, METH_O, NULL},
53804 { (char *)"Window_Validate", (PyCFunction)_wrap_Window_Validate, METH_O, NULL},
53805 { (char *)"Window_TransferDataToWindow", (PyCFunction)_wrap_Window_TransferDataToWindow, METH_O, NULL},
53806 { (char *)"Window_TransferDataFromWindow", (PyCFunction)_wrap_Window_TransferDataFromWindow, METH_O, NULL},
53807 { (char *)"Window_InitDialog", (PyCFunction)_wrap_Window_InitDialog, METH_O, NULL},
53808 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
53809 { (char *)"Window_GetAcceleratorTable", (PyCFunction)_wrap_Window_GetAcceleratorTable, METH_O, NULL},
53810 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
53811 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
53812 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
53813 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
53814 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
53815 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
53816 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
53817 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
53818 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
53819 { (char *)"Window_CaptureMouse", (PyCFunction)_wrap_Window_CaptureMouse, METH_O, NULL},
53820 { (char *)"Window_ReleaseMouse", (PyCFunction)_wrap_Window_ReleaseMouse, METH_O, NULL},
53821 { (char *)"Window_GetCapture", (PyCFunction)_wrap_Window_GetCapture, METH_NOARGS, NULL},
53822 { (char *)"Window_HasCapture", (PyCFunction)_wrap_Window_HasCapture, METH_O, NULL},
53823 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
53824 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
53825 { (char *)"Window_Update", (PyCFunction)_wrap_Window_Update, METH_O, NULL},
53826 { (char *)"Window_ClearBackground", (PyCFunction)_wrap_Window_ClearBackground, METH_O, NULL},
53827 { (char *)"Window_Freeze", (PyCFunction)_wrap_Window_Freeze, METH_O, NULL},
53828 { (char *)"Window_Thaw", (PyCFunction)_wrap_Window_Thaw, METH_O, NULL},
53829 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
53830 { (char *)"Window_GetUpdateRegion", (PyCFunction)_wrap_Window_GetUpdateRegion, METH_O, NULL},
53831 { (char *)"Window_GetUpdateClientRect", (PyCFunction)_wrap_Window_GetUpdateClientRect, METH_O, NULL},
53832 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
53833 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53834 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
53835 { (char *)"Window_GetDefaultAttributes", (PyCFunction)_wrap_Window_GetDefaultAttributes, METH_O, NULL},
53836 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
53837 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53838 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53839 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53840 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53841 { (char *)"Window_GetBackgroundColour", (PyCFunction)_wrap_Window_GetBackgroundColour, METH_O, NULL},
53842 { (char *)"Window_GetForegroundColour", (PyCFunction)_wrap_Window_GetForegroundColour, METH_O, NULL},
53843 { (char *)"Window_InheritsBackgroundColour", (PyCFunction)_wrap_Window_InheritsBackgroundColour, METH_O, NULL},
53844 { (char *)"Window_UseBgCol", (PyCFunction)_wrap_Window_UseBgCol, METH_O, NULL},
53845 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
53846 { (char *)"Window_GetBackgroundStyle", (PyCFunction)_wrap_Window_GetBackgroundStyle, METH_O, NULL},
53847 { (char *)"Window_HasTransparentBackground", (PyCFunction)_wrap_Window_HasTransparentBackground, METH_O, NULL},
53848 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
53849 { (char *)"Window_GetCursor", (PyCFunction)_wrap_Window_GetCursor, METH_O, NULL},
53850 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
53851 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
53852 { (char *)"Window_GetFont", (PyCFunction)_wrap_Window_GetFont, METH_O, NULL},
53853 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
53854 { (char *)"Window_GetCaret", (PyCFunction)_wrap_Window_GetCaret, METH_O, NULL},
53855 { (char *)"Window_GetCharHeight", (PyCFunction)_wrap_Window_GetCharHeight, METH_O, NULL},
53856 { (char *)"Window_GetCharWidth", (PyCFunction)_wrap_Window_GetCharWidth, METH_O, NULL},
53857 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
53858 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
53859 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
53860 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
53861 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
53862 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
53863 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
53864 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
53865 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
53866 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
53867 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
53868 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53869 { (char *)"Window_HasMultiplePages", (PyCFunction)_wrap_Window_HasMultiplePages, METH_O, NULL},
53870 { (char *)"Window_GetHandle", (PyCFunction)_wrap_Window_GetHandle, METH_O, NULL},
53871 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
53872 { (char *)"Window_DissociateHandle", (PyCFunction)_wrap_Window_DissociateHandle, METH_O, NULL},
53873 { (char *)"Window_OnPaint", (PyCFunction) _wrap_Window_OnPaint, METH_VARARGS | METH_KEYWORDS, NULL},
53874 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
53875 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
53876 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
53877 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
53878 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
53879 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
53880 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53881 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
53882 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
53883 { (char *)"Window_LineUp", (PyCFunction)_wrap_Window_LineUp, METH_O, NULL},
53884 { (char *)"Window_LineDown", (PyCFunction)_wrap_Window_LineDown, METH_O, NULL},
53885 { (char *)"Window_PageUp", (PyCFunction)_wrap_Window_PageUp, METH_O, NULL},
53886 { (char *)"Window_PageDown", (PyCFunction)_wrap_Window_PageDown, METH_O, NULL},
53887 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
53888 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
53889 { (char *)"Window_GetHelpTextAtPoint", (PyCFunction) _wrap_Window_GetHelpTextAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53890 { (char *)"Window_GetHelpText", (PyCFunction)_wrap_Window_GetHelpText, METH_O, NULL},
53891 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
53892 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
53893 { (char *)"Window_GetToolTip", (PyCFunction)_wrap_Window_GetToolTip, METH_O, NULL},
53894 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
53895 { (char *)"Window_GetDropTarget", (PyCFunction)_wrap_Window_GetDropTarget, METH_O, NULL},
53896 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
53897 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
53898 { (char *)"Window_GetConstraints", (PyCFunction)_wrap_Window_GetConstraints, METH_O, NULL},
53899 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
53900 { (char *)"Window_GetAutoLayout", (PyCFunction)_wrap_Window_GetAutoLayout, METH_O, NULL},
53901 { (char *)"Window_Layout", (PyCFunction)_wrap_Window_Layout, METH_O, NULL},
53902 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53903 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
53904 { (char *)"Window_GetSizer", (PyCFunction)_wrap_Window_GetSizer, METH_O, NULL},
53905 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53906 { (char *)"Window_GetContainingSizer", (PyCFunction)_wrap_Window_GetContainingSizer, METH_O, NULL},
53907 { (char *)"Window_InheritAttributes", (PyCFunction)_wrap_Window_InheritAttributes, METH_O, NULL},
53908 { (char *)"Window_ShouldInheritColours", (PyCFunction)_wrap_Window_ShouldInheritColours, METH_O, NULL},
53909 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
53910 { (char *)"Window_swiginit", Window_swiginit, METH_VARARGS, NULL},
53911 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
53912 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
53913 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53914 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
53915 { (char *)"GetTopLevelWindows", (PyCFunction)_wrap_GetTopLevelWindows, METH_NOARGS, NULL},
53916 { (char *)"new_Validator", (PyCFunction)_wrap_new_Validator, METH_NOARGS, NULL},
53917 { (char *)"Validator_Clone", (PyCFunction)_wrap_Validator_Clone, METH_O, NULL},
53918 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
53919 { (char *)"Validator_TransferToWindow", (PyCFunction)_wrap_Validator_TransferToWindow, METH_O, NULL},
53920 { (char *)"Validator_TransferFromWindow", (PyCFunction)_wrap_Validator_TransferFromWindow, METH_O, NULL},
53921 { (char *)"Validator_GetWindow", (PyCFunction)_wrap_Validator_GetWindow, METH_O, NULL},
53922 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53923 { (char *)"Validator_IsSilent", (PyCFunction)_wrap_Validator_IsSilent, METH_NOARGS, NULL},
53924 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
53925 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
53926 { (char *)"Validator_swiginit", Validator_swiginit, METH_VARARGS, NULL},
53927 { (char *)"new_PyValidator", (PyCFunction)_wrap_new_PyValidator, METH_NOARGS, NULL},
53928 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53929 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
53930 { (char *)"PyValidator_swiginit", PyValidator_swiginit, METH_VARARGS, NULL},
53931 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
53932 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
53933 { (char *)"Menu_AppendSeparator", (PyCFunction)_wrap_Menu_AppendSeparator, METH_O, NULL},
53934 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53935 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53936 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53937 { (char *)"Menu_AppendSubMenu", (PyCFunction) _wrap_Menu_AppendSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53938 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
53939 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
53940 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
53941 { (char *)"Menu_Break", (PyCFunction)_wrap_Menu_Break, METH_O, NULL},
53942 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53943 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
53944 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53945 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53946 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53947 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
53948 { (char *)"Menu_PrependSeparator", (PyCFunction)_wrap_Menu_PrependSeparator, METH_O, NULL},
53949 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53950 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53951 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53952 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
53953 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
53954 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
53955 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
53956 { (char *)"Menu_Destroy", (PyCFunction)_wrap_Menu_Destroy, METH_O, NULL},
53957 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
53958 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
53959 { (char *)"Menu_GetMenuItemCount", (PyCFunction)_wrap_Menu_GetMenuItemCount, METH_O, NULL},
53960 { (char *)"Menu_GetMenuItems", (PyCFunction)_wrap_Menu_GetMenuItems, METH_O, NULL},
53961 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
53962 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
53963 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53964 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53965 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53966 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53967 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
53968 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53969 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53970 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53971 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53972 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
53973 { (char *)"Menu_GetTitle", (PyCFunction)_wrap_Menu_GetTitle, METH_O, NULL},
53974 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53975 { (char *)"Menu_GetEventHandler", (PyCFunction)_wrap_Menu_GetEventHandler, METH_O, NULL},
53976 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53977 { (char *)"Menu_GetInvokingWindow", (PyCFunction)_wrap_Menu_GetInvokingWindow, METH_O, NULL},
53978 { (char *)"Menu_GetStyle", (PyCFunction)_wrap_Menu_GetStyle, METH_O, NULL},
53979 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
53980 { (char *)"Menu_GetMenuBar", (PyCFunction)_wrap_Menu_GetMenuBar, METH_O, NULL},
53981 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
53982 { (char *)"Menu_Detach", (PyCFunction)_wrap_Menu_Detach, METH_O, NULL},
53983 { (char *)"Menu_IsAttached", (PyCFunction)_wrap_Menu_IsAttached, METH_O, NULL},
53984 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
53985 { (char *)"Menu_GetParent", (PyCFunction)_wrap_Menu_GetParent, METH_O, NULL},
53986 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
53987 { (char *)"Menu_swiginit", Menu_swiginit, METH_VARARGS, NULL},
53988 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
53989 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
53990 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53991 { (char *)"MenuBar_GetMenuCount", (PyCFunction)_wrap_MenuBar_GetMenuCount, METH_O, NULL},
53992 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53993 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
53994 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
53995 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
53996 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
53997 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
53998 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
53999 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
54000 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
54001 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54002 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
54003 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
54004 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
54005 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
54006 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
54007 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
54008 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
54009 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
54010 { (char *)"MenuBar_GetFrame", (PyCFunction)_wrap_MenuBar_GetFrame, METH_O, NULL},
54011 { (char *)"MenuBar_IsAttached", (PyCFunction)_wrap_MenuBar_IsAttached, METH_O, NULL},
54012 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
54013 { (char *)"MenuBar_Detach", (PyCFunction)_wrap_MenuBar_Detach, METH_O, NULL},
54014 { (char *)"MenuBar_UpdateMenus", (PyCFunction)_wrap_MenuBar_UpdateMenus, METH_O, NULL},
54015 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54016 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction)_wrap_MenuBar_GetAutoWindowMenu, METH_NOARGS, NULL},
54017 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
54018 { (char *)"MenuBar_swiginit", MenuBar_swiginit, METH_VARARGS, NULL},
54019 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
54020 { (char *)"delete_MenuItem", (PyCFunction)_wrap_delete_MenuItem, METH_O, NULL},
54021 { (char *)"MenuItem_GetMenu", (PyCFunction)_wrap_MenuItem_GetMenu, METH_O, NULL},
54022 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54023 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
54024 { (char *)"MenuItem_GetId", (PyCFunction)_wrap_MenuItem_GetId, METH_O, NULL},
54025 { (char *)"MenuItem_IsSeparator", (PyCFunction)_wrap_MenuItem_IsSeparator, METH_O, NULL},
54026 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
54027 { (char *)"MenuItem_GetLabel", (PyCFunction)_wrap_MenuItem_GetLabel, METH_O, NULL},
54028 { (char *)"MenuItem_GetText", (PyCFunction)_wrap_MenuItem_GetText, METH_O, NULL},
54029 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
54030 { (char *)"MenuItem_GetKind", (PyCFunction)_wrap_MenuItem_GetKind, METH_O, NULL},
54031 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
54032 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
54033 { (char *)"MenuItem_IsCheckable", (PyCFunction)_wrap_MenuItem_IsCheckable, METH_O, NULL},
54034 { (char *)"MenuItem_IsSubMenu", (PyCFunction)_wrap_MenuItem_IsSubMenu, METH_O, NULL},
54035 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54036 { (char *)"MenuItem_GetSubMenu", (PyCFunction)_wrap_MenuItem_GetSubMenu, METH_O, NULL},
54037 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
54038 { (char *)"MenuItem_IsEnabled", (PyCFunction)_wrap_MenuItem_IsEnabled, METH_O, NULL},
54039 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
54040 { (char *)"MenuItem_IsChecked", (PyCFunction)_wrap_MenuItem_IsChecked, METH_O, NULL},
54041 { (char *)"MenuItem_Toggle", (PyCFunction)_wrap_MenuItem_Toggle, METH_O, NULL},
54042 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
54043 { (char *)"MenuItem_GetHelp", (PyCFunction)_wrap_MenuItem_GetHelp, METH_O, NULL},
54044 { (char *)"MenuItem_GetAccel", (PyCFunction)_wrap_MenuItem_GetAccel, METH_O, NULL},
54045 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
54046 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54047 { (char *)"MenuItem_GetBitmap", (PyCFunction)_wrap_MenuItem_GetBitmap, METH_O, NULL},
54048 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
54049 { (char *)"MenuItem_GetFont", (PyCFunction)_wrap_MenuItem_GetFont, METH_O, NULL},
54050 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
54051 { (char *)"MenuItem_GetTextColour", (PyCFunction)_wrap_MenuItem_GetTextColour, METH_O, NULL},
54052 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
54053 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction)_wrap_MenuItem_GetBackgroundColour, METH_O, NULL},
54054 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
54055 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54056 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction)_wrap_MenuItem_GetDisabledBitmap, METH_O, NULL},
54057 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
54058 { (char *)"MenuItem_GetMarginWidth", (PyCFunction)_wrap_MenuItem_GetMarginWidth, METH_O, NULL},
54059 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction)_wrap_MenuItem_GetDefaultMarginWidth, METH_NOARGS, NULL},
54060 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction)_wrap_MenuItem_IsOwnerDrawn, METH_O, NULL},
54061 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
54062 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction)_wrap_MenuItem_ResetOwnerDrawn, METH_O, NULL},
54063 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
54064 { (char *)"MenuItem_swiginit", MenuItem_swiginit, METH_VARARGS, NULL},
54065 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
54066 { (char *)"new_PreControl", (PyCFunction)_wrap_new_PreControl, METH_NOARGS, NULL},
54067 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
54068 { (char *)"Control_GetAlignment", (PyCFunction)_wrap_Control_GetAlignment, METH_O, NULL},
54069 { (char *)"Control_GetLabelText", (PyCFunction)_wrap_Control_GetLabelText, METH_O, NULL},
54070 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
54071 { (char *)"Control_GetLabel", (PyCFunction)_wrap_Control_GetLabel, METH_O, NULL},
54072 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
54073 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
54074 { (char *)"Control_swiginit", Control_swiginit, METH_VARARGS, NULL},
54075 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
54076 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
54077 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
54078 { (char *)"ItemContainer_Clear", (PyCFunction)_wrap_ItemContainer_Clear, METH_O, NULL},
54079 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
54080 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
54081 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
54082 { (char *)"ItemContainer_GetCount", (PyCFunction)_wrap_ItemContainer_GetCount, METH_O, NULL},
54083 { (char *)"ItemContainer_IsEmpty", (PyCFunction)_wrap_ItemContainer_IsEmpty, METH_O, NULL},
54084 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
54085 { (char *)"ItemContainer_GetStrings", (PyCFunction)_wrap_ItemContainer_GetStrings, METH_O, NULL},
54086 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
54087 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
54088 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
54089 { (char *)"ItemContainer_GetSelection", (PyCFunction)_wrap_ItemContainer_GetSelection, METH_O, NULL},
54090 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
54091 { (char *)"ItemContainer_GetStringSelection", (PyCFunction)_wrap_ItemContainer_GetStringSelection, METH_O, NULL},
54092 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
54093 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
54094 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
54095 { (char *)"new_SizerItem", (PyCFunction)_wrap_new_SizerItem, METH_NOARGS, NULL},
54096 { (char *)"delete_SizerItem", (PyCFunction)_wrap_delete_SizerItem, METH_O, NULL},
54097 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54098 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
54099 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54100 { (char *)"SizerItem_DeleteWindows", (PyCFunction)_wrap_SizerItem_DeleteWindows, METH_O, NULL},
54101 { (char *)"SizerItem_DetachSizer", (PyCFunction)_wrap_SizerItem_DetachSizer, METH_O, NULL},
54102 { (char *)"SizerItem_GetSize", (PyCFunction)_wrap_SizerItem_GetSize, METH_O, NULL},
54103 { (char *)"SizerItem_CalcMin", (PyCFunction)_wrap_SizerItem_CalcMin, METH_O, NULL},
54104 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
54105 { (char *)"SizerItem_GetMinSize", (PyCFunction)_wrap_SizerItem_GetMinSize, METH_O, NULL},
54106 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction)_wrap_SizerItem_GetMinSizeWithBorder, METH_O, NULL},
54107 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
54108 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
54109 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
54110 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
54111 { (char *)"SizerItem_GetRatio", (PyCFunction)_wrap_SizerItem_GetRatio, METH_O, NULL},
54112 { (char *)"SizerItem_GetRect", (PyCFunction)_wrap_SizerItem_GetRect, METH_O, NULL},
54113 { (char *)"SizerItem_IsWindow", (PyCFunction)_wrap_SizerItem_IsWindow, METH_O, NULL},
54114 { (char *)"SizerItem_IsSizer", (PyCFunction)_wrap_SizerItem_IsSizer, METH_O, NULL},
54115 { (char *)"SizerItem_IsSpacer", (PyCFunction)_wrap_SizerItem_IsSpacer, METH_O, NULL},
54116 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
54117 { (char *)"SizerItem_GetProportion", (PyCFunction)_wrap_SizerItem_GetProportion, METH_O, NULL},
54118 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
54119 { (char *)"SizerItem_GetFlag", (PyCFunction)_wrap_SizerItem_GetFlag, METH_O, NULL},
54120 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
54121 { (char *)"SizerItem_GetBorder", (PyCFunction)_wrap_SizerItem_GetBorder, METH_O, NULL},
54122 { (char *)"SizerItem_GetWindow", (PyCFunction)_wrap_SizerItem_GetWindow, METH_O, NULL},
54123 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54124 { (char *)"SizerItem_GetSizer", (PyCFunction)_wrap_SizerItem_GetSizer, METH_O, NULL},
54125 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54126 { (char *)"SizerItem_GetSpacer", (PyCFunction)_wrap_SizerItem_GetSpacer, METH_O, NULL},
54127 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
54128 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
54129 { (char *)"SizerItem_IsShown", (PyCFunction)_wrap_SizerItem_IsShown, METH_O, NULL},
54130 { (char *)"SizerItem_GetPosition", (PyCFunction)_wrap_SizerItem_GetPosition, METH_O, NULL},
54131 { (char *)"SizerItem_GetUserData", (PyCFunction)_wrap_SizerItem_GetUserData, METH_O, NULL},
54132 { (char *)"SizerItem_SetUserData", (PyCFunction) _wrap_SizerItem_SetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
54133 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
54134 { (char *)"SizerItem_swiginit", SizerItem_swiginit, METH_VARARGS, NULL},
54135 { (char *)"delete_Sizer", (PyCFunction)_wrap_delete_Sizer, METH_O, NULL},
54136 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54137 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
54138 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
54139 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
54140 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
54141 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
54142 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
54143 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
54144 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
54145 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
54146 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
54147 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
54148 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
54149 { (char *)"Sizer_GetSize", (PyCFunction)_wrap_Sizer_GetSize, METH_O, NULL},
54150 { (char *)"Sizer_GetPosition", (PyCFunction)_wrap_Sizer_GetPosition, METH_O, NULL},
54151 { (char *)"Sizer_GetMinSize", (PyCFunction)_wrap_Sizer_GetMinSize, METH_O, NULL},
54152 { (char *)"Sizer_RecalcSizes", (PyCFunction)_wrap_Sizer_RecalcSizes, METH_O, NULL},
54153 { (char *)"Sizer_CalcMin", (PyCFunction)_wrap_Sizer_CalcMin, METH_O, NULL},
54154 { (char *)"Sizer_Layout", (PyCFunction)_wrap_Sizer_Layout, METH_O, NULL},
54155 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
54156 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
54157 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
54158 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
54159 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
54160 { (char *)"Sizer_DeleteWindows", (PyCFunction)_wrap_Sizer_DeleteWindows, METH_O, NULL},
54161 { (char *)"Sizer_GetChildren", (PyCFunction)_wrap_Sizer_GetChildren, METH_O, NULL},
54162 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
54163 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
54164 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
54165 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
54166 { (char *)"new_PySizer", (PyCFunction)_wrap_new_PySizer, METH_NOARGS, NULL},
54167 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54168 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
54169 { (char *)"PySizer_swiginit", PySizer_swiginit, METH_VARARGS, NULL},
54170 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54171 { (char *)"BoxSizer_GetOrientation", (PyCFunction)_wrap_BoxSizer_GetOrientation, METH_O, NULL},
54172 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
54173 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
54174 { (char *)"BoxSizer_swiginit", BoxSizer_swiginit, METH_VARARGS, NULL},
54175 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54176 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction)_wrap_StaticBoxSizer_GetStaticBox, METH_O, NULL},
54177 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
54178 { (char *)"StaticBoxSizer_swiginit", StaticBoxSizer_swiginit, METH_VARARGS, NULL},
54179 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54180 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
54181 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
54182 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
54183 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
54184 { (char *)"GridSizer_GetCols", (PyCFunction)_wrap_GridSizer_GetCols, METH_O, NULL},
54185 { (char *)"GridSizer_GetRows", (PyCFunction)_wrap_GridSizer_GetRows, METH_O, NULL},
54186 { (char *)"GridSizer_GetVGap", (PyCFunction)_wrap_GridSizer_GetVGap, METH_O, NULL},
54187 { (char *)"GridSizer_GetHGap", (PyCFunction)_wrap_GridSizer_GetHGap, METH_O, NULL},
54188 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
54189 { (char *)"GridSizer_swiginit", GridSizer_swiginit, METH_VARARGS, NULL},
54190 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54191 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
54192 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
54193 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
54194 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
54195 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
54196 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction)_wrap_FlexGridSizer_GetFlexibleDirection, METH_O, NULL},
54197 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
54198 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction)_wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_O, NULL},
54199 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction)_wrap_FlexGridSizer_GetRowHeights, METH_O, NULL},
54200 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction)_wrap_FlexGridSizer_GetColWidths, METH_O, NULL},
54201 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
54202 { (char *)"FlexGridSizer_swiginit", FlexGridSizer_swiginit, METH_VARARGS, NULL},
54203 { (char *)"new_StdDialogButtonSizer", (PyCFunction)_wrap_new_StdDialogButtonSizer, METH_NOARGS, NULL},
54204 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
54205 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction)_wrap_StdDialogButtonSizer_Realize, METH_O, NULL},
54206 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
54207 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
54208 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
54209 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_O, NULL},
54210 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetApplyButton, METH_O, NULL},
54211 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetNegativeButton, METH_O, NULL},
54212 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetCancelButton, METH_O, NULL},
54213 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetHelpButton, METH_O, NULL},
54214 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
54215 { (char *)"StdDialogButtonSizer_swiginit", StdDialogButtonSizer_swiginit, METH_VARARGS, NULL},
54216 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54217 { (char *)"delete_GBPosition", (PyCFunction)_wrap_delete_GBPosition, METH_O, NULL},
54218 { (char *)"GBPosition_GetRow", (PyCFunction)_wrap_GBPosition_GetRow, METH_O, NULL},
54219 { (char *)"GBPosition_GetCol", (PyCFunction)_wrap_GBPosition_GetCol, METH_O, NULL},
54220 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
54221 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
54222 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
54223 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
54224 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54225 { (char *)"GBPosition_Get", (PyCFunction)_wrap_GBPosition_Get, METH_O, NULL},
54226 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
54227 { (char *)"GBPosition_swiginit", GBPosition_swiginit, METH_VARARGS, NULL},
54228 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
54229 { (char *)"delete_GBSpan", (PyCFunction)_wrap_delete_GBSpan, METH_O, NULL},
54230 { (char *)"GBSpan_GetRowspan", (PyCFunction)_wrap_GBSpan_GetRowspan, METH_O, NULL},
54231 { (char *)"GBSpan_GetColspan", (PyCFunction)_wrap_GBSpan_GetColspan, METH_O, NULL},
54232 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
54233 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
54234 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
54235 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
54236 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54237 { (char *)"GBSpan_Get", (PyCFunction)_wrap_GBSpan_Get, METH_O, NULL},
54238 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
54239 { (char *)"GBSpan_swiginit", GBSpan_swiginit, METH_VARARGS, NULL},
54240 { (char *)"new_GBSizerItem", (PyCFunction)_wrap_new_GBSizerItem, METH_NOARGS, NULL},
54241 { (char *)"delete_GBSizerItem", (PyCFunction)_wrap_delete_GBSizerItem, METH_O, NULL},
54242 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54243 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54244 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
54245 { (char *)"GBSizerItem_GetPos", (PyCFunction)_wrap_GBSizerItem_GetPos, METH_O, NULL},
54246 { (char *)"GBSizerItem_GetSpan", (PyCFunction)_wrap_GBSizerItem_GetSpan, METH_O, NULL},
54247 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
54248 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
54249 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
54250 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
54251 { (char *)"GBSizerItem_GetEndPos", (PyCFunction)_wrap_GBSizerItem_GetEndPos, METH_O, NULL},
54252 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction)_wrap_GBSizerItem_GetGBSizer, METH_O, NULL},
54253 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54254 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
54255 { (char *)"GBSizerItem_swiginit", GBSizerItem_swiginit, METH_VARARGS, NULL},
54256 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54257 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
54258 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
54259 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
54260 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction)_wrap_GridBagSizer_GetEmptyCellSize, METH_O, NULL},
54261 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
54262 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
54263 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
54264 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
54265 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
54266 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
54267 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54268 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
54269 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
54270 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
54271 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
54272 { (char *)"GridBagSizer_swiginit", GridBagSizer_swiginit, METH_VARARGS, NULL},
54273 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54274 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
54275 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
54276 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
54277 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
54278 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
54279 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
54280 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
54281 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction)_wrap_IndividualLayoutConstraint_Unconstrained, METH_O, NULL},
54282 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction)_wrap_IndividualLayoutConstraint_AsIs, METH_O, NULL},
54283 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherWindow, METH_O, NULL},
54284 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMyEdge, METH_O, NULL},
54285 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
54286 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
54287 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMargin, METH_O, NULL},
54288 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
54289 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction)_wrap_IndividualLayoutConstraint_GetValue, METH_O, NULL},
54290 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction)_wrap_IndividualLayoutConstraint_GetPercent, METH_O, NULL},
54291 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherEdge, METH_O, NULL},
54292 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction)_wrap_IndividualLayoutConstraint_GetDone, METH_O, NULL},
54293 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
54294 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction)_wrap_IndividualLayoutConstraint_GetRelationship, METH_O, NULL},
54295 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
54296 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
54297 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
54298 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
54299 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
54300 { (char *)"LayoutConstraints_left_get", (PyCFunction)_wrap_LayoutConstraints_left_get, METH_O, NULL},
54301 { (char *)"LayoutConstraints_top_get", (PyCFunction)_wrap_LayoutConstraints_top_get, METH_O, NULL},
54302 { (char *)"LayoutConstraints_right_get", (PyCFunction)_wrap_LayoutConstraints_right_get, METH_O, NULL},
54303 { (char *)"LayoutConstraints_bottom_get", (PyCFunction)_wrap_LayoutConstraints_bottom_get, METH_O, NULL},
54304 { (char *)"LayoutConstraints_width_get", (PyCFunction)_wrap_LayoutConstraints_width_get, METH_O, NULL},
54305 { (char *)"LayoutConstraints_height_get", (PyCFunction)_wrap_LayoutConstraints_height_get, METH_O, NULL},
54306 { (char *)"LayoutConstraints_centreX_get", (PyCFunction)_wrap_LayoutConstraints_centreX_get, METH_O, NULL},
54307 { (char *)"LayoutConstraints_centreY_get", (PyCFunction)_wrap_LayoutConstraints_centreY_get, METH_O, NULL},
54308 { (char *)"new_LayoutConstraints", (PyCFunction)_wrap_new_LayoutConstraints, METH_NOARGS, NULL},
54309 { (char *)"delete_LayoutConstraints", (PyCFunction)_wrap_delete_LayoutConstraints, METH_O, NULL},
54310 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
54311 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction)_wrap_LayoutConstraints_AreSatisfied, METH_O, NULL},
54312 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
54313 { (char *)"LayoutConstraints_swiginit", LayoutConstraints_swiginit, METH_VARARGS, NULL},
54314 { NULL, NULL, 0, NULL }
54315 };
54316
54317
54318 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
54319
54320 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
54321 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
54322 }
54323 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
54324 return (void *)((wxSizer *) ((wxBoxSizer *) x));
54325 }
54326 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
54327 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
54328 }
54329 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
54330 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54331 }
54332 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
54333 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
54334 }
54335 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
54336 return (void *)((wxSizer *) ((wxGridSizer *) x));
54337 }
54338 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
54339 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
54340 }
54341 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
54342 return (void *)((wxSizer *) ((wxPySizer *) x));
54343 }
54344 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
54345 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
54346 }
54347 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
54348 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54349 }
54350 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
54351 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
54352 }
54353 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
54354 return (void *)((wxEvent *) ((wxMenuEvent *) x));
54355 }
54356 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
54357 return (void *)((wxEvent *) ((wxCloseEvent *) x));
54358 }
54359 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
54360 return (void *)((wxEvent *) ((wxMouseEvent *) x));
54361 }
54362 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
54363 return (void *)((wxEvent *) ((wxEraseEvent *) x));
54364 }
54365 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
54366 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
54367 }
54368 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
54369 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
54370 }
54371 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
54372 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
54373 }
54374 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
54375 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
54376 }
54377 static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {
54378 return (void *)((wxEvent *) ((wxMouseCaptureLostEvent *) x));
54379 }
54380 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
54381 return (void *)((wxEvent *) ((wxPyEvent *) x));
54382 }
54383 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
54384 return (void *)((wxEvent *) ((wxIdleEvent *) x));
54385 }
54386 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
54387 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
54388 }
54389 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
54390 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
54391 }
54392 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
54393 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
54394 }
54395 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
54396 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
54397 }
54398 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
54399 return (void *)((wxEvent *) ((wxActivateEvent *) x));
54400 }
54401 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
54402 return (void *)((wxEvent *) ((wxSizeEvent *) x));
54403 }
54404 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
54405 return (void *)((wxEvent *) ((wxMoveEvent *) x));
54406 }
54407 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
54408 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
54409 }
54410 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
54411 return (void *)((wxEvent *) ((wxPaintEvent *) x));
54412 }
54413 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
54414 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
54415 }
54416 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
54417 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
54418 }
54419 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
54420 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
54421 }
54422 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
54423 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
54424 }
54425 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
54426 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
54427 }
54428 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
54429 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
54430 }
54431 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
54432 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
54433 }
54434 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
54435 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
54436 }
54437 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
54438 return (void *)((wxEvent *) ((wxFocusEvent *) x));
54439 }
54440 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
54441 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
54442 }
54443 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
54444 return (void *)((wxEvent *) ((wxShowEvent *) x));
54445 }
54446 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
54447 return (void *)((wxEvent *) ((wxCommandEvent *) x));
54448 }
54449 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
54450 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
54451 }
54452 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
54453 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54454 }
54455 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
54456 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
54457 }
54458 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
54459 return (void *)((wxEvent *) ((wxKeyEvent *) x));
54460 }
54461 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
54462 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
54463 }
54464 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
54465 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
54466 }
54467 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
54468 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
54469 }
54470 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
54471 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
54472 }
54473 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
54474 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
54475 }
54476 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
54477 return (void *)((wxControl *) ((wxControlWithItems *) x));
54478 }
54479 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
54480 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
54481 }
54482 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
54483 return (void *)((wxEvtHandler *) ((wxWindow *) x));
54484 }
54485 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
54486 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
54487 }
54488 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
54489 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
54490 }
54491 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
54492 return (void *)((wxEvtHandler *) ((wxValidator *) x));
54493 }
54494 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
54495 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
54496 }
54497 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
54498 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
54499 }
54500 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
54501 return (void *)((wxEvtHandler *) ((wxMenu *) x));
54502 }
54503 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
54504 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
54505 }
54506 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
54507 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
54508 }
54509 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
54510 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
54511 }
54512 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
54513 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
54514 }
54515 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
54516 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
54517 }
54518 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
54519 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54520 }
54521 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
54522 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
54523 }
54524 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
54525 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
54526 }
54527 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
54528 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
54529 }
54530 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
54531 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
54532 }
54533 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
54534 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54535 }
54536 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
54537 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
54538 }
54539 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
54540 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
54541 }
54542 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
54543 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
54544 }
54545 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
54546 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
54547 }
54548 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
54549 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
54550 }
54551 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
54552 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
54553 }
54554 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
54555 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
54556 }
54557 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
54558 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
54559 }
54560 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
54561 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
54562 }
54563 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
54564 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
54565 }
54566 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
54567 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
54568 }
54569 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
54570 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
54571 }
54572 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
54573 return (void *)((wxObject *) ((wxSizerItem *) x));
54574 }
54575 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
54576 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
54577 }
54578 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
54579 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
54580 }
54581 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
54582 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
54583 }
54584 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
54585 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
54586 }
54587 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
54588 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
54589 }
54590 static void *_p_wxSizerTo_p_wxObject(void *x) {
54591 return (void *)((wxObject *) ((wxSizer *) x));
54592 }
54593 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
54594 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
54595 }
54596 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
54597 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
54598 }
54599 static void *_p_wxEventTo_p_wxObject(void *x) {
54600 return (void *)((wxObject *) ((wxEvent *) x));
54601 }
54602 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
54603 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
54604 }
54605 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
54606 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
54607 }
54608 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
54609 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
54610 }
54611 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
54612 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
54613 }
54614 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
54615 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
54616 }
54617 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
54618 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
54619 }
54620 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
54621 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
54622 }
54623 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
54624 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
54625 }
54626 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
54627 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
54628 }
54629 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
54630 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
54631 }
54632 static void *_p_wxControlTo_p_wxObject(void *x) {
54633 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
54634 }
54635 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
54636 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
54637 }
54638 static void *_p_wxFSFileTo_p_wxObject(void *x) {
54639 return (void *)((wxObject *) ((wxFSFile *) x));
54640 }
54641 static void *_p_wxPySizerTo_p_wxObject(void *x) {
54642 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
54643 }
54644 static void *_p_wxPyEventTo_p_wxObject(void *x) {
54645 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
54646 }
54647 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
54648 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
54649 }
54650 static void *_p_wxShowEventTo_p_wxObject(void *x) {
54651 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
54652 }
54653 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
54654 return (void *)((wxObject *) ((wxMenuItem *) x));
54655 }
54656 static void *_p_wxDateEventTo_p_wxObject(void *x) {
54657 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
54658 }
54659 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
54660 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
54661 }
54662 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
54663 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
54664 }
54665 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
54666 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
54667 }
54668 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
54669 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
54670 }
54671 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
54672 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
54673 }
54674 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
54675 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
54676 }
54677 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
54678 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
54679 }
54680 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
54681 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
54682 }
54683 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
54684 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
54685 }
54686 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
54687 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
54688 }
54689 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
54690 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
54691 }
54692 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
54693 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
54694 }
54695 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
54696 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
54697 }
54698 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
54699 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54700 }
54701 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
54702 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
54703 }
54704 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
54705 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
54706 }
54707 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
54708 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
54709 }
54710 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
54711 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
54712 }
54713 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
54714 return (void *)((wxObject *) ((wxImageHandler *) x));
54715 }
54716 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
54717 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
54718 }
54719 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
54720 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
54721 }
54722 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
54723 return (void *)((wxObject *) ((wxEvtHandler *) x));
54724 }
54725 static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
54726 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
54727 }
54728 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
54729 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54730 }
54731 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
54732 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
54733 }
54734 static void *_p_wxImageTo_p_wxObject(void *x) {
54735 return (void *)((wxObject *) ((wxImage *) x));
54736 }
54737 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
54738 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
54739 }
54740 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
54741 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54742 }
54743 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
54744 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
54745 }
54746 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
54747 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
54748 }
54749 static void *_p_wxWindowTo_p_wxObject(void *x) {
54750 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
54751 }
54752 static void *_p_wxMenuTo_p_wxObject(void *x) {
54753 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
54754 }
54755 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
54756 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
54757 }
54758 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
54759 return (void *)((wxObject *) ((wxFileSystem *) x));
54760 }
54761 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
54762 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
54763 }
54764 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
54765 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
54766 }
54767 static void *_p_wxPyAppTo_p_wxObject(void *x) {
54768 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
54769 }
54770 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
54771 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
54772 }
54773 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
54774 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
54775 }
54776 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
54777 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
54778 }
54779 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
54780 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
54781 }
54782 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
54783 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
54784 }
54785 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
54786 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
54787 }
54788 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
54789 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
54790 }
54791 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
54792 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
54793 }
54794 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
54795 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
54796 }
54797 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
54798 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
54799 }
54800 static void *_p_wxValidatorTo_p_wxObject(void *x) {
54801 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
54802 }
54803 static void *_p_wxControlTo_p_wxWindow(void *x) {
54804 return (void *)((wxWindow *) ((wxControl *) x));
54805 }
54806 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
54807 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
54808 }
54809 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
54810 return (void *)((wxWindow *) ((wxMenuBar *) x));
54811 }
54812 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
54813 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
54814 }
54815 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
54816 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
54817 }
54818 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
54819 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
54820 }
54821 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
54822 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
54823 }
54824 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
54825 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
54826 }
54827 static void *_p_wxClipboardTextEventTo_p_wxCommandEvent(void *x) {
54828 return (void *)((wxCommandEvent *) ((wxClipboardTextEvent *) x));
54829 }
54830 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
54831 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54832 }
54833 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
54834 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
54835 }
54836 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
54837 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
54838 }
54839 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
54840 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
54841 }
54842 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
54843 return (void *)((wxValidator *) ((wxPyValidator *) x));
54844 }
54845 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, (void*)0, 0};
54846 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
54847 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};
54848 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
54849 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
54850 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
54851 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
54852 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
54853 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", "wxANIHandler *", 0, 0, (void*)0, 0};
54854 static swig_type_info _swigt__p_wxAcceleratorEntry = {"_p_wxAcceleratorEntry", "wxAcceleratorEntry *", 0, 0, (void*)0, 0};
54855 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", "wxAcceleratorTable *", 0, 0, (void*)0, 0};
54856 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", "wxActivateEvent *", 0, 0, (void*)0, 0};
54857 static swig_type_info _swigt__p_wxAppTraits = {"_p_wxAppTraits", "wxAppTraits *", 0, 0, (void*)0, 0};
54858 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
54859 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", "wxBMPHandler *", 0, 0, (void*)0, 0};
54860 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
54861 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", "wxBoxSizer *", 0, 0, (void*)0, 0};
54862 static swig_type_info _swigt__p_wxButton = {"_p_wxButton", "wxButton *", 0, 0, (void*)0, 0};
54863 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", "wxCURHandler *", 0, 0, (void*)0, 0};
54864 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
54865 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", "wxChildFocusEvent *", 0, 0, (void*)0, 0};
54866 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", "wxClipboardTextEvent *", 0, 0, (void*)0, 0};
54867 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", "wxCloseEvent *", 0, 0, (void*)0, 0};
54868 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
54869 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
54870 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", "wxContextMenuEvent *", 0, 0, (void*)0, 0};
54871 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
54872 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", "wxControlWithItems *", 0, 0, (void*)0, 0};
54873 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
54874 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
54875 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", "wxDateEvent *", 0, 0, (void*)0, 0};
54876 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
54877 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", "wxDisplayChangedEvent *", 0, 0, (void*)0, 0};
54878 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", "wxDropFilesEvent *", 0, 0, (void*)0, 0};
54879 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
54880 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", "wxEraseEvent *", 0, 0, (void*)0, 0};
54881 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
54882 static swig_type_info _swigt__p_wxEventLoop = {"_p_wxEventLoop", "wxEventLoop *", 0, 0, (void*)0, 0};
54883 static swig_type_info _swigt__p_wxEventLoopActivator = {"_p_wxEventLoopActivator", "wxEventLoopActivator *", 0, 0, (void*)0, 0};
54884 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
54885 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", "wxFSFile *", 0, 0, (void*)0, 0};
54886 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, (void*)0, 0};
54887 static swig_type_info _swigt__p_wxFileSystemHandler = {"_p_wxFileSystemHandler", "wxFileSystemHandler *", 0, 0, (void*)0, 0};
54888 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", "wxFlexGridSizer *", 0, 0, (void*)0, 0};
54889 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", "wxFocusEvent *", 0, 0, (void*)0, 0};
54890 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
54891 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
54892 static swig_type_info _swigt__p_wxGBPosition = {"_p_wxGBPosition", "wxGBPosition *", 0, 0, (void*)0, 0};
54893 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", "wxGBSizerItem *", 0, 0, (void*)0, 0};
54894 static swig_type_info _swigt__p_wxGBSpan = {"_p_wxGBSpan", "wxGBSpan *", 0, 0, (void*)0, 0};
54895 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", "wxGIFHandler *", 0, 0, (void*)0, 0};
54896 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", "wxGridBagSizer *", 0, 0, (void*)0, 0};
54897 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", "wxGridSizer *", 0, 0, (void*)0, 0};
54898 static swig_type_info _swigt__p_wxHelpEvent__Origin = {"_p_wxHelpEvent__Origin", "wxHelpEvent::Origin *", 0, 0, (void*)0, 0};
54899 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", "wxICOHandler *", 0, 0, (void*)0, 0};
54900 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", "wxIconizeEvent *", 0, 0, (void*)0, 0};
54901 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", "wxIdleEvent *", 0, 0, (void*)0, 0};
54902 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, (void*)0, 0};
54903 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", "wxImageHandler *", 0, 0, (void*)0, 0};
54904 static swig_type_info _swigt__p_wxImageHistogram = {"_p_wxImageHistogram", "wxImageHistogram *", 0, 0, (void*)0, 0};
54905 static swig_type_info _swigt__p_wxImage_HSVValue = {"_p_wxImage_HSVValue", "wxImage_HSVValue *", 0, 0, (void*)0, 0};
54906 static swig_type_info _swigt__p_wxImage_RGBValue = {"_p_wxImage_RGBValue", "wxImage_RGBValue *", 0, 0, (void*)0, 0};
54907 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", "wxIndividualLayoutConstraint *", 0, 0, (void*)0, 0};
54908 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", "wxInitDialogEvent *", 0, 0, (void*)0, 0};
54909 static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, (void*)0, 0};
54910 static swig_type_info _swigt__p_wxInternetFSHandler = {"_p_wxInternetFSHandler", "wxInternetFSHandler *", 0, 0, (void*)0, 0};
54911 static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, (void*)0, 0};
54912 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", "wxJPEGHandler *", 0, 0, (void*)0, 0};
54913 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
54914 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", "wxLayoutConstraints *", 0, 0, (void*)0, 0};
54915 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", "wxMaximizeEvent *", 0, 0, (void*)0, 0};
54916 static swig_type_info _swigt__p_wxMemoryFSHandler = {"_p_wxMemoryFSHandler", "wxMemoryFSHandler *", 0, 0, (void*)0, 0};
54917 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
54918 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", "wxMenuBar *", 0, 0, (void*)0, 0};
54919 static swig_type_info _swigt__p_wxMenuBarBase = {"_p_wxMenuBarBase", "wxMenuBarBase *", 0, 0, (void*)0, 0};
54920 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", "wxMenuEvent *", 0, 0, (void*)0, 0};
54921 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", "wxMenuItem *", 0, 0, (void*)0, 0};
54922 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", "wxMouseCaptureChangedEvent *", 0, 0, (void*)0, 0};
54923 static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", "wxMouseCaptureLostEvent *", 0, 0, (void*)0, 0};
54924 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", "wxMouseEvent *", 0, 0, (void*)0, 0};
54925 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", "wxMoveEvent *", 0, 0, (void*)0, 0};
54926 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", "wxNavigationKeyEvent *", 0, 0, (void*)0, 0};
54927 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", "wxNcPaintEvent *", 0, 0, (void*)0, 0};
54928 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
54929 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
54930 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
54931 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", "wxPCXHandler *", 0, 0, (void*)0, 0};
54932 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", "wxPNGHandler *", 0, 0, (void*)0, 0};
54933 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", "wxPNMHandler *", 0, 0, (void*)0, 0};
54934 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", "wxPaintEvent *", 0, 0, (void*)0, 0};
54935 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", "wxPaletteChangedEvent *", 0, 0, (void*)0, 0};
54936 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
54937 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
54938 static swig_type_info _swigt__p_wxPoint2D = {"_p_wxPoint2D", "wxPoint2D *", 0, 0, (void*)0, 0};
54939 static swig_type_info _swigt__p_wxPropagateOnce = {"_p_wxPropagateOnce", "wxPropagateOnce *", 0, 0, (void*)0, 0};
54940 static swig_type_info _swigt__p_wxPropagationDisabler = {"_p_wxPropagationDisabler", "wxPropagationDisabler *", 0, 0, (void*)0, 0};
54941 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", "wxPyApp *", 0, 0, (void*)0, 0};
54942 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", "wxPyCommandEvent *", 0, 0, (void*)0, 0};
54943 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
54944 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", "wxPyEvent *", 0, 0, (void*)0, 0};
54945 static swig_type_info _swigt__p_wxPyFileSystemHandler = {"_p_wxPyFileSystemHandler", "wxPyFileSystemHandler *", 0, 0, (void*)0, 0};
54946 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", "wxPyImageHandler *", 0, 0, (void*)0, 0};
54947 static swig_type_info _swigt__p_wxPyInputStream = {"_p_wxPyInputStream", "wxPyInputStream *", 0, 0, (void*)0, 0};
54948 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", "wxPySizer *", 0, 0, (void*)0, 0};
54949 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", "wxPyValidator *", 0, 0, (void*)0, 0};
54950 static swig_type_info _swigt__p_wxQuantize = {"_p_wxQuantize", "wxQuantize *", 0, 0, (void*)0, 0};
54951 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", "wxQueryNewPaletteEvent *", 0, 0, (void*)0, 0};
54952 static swig_type_info _swigt__p_wxRealPoint = {"_p_wxRealPoint", "wxRealPoint *", 0, 0, (void*)0, 0};
54953 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
54954 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, (void*)0, 0};
54955 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", "wxScrollEvent *", 0, 0, (void*)0, 0};
54956 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", "wxScrollWinEvent *", 0, 0, (void*)0, 0};
54957 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", "wxSetCursorEvent *", 0, 0, (void*)0, 0};
54958 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", "wxShowEvent *", 0, 0, (void*)0, 0};
54959 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
54960 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", "wxSizeEvent *", 0, 0, (void*)0, 0};
54961 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", "wxSizer *", 0, 0, (void*)0, 0};
54962 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", "wxSizerItem *", 0, 0, (void*)0, 0};
54963 static swig_type_info _swigt__p_wxStaticBox = {"_p_wxStaticBox", "wxStaticBox *", 0, 0, (void*)0, 0};
54964 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", "wxStaticBoxSizer *", 0, 0, (void*)0, 0};
54965 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", "wxStdDialogButtonSizer *", 0, 0, (void*)0, 0};
54966 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", "wxSysColourChangedEvent *", 0, 0, (void*)0, 0};
54967 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", "wxTIFFHandler *", 0, 0, (void*)0, 0};
54968 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
54969 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", "wxUpdateUIEvent *", 0, 0, (void*)0, 0};
54970 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, (void*)0, 0};
54971 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
54972 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
54973 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", "wxWindowCreateEvent *", 0, 0, (void*)0, 0};
54974 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", "wxWindowDestroyEvent *", 0, 0, (void*)0, 0};
54975 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", "wxXPMHandler *", 0, 0, (void*)0, 0};
54976 static swig_type_info _swigt__p_wxZipFSHandler = {"_p_wxZipFSHandler", "wxZipFSHandler *", 0, 0, (void*)0, 0};
54977
54978 static swig_type_info *swig_type_initial[] = {
54979 &_swigt__p_buffer,
54980 &_swigt__p_char,
54981 &_swigt__p_form_ops_t,
54982 &_swigt__p_int,
54983 &_swigt__p_long,
54984 &_swigt__p_unsigned_char,
54985 &_swigt__p_unsigned_int,
54986 &_swigt__p_unsigned_long,
54987 &_swigt__p_wxANIHandler,
54988 &_swigt__p_wxAcceleratorEntry,
54989 &_swigt__p_wxAcceleratorTable,
54990 &_swigt__p_wxActivateEvent,
54991 &_swigt__p_wxAppTraits,
54992 &_swigt__p_wxArrayString,
54993 &_swigt__p_wxBMPHandler,
54994 &_swigt__p_wxBitmap,
54995 &_swigt__p_wxBoxSizer,
54996 &_swigt__p_wxButton,
54997 &_swigt__p_wxCURHandler,
54998 &_swigt__p_wxCaret,
54999 &_swigt__p_wxChildFocusEvent,
55000 &_swigt__p_wxClipboardTextEvent,
55001 &_swigt__p_wxCloseEvent,
55002 &_swigt__p_wxColour,
55003 &_swigt__p_wxCommandEvent,
55004 &_swigt__p_wxContextMenuEvent,
55005 &_swigt__p_wxControl,
55006 &_swigt__p_wxControlWithItems,
55007 &_swigt__p_wxCursor,
55008 &_swigt__p_wxDC,
55009 &_swigt__p_wxDateEvent,
55010 &_swigt__p_wxDateTime,
55011 &_swigt__p_wxDisplayChangedEvent,
55012 &_swigt__p_wxDropFilesEvent,
55013 &_swigt__p_wxDuplexMode,
55014 &_swigt__p_wxEraseEvent,
55015 &_swigt__p_wxEvent,
55016 &_swigt__p_wxEventLoop,
55017 &_swigt__p_wxEventLoopActivator,
55018 &_swigt__p_wxEvtHandler,
55019 &_swigt__p_wxFSFile,
55020 &_swigt__p_wxFileSystem,
55021 &_swigt__p_wxFileSystemHandler,
55022 &_swigt__p_wxFlexGridSizer,
55023 &_swigt__p_wxFocusEvent,
55024 &_swigt__p_wxFont,
55025 &_swigt__p_wxFrame,
55026 &_swigt__p_wxGBPosition,
55027 &_swigt__p_wxGBSizerItem,
55028 &_swigt__p_wxGBSpan,
55029 &_swigt__p_wxGIFHandler,
55030 &_swigt__p_wxGridBagSizer,
55031 &_swigt__p_wxGridSizer,
55032 &_swigt__p_wxHelpEvent__Origin,
55033 &_swigt__p_wxICOHandler,
55034 &_swigt__p_wxIconizeEvent,
55035 &_swigt__p_wxIdleEvent,
55036 &_swigt__p_wxImage,
55037 &_swigt__p_wxImageHandler,
55038 &_swigt__p_wxImageHistogram,
55039 &_swigt__p_wxImage_HSVValue,
55040 &_swigt__p_wxImage_RGBValue,
55041 &_swigt__p_wxIndividualLayoutConstraint,
55042 &_swigt__p_wxInitDialogEvent,
55043 &_swigt__p_wxInputStream,
55044 &_swigt__p_wxInternetFSHandler,
55045 &_swigt__p_wxItemContainer,
55046 &_swigt__p_wxJPEGHandler,
55047 &_swigt__p_wxKeyEvent,
55048 &_swigt__p_wxLayoutConstraints,
55049 &_swigt__p_wxMaximizeEvent,
55050 &_swigt__p_wxMemoryFSHandler,
55051 &_swigt__p_wxMenu,
55052 &_swigt__p_wxMenuBar,
55053 &_swigt__p_wxMenuBarBase,
55054 &_swigt__p_wxMenuEvent,
55055 &_swigt__p_wxMenuItem,
55056 &_swigt__p_wxMouseCaptureChangedEvent,
55057 &_swigt__p_wxMouseCaptureLostEvent,
55058 &_swigt__p_wxMouseEvent,
55059 &_swigt__p_wxMoveEvent,
55060 &_swigt__p_wxNavigationKeyEvent,
55061 &_swigt__p_wxNcPaintEvent,
55062 &_swigt__p_wxNotifyEvent,
55063 &_swigt__p_wxObject,
55064 &_swigt__p_wxOutputStream,
55065 &_swigt__p_wxPCXHandler,
55066 &_swigt__p_wxPNGHandler,
55067 &_swigt__p_wxPNMHandler,
55068 &_swigt__p_wxPaintEvent,
55069 &_swigt__p_wxPaletteChangedEvent,
55070 &_swigt__p_wxPaperSize,
55071 &_swigt__p_wxPoint,
55072 &_swigt__p_wxPoint2D,
55073 &_swigt__p_wxPropagateOnce,
55074 &_swigt__p_wxPropagationDisabler,
55075 &_swigt__p_wxPyApp,
55076 &_swigt__p_wxPyCommandEvent,
55077 &_swigt__p_wxPyDropTarget,
55078 &_swigt__p_wxPyEvent,
55079 &_swigt__p_wxPyFileSystemHandler,
55080 &_swigt__p_wxPyImageHandler,
55081 &_swigt__p_wxPyInputStream,
55082 &_swigt__p_wxPySizer,
55083 &_swigt__p_wxPyValidator,
55084 &_swigt__p_wxQuantize,
55085 &_swigt__p_wxQueryNewPaletteEvent,
55086 &_swigt__p_wxRealPoint,
55087 &_swigt__p_wxRect,
55088 &_swigt__p_wxRegion,
55089 &_swigt__p_wxScrollEvent,
55090 &_swigt__p_wxScrollWinEvent,
55091 &_swigt__p_wxSetCursorEvent,
55092 &_swigt__p_wxShowEvent,
55093 &_swigt__p_wxSize,
55094 &_swigt__p_wxSizeEvent,
55095 &_swigt__p_wxSizer,
55096 &_swigt__p_wxSizerItem,
55097 &_swigt__p_wxStaticBox,
55098 &_swigt__p_wxStaticBoxSizer,
55099 &_swigt__p_wxStdDialogButtonSizer,
55100 &_swigt__p_wxSysColourChangedEvent,
55101 &_swigt__p_wxTIFFHandler,
55102 &_swigt__p_wxToolTip,
55103 &_swigt__p_wxUpdateUIEvent,
55104 &_swigt__p_wxValidator,
55105 &_swigt__p_wxVisualAttributes,
55106 &_swigt__p_wxWindow,
55107 &_swigt__p_wxWindowCreateEvent,
55108 &_swigt__p_wxWindowDestroyEvent,
55109 &_swigt__p_wxXPMHandler,
55110 &_swigt__p_wxZipFSHandler,
55111 };
55112
55113 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
55114 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
55115 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
55116 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
55117 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
55118 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
55119 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
55120 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
55121 static swig_cast_info _swigc__p_wxANIHandler[] = { {&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
55122 static swig_cast_info _swigc__p_wxAcceleratorEntry[] = { {&_swigt__p_wxAcceleratorEntry, 0, 0, 0},{0, 0, 0, 0}};
55123 static swig_cast_info _swigc__p_wxAcceleratorTable[] = { {&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
55124 static swig_cast_info _swigc__p_wxActivateEvent[] = { {&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
55125 static swig_cast_info _swigc__p_wxAppTraits[] = { {&_swigt__p_wxAppTraits, 0, 0, 0},{0, 0, 0, 0}};
55126 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
55127 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}};
55128 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
55129 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}};
55130 static swig_cast_info _swigc__p_wxButton[] = { {&_swigt__p_wxButton, 0, 0, 0},{0, 0, 0, 0}};
55131 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}};
55132 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
55133 static swig_cast_info _swigc__p_wxChildFocusEvent[] = { {&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
55134 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = { {&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
55135 static swig_cast_info _swigc__p_wxCloseEvent[] = { {&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
55136 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
55137 static swig_cast_info _swigc__p_wxCommandEvent[] = { {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxCommandEvent, 0, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxCommandEvent, 0, 0},{0, 0, 0, 0}};
55138 static swig_cast_info _swigc__p_wxContextMenuEvent[] = { {&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
55139 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}};
55140 static swig_cast_info _swigc__p_wxControlWithItems[] = { {&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
55141 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
55142 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
55143 static swig_cast_info _swigc__p_wxDateEvent[] = { {&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
55144 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
55145 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = { {&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
55146 static swig_cast_info _swigc__p_wxDropFilesEvent[] = { {&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
55147 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
55148 static swig_cast_info _swigc__p_wxEraseEvent[] = { {&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
55149 static swig_cast_info _swigc__p_wxEvent[] = { {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseCaptureLostEvent, _p_wxMouseCaptureLostEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEvent, 0, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxEvent, 0, 0},{0, 0, 0, 0}};
55150 static swig_cast_info _swigc__p_wxEventLoop[] = { {&_swigt__p_wxEventLoop, 0, 0, 0},{0, 0, 0, 0}};
55151 static swig_cast_info _swigc__p_wxEventLoopActivator[] = { {&_swigt__p_wxEventLoopActivator, 0, 0, 0},{0, 0, 0, 0}};
55152 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}};
55153 static swig_cast_info _swigc__p_wxFSFile[] = { {&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
55154 static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
55155 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}};
55156 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}};
55157 static swig_cast_info _swigc__p_wxFocusEvent[] = { {&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
55158 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
55159 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
55160 static swig_cast_info _swigc__p_wxGBPosition[] = { {&_swigt__p_wxGBPosition, 0, 0, 0},{0, 0, 0, 0}};
55161 static swig_cast_info _swigc__p_wxGBSizerItem[] = { {&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
55162 static swig_cast_info _swigc__p_wxGBSpan[] = { {&_swigt__p_wxGBSpan, 0, 0, 0},{0, 0, 0, 0}};
55163 static swig_cast_info _swigc__p_wxGIFHandler[] = { {&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
55164 static swig_cast_info _swigc__p_wxGridBagSizer[] = { {&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
55165 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}};
55166 static swig_cast_info _swigc__p_wxHelpEvent__Origin[] = { {&_swigt__p_wxHelpEvent__Origin, 0, 0, 0},{0, 0, 0, 0}};
55167 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}};
55168 static swig_cast_info _swigc__p_wxIconizeEvent[] = { {&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
55169 static swig_cast_info _swigc__p_wxIdleEvent[] = { {&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
55170 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
55171 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}};
55172 static swig_cast_info _swigc__p_wxImageHistogram[] = { {&_swigt__p_wxImageHistogram, 0, 0, 0},{0, 0, 0, 0}};
55173 static swig_cast_info _swigc__p_wxImage_HSVValue[] = { {&_swigt__p_wxImage_HSVValue, 0, 0, 0},{0, 0, 0, 0}};
55174 static swig_cast_info _swigc__p_wxImage_RGBValue[] = { {&_swigt__p_wxImage_RGBValue, 0, 0, 0},{0, 0, 0, 0}};
55175 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = { {&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
55176 static swig_cast_info _swigc__p_wxInitDialogEvent[] = { {&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
55177 static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
55178 static swig_cast_info _swigc__p_wxInternetFSHandler[] = { {&_swigt__p_wxInternetFSHandler, 0, 0, 0},{0, 0, 0, 0}};
55179 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}};
55180 static swig_cast_info _swigc__p_wxJPEGHandler[] = { {&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
55181 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
55182 static swig_cast_info _swigc__p_wxLayoutConstraints[] = { {&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
55183 static swig_cast_info _swigc__p_wxMaximizeEvent[] = { {&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
55184 static swig_cast_info _swigc__p_wxMemoryFSHandler[] = { {&_swigt__p_wxMemoryFSHandler, 0, 0, 0},{0, 0, 0, 0}};
55185 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
55186 static swig_cast_info _swigc__p_wxMenuBar[] = { {&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
55187 static swig_cast_info _swigc__p_wxMenuBarBase[] = { {&_swigt__p_wxMenuBarBase, 0, 0, 0},{0, 0, 0, 0}};
55188 static swig_cast_info _swigc__p_wxMenuEvent[] = { {&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
55189 static swig_cast_info _swigc__p_wxMenuItem[] = { {&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
55190 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = { {&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
55191 static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = { {&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
55192 static swig_cast_info _swigc__p_wxMouseEvent[] = { {&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
55193 static swig_cast_info _swigc__p_wxMoveEvent[] = { {&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
55194 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = { {&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
55195 static swig_cast_info _swigc__p_wxNcPaintEvent[] = { {&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
55196 static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
55197 static swig_cast_info _swigc__p_wxObject[] = { {&_swigt__p_wxLayoutConstraints, _p_wxLayoutConstraintsTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizerItem, _p_wxSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxGBSizerItem, _p_wxGBSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIndividualLayoutConstraint, _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0}, {&_swigt__p_wxStaticBoxSizer, _p_wxStaticBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBoxSizer, _p_wxBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizer, _p_wxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridBagSizer, _p_wxGridBagSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvent, _p_wxEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFlexGridSizer, _p_wxFlexGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridSizer, _p_wxGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControl, _p_wxControlTo_p_wxObject, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFSFile, _p_wxFSFileTo_p_wxObject, 0, 0}, {&_swigt__p_wxPySizer, _p_wxPySizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuItem, _p_wxMenuItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPCXHandler, _p_wxPCXHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGIFHandler, _p_wxGIFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNGHandler, _p_wxPNGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxCURHandler, _p_wxCURHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxICOHandler, _p_wxICOHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBMPHandler, _p_wxBMPHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyImageHandler, _p_wxPyImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxImageHandler, _p_wxImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxXPMHandler, _p_wxXPMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxTIFFHandler, _p_wxTIFFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvtHandler, _p_wxEvtHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureLostEvent, _p_wxMouseCaptureLostEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNMHandler, _p_wxPNMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxStdDialogButtonSizer, _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxAcceleratorTable, _p_wxAcceleratorTableTo_p_wxObject, 0, 0}, {&_swigt__p_wxImage, _p_wxImageTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxObject, 0, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileSystem, _p_wxFileSystemTo_p_wxObject, 0, 0}, {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxObject, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxObject, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxObject, 0, 0},{0, 0, 0, 0}};
55198 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
55199 static swig_cast_info _swigc__p_wxPCXHandler[] = { {&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
55200 static swig_cast_info _swigc__p_wxPNGHandler[] = { {&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
55201 static swig_cast_info _swigc__p_wxPNMHandler[] = { {&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
55202 static swig_cast_info _swigc__p_wxPaintEvent[] = { {&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
55203 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = { {&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
55204 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
55205 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
55206 static swig_cast_info _swigc__p_wxPoint2D[] = { {&_swigt__p_wxPoint2D, 0, 0, 0},{0, 0, 0, 0}};
55207 static swig_cast_info _swigc__p_wxPropagateOnce[] = { {&_swigt__p_wxPropagateOnce, 0, 0, 0},{0, 0, 0, 0}};
55208 static swig_cast_info _swigc__p_wxPropagationDisabler[] = { {&_swigt__p_wxPropagationDisabler, 0, 0, 0},{0, 0, 0, 0}};
55209 static swig_cast_info _swigc__p_wxPyApp[] = { {&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
55210 static swig_cast_info _swigc__p_wxPyCommandEvent[] = { {&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
55211 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0},{0, 0, 0, 0}};
55212 static swig_cast_info _swigc__p_wxPyEvent[] = { {&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
55213 static swig_cast_info _swigc__p_wxPyFileSystemHandler[] = { {&_swigt__p_wxPyFileSystemHandler, 0, 0, 0},{0, 0, 0, 0}};
55214 static swig_cast_info _swigc__p_wxPyImageHandler[] = { {&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
55215 static swig_cast_info _swigc__p_wxPyInputStream[] = { {&_swigt__p_wxPyInputStream, 0, 0, 0},{0, 0, 0, 0}};
55216 static swig_cast_info _swigc__p_wxPySizer[] = { {&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
55217 static swig_cast_info _swigc__p_wxPyValidator[] = { {&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
55218 static swig_cast_info _swigc__p_wxQuantize[] = { {&_swigt__p_wxQuantize, 0, 0, 0},{0, 0, 0, 0}};
55219 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = { {&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
55220 static swig_cast_info _swigc__p_wxRealPoint[] = { {&_swigt__p_wxRealPoint, 0, 0, 0},{0, 0, 0, 0}};
55221 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
55222 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
55223 static swig_cast_info _swigc__p_wxScrollEvent[] = { {&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
55224 static swig_cast_info _swigc__p_wxScrollWinEvent[] = { {&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
55225 static swig_cast_info _swigc__p_wxSetCursorEvent[] = { {&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
55226 static swig_cast_info _swigc__p_wxShowEvent[] = { {&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
55227 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
55228 static swig_cast_info _swigc__p_wxSizeEvent[] = { {&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
55229 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}};
55230 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}};
55231 static swig_cast_info _swigc__p_wxStaticBox[] = { {&_swigt__p_wxStaticBox, 0, 0, 0},{0, 0, 0, 0}};
55232 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = { {&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
55233 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = { {&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
55234 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = { {&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
55235 static swig_cast_info _swigc__p_wxTIFFHandler[] = { {&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
55236 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
55237 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = { {&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
55238 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}};
55239 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
55240 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}};
55241 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = { {&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
55242 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = { {&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
55243 static swig_cast_info _swigc__p_wxXPMHandler[] = { {&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
55244 static swig_cast_info _swigc__p_wxZipFSHandler[] = { {&_swigt__p_wxZipFSHandler, 0, 0, 0},{0, 0, 0, 0}};
55245
55246 static swig_cast_info *swig_cast_initial[] = {
55247 _swigc__p_buffer,
55248 _swigc__p_char,
55249 _swigc__p_form_ops_t,
55250 _swigc__p_int,
55251 _swigc__p_long,
55252 _swigc__p_unsigned_char,
55253 _swigc__p_unsigned_int,
55254 _swigc__p_unsigned_long,
55255 _swigc__p_wxANIHandler,
55256 _swigc__p_wxAcceleratorEntry,
55257 _swigc__p_wxAcceleratorTable,
55258 _swigc__p_wxActivateEvent,
55259 _swigc__p_wxAppTraits,
55260 _swigc__p_wxArrayString,
55261 _swigc__p_wxBMPHandler,
55262 _swigc__p_wxBitmap,
55263 _swigc__p_wxBoxSizer,
55264 _swigc__p_wxButton,
55265 _swigc__p_wxCURHandler,
55266 _swigc__p_wxCaret,
55267 _swigc__p_wxChildFocusEvent,
55268 _swigc__p_wxClipboardTextEvent,
55269 _swigc__p_wxCloseEvent,
55270 _swigc__p_wxColour,
55271 _swigc__p_wxCommandEvent,
55272 _swigc__p_wxContextMenuEvent,
55273 _swigc__p_wxControl,
55274 _swigc__p_wxControlWithItems,
55275 _swigc__p_wxCursor,
55276 _swigc__p_wxDC,
55277 _swigc__p_wxDateEvent,
55278 _swigc__p_wxDateTime,
55279 _swigc__p_wxDisplayChangedEvent,
55280 _swigc__p_wxDropFilesEvent,
55281 _swigc__p_wxDuplexMode,
55282 _swigc__p_wxEraseEvent,
55283 _swigc__p_wxEvent,
55284 _swigc__p_wxEventLoop,
55285 _swigc__p_wxEventLoopActivator,
55286 _swigc__p_wxEvtHandler,
55287 _swigc__p_wxFSFile,
55288 _swigc__p_wxFileSystem,
55289 _swigc__p_wxFileSystemHandler,
55290 _swigc__p_wxFlexGridSizer,
55291 _swigc__p_wxFocusEvent,
55292 _swigc__p_wxFont,
55293 _swigc__p_wxFrame,
55294 _swigc__p_wxGBPosition,
55295 _swigc__p_wxGBSizerItem,
55296 _swigc__p_wxGBSpan,
55297 _swigc__p_wxGIFHandler,
55298 _swigc__p_wxGridBagSizer,
55299 _swigc__p_wxGridSizer,
55300 _swigc__p_wxHelpEvent__Origin,
55301 _swigc__p_wxICOHandler,
55302 _swigc__p_wxIconizeEvent,
55303 _swigc__p_wxIdleEvent,
55304 _swigc__p_wxImage,
55305 _swigc__p_wxImageHandler,
55306 _swigc__p_wxImageHistogram,
55307 _swigc__p_wxImage_HSVValue,
55308 _swigc__p_wxImage_RGBValue,
55309 _swigc__p_wxIndividualLayoutConstraint,
55310 _swigc__p_wxInitDialogEvent,
55311 _swigc__p_wxInputStream,
55312 _swigc__p_wxInternetFSHandler,
55313 _swigc__p_wxItemContainer,
55314 _swigc__p_wxJPEGHandler,
55315 _swigc__p_wxKeyEvent,
55316 _swigc__p_wxLayoutConstraints,
55317 _swigc__p_wxMaximizeEvent,
55318 _swigc__p_wxMemoryFSHandler,
55319 _swigc__p_wxMenu,
55320 _swigc__p_wxMenuBar,
55321 _swigc__p_wxMenuBarBase,
55322 _swigc__p_wxMenuEvent,
55323 _swigc__p_wxMenuItem,
55324 _swigc__p_wxMouseCaptureChangedEvent,
55325 _swigc__p_wxMouseCaptureLostEvent,
55326 _swigc__p_wxMouseEvent,
55327 _swigc__p_wxMoveEvent,
55328 _swigc__p_wxNavigationKeyEvent,
55329 _swigc__p_wxNcPaintEvent,
55330 _swigc__p_wxNotifyEvent,
55331 _swigc__p_wxObject,
55332 _swigc__p_wxOutputStream,
55333 _swigc__p_wxPCXHandler,
55334 _swigc__p_wxPNGHandler,
55335 _swigc__p_wxPNMHandler,
55336 _swigc__p_wxPaintEvent,
55337 _swigc__p_wxPaletteChangedEvent,
55338 _swigc__p_wxPaperSize,
55339 _swigc__p_wxPoint,
55340 _swigc__p_wxPoint2D,
55341 _swigc__p_wxPropagateOnce,
55342 _swigc__p_wxPropagationDisabler,
55343 _swigc__p_wxPyApp,
55344 _swigc__p_wxPyCommandEvent,
55345 _swigc__p_wxPyDropTarget,
55346 _swigc__p_wxPyEvent,
55347 _swigc__p_wxPyFileSystemHandler,
55348 _swigc__p_wxPyImageHandler,
55349 _swigc__p_wxPyInputStream,
55350 _swigc__p_wxPySizer,
55351 _swigc__p_wxPyValidator,
55352 _swigc__p_wxQuantize,
55353 _swigc__p_wxQueryNewPaletteEvent,
55354 _swigc__p_wxRealPoint,
55355 _swigc__p_wxRect,
55356 _swigc__p_wxRegion,
55357 _swigc__p_wxScrollEvent,
55358 _swigc__p_wxScrollWinEvent,
55359 _swigc__p_wxSetCursorEvent,
55360 _swigc__p_wxShowEvent,
55361 _swigc__p_wxSize,
55362 _swigc__p_wxSizeEvent,
55363 _swigc__p_wxSizer,
55364 _swigc__p_wxSizerItem,
55365 _swigc__p_wxStaticBox,
55366 _swigc__p_wxStaticBoxSizer,
55367 _swigc__p_wxStdDialogButtonSizer,
55368 _swigc__p_wxSysColourChangedEvent,
55369 _swigc__p_wxTIFFHandler,
55370 _swigc__p_wxToolTip,
55371 _swigc__p_wxUpdateUIEvent,
55372 _swigc__p_wxValidator,
55373 _swigc__p_wxVisualAttributes,
55374 _swigc__p_wxWindow,
55375 _swigc__p_wxWindowCreateEvent,
55376 _swigc__p_wxWindowDestroyEvent,
55377 _swigc__p_wxXPMHandler,
55378 _swigc__p_wxZipFSHandler,
55379 };
55380
55381
55382 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
55383
55384 static swig_const_info swig_const_table[] = {
55385 {0, 0, 0, 0.0, 0, 0}};
55386
55387 #ifdef __cplusplus
55388 }
55389 #endif
55390 /* -----------------------------------------------------------------------------
55391 * Type initialization:
55392 * This problem is tough by the requirement that no dynamic
55393 * memory is used. Also, since swig_type_info structures store pointers to
55394 * swig_cast_info structures and swig_cast_info structures store pointers back
55395 * to swig_type_info structures, we need some lookup code at initialization.
55396 * The idea is that swig generates all the structures that are needed.
55397 * The runtime then collects these partially filled structures.
55398 * The SWIG_InitializeModule function takes these initial arrays out of
55399 * swig_module, and does all the lookup, filling in the swig_module.types
55400 * array with the correct data and linking the correct swig_cast_info
55401 * structures together.
55402 *
55403 * The generated swig_type_info structures are assigned staticly to an initial
55404 * array. We just loop though that array, and handle each type individually.
55405 * First we lookup if this type has been already loaded, and if so, use the
55406 * loaded structure instead of the generated one. Then we have to fill in the
55407 * cast linked list. The cast data is initially stored in something like a
55408 * two-dimensional array. Each row corresponds to a type (there are the same
55409 * number of rows as there are in the swig_type_initial array). Each entry in
55410 * a column is one of the swig_cast_info structures for that type.
55411 * The cast_initial array is actually an array of arrays, because each row has
55412 * a variable number of columns. So to actually build the cast linked list,
55413 * we find the array of casts associated with the type, and loop through it
55414 * adding the casts to the list. The one last trick we need to do is making
55415 * sure the type pointer in the swig_cast_info struct is correct.
55416 *
55417 * First off, we lookup the cast->type name to see if it is already loaded.
55418 * There are three cases to handle:
55419 * 1) If the cast->type has already been loaded AND the type we are adding
55420 * casting info to has not been loaded (it is in this module), THEN we
55421 * replace the cast->type pointer with the type pointer that has already
55422 * been loaded.
55423 * 2) If BOTH types (the one we are adding casting info to, and the
55424 * cast->type) are loaded, THEN the cast info has already been loaded by
55425 * the previous module so we just ignore it.
55426 * 3) Finally, if cast->type has not already been loaded, then we add that
55427 * swig_cast_info to the linked list (because the cast->type) pointer will
55428 * be correct.
55429 * ----------------------------------------------------------------------------- */
55430
55431 #ifdef __cplusplus
55432 extern "C" {
55433 #if 0
55434 } /* c-mode */
55435 #endif
55436 #endif
55437
55438 #if 0
55439 #define SWIGRUNTIME_DEBUG
55440 #endif
55441
55442 SWIGRUNTIME void
55443 SWIG_InitializeModule(void *clientdata) {
55444 size_t i;
55445 swig_module_info *module_head;
55446 static int init_run = 0;
55447
55448 clientdata = clientdata;
55449
55450 if (init_run) return;
55451 init_run = 1;
55452
55453 /* Initialize the swig_module */
55454 swig_module.type_initial = swig_type_initial;
55455 swig_module.cast_initial = swig_cast_initial;
55456
55457 /* Try and load any already created modules */
55458 module_head = SWIG_GetModule(clientdata);
55459 if (module_head) {
55460 swig_module.next = module_head->next;
55461 module_head->next = &swig_module;
55462 } else {
55463 /* This is the first module loaded */
55464 swig_module.next = &swig_module;
55465 SWIG_SetModule(clientdata, &swig_module);
55466 }
55467
55468 /* Now work on filling in swig_module.types */
55469 #ifdef SWIGRUNTIME_DEBUG
55470 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
55471 #endif
55472 for (i = 0; i < swig_module.size; ++i) {
55473 swig_type_info *type = 0;
55474 swig_type_info *ret;
55475 swig_cast_info *cast;
55476
55477 #ifdef SWIGRUNTIME_DEBUG
55478 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
55479 #endif
55480
55481 /* if there is another module already loaded */
55482 if (swig_module.next != &swig_module) {
55483 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
55484 }
55485 if (type) {
55486 /* Overwrite clientdata field */
55487 #ifdef SWIGRUNTIME_DEBUG
55488 printf("SWIG_InitializeModule: found type %s\n", type->name);
55489 #endif
55490 if (swig_module.type_initial[i]->clientdata) {
55491 type->clientdata = swig_module.type_initial[i]->clientdata;
55492 #ifdef SWIGRUNTIME_DEBUG
55493 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
55494 #endif
55495 }
55496 } else {
55497 type = swig_module.type_initial[i];
55498 }
55499
55500 /* Insert casting types */
55501 cast = swig_module.cast_initial[i];
55502 while (cast->type) {
55503 /* Don't need to add information already in the list */
55504 ret = 0;
55505 #ifdef SWIGRUNTIME_DEBUG
55506 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
55507 #endif
55508 if (swig_module.next != &swig_module) {
55509 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
55510 #ifdef SWIGRUNTIME_DEBUG
55511 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
55512 #endif
55513 }
55514 if (ret) {
55515 if (type == swig_module.type_initial[i]) {
55516 #ifdef SWIGRUNTIME_DEBUG
55517 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
55518 #endif
55519 cast->type = ret;
55520 ret = 0;
55521 } else {
55522 /* Check for casting already in the list */
55523 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
55524 #ifdef SWIGRUNTIME_DEBUG
55525 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
55526 #endif
55527 if (!ocast) ret = 0;
55528 }
55529 }
55530
55531 if (!ret) {
55532 #ifdef SWIGRUNTIME_DEBUG
55533 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
55534 #endif
55535 if (type->cast) {
55536 type->cast->prev = cast;
55537 cast->next = type->cast;
55538 }
55539 type->cast = cast;
55540 }
55541 cast++;
55542 }
55543 /* Set entry in modules->types array equal to the type */
55544 swig_module.types[i] = type;
55545 }
55546 swig_module.types[i] = 0;
55547
55548 #ifdef SWIGRUNTIME_DEBUG
55549 printf("**** SWIG_InitializeModule: Cast List ******\n");
55550 for (i = 0; i < swig_module.size; ++i) {
55551 int j = 0;
55552 swig_cast_info *cast = swig_module.cast_initial[i];
55553 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
55554 while (cast->type) {
55555 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
55556 cast++;
55557 ++j;
55558 }
55559 printf("---- Total casts: %d\n",j);
55560 }
55561 printf("**** SWIG_InitializeModule: Cast List ******\n");
55562 #endif
55563 }
55564
55565 /* This function will propagate the clientdata field of type to
55566 * any new swig_type_info structures that have been added into the list
55567 * of equivalent types. It is like calling
55568 * SWIG_TypeClientData(type, clientdata) a second time.
55569 */
55570 SWIGRUNTIME void
55571 SWIG_PropagateClientData(void) {
55572 size_t i;
55573 swig_cast_info *equiv;
55574 static int init_run = 0;
55575
55576 if (init_run) return;
55577 init_run = 1;
55578
55579 for (i = 0; i < swig_module.size; i++) {
55580 if (swig_module.types[i]->clientdata) {
55581 equiv = swig_module.types[i]->cast;
55582 while (equiv) {
55583 if (!equiv->converter) {
55584 if (equiv->type && !equiv->type->clientdata)
55585 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
55586 }
55587 equiv = equiv->next;
55588 }
55589 }
55590 }
55591 }
55592
55593 #ifdef __cplusplus
55594 #if 0
55595 {
55596 /* c-mode */
55597 #endif
55598 }
55599 #endif
55600
55601
55602
55603 #ifdef __cplusplus
55604 extern "C" {
55605 #endif
55606
55607 /* Python-specific SWIG API */
55608 #define SWIG_newvarlink() SWIG_Python_newvarlink()
55609 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
55610 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
55611
55612 /* -----------------------------------------------------------------------------
55613 * global variable support code.
55614 * ----------------------------------------------------------------------------- */
55615
55616 typedef struct swig_globalvar {
55617 char *name; /* Name of global variable */
55618 PyObject *(*get_attr)(void); /* Return the current value */
55619 int (*set_attr)(PyObject *); /* Set the value */
55620 struct swig_globalvar *next;
55621 } swig_globalvar;
55622
55623 typedef struct swig_varlinkobject {
55624 PyObject_HEAD
55625 swig_globalvar *vars;
55626 } swig_varlinkobject;
55627
55628 SWIGINTERN PyObject *
55629 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
55630 return PyString_FromString("<Swig global variables>");
55631 }
55632
55633 SWIGINTERN PyObject *
55634 swig_varlink_str(swig_varlinkobject *v) {
55635 PyObject *str = PyString_FromString("(");
55636 swig_globalvar *var;
55637 for (var = v->vars; var; var=var->next) {
55638 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
55639 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
55640 }
55641 PyString_ConcatAndDel(&str,PyString_FromString(")"));
55642 return str;
55643 }
55644
55645 SWIGINTERN int
55646 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
55647 PyObject *str = swig_varlink_str(v);
55648 fprintf(fp,"Swig global variables ");
55649 fprintf(fp,"%s\n", PyString_AsString(str));
55650 Py_DECREF(str);
55651 return 0;
55652 }
55653
55654 SWIGINTERN void
55655 swig_varlink_dealloc(swig_varlinkobject *v) {
55656 swig_globalvar *var = v->vars;
55657 while (var) {
55658 swig_globalvar *n = var->next;
55659 free(var->name);
55660 free(var);
55661 var = n;
55662 }
55663 }
55664
55665 SWIGINTERN PyObject *
55666 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
55667 PyObject *res = NULL;
55668 swig_globalvar *var = v->vars;
55669 while (var) {
55670 if (strcmp(var->name,n) == 0) {
55671 res = (*var->get_attr)();
55672 break;
55673 }
55674 var = var->next;
55675 }
55676 if (res == NULL && !PyErr_Occurred()) {
55677 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
55678 }
55679 return res;
55680 }
55681
55682 SWIGINTERN int
55683 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
55684 int res = 1;
55685 swig_globalvar *var = v->vars;
55686 while (var) {
55687 if (strcmp(var->name,n) == 0) {
55688 res = (*var->set_attr)(p);
55689 break;
55690 }
55691 var = var->next;
55692 }
55693 if (res == 1 && !PyErr_Occurred()) {
55694 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
55695 }
55696 return res;
55697 }
55698
55699 SWIGINTERN PyTypeObject*
55700 swig_varlink_type(void) {
55701 static char varlink__doc__[] = "Swig var link object";
55702 static PyTypeObject varlink_type;
55703 static int type_init = 0;
55704 if (!type_init) {
55705 const PyTypeObject tmp
55706 = {
55707 PyObject_HEAD_INIT(NULL)
55708 0, /* Number of items in variable part (ob_size) */
55709 (char *)"swigvarlink", /* Type name (tp_name) */
55710 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
55711 0, /* Itemsize (tp_itemsize) */
55712 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
55713 (printfunc) swig_varlink_print, /* Print (tp_print) */
55714 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
55715 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
55716 0, /* tp_compare */
55717 (reprfunc) swig_varlink_repr, /* tp_repr */
55718 0, /* tp_as_number */
55719 0, /* tp_as_sequence */
55720 0, /* tp_as_mapping */
55721 0, /* tp_hash */
55722 0, /* tp_call */
55723 (reprfunc)swig_varlink_str, /* tp_str */
55724 0, /* tp_getattro */
55725 0, /* tp_setattro */
55726 0, /* tp_as_buffer */
55727 0, /* tp_flags */
55728 varlink__doc__, /* tp_doc */
55729 0, /* tp_traverse */
55730 0, /* tp_clear */
55731 0, /* tp_richcompare */
55732 0, /* tp_weaklistoffset */
55733 #if PY_VERSION_HEX >= 0x02020000
55734 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
55735 #endif
55736 #if PY_VERSION_HEX >= 0x02030000
55737 0, /* tp_del */
55738 #endif
55739 #ifdef COUNT_ALLOCS
55740 0,0,0,0 /* tp_alloc -> tp_next */
55741 #endif
55742 };
55743 varlink_type = tmp;
55744 varlink_type.ob_type = &PyType_Type;
55745 type_init = 1;
55746 }
55747 return &varlink_type;
55748 }
55749
55750 /* Create a variable linking object for use later */
55751 SWIGINTERN PyObject *
55752 SWIG_Python_newvarlink(void) {
55753 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
55754 if (result) {
55755 result->vars = 0;
55756 }
55757 return ((PyObject*) result);
55758 }
55759
55760 SWIGINTERN void
55761 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
55762 swig_varlinkobject *v = (swig_varlinkobject *) p;
55763 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
55764 if (gv) {
55765 size_t size = strlen(name)+1;
55766 gv->name = (char *)malloc(size);
55767 if (gv->name) {
55768 strncpy(gv->name,name,size);
55769 gv->get_attr = get_attr;
55770 gv->set_attr = set_attr;
55771 gv->next = v->vars;
55772 }
55773 }
55774 v->vars = gv;
55775 }
55776
55777 SWIGINTERN PyObject *
55778 SWIG_globals() {
55779 static PyObject *_SWIG_globals = 0;
55780 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
55781 return _SWIG_globals;
55782 }
55783
55784 /* -----------------------------------------------------------------------------
55785 * constants/methods manipulation
55786 * ----------------------------------------------------------------------------- */
55787
55788 /* Install Constants */
55789 SWIGINTERN void
55790 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
55791 PyObject *obj = 0;
55792 size_t i;
55793 for (i = 0; constants[i].type; ++i) {
55794 switch(constants[i].type) {
55795 case SWIG_PY_POINTER:
55796 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
55797 break;
55798 case SWIG_PY_BINARY:
55799 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
55800 break;
55801 default:
55802 obj = 0;
55803 break;
55804 }
55805 if (obj) {
55806 PyDict_SetItemString(d, constants[i].name, obj);
55807 Py_DECREF(obj);
55808 }
55809 }
55810 }
55811
55812 /* -----------------------------------------------------------------------------*/
55813 /* Fix SwigMethods to carry the callback ptrs when needed */
55814 /* -----------------------------------------------------------------------------*/
55815
55816 SWIGINTERN void
55817 SWIG_Python_FixMethods(PyMethodDef *methods,
55818 swig_const_info *const_table,
55819 swig_type_info **types,
55820 swig_type_info **types_initial) {
55821 size_t i;
55822 for (i = 0; methods[i].ml_name; ++i) {
55823 const char *c = methods[i].ml_doc;
55824 if (c && (c = strstr(c, "swig_ptr: "))) {
55825 int j;
55826 swig_const_info *ci = 0;
55827 const char *name = c + 10;
55828 for (j = 0; const_table[j].type; ++j) {
55829 if (strncmp(const_table[j].name, name,
55830 strlen(const_table[j].name)) == 0) {
55831 ci = &(const_table[j]);
55832 break;
55833 }
55834 }
55835 if (ci) {
55836 size_t shift = (ci->ptype) - types;
55837 swig_type_info *ty = types_initial[shift];
55838 size_t ldoc = (c - methods[i].ml_doc);
55839 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
55840 char *ndoc = (char*)malloc(ldoc + lptr + 10);
55841 if (ndoc) {
55842 char *buff = ndoc;
55843 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
55844 if (ptr) {
55845 strncpy(buff, methods[i].ml_doc, ldoc);
55846 buff += ldoc;
55847 strncpy(buff, "swig_ptr: ", 10);
55848 buff += 10;
55849 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
55850 methods[i].ml_doc = ndoc;
55851 }
55852 }
55853 }
55854 }
55855 }
55856 }
55857
55858 #ifdef __cplusplus
55859 }
55860 #endif
55861
55862 /* -----------------------------------------------------------------------------*
55863 * Partial Init method
55864 * -----------------------------------------------------------------------------*/
55865
55866 #ifdef __cplusplus
55867 extern "C"
55868 #endif
55869 SWIGEXPORT void SWIG_init(void) {
55870 PyObject *m, *d;
55871
55872 /* Fix SwigMethods to carry the callback ptrs when needed */
55873 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
55874
55875 m = Py_InitModule((char *) SWIG_name, SwigMethods);
55876 d = PyModule_GetDict(m);
55877
55878 SWIG_InitializeModule(0);
55879 SWIG_InstallConstants(d,swig_const_table);
55880
55881
55882
55883 #ifndef wxPyUSE_EXPORT
55884 // Make our API structure a CObject so other modules can import it
55885 // from this module.
55886 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
55887 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
55888 Py_XDECREF(cobj);
55889 #endif
55890
55891 SWIG_Python_SetConstant(d, "NOT_FOUND",SWIG_From_int(static_cast< int >(wxNOT_FOUND)));
55892 SWIG_Python_SetConstant(d, "VSCROLL",SWIG_From_int(static_cast< int >(wxVSCROLL)));
55893 SWIG_Python_SetConstant(d, "HSCROLL",SWIG_From_int(static_cast< int >(wxHSCROLL)));
55894 SWIG_Python_SetConstant(d, "CAPTION",SWIG_From_int(static_cast< int >(wxCAPTION)));
55895 SWIG_Python_SetConstant(d, "DOUBLE_BORDER",SWIG_From_int(static_cast< int >(wxDOUBLE_BORDER)));
55896 SWIG_Python_SetConstant(d, "SUNKEN_BORDER",SWIG_From_int(static_cast< int >(wxSUNKEN_BORDER)));
55897 SWIG_Python_SetConstant(d, "RAISED_BORDER",SWIG_From_int(static_cast< int >(wxRAISED_BORDER)));
55898 SWIG_Python_SetConstant(d, "BORDER",SWIG_From_int(static_cast< int >(wxBORDER)));
55899 SWIG_Python_SetConstant(d, "SIMPLE_BORDER",SWIG_From_int(static_cast< int >(wxSIMPLE_BORDER)));
55900 SWIG_Python_SetConstant(d, "STATIC_BORDER",SWIG_From_int(static_cast< int >(wxSTATIC_BORDER)));
55901 SWIG_Python_SetConstant(d, "TRANSPARENT_WINDOW",SWIG_From_int(static_cast< int >(wxTRANSPARENT_WINDOW)));
55902 SWIG_Python_SetConstant(d, "NO_BORDER",SWIG_From_int(static_cast< int >(wxNO_BORDER)));
55903 SWIG_Python_SetConstant(d, "DEFAULT_CONTROL_BORDER",SWIG_From_int(static_cast< int >(wxDEFAULT_CONTROL_BORDER)));
55904 SWIG_Python_SetConstant(d, "DEFAULT_STATUSBAR_STYLE",SWIG_From_int(static_cast< int >(wxDEFAULT_STATUSBAR_STYLE)));
55905 SWIG_Python_SetConstant(d, "TAB_TRAVERSAL",SWIG_From_int(static_cast< int >(wxTAB_TRAVERSAL)));
55906 SWIG_Python_SetConstant(d, "WANTS_CHARS",SWIG_From_int(static_cast< int >(wxWANTS_CHARS)));
55907 SWIG_Python_SetConstant(d, "POPUP_WINDOW",SWIG_From_int(static_cast< int >(wxPOPUP_WINDOW)));
55908 SWIG_Python_SetConstant(d, "CENTER_FRAME",SWIG_From_int(static_cast< int >(wxCENTER_FRAME)));
55909 SWIG_Python_SetConstant(d, "CENTRE_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTRE_ON_SCREEN)));
55910 SWIG_Python_SetConstant(d, "CENTER_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTER_ON_SCREEN)));
55911 SWIG_Python_SetConstant(d, "CLIP_CHILDREN",SWIG_From_int(static_cast< int >(wxCLIP_CHILDREN)));
55912 SWIG_Python_SetConstant(d, "CLIP_SIBLINGS",SWIG_From_int(static_cast< int >(wxCLIP_SIBLINGS)));
55913 SWIG_Python_SetConstant(d, "WINDOW_STYLE_MASK",SWIG_From_int(static_cast< int >(wxWINDOW_STYLE_MASK)));
55914 SWIG_Python_SetConstant(d, "ALWAYS_SHOW_SB",SWIG_From_int(static_cast< int >(wxALWAYS_SHOW_SB)));
55915 SWIG_Python_SetConstant(d, "RETAINED",SWIG_From_int(static_cast< int >(wxRETAINED)));
55916 SWIG_Python_SetConstant(d, "BACKINGSTORE",SWIG_From_int(static_cast< int >(wxBACKINGSTORE)));
55917 SWIG_Python_SetConstant(d, "COLOURED",SWIG_From_int(static_cast< int >(wxCOLOURED)));
55918 SWIG_Python_SetConstant(d, "FIXED_LENGTH",SWIG_From_int(static_cast< int >(wxFIXED_LENGTH)));
55919 SWIG_Python_SetConstant(d, "LB_NEEDED_SB",SWIG_From_int(static_cast< int >(wxLB_NEEDED_SB)));
55920 SWIG_Python_SetConstant(d, "LB_ALWAYS_SB",SWIG_From_int(static_cast< int >(wxLB_ALWAYS_SB)));
55921 SWIG_Python_SetConstant(d, "LB_SORT",SWIG_From_int(static_cast< int >(wxLB_SORT)));
55922 SWIG_Python_SetConstant(d, "LB_SINGLE",SWIG_From_int(static_cast< int >(wxLB_SINGLE)));
55923 SWIG_Python_SetConstant(d, "LB_MULTIPLE",SWIG_From_int(static_cast< int >(wxLB_MULTIPLE)));
55924 SWIG_Python_SetConstant(d, "LB_EXTENDED",SWIG_From_int(static_cast< int >(wxLB_EXTENDED)));
55925 SWIG_Python_SetConstant(d, "LB_OWNERDRAW",SWIG_From_int(static_cast< int >(wxLB_OWNERDRAW)));
55926 SWIG_Python_SetConstant(d, "LB_HSCROLL",SWIG_From_int(static_cast< int >(wxLB_HSCROLL)));
55927 SWIG_Python_SetConstant(d, "PROCESS_ENTER",SWIG_From_int(static_cast< int >(wxPROCESS_ENTER)));
55928 SWIG_Python_SetConstant(d, "PASSWORD",SWIG_From_int(static_cast< int >(wxPASSWORD)));
55929 SWIG_Python_SetConstant(d, "CB_SIMPLE",SWIG_From_int(static_cast< int >(wxCB_SIMPLE)));
55930 SWIG_Python_SetConstant(d, "CB_DROPDOWN",SWIG_From_int(static_cast< int >(wxCB_DROPDOWN)));
55931 SWIG_Python_SetConstant(d, "CB_SORT",SWIG_From_int(static_cast< int >(wxCB_SORT)));
55932 SWIG_Python_SetConstant(d, "CB_READONLY",SWIG_From_int(static_cast< int >(wxCB_READONLY)));
55933 SWIG_Python_SetConstant(d, "RA_HORIZONTAL",SWIG_From_int(static_cast< int >(wxRA_HORIZONTAL)));
55934 SWIG_Python_SetConstant(d, "RA_VERTICAL",SWIG_From_int(static_cast< int >(wxRA_VERTICAL)));
55935 SWIG_Python_SetConstant(d, "RA_SPECIFY_ROWS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_ROWS)));
55936 SWIG_Python_SetConstant(d, "RA_SPECIFY_COLS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_COLS)));
55937 SWIG_Python_SetConstant(d, "RA_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRA_USE_CHECKBOX)));
55938 SWIG_Python_SetConstant(d, "RB_GROUP",SWIG_From_int(static_cast< int >(wxRB_GROUP)));
55939 SWIG_Python_SetConstant(d, "RB_SINGLE",SWIG_From_int(static_cast< int >(wxRB_SINGLE)));
55940 SWIG_Python_SetConstant(d, "SB_HORIZONTAL",SWIG_From_int(static_cast< int >(wxSB_HORIZONTAL)));
55941 SWIG_Python_SetConstant(d, "SB_VERTICAL",SWIG_From_int(static_cast< int >(wxSB_VERTICAL)));
55942 SWIG_Python_SetConstant(d, "RB_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRB_USE_CHECKBOX)));
55943 SWIG_Python_SetConstant(d, "ST_SIZEGRIP",SWIG_From_int(static_cast< int >(wxST_SIZEGRIP)));
55944 SWIG_Python_SetConstant(d, "ST_NO_AUTORESIZE",SWIG_From_int(static_cast< int >(wxST_NO_AUTORESIZE)));
55945 SWIG_Python_SetConstant(d, "ST_DOTS_MIDDLE",SWIG_From_int(static_cast< int >(wxST_DOTS_MIDDLE)));
55946 SWIG_Python_SetConstant(d, "ST_DOTS_END",SWIG_From_int(static_cast< int >(wxST_DOTS_END)));
55947 SWIG_Python_SetConstant(d, "FLOOD_SURFACE",SWIG_From_int(static_cast< int >(wxFLOOD_SURFACE)));
55948 SWIG_Python_SetConstant(d, "FLOOD_BORDER",SWIG_From_int(static_cast< int >(wxFLOOD_BORDER)));
55949 SWIG_Python_SetConstant(d, "ODDEVEN_RULE",SWIG_From_int(static_cast< int >(wxODDEVEN_RULE)));
55950 SWIG_Python_SetConstant(d, "WINDING_RULE",SWIG_From_int(static_cast< int >(wxWINDING_RULE)));
55951 SWIG_Python_SetConstant(d, "TOOL_TOP",SWIG_From_int(static_cast< int >(wxTOOL_TOP)));
55952 SWIG_Python_SetConstant(d, "TOOL_BOTTOM",SWIG_From_int(static_cast< int >(wxTOOL_BOTTOM)));
55953 SWIG_Python_SetConstant(d, "TOOL_LEFT",SWIG_From_int(static_cast< int >(wxTOOL_LEFT)));
55954 SWIG_Python_SetConstant(d, "TOOL_RIGHT",SWIG_From_int(static_cast< int >(wxTOOL_RIGHT)));
55955 SWIG_Python_SetConstant(d, "OK",SWIG_From_int(static_cast< int >(wxOK)));
55956 SWIG_Python_SetConstant(d, "YES_NO",SWIG_From_int(static_cast< int >(wxYES_NO)));
55957 SWIG_Python_SetConstant(d, "CANCEL",SWIG_From_int(static_cast< int >(wxCANCEL)));
55958 SWIG_Python_SetConstant(d, "YES",SWIG_From_int(static_cast< int >(wxYES)));
55959 SWIG_Python_SetConstant(d, "NO",SWIG_From_int(static_cast< int >(wxNO)));
55960 SWIG_Python_SetConstant(d, "NO_DEFAULT",SWIG_From_int(static_cast< int >(wxNO_DEFAULT)));
55961 SWIG_Python_SetConstant(d, "YES_DEFAULT",SWIG_From_int(static_cast< int >(wxYES_DEFAULT)));
55962 SWIG_Python_SetConstant(d, "ICON_EXCLAMATION",SWIG_From_int(static_cast< int >(wxICON_EXCLAMATION)));
55963 SWIG_Python_SetConstant(d, "ICON_HAND",SWIG_From_int(static_cast< int >(wxICON_HAND)));
55964 SWIG_Python_SetConstant(d, "ICON_QUESTION",SWIG_From_int(static_cast< int >(wxICON_QUESTION)));
55965 SWIG_Python_SetConstant(d, "ICON_INFORMATION",SWIG_From_int(static_cast< int >(wxICON_INFORMATION)));
55966 SWIG_Python_SetConstant(d, "ICON_STOP",SWIG_From_int(static_cast< int >(wxICON_STOP)));
55967 SWIG_Python_SetConstant(d, "ICON_ASTERISK",SWIG_From_int(static_cast< int >(wxICON_ASTERISK)));
55968 SWIG_Python_SetConstant(d, "ICON_MASK",SWIG_From_int(static_cast< int >(wxICON_MASK)));
55969 SWIG_Python_SetConstant(d, "ICON_WARNING",SWIG_From_int(static_cast< int >(wxICON_WARNING)));
55970 SWIG_Python_SetConstant(d, "ICON_ERROR",SWIG_From_int(static_cast< int >(wxICON_ERROR)));
55971 SWIG_Python_SetConstant(d, "FORWARD",SWIG_From_int(static_cast< int >(wxFORWARD)));
55972 SWIG_Python_SetConstant(d, "BACKWARD",SWIG_From_int(static_cast< int >(wxBACKWARD)));
55973 SWIG_Python_SetConstant(d, "RESET",SWIG_From_int(static_cast< int >(wxRESET)));
55974 SWIG_Python_SetConstant(d, "HELP",SWIG_From_int(static_cast< int >(wxHELP)));
55975 SWIG_Python_SetConstant(d, "MORE",SWIG_From_int(static_cast< int >(wxMORE)));
55976 SWIG_Python_SetConstant(d, "SETUP",SWIG_From_int(static_cast< int >(wxSETUP)));
55977 SWIG_Python_SetConstant(d, "SIZE_AUTO_WIDTH",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_WIDTH)));
55978 SWIG_Python_SetConstant(d, "SIZE_AUTO_HEIGHT",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_HEIGHT)));
55979 SWIG_Python_SetConstant(d, "SIZE_AUTO",SWIG_From_int(static_cast< int >(wxSIZE_AUTO)));
55980 SWIG_Python_SetConstant(d, "SIZE_USE_EXISTING",SWIG_From_int(static_cast< int >(wxSIZE_USE_EXISTING)));
55981 SWIG_Python_SetConstant(d, "SIZE_ALLOW_MINUS_ONE",SWIG_From_int(static_cast< int >(wxSIZE_ALLOW_MINUS_ONE)));
55982 SWIG_Python_SetConstant(d, "SIZE_FORCE",SWIG_From_int(static_cast< int >(wxSIZE_FORCE)));
55983 SWIG_Python_SetConstant(d, "PORTRAIT",SWIG_From_int(static_cast< int >(wxPORTRAIT)));
55984 SWIG_Python_SetConstant(d, "LANDSCAPE",SWIG_From_int(static_cast< int >(wxLANDSCAPE)));
55985 SWIG_Python_SetConstant(d, "PRINT_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_HIGH)));
55986 SWIG_Python_SetConstant(d, "PRINT_QUALITY_MEDIUM",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_MEDIUM)));
55987 SWIG_Python_SetConstant(d, "PRINT_QUALITY_LOW",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_LOW)));
55988 SWIG_Python_SetConstant(d, "PRINT_QUALITY_DRAFT",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_DRAFT)));
55989 SWIG_Python_SetConstant(d, "ID_ANY",SWIG_From_int(static_cast< int >(wxID_ANY)));
55990 SWIG_Python_SetConstant(d, "ID_SEPARATOR",SWIG_From_int(static_cast< int >(wxID_SEPARATOR)));
55991 SWIG_Python_SetConstant(d, "ID_NONE",SWIG_From_int(static_cast< int >(wxID_NONE)));
55992 SWIG_Python_SetConstant(d, "ID_LOWEST",SWIG_From_int(static_cast< int >(wxID_LOWEST)));
55993 SWIG_Python_SetConstant(d, "ID_OPEN",SWIG_From_int(static_cast< int >(wxID_OPEN)));
55994 SWIG_Python_SetConstant(d, "ID_CLOSE",SWIG_From_int(static_cast< int >(wxID_CLOSE)));
55995 SWIG_Python_SetConstant(d, "ID_NEW",SWIG_From_int(static_cast< int >(wxID_NEW)));
55996 SWIG_Python_SetConstant(d, "ID_SAVE",SWIG_From_int(static_cast< int >(wxID_SAVE)));
55997 SWIG_Python_SetConstant(d, "ID_SAVEAS",SWIG_From_int(static_cast< int >(wxID_SAVEAS)));
55998 SWIG_Python_SetConstant(d, "ID_REVERT",SWIG_From_int(static_cast< int >(wxID_REVERT)));
55999 SWIG_Python_SetConstant(d, "ID_EXIT",SWIG_From_int(static_cast< int >(wxID_EXIT)));
56000 SWIG_Python_SetConstant(d, "ID_UNDO",SWIG_From_int(static_cast< int >(wxID_UNDO)));
56001 SWIG_Python_SetConstant(d, "ID_REDO",SWIG_From_int(static_cast< int >(wxID_REDO)));
56002 SWIG_Python_SetConstant(d, "ID_HELP",SWIG_From_int(static_cast< int >(wxID_HELP)));
56003 SWIG_Python_SetConstant(d, "ID_PRINT",SWIG_From_int(static_cast< int >(wxID_PRINT)));
56004 SWIG_Python_SetConstant(d, "ID_PRINT_SETUP",SWIG_From_int(static_cast< int >(wxID_PRINT_SETUP)));
56005 SWIG_Python_SetConstant(d, "ID_PREVIEW",SWIG_From_int(static_cast< int >(wxID_PREVIEW)));
56006 SWIG_Python_SetConstant(d, "ID_ABOUT",SWIG_From_int(static_cast< int >(wxID_ABOUT)));
56007 SWIG_Python_SetConstant(d, "ID_HELP_CONTENTS",SWIG_From_int(static_cast< int >(wxID_HELP_CONTENTS)));
56008 SWIG_Python_SetConstant(d, "ID_HELP_COMMANDS",SWIG_From_int(static_cast< int >(wxID_HELP_COMMANDS)));
56009 SWIG_Python_SetConstant(d, "ID_HELP_PROCEDURES",SWIG_From_int(static_cast< int >(wxID_HELP_PROCEDURES)));
56010 SWIG_Python_SetConstant(d, "ID_HELP_CONTEXT",SWIG_From_int(static_cast< int >(wxID_HELP_CONTEXT)));
56011 SWIG_Python_SetConstant(d, "ID_HELP_INDEX",SWIG_From_int(static_cast< int >(wxID_HELP_INDEX)));
56012 SWIG_Python_SetConstant(d, "ID_HELP_SEARCH",SWIG_From_int(static_cast< int >(wxID_HELP_SEARCH)));
56013 SWIG_Python_SetConstant(d, "ID_CLOSE_ALL",SWIG_From_int(static_cast< int >(wxID_CLOSE_ALL)));
56014 SWIG_Python_SetConstant(d, "ID_PREFERENCES",SWIG_From_int(static_cast< int >(wxID_PREFERENCES)));
56015 SWIG_Python_SetConstant(d, "ID_CUT",SWIG_From_int(static_cast< int >(wxID_CUT)));
56016 SWIG_Python_SetConstant(d, "ID_COPY",SWIG_From_int(static_cast< int >(wxID_COPY)));
56017 SWIG_Python_SetConstant(d, "ID_PASTE",SWIG_From_int(static_cast< int >(wxID_PASTE)));
56018 SWIG_Python_SetConstant(d, "ID_CLEAR",SWIG_From_int(static_cast< int >(wxID_CLEAR)));
56019 SWIG_Python_SetConstant(d, "ID_FIND",SWIG_From_int(static_cast< int >(wxID_FIND)));
56020 SWIG_Python_SetConstant(d, "ID_DUPLICATE",SWIG_From_int(static_cast< int >(wxID_DUPLICATE)));
56021 SWIG_Python_SetConstant(d, "ID_SELECTALL",SWIG_From_int(static_cast< int >(wxID_SELECTALL)));
56022 SWIG_Python_SetConstant(d, "ID_DELETE",SWIG_From_int(static_cast< int >(wxID_DELETE)));
56023 SWIG_Python_SetConstant(d, "ID_REPLACE",SWIG_From_int(static_cast< int >(wxID_REPLACE)));
56024 SWIG_Python_SetConstant(d, "ID_REPLACE_ALL",SWIG_From_int(static_cast< int >(wxID_REPLACE_ALL)));
56025 SWIG_Python_SetConstant(d, "ID_PROPERTIES",SWIG_From_int(static_cast< int >(wxID_PROPERTIES)));
56026 SWIG_Python_SetConstant(d, "ID_VIEW_DETAILS",SWIG_From_int(static_cast< int >(wxID_VIEW_DETAILS)));
56027 SWIG_Python_SetConstant(d, "ID_VIEW_LARGEICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_LARGEICONS)));
56028 SWIG_Python_SetConstant(d, "ID_VIEW_SMALLICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_SMALLICONS)));
56029 SWIG_Python_SetConstant(d, "ID_VIEW_LIST",SWIG_From_int(static_cast< int >(wxID_VIEW_LIST)));
56030 SWIG_Python_SetConstant(d, "ID_VIEW_SORTDATE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTDATE)));
56031 SWIG_Python_SetConstant(d, "ID_VIEW_SORTNAME",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTNAME)));
56032 SWIG_Python_SetConstant(d, "ID_VIEW_SORTSIZE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTSIZE)));
56033 SWIG_Python_SetConstant(d, "ID_VIEW_SORTTYPE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTTYPE)));
56034 SWIG_Python_SetConstant(d, "ID_FILE1",SWIG_From_int(static_cast< int >(wxID_FILE1)));
56035 SWIG_Python_SetConstant(d, "ID_FILE2",SWIG_From_int(static_cast< int >(wxID_FILE2)));
56036 SWIG_Python_SetConstant(d, "ID_FILE3",SWIG_From_int(static_cast< int >(wxID_FILE3)));
56037 SWIG_Python_SetConstant(d, "ID_FILE4",SWIG_From_int(static_cast< int >(wxID_FILE4)));
56038 SWIG_Python_SetConstant(d, "ID_FILE5",SWIG_From_int(static_cast< int >(wxID_FILE5)));
56039 SWIG_Python_SetConstant(d, "ID_FILE6",SWIG_From_int(static_cast< int >(wxID_FILE6)));
56040 SWIG_Python_SetConstant(d, "ID_FILE7",SWIG_From_int(static_cast< int >(wxID_FILE7)));
56041 SWIG_Python_SetConstant(d, "ID_FILE8",SWIG_From_int(static_cast< int >(wxID_FILE8)));
56042 SWIG_Python_SetConstant(d, "ID_FILE9",SWIG_From_int(static_cast< int >(wxID_FILE9)));
56043 SWIG_Python_SetConstant(d, "ID_OK",SWIG_From_int(static_cast< int >(wxID_OK)));
56044 SWIG_Python_SetConstant(d, "ID_CANCEL",SWIG_From_int(static_cast< int >(wxID_CANCEL)));
56045 SWIG_Python_SetConstant(d, "ID_APPLY",SWIG_From_int(static_cast< int >(wxID_APPLY)));
56046 SWIG_Python_SetConstant(d, "ID_YES",SWIG_From_int(static_cast< int >(wxID_YES)));
56047 SWIG_Python_SetConstant(d, "ID_NO",SWIG_From_int(static_cast< int >(wxID_NO)));
56048 SWIG_Python_SetConstant(d, "ID_STATIC",SWIG_From_int(static_cast< int >(wxID_STATIC)));
56049 SWIG_Python_SetConstant(d, "ID_FORWARD",SWIG_From_int(static_cast< int >(wxID_FORWARD)));
56050 SWIG_Python_SetConstant(d, "ID_BACKWARD",SWIG_From_int(static_cast< int >(wxID_BACKWARD)));
56051 SWIG_Python_SetConstant(d, "ID_DEFAULT",SWIG_From_int(static_cast< int >(wxID_DEFAULT)));
56052 SWIG_Python_SetConstant(d, "ID_MORE",SWIG_From_int(static_cast< int >(wxID_MORE)));
56053 SWIG_Python_SetConstant(d, "ID_SETUP",SWIG_From_int(static_cast< int >(wxID_SETUP)));
56054 SWIG_Python_SetConstant(d, "ID_RESET",SWIG_From_int(static_cast< int >(wxID_RESET)));
56055 SWIG_Python_SetConstant(d, "ID_CONTEXT_HELP",SWIG_From_int(static_cast< int >(wxID_CONTEXT_HELP)));
56056 SWIG_Python_SetConstant(d, "ID_YESTOALL",SWIG_From_int(static_cast< int >(wxID_YESTOALL)));
56057 SWIG_Python_SetConstant(d, "ID_NOTOALL",SWIG_From_int(static_cast< int >(wxID_NOTOALL)));
56058 SWIG_Python_SetConstant(d, "ID_ABORT",SWIG_From_int(static_cast< int >(wxID_ABORT)));
56059 SWIG_Python_SetConstant(d, "ID_RETRY",SWIG_From_int(static_cast< int >(wxID_RETRY)));
56060 SWIG_Python_SetConstant(d, "ID_IGNORE",SWIG_From_int(static_cast< int >(wxID_IGNORE)));
56061 SWIG_Python_SetConstant(d, "ID_ADD",SWIG_From_int(static_cast< int >(wxID_ADD)));
56062 SWIG_Python_SetConstant(d, "ID_REMOVE",SWIG_From_int(static_cast< int >(wxID_REMOVE)));
56063 SWIG_Python_SetConstant(d, "ID_UP",SWIG_From_int(static_cast< int >(wxID_UP)));
56064 SWIG_Python_SetConstant(d, "ID_DOWN",SWIG_From_int(static_cast< int >(wxID_DOWN)));
56065 SWIG_Python_SetConstant(d, "ID_HOME",SWIG_From_int(static_cast< int >(wxID_HOME)));
56066 SWIG_Python_SetConstant(d, "ID_REFRESH",SWIG_From_int(static_cast< int >(wxID_REFRESH)));
56067 SWIG_Python_SetConstant(d, "ID_STOP",SWIG_From_int(static_cast< int >(wxID_STOP)));
56068 SWIG_Python_SetConstant(d, "ID_INDEX",SWIG_From_int(static_cast< int >(wxID_INDEX)));
56069 SWIG_Python_SetConstant(d, "ID_BOLD",SWIG_From_int(static_cast< int >(wxID_BOLD)));
56070 SWIG_Python_SetConstant(d, "ID_ITALIC",SWIG_From_int(static_cast< int >(wxID_ITALIC)));
56071 SWIG_Python_SetConstant(d, "ID_JUSTIFY_CENTER",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_CENTER)));
56072 SWIG_Python_SetConstant(d, "ID_JUSTIFY_FILL",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_FILL)));
56073 SWIG_Python_SetConstant(d, "ID_JUSTIFY_RIGHT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_RIGHT)));
56074 SWIG_Python_SetConstant(d, "ID_JUSTIFY_LEFT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_LEFT)));
56075 SWIG_Python_SetConstant(d, "ID_UNDERLINE",SWIG_From_int(static_cast< int >(wxID_UNDERLINE)));
56076 SWIG_Python_SetConstant(d, "ID_INDENT",SWIG_From_int(static_cast< int >(wxID_INDENT)));
56077 SWIG_Python_SetConstant(d, "ID_UNINDENT",SWIG_From_int(static_cast< int >(wxID_UNINDENT)));
56078 SWIG_Python_SetConstant(d, "ID_ZOOM_100",SWIG_From_int(static_cast< int >(wxID_ZOOM_100)));
56079 SWIG_Python_SetConstant(d, "ID_ZOOM_FIT",SWIG_From_int(static_cast< int >(wxID_ZOOM_FIT)));
56080 SWIG_Python_SetConstant(d, "ID_ZOOM_IN",SWIG_From_int(static_cast< int >(wxID_ZOOM_IN)));
56081 SWIG_Python_SetConstant(d, "ID_ZOOM_OUT",SWIG_From_int(static_cast< int >(wxID_ZOOM_OUT)));
56082 SWIG_Python_SetConstant(d, "ID_UNDELETE",SWIG_From_int(static_cast< int >(wxID_UNDELETE)));
56083 SWIG_Python_SetConstant(d, "ID_REVERT_TO_SAVED",SWIG_From_int(static_cast< int >(wxID_REVERT_TO_SAVED)));
56084 SWIG_Python_SetConstant(d, "ID_HIGHEST",SWIG_From_int(static_cast< int >(wxID_HIGHEST)));
56085 SWIG_Python_SetConstant(d, "ACCEL_ALT",SWIG_From_int(static_cast< int >(wxACCEL_ALT)));
56086 SWIG_Python_SetConstant(d, "ACCEL_CTRL",SWIG_From_int(static_cast< int >(wxACCEL_CTRL)));
56087 SWIG_Python_SetConstant(d, "ACCEL_SHIFT",SWIG_From_int(static_cast< int >(wxACCEL_SHIFT)));
56088 SWIG_Python_SetConstant(d, "ACCEL_NORMAL",SWIG_From_int(static_cast< int >(wxACCEL_NORMAL)));
56089 SWIG_Python_SetConstant(d, "PD_AUTO_HIDE",SWIG_From_int(static_cast< int >(wxPD_AUTO_HIDE)));
56090 SWIG_Python_SetConstant(d, "PD_APP_MODAL",SWIG_From_int(static_cast< int >(wxPD_APP_MODAL)));
56091 SWIG_Python_SetConstant(d, "PD_CAN_ABORT",SWIG_From_int(static_cast< int >(wxPD_CAN_ABORT)));
56092 SWIG_Python_SetConstant(d, "PD_ELAPSED_TIME",SWIG_From_int(static_cast< int >(wxPD_ELAPSED_TIME)));
56093 SWIG_Python_SetConstant(d, "PD_ESTIMATED_TIME",SWIG_From_int(static_cast< int >(wxPD_ESTIMATED_TIME)));
56094 SWIG_Python_SetConstant(d, "PD_REMAINING_TIME",SWIG_From_int(static_cast< int >(wxPD_REMAINING_TIME)));
56095 SWIG_Python_SetConstant(d, "PD_SMOOTH",SWIG_From_int(static_cast< int >(wxPD_SMOOTH)));
56096 SWIG_Python_SetConstant(d, "PD_CAN_SKIP",SWIG_From_int(static_cast< int >(wxPD_CAN_SKIP)));
56097 SWIG_Python_SetConstant(d, "MENU_TEAROFF",SWIG_From_int(static_cast< int >(wxMENU_TEAROFF)));
56098 SWIG_Python_SetConstant(d, "MB_DOCKABLE",SWIG_From_int(static_cast< int >(wxMB_DOCKABLE)));
56099 SWIG_Python_SetConstant(d, "NO_FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxNO_FULL_REPAINT_ON_RESIZE)));
56100 SWIG_Python_SetConstant(d, "FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxFULL_REPAINT_ON_RESIZE)));
56101 SWIG_Python_SetConstant(d, "LI_HORIZONTAL",SWIG_From_int(static_cast< int >(wxLI_HORIZONTAL)));
56102 SWIG_Python_SetConstant(d, "LI_VERTICAL",SWIG_From_int(static_cast< int >(wxLI_VERTICAL)));
56103 SWIG_Python_SetConstant(d, "WS_EX_VALIDATE_RECURSIVELY",SWIG_From_int(static_cast< int >(wxWS_EX_VALIDATE_RECURSIVELY)));
56104 SWIG_Python_SetConstant(d, "WS_EX_BLOCK_EVENTS",SWIG_From_int(static_cast< int >(wxWS_EX_BLOCK_EVENTS)));
56105 SWIG_Python_SetConstant(d, "WS_EX_TRANSIENT",SWIG_From_int(static_cast< int >(wxWS_EX_TRANSIENT)));
56106 SWIG_Python_SetConstant(d, "WS_EX_THEMED_BACKGROUND",SWIG_From_int(static_cast< int >(wxWS_EX_THEMED_BACKGROUND)));
56107 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_IDLE",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_IDLE)));
56108 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_UI_UPDATES",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_UI_UPDATES)));
56109 SWIG_Python_SetConstant(d, "MM_TEXT",SWIG_From_int(static_cast< int >(wxMM_TEXT)));
56110 SWIG_Python_SetConstant(d, "MM_LOMETRIC",SWIG_From_int(static_cast< int >(wxMM_LOMETRIC)));
56111 SWIG_Python_SetConstant(d, "MM_HIMETRIC",SWIG_From_int(static_cast< int >(wxMM_HIMETRIC)));
56112 SWIG_Python_SetConstant(d, "MM_LOENGLISH",SWIG_From_int(static_cast< int >(wxMM_LOENGLISH)));
56113 SWIG_Python_SetConstant(d, "MM_HIENGLISH",SWIG_From_int(static_cast< int >(wxMM_HIENGLISH)));
56114 SWIG_Python_SetConstant(d, "MM_TWIPS",SWIG_From_int(static_cast< int >(wxMM_TWIPS)));
56115 SWIG_Python_SetConstant(d, "MM_ISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ISOTROPIC)));
56116 SWIG_Python_SetConstant(d, "MM_ANISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ANISOTROPIC)));
56117 SWIG_Python_SetConstant(d, "MM_POINTS",SWIG_From_int(static_cast< int >(wxMM_POINTS)));
56118 SWIG_Python_SetConstant(d, "MM_METRIC",SWIG_From_int(static_cast< int >(wxMM_METRIC)));
56119 SWIG_Python_SetConstant(d, "CENTRE",SWIG_From_int(static_cast< int >(wxCENTRE)));
56120 SWIG_Python_SetConstant(d, "CENTER",SWIG_From_int(static_cast< int >(wxCENTER)));
56121 SWIG_Python_SetConstant(d, "HORIZONTAL",SWIG_From_int(static_cast< int >(wxHORIZONTAL)));
56122 SWIG_Python_SetConstant(d, "VERTICAL",SWIG_From_int(static_cast< int >(wxVERTICAL)));
56123 SWIG_Python_SetConstant(d, "BOTH",SWIG_From_int(static_cast< int >(wxBOTH)));
56124 SWIG_Python_SetConstant(d, "LEFT",SWIG_From_int(static_cast< int >(wxLEFT)));
56125 SWIG_Python_SetConstant(d, "RIGHT",SWIG_From_int(static_cast< int >(wxRIGHT)));
56126 SWIG_Python_SetConstant(d, "UP",SWIG_From_int(static_cast< int >(wxUP)));
56127 SWIG_Python_SetConstant(d, "DOWN",SWIG_From_int(static_cast< int >(wxDOWN)));
56128 SWIG_Python_SetConstant(d, "TOP",SWIG_From_int(static_cast< int >(wxTOP)));
56129 SWIG_Python_SetConstant(d, "BOTTOM",SWIG_From_int(static_cast< int >(wxBOTTOM)));
56130 SWIG_Python_SetConstant(d, "NORTH",SWIG_From_int(static_cast< int >(wxNORTH)));
56131 SWIG_Python_SetConstant(d, "SOUTH",SWIG_From_int(static_cast< int >(wxSOUTH)));
56132 SWIG_Python_SetConstant(d, "WEST",SWIG_From_int(static_cast< int >(wxWEST)));
56133 SWIG_Python_SetConstant(d, "EAST",SWIG_From_int(static_cast< int >(wxEAST)));
56134 SWIG_Python_SetConstant(d, "ALL",SWIG_From_int(static_cast< int >(wxALL)));
56135 SWIG_Python_SetConstant(d, "ALIGN_NOT",SWIG_From_int(static_cast< int >(wxALIGN_NOT)));
56136 SWIG_Python_SetConstant(d, "ALIGN_CENTER_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_HORIZONTAL)));
56137 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_HORIZONTAL)));
56138 SWIG_Python_SetConstant(d, "ALIGN_LEFT",SWIG_From_int(static_cast< int >(wxALIGN_LEFT)));
56139 SWIG_Python_SetConstant(d, "ALIGN_TOP",SWIG_From_int(static_cast< int >(wxALIGN_TOP)));
56140 SWIG_Python_SetConstant(d, "ALIGN_RIGHT",SWIG_From_int(static_cast< int >(wxALIGN_RIGHT)));
56141 SWIG_Python_SetConstant(d, "ALIGN_BOTTOM",SWIG_From_int(static_cast< int >(wxALIGN_BOTTOM)));
56142 SWIG_Python_SetConstant(d, "ALIGN_CENTER_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_VERTICAL)));
56143 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_VERTICAL)));
56144 SWIG_Python_SetConstant(d, "ALIGN_CENTER",SWIG_From_int(static_cast< int >(wxALIGN_CENTER)));
56145 SWIG_Python_SetConstant(d, "ALIGN_CENTRE",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE)));
56146 SWIG_Python_SetConstant(d, "ALIGN_MASK",SWIG_From_int(static_cast< int >(wxALIGN_MASK)));
56147 SWIG_Python_SetConstant(d, "STRETCH_NOT",SWIG_From_int(static_cast< int >(wxSTRETCH_NOT)));
56148 SWIG_Python_SetConstant(d, "SHRINK",SWIG_From_int(static_cast< int >(wxSHRINK)));
56149 SWIG_Python_SetConstant(d, "GROW",SWIG_From_int(static_cast< int >(wxGROW)));
56150 SWIG_Python_SetConstant(d, "EXPAND",SWIG_From_int(static_cast< int >(wxEXPAND)));
56151 SWIG_Python_SetConstant(d, "SHAPED",SWIG_From_int(static_cast< int >(wxSHAPED)));
56152 SWIG_Python_SetConstant(d, "FIXED_MINSIZE",SWIG_From_int(static_cast< int >(wxFIXED_MINSIZE)));
56153 SWIG_Python_SetConstant(d, "TILE",SWIG_From_int(static_cast< int >(wxTILE)));
56154 SWIG_Python_SetConstant(d, "ADJUST_MINSIZE",SWIG_From_int(static_cast< int >(wxADJUST_MINSIZE)));
56155 SWIG_Python_SetConstant(d, "BORDER_DEFAULT",SWIG_From_int(static_cast< int >(wxBORDER_DEFAULT)));
56156 SWIG_Python_SetConstant(d, "BORDER_NONE",SWIG_From_int(static_cast< int >(wxBORDER_NONE)));
56157 SWIG_Python_SetConstant(d, "BORDER_STATIC",SWIG_From_int(static_cast< int >(wxBORDER_STATIC)));
56158 SWIG_Python_SetConstant(d, "BORDER_SIMPLE",SWIG_From_int(static_cast< int >(wxBORDER_SIMPLE)));
56159 SWIG_Python_SetConstant(d, "BORDER_RAISED",SWIG_From_int(static_cast< int >(wxBORDER_RAISED)));
56160 SWIG_Python_SetConstant(d, "BORDER_SUNKEN",SWIG_From_int(static_cast< int >(wxBORDER_SUNKEN)));
56161 SWIG_Python_SetConstant(d, "BORDER_DOUBLE",SWIG_From_int(static_cast< int >(wxBORDER_DOUBLE)));
56162 SWIG_Python_SetConstant(d, "BORDER_MASK",SWIG_From_int(static_cast< int >(wxBORDER_MASK)));
56163 SWIG_Python_SetConstant(d, "BG_STYLE_SYSTEM",SWIG_From_int(static_cast< int >(wxBG_STYLE_SYSTEM)));
56164 SWIG_Python_SetConstant(d, "BG_STYLE_COLOUR",SWIG_From_int(static_cast< int >(wxBG_STYLE_COLOUR)));
56165 SWIG_Python_SetConstant(d, "BG_STYLE_CUSTOM",SWIG_From_int(static_cast< int >(wxBG_STYLE_CUSTOM)));
56166 SWIG_Python_SetConstant(d, "DEFAULT",SWIG_From_int(static_cast< int >(wxDEFAULT)));
56167 SWIG_Python_SetConstant(d, "DECORATIVE",SWIG_From_int(static_cast< int >(wxDECORATIVE)));
56168 SWIG_Python_SetConstant(d, "ROMAN",SWIG_From_int(static_cast< int >(wxROMAN)));
56169 SWIG_Python_SetConstant(d, "SCRIPT",SWIG_From_int(static_cast< int >(wxSCRIPT)));
56170 SWIG_Python_SetConstant(d, "SWISS",SWIG_From_int(static_cast< int >(wxSWISS)));
56171 SWIG_Python_SetConstant(d, "MODERN",SWIG_From_int(static_cast< int >(wxMODERN)));
56172 SWIG_Python_SetConstant(d, "TELETYPE",SWIG_From_int(static_cast< int >(wxTELETYPE)));
56173 SWIG_Python_SetConstant(d, "VARIABLE",SWIG_From_int(static_cast< int >(wxVARIABLE)));
56174 SWIG_Python_SetConstant(d, "FIXED",SWIG_From_int(static_cast< int >(wxFIXED)));
56175 SWIG_Python_SetConstant(d, "NORMAL",SWIG_From_int(static_cast< int >(wxNORMAL)));
56176 SWIG_Python_SetConstant(d, "LIGHT",SWIG_From_int(static_cast< int >(wxLIGHT)));
56177 SWIG_Python_SetConstant(d, "BOLD",SWIG_From_int(static_cast< int >(wxBOLD)));
56178 SWIG_Python_SetConstant(d, "ITALIC",SWIG_From_int(static_cast< int >(wxITALIC)));
56179 SWIG_Python_SetConstant(d, "SLANT",SWIG_From_int(static_cast< int >(wxSLANT)));
56180 SWIG_Python_SetConstant(d, "SOLID",SWIG_From_int(static_cast< int >(wxSOLID)));
56181 SWIG_Python_SetConstant(d, "DOT",SWIG_From_int(static_cast< int >(wxDOT)));
56182 SWIG_Python_SetConstant(d, "LONG_DASH",SWIG_From_int(static_cast< int >(wxLONG_DASH)));
56183 SWIG_Python_SetConstant(d, "SHORT_DASH",SWIG_From_int(static_cast< int >(wxSHORT_DASH)));
56184 SWIG_Python_SetConstant(d, "DOT_DASH",SWIG_From_int(static_cast< int >(wxDOT_DASH)));
56185 SWIG_Python_SetConstant(d, "USER_DASH",SWIG_From_int(static_cast< int >(wxUSER_DASH)));
56186 SWIG_Python_SetConstant(d, "TRANSPARENT",SWIG_From_int(static_cast< int >(wxTRANSPARENT)));
56187 SWIG_Python_SetConstant(d, "STIPPLE",SWIG_From_int(static_cast< int >(wxSTIPPLE)));
56188 SWIG_Python_SetConstant(d, "STIPPLE_MASK",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK)));
56189 SWIG_Python_SetConstant(d, "STIPPLE_MASK_OPAQUE",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK_OPAQUE)));
56190 SWIG_Python_SetConstant(d, "BDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxBDIAGONAL_HATCH)));
56191 SWIG_Python_SetConstant(d, "CROSSDIAG_HATCH",SWIG_From_int(static_cast< int >(wxCROSSDIAG_HATCH)));
56192 SWIG_Python_SetConstant(d, "FDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxFDIAGONAL_HATCH)));
56193 SWIG_Python_SetConstant(d, "CROSS_HATCH",SWIG_From_int(static_cast< int >(wxCROSS_HATCH)));
56194 SWIG_Python_SetConstant(d, "HORIZONTAL_HATCH",SWIG_From_int(static_cast< int >(wxHORIZONTAL_HATCH)));
56195 SWIG_Python_SetConstant(d, "VERTICAL_HATCH",SWIG_From_int(static_cast< int >(wxVERTICAL_HATCH)));
56196 SWIG_Python_SetConstant(d, "JOIN_BEVEL",SWIG_From_int(static_cast< int >(wxJOIN_BEVEL)));
56197 SWIG_Python_SetConstant(d, "JOIN_MITER",SWIG_From_int(static_cast< int >(wxJOIN_MITER)));
56198 SWIG_Python_SetConstant(d, "JOIN_ROUND",SWIG_From_int(static_cast< int >(wxJOIN_ROUND)));
56199 SWIG_Python_SetConstant(d, "CAP_ROUND",SWIG_From_int(static_cast< int >(wxCAP_ROUND)));
56200 SWIG_Python_SetConstant(d, "CAP_PROJECTING",SWIG_From_int(static_cast< int >(wxCAP_PROJECTING)));
56201 SWIG_Python_SetConstant(d, "CAP_BUTT",SWIG_From_int(static_cast< int >(wxCAP_BUTT)));
56202 SWIG_Python_SetConstant(d, "CLEAR",SWIG_From_int(static_cast< int >(wxCLEAR)));
56203 SWIG_Python_SetConstant(d, "XOR",SWIG_From_int(static_cast< int >(wxXOR)));
56204 SWIG_Python_SetConstant(d, "INVERT",SWIG_From_int(static_cast< int >(wxINVERT)));
56205 SWIG_Python_SetConstant(d, "OR_REVERSE",SWIG_From_int(static_cast< int >(wxOR_REVERSE)));
56206 SWIG_Python_SetConstant(d, "AND_REVERSE",SWIG_From_int(static_cast< int >(wxAND_REVERSE)));
56207 SWIG_Python_SetConstant(d, "COPY",SWIG_From_int(static_cast< int >(wxCOPY)));
56208 SWIG_Python_SetConstant(d, "AND",SWIG_From_int(static_cast< int >(wxAND)));
56209 SWIG_Python_SetConstant(d, "AND_INVERT",SWIG_From_int(static_cast< int >(wxAND_INVERT)));
56210 SWIG_Python_SetConstant(d, "NO_OP",SWIG_From_int(static_cast< int >(wxNO_OP)));
56211 SWIG_Python_SetConstant(d, "NOR",SWIG_From_int(static_cast< int >(wxNOR)));
56212 SWIG_Python_SetConstant(d, "EQUIV",SWIG_From_int(static_cast< int >(wxEQUIV)));
56213 SWIG_Python_SetConstant(d, "SRC_INVERT",SWIG_From_int(static_cast< int >(wxSRC_INVERT)));
56214 SWIG_Python_SetConstant(d, "OR_INVERT",SWIG_From_int(static_cast< int >(wxOR_INVERT)));
56215 SWIG_Python_SetConstant(d, "NAND",SWIG_From_int(static_cast< int >(wxNAND)));
56216 SWIG_Python_SetConstant(d, "OR",SWIG_From_int(static_cast< int >(wxOR)));
56217 SWIG_Python_SetConstant(d, "SET",SWIG_From_int(static_cast< int >(wxSET)));
56218 SWIG_Python_SetConstant(d, "WXK_BACK",SWIG_From_int(static_cast< int >(WXK_BACK)));
56219 SWIG_Python_SetConstant(d, "WXK_TAB",SWIG_From_int(static_cast< int >(WXK_TAB)));
56220 SWIG_Python_SetConstant(d, "WXK_RETURN",SWIG_From_int(static_cast< int >(WXK_RETURN)));
56221 SWIG_Python_SetConstant(d, "WXK_ESCAPE",SWIG_From_int(static_cast< int >(WXK_ESCAPE)));
56222 SWIG_Python_SetConstant(d, "WXK_SPACE",SWIG_From_int(static_cast< int >(WXK_SPACE)));
56223 SWIG_Python_SetConstant(d, "WXK_DELETE",SWIG_From_int(static_cast< int >(WXK_DELETE)));
56224 SWIG_Python_SetConstant(d, "WXK_START",SWIG_From_int(static_cast< int >(WXK_START)));
56225 SWIG_Python_SetConstant(d, "WXK_LBUTTON",SWIG_From_int(static_cast< int >(WXK_LBUTTON)));
56226 SWIG_Python_SetConstant(d, "WXK_RBUTTON",SWIG_From_int(static_cast< int >(WXK_RBUTTON)));
56227 SWIG_Python_SetConstant(d, "WXK_CANCEL",SWIG_From_int(static_cast< int >(WXK_CANCEL)));
56228 SWIG_Python_SetConstant(d, "WXK_MBUTTON",SWIG_From_int(static_cast< int >(WXK_MBUTTON)));
56229 SWIG_Python_SetConstant(d, "WXK_CLEAR",SWIG_From_int(static_cast< int >(WXK_CLEAR)));
56230 SWIG_Python_SetConstant(d, "WXK_SHIFT",SWIG_From_int(static_cast< int >(WXK_SHIFT)));
56231 SWIG_Python_SetConstant(d, "WXK_ALT",SWIG_From_int(static_cast< int >(WXK_ALT)));
56232 SWIG_Python_SetConstant(d, "WXK_CONTROL",SWIG_From_int(static_cast< int >(WXK_CONTROL)));
56233 SWIG_Python_SetConstant(d, "WXK_MENU",SWIG_From_int(static_cast< int >(WXK_MENU)));
56234 SWIG_Python_SetConstant(d, "WXK_PAUSE",SWIG_From_int(static_cast< int >(WXK_PAUSE)));
56235 SWIG_Python_SetConstant(d, "WXK_CAPITAL",SWIG_From_int(static_cast< int >(WXK_CAPITAL)));
56236 SWIG_Python_SetConstant(d, "WXK_PRIOR",SWIG_From_int(static_cast< int >(WXK_PRIOR)));
56237 SWIG_Python_SetConstant(d, "WXK_NEXT",SWIG_From_int(static_cast< int >(WXK_NEXT)));
56238 SWIG_Python_SetConstant(d, "WXK_END",SWIG_From_int(static_cast< int >(WXK_END)));
56239 SWIG_Python_SetConstant(d, "WXK_HOME",SWIG_From_int(static_cast< int >(WXK_HOME)));
56240 SWIG_Python_SetConstant(d, "WXK_LEFT",SWIG_From_int(static_cast< int >(WXK_LEFT)));
56241 SWIG_Python_SetConstant(d, "WXK_UP",SWIG_From_int(static_cast< int >(WXK_UP)));
56242 SWIG_Python_SetConstant(d, "WXK_RIGHT",SWIG_From_int(static_cast< int >(WXK_RIGHT)));
56243 SWIG_Python_SetConstant(d, "WXK_DOWN",SWIG_From_int(static_cast< int >(WXK_DOWN)));
56244 SWIG_Python_SetConstant(d, "WXK_SELECT",SWIG_From_int(static_cast< int >(WXK_SELECT)));
56245 SWIG_Python_SetConstant(d, "WXK_PRINT",SWIG_From_int(static_cast< int >(WXK_PRINT)));
56246 SWIG_Python_SetConstant(d, "WXK_EXECUTE",SWIG_From_int(static_cast< int >(WXK_EXECUTE)));
56247 SWIG_Python_SetConstant(d, "WXK_SNAPSHOT",SWIG_From_int(static_cast< int >(WXK_SNAPSHOT)));
56248 SWIG_Python_SetConstant(d, "WXK_INSERT",SWIG_From_int(static_cast< int >(WXK_INSERT)));
56249 SWIG_Python_SetConstant(d, "WXK_HELP",SWIG_From_int(static_cast< int >(WXK_HELP)));
56250 SWIG_Python_SetConstant(d, "WXK_NUMPAD0",SWIG_From_int(static_cast< int >(WXK_NUMPAD0)));
56251 SWIG_Python_SetConstant(d, "WXK_NUMPAD1",SWIG_From_int(static_cast< int >(WXK_NUMPAD1)));
56252 SWIG_Python_SetConstant(d, "WXK_NUMPAD2",SWIG_From_int(static_cast< int >(WXK_NUMPAD2)));
56253 SWIG_Python_SetConstant(d, "WXK_NUMPAD3",SWIG_From_int(static_cast< int >(WXK_NUMPAD3)));
56254 SWIG_Python_SetConstant(d, "WXK_NUMPAD4",SWIG_From_int(static_cast< int >(WXK_NUMPAD4)));
56255 SWIG_Python_SetConstant(d, "WXK_NUMPAD5",SWIG_From_int(static_cast< int >(WXK_NUMPAD5)));
56256 SWIG_Python_SetConstant(d, "WXK_NUMPAD6",SWIG_From_int(static_cast< int >(WXK_NUMPAD6)));
56257 SWIG_Python_SetConstant(d, "WXK_NUMPAD7",SWIG_From_int(static_cast< int >(WXK_NUMPAD7)));
56258 SWIG_Python_SetConstant(d, "WXK_NUMPAD8",SWIG_From_int(static_cast< int >(WXK_NUMPAD8)));
56259 SWIG_Python_SetConstant(d, "WXK_NUMPAD9",SWIG_From_int(static_cast< int >(WXK_NUMPAD9)));
56260 SWIG_Python_SetConstant(d, "WXK_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_MULTIPLY)));
56261 SWIG_Python_SetConstant(d, "WXK_ADD",SWIG_From_int(static_cast< int >(WXK_ADD)));
56262 SWIG_Python_SetConstant(d, "WXK_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_SEPARATOR)));
56263 SWIG_Python_SetConstant(d, "WXK_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_SUBTRACT)));
56264 SWIG_Python_SetConstant(d, "WXK_DECIMAL",SWIG_From_int(static_cast< int >(WXK_DECIMAL)));
56265 SWIG_Python_SetConstant(d, "WXK_DIVIDE",SWIG_From_int(static_cast< int >(WXK_DIVIDE)));
56266 SWIG_Python_SetConstant(d, "WXK_F1",SWIG_From_int(static_cast< int >(WXK_F1)));
56267 SWIG_Python_SetConstant(d, "WXK_F2",SWIG_From_int(static_cast< int >(WXK_F2)));
56268 SWIG_Python_SetConstant(d, "WXK_F3",SWIG_From_int(static_cast< int >(WXK_F3)));
56269 SWIG_Python_SetConstant(d, "WXK_F4",SWIG_From_int(static_cast< int >(WXK_F4)));
56270 SWIG_Python_SetConstant(d, "WXK_F5",SWIG_From_int(static_cast< int >(WXK_F5)));
56271 SWIG_Python_SetConstant(d, "WXK_F6",SWIG_From_int(static_cast< int >(WXK_F6)));
56272 SWIG_Python_SetConstant(d, "WXK_F7",SWIG_From_int(static_cast< int >(WXK_F7)));
56273 SWIG_Python_SetConstant(d, "WXK_F8",SWIG_From_int(static_cast< int >(WXK_F8)));
56274 SWIG_Python_SetConstant(d, "WXK_F9",SWIG_From_int(static_cast< int >(WXK_F9)));
56275 SWIG_Python_SetConstant(d, "WXK_F10",SWIG_From_int(static_cast< int >(WXK_F10)));
56276 SWIG_Python_SetConstant(d, "WXK_F11",SWIG_From_int(static_cast< int >(WXK_F11)));
56277 SWIG_Python_SetConstant(d, "WXK_F12",SWIG_From_int(static_cast< int >(WXK_F12)));
56278 SWIG_Python_SetConstant(d, "WXK_F13",SWIG_From_int(static_cast< int >(WXK_F13)));
56279 SWIG_Python_SetConstant(d, "WXK_F14",SWIG_From_int(static_cast< int >(WXK_F14)));
56280 SWIG_Python_SetConstant(d, "WXK_F15",SWIG_From_int(static_cast< int >(WXK_F15)));
56281 SWIG_Python_SetConstant(d, "WXK_F16",SWIG_From_int(static_cast< int >(WXK_F16)));
56282 SWIG_Python_SetConstant(d, "WXK_F17",SWIG_From_int(static_cast< int >(WXK_F17)));
56283 SWIG_Python_SetConstant(d, "WXK_F18",SWIG_From_int(static_cast< int >(WXK_F18)));
56284 SWIG_Python_SetConstant(d, "WXK_F19",SWIG_From_int(static_cast< int >(WXK_F19)));
56285 SWIG_Python_SetConstant(d, "WXK_F20",SWIG_From_int(static_cast< int >(WXK_F20)));
56286 SWIG_Python_SetConstant(d, "WXK_F21",SWIG_From_int(static_cast< int >(WXK_F21)));
56287 SWIG_Python_SetConstant(d, "WXK_F22",SWIG_From_int(static_cast< int >(WXK_F22)));
56288 SWIG_Python_SetConstant(d, "WXK_F23",SWIG_From_int(static_cast< int >(WXK_F23)));
56289 SWIG_Python_SetConstant(d, "WXK_F24",SWIG_From_int(static_cast< int >(WXK_F24)));
56290 SWIG_Python_SetConstant(d, "WXK_NUMLOCK",SWIG_From_int(static_cast< int >(WXK_NUMLOCK)));
56291 SWIG_Python_SetConstant(d, "WXK_SCROLL",SWIG_From_int(static_cast< int >(WXK_SCROLL)));
56292 SWIG_Python_SetConstant(d, "WXK_PAGEUP",SWIG_From_int(static_cast< int >(WXK_PAGEUP)));
56293 SWIG_Python_SetConstant(d, "WXK_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_PAGEDOWN)));
56294 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SPACE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SPACE)));
56295 SWIG_Python_SetConstant(d, "WXK_NUMPAD_TAB",SWIG_From_int(static_cast< int >(WXK_NUMPAD_TAB)));
56296 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ENTER",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ENTER)));
56297 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F1",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F1)));
56298 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F2",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F2)));
56299 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F3",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F3)));
56300 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F4",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F4)));
56301 SWIG_Python_SetConstant(d, "WXK_NUMPAD_HOME",SWIG_From_int(static_cast< int >(WXK_NUMPAD_HOME)));
56302 SWIG_Python_SetConstant(d, "WXK_NUMPAD_LEFT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_LEFT)));
56303 SWIG_Python_SetConstant(d, "WXK_NUMPAD_UP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_UP)));
56304 SWIG_Python_SetConstant(d, "WXK_NUMPAD_RIGHT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_RIGHT)));
56305 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DOWN)));
56306 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PRIOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PRIOR)));
56307 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEUP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEUP)));
56308 SWIG_Python_SetConstant(d, "WXK_NUMPAD_NEXT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_NEXT)));
56309 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEDOWN)));
56310 SWIG_Python_SetConstant(d, "WXK_NUMPAD_END",SWIG_From_int(static_cast< int >(WXK_NUMPAD_END)));
56311 SWIG_Python_SetConstant(d, "WXK_NUMPAD_BEGIN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_BEGIN)));
56312 SWIG_Python_SetConstant(d, "WXK_NUMPAD_INSERT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_INSERT)));
56313 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DELETE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DELETE)));
56314 SWIG_Python_SetConstant(d, "WXK_NUMPAD_EQUAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_EQUAL)));
56315 SWIG_Python_SetConstant(d, "WXK_NUMPAD_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_NUMPAD_MULTIPLY)));
56316 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ADD",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ADD)));
56317 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SEPARATOR)));
56318 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SUBTRACT)));
56319 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DECIMAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DECIMAL)));
56320 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DIVIDE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DIVIDE)));
56321 SWIG_Python_SetConstant(d, "WXK_WINDOWS_LEFT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_LEFT)));
56322 SWIG_Python_SetConstant(d, "WXK_WINDOWS_RIGHT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_RIGHT)));
56323 SWIG_Python_SetConstant(d, "WXK_WINDOWS_MENU",SWIG_From_int(static_cast< int >(WXK_WINDOWS_MENU)));
56324 SWIG_Python_SetConstant(d, "WXK_COMMAND",SWIG_From_int(static_cast< int >(WXK_COMMAND)));
56325 SWIG_Python_SetConstant(d, "WXK_SPECIAL1",SWIG_From_int(static_cast< int >(WXK_SPECIAL1)));
56326 SWIG_Python_SetConstant(d, "WXK_SPECIAL2",SWIG_From_int(static_cast< int >(WXK_SPECIAL2)));
56327 SWIG_Python_SetConstant(d, "WXK_SPECIAL3",SWIG_From_int(static_cast< int >(WXK_SPECIAL3)));
56328 SWIG_Python_SetConstant(d, "WXK_SPECIAL4",SWIG_From_int(static_cast< int >(WXK_SPECIAL4)));
56329 SWIG_Python_SetConstant(d, "WXK_SPECIAL5",SWIG_From_int(static_cast< int >(WXK_SPECIAL5)));
56330 SWIG_Python_SetConstant(d, "WXK_SPECIAL6",SWIG_From_int(static_cast< int >(WXK_SPECIAL6)));
56331 SWIG_Python_SetConstant(d, "WXK_SPECIAL7",SWIG_From_int(static_cast< int >(WXK_SPECIAL7)));
56332 SWIG_Python_SetConstant(d, "WXK_SPECIAL8",SWIG_From_int(static_cast< int >(WXK_SPECIAL8)));
56333 SWIG_Python_SetConstant(d, "WXK_SPECIAL9",SWIG_From_int(static_cast< int >(WXK_SPECIAL9)));
56334 SWIG_Python_SetConstant(d, "WXK_SPECIAL10",SWIG_From_int(static_cast< int >(WXK_SPECIAL10)));
56335 SWIG_Python_SetConstant(d, "WXK_SPECIAL11",SWIG_From_int(static_cast< int >(WXK_SPECIAL11)));
56336 SWIG_Python_SetConstant(d, "WXK_SPECIAL12",SWIG_From_int(static_cast< int >(WXK_SPECIAL12)));
56337 SWIG_Python_SetConstant(d, "WXK_SPECIAL13",SWIG_From_int(static_cast< int >(WXK_SPECIAL13)));
56338 SWIG_Python_SetConstant(d, "WXK_SPECIAL14",SWIG_From_int(static_cast< int >(WXK_SPECIAL14)));
56339 SWIG_Python_SetConstant(d, "WXK_SPECIAL15",SWIG_From_int(static_cast< int >(WXK_SPECIAL15)));
56340 SWIG_Python_SetConstant(d, "WXK_SPECIAL16",SWIG_From_int(static_cast< int >(WXK_SPECIAL16)));
56341 SWIG_Python_SetConstant(d, "WXK_SPECIAL17",SWIG_From_int(static_cast< int >(WXK_SPECIAL17)));
56342 SWIG_Python_SetConstant(d, "WXK_SPECIAL18",SWIG_From_int(static_cast< int >(WXK_SPECIAL18)));
56343 SWIG_Python_SetConstant(d, "WXK_SPECIAL19",SWIG_From_int(static_cast< int >(WXK_SPECIAL19)));
56344 SWIG_Python_SetConstant(d, "WXK_SPECIAL20",SWIG_From_int(static_cast< int >(WXK_SPECIAL20)));
56345 SWIG_Python_SetConstant(d, "PAPER_NONE",SWIG_From_int(static_cast< int >(wxPAPER_NONE)));
56346 SWIG_Python_SetConstant(d, "PAPER_LETTER",SWIG_From_int(static_cast< int >(wxPAPER_LETTER)));
56347 SWIG_Python_SetConstant(d, "PAPER_LEGAL",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL)));
56348 SWIG_Python_SetConstant(d, "PAPER_A4",SWIG_From_int(static_cast< int >(wxPAPER_A4)));
56349 SWIG_Python_SetConstant(d, "PAPER_CSHEET",SWIG_From_int(static_cast< int >(wxPAPER_CSHEET)));
56350 SWIG_Python_SetConstant(d, "PAPER_DSHEET",SWIG_From_int(static_cast< int >(wxPAPER_DSHEET)));
56351 SWIG_Python_SetConstant(d, "PAPER_ESHEET",SWIG_From_int(static_cast< int >(wxPAPER_ESHEET)));
56352 SWIG_Python_SetConstant(d, "PAPER_LETTERSMALL",SWIG_From_int(static_cast< int >(wxPAPER_LETTERSMALL)));
56353 SWIG_Python_SetConstant(d, "PAPER_TABLOID",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID)));
56354 SWIG_Python_SetConstant(d, "PAPER_LEDGER",SWIG_From_int(static_cast< int >(wxPAPER_LEDGER)));
56355 SWIG_Python_SetConstant(d, "PAPER_STATEMENT",SWIG_From_int(static_cast< int >(wxPAPER_STATEMENT)));
56356 SWIG_Python_SetConstant(d, "PAPER_EXECUTIVE",SWIG_From_int(static_cast< int >(wxPAPER_EXECUTIVE)));
56357 SWIG_Python_SetConstant(d, "PAPER_A3",SWIG_From_int(static_cast< int >(wxPAPER_A3)));
56358 SWIG_Python_SetConstant(d, "PAPER_A4SMALL",SWIG_From_int(static_cast< int >(wxPAPER_A4SMALL)));
56359 SWIG_Python_SetConstant(d, "PAPER_A5",SWIG_From_int(static_cast< int >(wxPAPER_A5)));
56360 SWIG_Python_SetConstant(d, "PAPER_B4",SWIG_From_int(static_cast< int >(wxPAPER_B4)));
56361 SWIG_Python_SetConstant(d, "PAPER_B5",SWIG_From_int(static_cast< int >(wxPAPER_B5)));
56362 SWIG_Python_SetConstant(d, "PAPER_FOLIO",SWIG_From_int(static_cast< int >(wxPAPER_FOLIO)));
56363 SWIG_Python_SetConstant(d, "PAPER_QUARTO",SWIG_From_int(static_cast< int >(wxPAPER_QUARTO)));
56364 SWIG_Python_SetConstant(d, "PAPER_10X14",SWIG_From_int(static_cast< int >(wxPAPER_10X14)));
56365 SWIG_Python_SetConstant(d, "PAPER_11X17",SWIG_From_int(static_cast< int >(wxPAPER_11X17)));
56366 SWIG_Python_SetConstant(d, "PAPER_NOTE",SWIG_From_int(static_cast< int >(wxPAPER_NOTE)));
56367 SWIG_Python_SetConstant(d, "PAPER_ENV_9",SWIG_From_int(static_cast< int >(wxPAPER_ENV_9)));
56368 SWIG_Python_SetConstant(d, "PAPER_ENV_10",SWIG_From_int(static_cast< int >(wxPAPER_ENV_10)));
56369 SWIG_Python_SetConstant(d, "PAPER_ENV_11",SWIG_From_int(static_cast< int >(wxPAPER_ENV_11)));
56370 SWIG_Python_SetConstant(d, "PAPER_ENV_12",SWIG_From_int(static_cast< int >(wxPAPER_ENV_12)));
56371 SWIG_Python_SetConstant(d, "PAPER_ENV_14",SWIG_From_int(static_cast< int >(wxPAPER_ENV_14)));
56372 SWIG_Python_SetConstant(d, "PAPER_ENV_DL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_DL)));
56373 SWIG_Python_SetConstant(d, "PAPER_ENV_C5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C5)));
56374 SWIG_Python_SetConstant(d, "PAPER_ENV_C3",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C3)));
56375 SWIG_Python_SetConstant(d, "PAPER_ENV_C4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C4)));
56376 SWIG_Python_SetConstant(d, "PAPER_ENV_C6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C6)));
56377 SWIG_Python_SetConstant(d, "PAPER_ENV_C65",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C65)));
56378 SWIG_Python_SetConstant(d, "PAPER_ENV_B4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B4)));
56379 SWIG_Python_SetConstant(d, "PAPER_ENV_B5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B5)));
56380 SWIG_Python_SetConstant(d, "PAPER_ENV_B6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B6)));
56381 SWIG_Python_SetConstant(d, "PAPER_ENV_ITALY",SWIG_From_int(static_cast< int >(wxPAPER_ENV_ITALY)));
56382 SWIG_Python_SetConstant(d, "PAPER_ENV_MONARCH",SWIG_From_int(static_cast< int >(wxPAPER_ENV_MONARCH)));
56383 SWIG_Python_SetConstant(d, "PAPER_ENV_PERSONAL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_PERSONAL)));
56384 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_US",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_US)));
56385 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_STD_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_STD_GERMAN)));
56386 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_LGL_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_LGL_GERMAN)));
56387 SWIG_Python_SetConstant(d, "PAPER_ISO_B4",SWIG_From_int(static_cast< int >(wxPAPER_ISO_B4)));
56388 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD)));
56389 SWIG_Python_SetConstant(d, "PAPER_9X11",SWIG_From_int(static_cast< int >(wxPAPER_9X11)));
56390 SWIG_Python_SetConstant(d, "PAPER_10X11",SWIG_From_int(static_cast< int >(wxPAPER_10X11)));
56391 SWIG_Python_SetConstant(d, "PAPER_15X11",SWIG_From_int(static_cast< int >(wxPAPER_15X11)));
56392 SWIG_Python_SetConstant(d, "PAPER_ENV_INVITE",SWIG_From_int(static_cast< int >(wxPAPER_ENV_INVITE)));
56393 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA)));
56394 SWIG_Python_SetConstant(d, "PAPER_LEGAL_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL_EXTRA)));
56395 SWIG_Python_SetConstant(d, "PAPER_TABLOID_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID_EXTRA)));
56396 SWIG_Python_SetConstant(d, "PAPER_A4_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A4_EXTRA)));
56397 SWIG_Python_SetConstant(d, "PAPER_LETTER_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_TRANSVERSE)));
56398 SWIG_Python_SetConstant(d, "PAPER_A4_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A4_TRANSVERSE)));
56399 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
56400 SWIG_Python_SetConstant(d, "PAPER_A_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A_PLUS)));
56401 SWIG_Python_SetConstant(d, "PAPER_B_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_B_PLUS)));
56402 SWIG_Python_SetConstant(d, "PAPER_LETTER_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_PLUS)));
56403 SWIG_Python_SetConstant(d, "PAPER_A4_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A4_PLUS)));
56404 SWIG_Python_SetConstant(d, "PAPER_A5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A5_TRANSVERSE)));
56405 SWIG_Python_SetConstant(d, "PAPER_B5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_B5_TRANSVERSE)));
56406 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA)));
56407 SWIG_Python_SetConstant(d, "PAPER_A5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A5_EXTRA)));
56408 SWIG_Python_SetConstant(d, "PAPER_B5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_B5_EXTRA)));
56409 SWIG_Python_SetConstant(d, "PAPER_A2",SWIG_From_int(static_cast< int >(wxPAPER_A2)));
56410 SWIG_Python_SetConstant(d, "PAPER_A3_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_TRANSVERSE)));
56411 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA_TRANSVERSE)));
56412 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD)));
56413 SWIG_Python_SetConstant(d, "PAPER_A6",SWIG_From_int(static_cast< int >(wxPAPER_A6)));
56414 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2)));
56415 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3)));
56416 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3)));
56417 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4)));
56418 SWIG_Python_SetConstant(d, "PAPER_LETTER_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_ROTATED)));
56419 SWIG_Python_SetConstant(d, "PAPER_A3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A3_ROTATED)));
56420 SWIG_Python_SetConstant(d, "PAPER_A4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A4_ROTATED)));
56421 SWIG_Python_SetConstant(d, "PAPER_A5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A5_ROTATED)));
56422 SWIG_Python_SetConstant(d, "PAPER_B4_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B4_JIS_ROTATED)));
56423 SWIG_Python_SetConstant(d, "PAPER_B5_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B5_JIS_ROTATED)));
56424 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
56425 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
56426 SWIG_Python_SetConstant(d, "PAPER_A6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A6_ROTATED)));
56427 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2_ROTATED)));
56428 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3_ROTATED)));
56429 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3_ROTATED)));
56430 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4_ROTATED)));
56431 SWIG_Python_SetConstant(d, "PAPER_B6_JIS",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS)));
56432 SWIG_Python_SetConstant(d, "PAPER_B6_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS_ROTATED)));
56433 SWIG_Python_SetConstant(d, "PAPER_12X11",SWIG_From_int(static_cast< int >(wxPAPER_12X11)));
56434 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4)));
56435 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4_ROTATED)));
56436 SWIG_Python_SetConstant(d, "PAPER_P16K",SWIG_From_int(static_cast< int >(wxPAPER_P16K)));
56437 SWIG_Python_SetConstant(d, "PAPER_P32K",SWIG_From_int(static_cast< int >(wxPAPER_P32K)));
56438 SWIG_Python_SetConstant(d, "PAPER_P32KBIG",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG)));
56439 SWIG_Python_SetConstant(d, "PAPER_PENV_1",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1)));
56440 SWIG_Python_SetConstant(d, "PAPER_PENV_2",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2)));
56441 SWIG_Python_SetConstant(d, "PAPER_PENV_3",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3)));
56442 SWIG_Python_SetConstant(d, "PAPER_PENV_4",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4)));
56443 SWIG_Python_SetConstant(d, "PAPER_PENV_5",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5)));
56444 SWIG_Python_SetConstant(d, "PAPER_PENV_6",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6)));
56445 SWIG_Python_SetConstant(d, "PAPER_PENV_7",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7)));
56446 SWIG_Python_SetConstant(d, "PAPER_PENV_8",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8)));
56447 SWIG_Python_SetConstant(d, "PAPER_PENV_9",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9)));
56448 SWIG_Python_SetConstant(d, "PAPER_PENV_10",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10)));
56449 SWIG_Python_SetConstant(d, "PAPER_P16K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P16K_ROTATED)));
56450 SWIG_Python_SetConstant(d, "PAPER_P32K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32K_ROTATED)));
56451 SWIG_Python_SetConstant(d, "PAPER_P32KBIG_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG_ROTATED)));
56452 SWIG_Python_SetConstant(d, "PAPER_PENV_1_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1_ROTATED)));
56453 SWIG_Python_SetConstant(d, "PAPER_PENV_2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2_ROTATED)));
56454 SWIG_Python_SetConstant(d, "PAPER_PENV_3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3_ROTATED)));
56455 SWIG_Python_SetConstant(d, "PAPER_PENV_4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4_ROTATED)));
56456 SWIG_Python_SetConstant(d, "PAPER_PENV_5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5_ROTATED)));
56457 SWIG_Python_SetConstant(d, "PAPER_PENV_6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6_ROTATED)));
56458 SWIG_Python_SetConstant(d, "PAPER_PENV_7_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7_ROTATED)));
56459 SWIG_Python_SetConstant(d, "PAPER_PENV_8_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8_ROTATED)));
56460 SWIG_Python_SetConstant(d, "PAPER_PENV_9_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9_ROTATED)));
56461 SWIG_Python_SetConstant(d, "PAPER_PENV_10_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10_ROTATED)));
56462 SWIG_Python_SetConstant(d, "DUPLEX_SIMPLEX",SWIG_From_int(static_cast< int >(wxDUPLEX_SIMPLEX)));
56463 SWIG_Python_SetConstant(d, "DUPLEX_HORIZONTAL",SWIG_From_int(static_cast< int >(wxDUPLEX_HORIZONTAL)));
56464 SWIG_Python_SetConstant(d, "DUPLEX_VERTICAL",SWIG_From_int(static_cast< int >(wxDUPLEX_VERTICAL)));
56465 SWIG_Python_SetConstant(d, "ITEM_SEPARATOR",SWIG_From_int(static_cast< int >(wxITEM_SEPARATOR)));
56466 SWIG_Python_SetConstant(d, "ITEM_NORMAL",SWIG_From_int(static_cast< int >(wxITEM_NORMAL)));
56467 SWIG_Python_SetConstant(d, "ITEM_CHECK",SWIG_From_int(static_cast< int >(wxITEM_CHECK)));
56468 SWIG_Python_SetConstant(d, "ITEM_RADIO",SWIG_From_int(static_cast< int >(wxITEM_RADIO)));
56469 SWIG_Python_SetConstant(d, "ITEM_MAX",SWIG_From_int(static_cast< int >(wxITEM_MAX)));
56470 SWIG_Python_SetConstant(d, "HT_NOWHERE",SWIG_From_int(static_cast< int >(wxHT_NOWHERE)));
56471 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_FIRST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_FIRST)));
56472 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_1)));
56473 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_2)));
56474 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_1)));
56475 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_2)));
56476 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_THUMB",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_THUMB)));
56477 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_1)));
56478 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_2)));
56479 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_LAST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_LAST)));
56480 SWIG_Python_SetConstant(d, "HT_WINDOW_OUTSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_OUTSIDE)));
56481 SWIG_Python_SetConstant(d, "HT_WINDOW_INSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_INSIDE)));
56482 SWIG_Python_SetConstant(d, "HT_WINDOW_VERT_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_VERT_SCROLLBAR)));
56483 SWIG_Python_SetConstant(d, "HT_WINDOW_HORZ_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_HORZ_SCROLLBAR)));
56484 SWIG_Python_SetConstant(d, "HT_WINDOW_CORNER",SWIG_From_int(static_cast< int >(wxHT_WINDOW_CORNER)));
56485 SWIG_Python_SetConstant(d, "HT_MAX",SWIG_From_int(static_cast< int >(wxHT_MAX)));
56486 SWIG_Python_SetConstant(d, "MOD_NONE",SWIG_From_int(static_cast< int >(wxMOD_NONE)));
56487 SWIG_Python_SetConstant(d, "MOD_ALT",SWIG_From_int(static_cast< int >(wxMOD_ALT)));
56488 SWIG_Python_SetConstant(d, "MOD_CONTROL",SWIG_From_int(static_cast< int >(wxMOD_CONTROL)));
56489 SWIG_Python_SetConstant(d, "MOD_ALTGR",SWIG_From_int(static_cast< int >(wxMOD_ALTGR)));
56490 SWIG_Python_SetConstant(d, "MOD_SHIFT",SWIG_From_int(static_cast< int >(wxMOD_SHIFT)));
56491 SWIG_Python_SetConstant(d, "MOD_META",SWIG_From_int(static_cast< int >(wxMOD_META)));
56492 SWIG_Python_SetConstant(d, "MOD_WIN",SWIG_From_int(static_cast< int >(wxMOD_WIN)));
56493 SWIG_Python_SetConstant(d, "MOD_CMD",SWIG_From_int(static_cast< int >(wxMOD_CMD)));
56494 SWIG_Python_SetConstant(d, "MOD_ALL",SWIG_From_int(static_cast< int >(wxMOD_ALL)));
56495 SWIG_Python_SetConstant(d, "UPDATE_UI_NONE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_NONE)));
56496 SWIG_Python_SetConstant(d, "UPDATE_UI_RECURSE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_RECURSE)));
56497 SWIG_Python_SetConstant(d, "UPDATE_UI_FROMIDLE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_FROMIDLE)));
56498 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
56499 SWIG_addvarlink(SWIG_globals(),(char*)"EmptyString",EmptyString_get, EmptyString_set);
56500 SWIG_Python_SetConstant(d, "BITMAP_TYPE_INVALID",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_INVALID)));
56501 SWIG_Python_SetConstant(d, "BITMAP_TYPE_BMP",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_BMP)));
56502 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICO",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICO)));
56503 SWIG_Python_SetConstant(d, "BITMAP_TYPE_CUR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_CUR)));
56504 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM)));
56505 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM_DATA)));
56506 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM)));
56507 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM_DATA)));
56508 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TIF)));
56509 SWIG_Python_SetConstant(d, "BITMAP_TYPE_GIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_GIF)));
56510 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNG)));
56511 SWIG_Python_SetConstant(d, "BITMAP_TYPE_JPEG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_JPEG)));
56512 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNM)));
56513 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PCX",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PCX)));
56514 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PICT",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PICT)));
56515 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICON",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICON)));
56516 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANI",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANI)));
56517 SWIG_Python_SetConstant(d, "BITMAP_TYPE_IFF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_IFF)));
56518 SWIG_Python_SetConstant(d, "BITMAP_TYPE_MACCURSOR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_MACCURSOR)));
56519 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANY",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANY)));
56520 SWIG_Python_SetConstant(d, "CURSOR_NONE",SWIG_From_int(static_cast< int >(wxCURSOR_NONE)));
56521 SWIG_Python_SetConstant(d, "CURSOR_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_ARROW)));
56522 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_ARROW)));
56523 SWIG_Python_SetConstant(d, "CURSOR_BULLSEYE",SWIG_From_int(static_cast< int >(wxCURSOR_BULLSEYE)));
56524 SWIG_Python_SetConstant(d, "CURSOR_CHAR",SWIG_From_int(static_cast< int >(wxCURSOR_CHAR)));
56525 SWIG_Python_SetConstant(d, "CURSOR_CROSS",SWIG_From_int(static_cast< int >(wxCURSOR_CROSS)));
56526 SWIG_Python_SetConstant(d, "CURSOR_HAND",SWIG_From_int(static_cast< int >(wxCURSOR_HAND)));
56527 SWIG_Python_SetConstant(d, "CURSOR_IBEAM",SWIG_From_int(static_cast< int >(wxCURSOR_IBEAM)));
56528 SWIG_Python_SetConstant(d, "CURSOR_LEFT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_LEFT_BUTTON)));
56529 SWIG_Python_SetConstant(d, "CURSOR_MAGNIFIER",SWIG_From_int(static_cast< int >(wxCURSOR_MAGNIFIER)));
56530 SWIG_Python_SetConstant(d, "CURSOR_MIDDLE_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_MIDDLE_BUTTON)));
56531 SWIG_Python_SetConstant(d, "CURSOR_NO_ENTRY",SWIG_From_int(static_cast< int >(wxCURSOR_NO_ENTRY)));
56532 SWIG_Python_SetConstant(d, "CURSOR_PAINT_BRUSH",SWIG_From_int(static_cast< int >(wxCURSOR_PAINT_BRUSH)));
56533 SWIG_Python_SetConstant(d, "CURSOR_PENCIL",SWIG_From_int(static_cast< int >(wxCURSOR_PENCIL)));
56534 SWIG_Python_SetConstant(d, "CURSOR_POINT_LEFT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_LEFT)));
56535 SWIG_Python_SetConstant(d, "CURSOR_POINT_RIGHT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_RIGHT)));
56536 SWIG_Python_SetConstant(d, "CURSOR_QUESTION_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_QUESTION_ARROW)));
56537 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_BUTTON)));
56538 SWIG_Python_SetConstant(d, "CURSOR_SIZENESW",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENESW)));
56539 SWIG_Python_SetConstant(d, "CURSOR_SIZENS",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENS)));
56540 SWIG_Python_SetConstant(d, "CURSOR_SIZENWSE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENWSE)));
56541 SWIG_Python_SetConstant(d, "CURSOR_SIZEWE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZEWE)));
56542 SWIG_Python_SetConstant(d, "CURSOR_SIZING",SWIG_From_int(static_cast< int >(wxCURSOR_SIZING)));
56543 SWIG_Python_SetConstant(d, "CURSOR_SPRAYCAN",SWIG_From_int(static_cast< int >(wxCURSOR_SPRAYCAN)));
56544 SWIG_Python_SetConstant(d, "CURSOR_WAIT",SWIG_From_int(static_cast< int >(wxCURSOR_WAIT)));
56545 SWIG_Python_SetConstant(d, "CURSOR_WATCH",SWIG_From_int(static_cast< int >(wxCURSOR_WATCH)));
56546 SWIG_Python_SetConstant(d, "CURSOR_BLANK",SWIG_From_int(static_cast< int >(wxCURSOR_BLANK)));
56547 SWIG_Python_SetConstant(d, "CURSOR_DEFAULT",SWIG_From_int(static_cast< int >(wxCURSOR_DEFAULT)));
56548 SWIG_Python_SetConstant(d, "CURSOR_COPY_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_COPY_ARROW)));
56549 SWIG_Python_SetConstant(d, "CURSOR_ARROWWAIT",SWIG_From_int(static_cast< int >(wxCURSOR_ARROWWAIT)));
56550 SWIG_Python_SetConstant(d, "CURSOR_MAX",SWIG_From_int(static_cast< int >(wxCURSOR_MAX)));
56551 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultPosition",DefaultPosition_get, DefaultPosition_set);
56552 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSize",DefaultSize_get, DefaultSize_set);
56553 SWIG_Python_SetConstant(d, "FromStart",SWIG_From_int(static_cast< int >(wxFromStart)));
56554 SWIG_Python_SetConstant(d, "FromCurrent",SWIG_From_int(static_cast< int >(wxFromCurrent)));
56555 SWIG_Python_SetConstant(d, "FromEnd",SWIG_From_int(static_cast< int >(wxFromEnd)));
56556
56557 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
56558
56559
56560 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
56561
56562 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_TRANSPARENT",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_TRANSPARENT)));
56563 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_THRESHOLD",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_THRESHOLD)));
56564 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_OPAQUE",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_OPAQUE)));
56565 SWIG_addvarlink(SWIG_globals(),(char*)"NullImage",NullImage_get, NullImage_set);
56566 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_FILENAME",IMAGE_OPTION_FILENAME_get, IMAGE_OPTION_FILENAME_set);
56567 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BMP_FORMAT",IMAGE_OPTION_BMP_FORMAT_get, IMAGE_OPTION_BMP_FORMAT_set);
56568 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",IMAGE_OPTION_CUR_HOTSPOT_X_get, IMAGE_OPTION_CUR_HOTSPOT_X_set);
56569 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",IMAGE_OPTION_CUR_HOTSPOT_Y_get, IMAGE_OPTION_CUR_HOTSPOT_Y_set);
56570 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTION",IMAGE_OPTION_RESOLUTION_get, IMAGE_OPTION_RESOLUTION_set);
56571 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONX",IMAGE_OPTION_RESOLUTIONX_get, IMAGE_OPTION_RESOLUTIONX_set);
56572 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONY",IMAGE_OPTION_RESOLUTIONY_get, IMAGE_OPTION_RESOLUTIONY_set);
56573 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONUNIT",IMAGE_OPTION_RESOLUTIONUNIT_get, IMAGE_OPTION_RESOLUTIONUNIT_set);
56574 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_QUALITY",IMAGE_OPTION_QUALITY_get, IMAGE_OPTION_QUALITY_set);
56575 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_INCHES",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_INCHES)));
56576 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_CM",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_CM)));
56577 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BITSPERSAMPLE",IMAGE_OPTION_BITSPERSAMPLE_get, IMAGE_OPTION_BITSPERSAMPLE_set);
56578 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",IMAGE_OPTION_SAMPLESPERPIXEL_get, IMAGE_OPTION_SAMPLESPERPIXEL_set);
56579 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_COMPRESSION",IMAGE_OPTION_COMPRESSION_get, IMAGE_OPTION_COMPRESSION_set);
56580 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",IMAGE_OPTION_IMAGEDESCRIPTOR_get, IMAGE_OPTION_IMAGEDESCRIPTOR_set);
56581 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_FORMAT",IMAGE_OPTION_PNG_FORMAT_get, IMAGE_OPTION_PNG_FORMAT_set);
56582 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_BITDEPTH",IMAGE_OPTION_PNG_BITDEPTH_get, IMAGE_OPTION_PNG_BITDEPTH_set);
56583 SWIG_Python_SetConstant(d, "PNG_TYPE_COLOUR",SWIG_From_int(static_cast< int >(wxPNG_TYPE_COLOUR)));
56584 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY)));
56585 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY_RED",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY_RED)));
56586 SWIG_Python_SetConstant(d, "BMP_24BPP",SWIG_From_int(static_cast< int >(wxBMP_24BPP)));
56587 SWIG_Python_SetConstant(d, "BMP_8BPP",SWIG_From_int(static_cast< int >(wxBMP_8BPP)));
56588 SWIG_Python_SetConstant(d, "BMP_8BPP_GREY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GREY)));
56589 SWIG_Python_SetConstant(d, "BMP_8BPP_GRAY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GRAY)));
56590 SWIG_Python_SetConstant(d, "BMP_8BPP_RED",SWIG_From_int(static_cast< int >(wxBMP_8BPP_RED)));
56591 SWIG_Python_SetConstant(d, "BMP_8BPP_PALETTE",SWIG_From_int(static_cast< int >(wxBMP_8BPP_PALETTE)));
56592 SWIG_Python_SetConstant(d, "BMP_4BPP",SWIG_From_int(static_cast< int >(wxBMP_4BPP)));
56593 SWIG_Python_SetConstant(d, "BMP_1BPP",SWIG_From_int(static_cast< int >(wxBMP_1BPP)));
56594 SWIG_Python_SetConstant(d, "BMP_1BPP_BW",SWIG_From_int(static_cast< int >(wxBMP_1BPP_BW)));
56595 SWIG_Python_SetConstant(d, "QUANTIZE_INCLUDE_WINDOWS_COLOURS",SWIG_From_int(static_cast< int >(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
56596 SWIG_Python_SetConstant(d, "QUANTIZE_FILL_DESTINATION_IMAGE",SWIG_From_int(static_cast< int >(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
56597 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_NONE",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_NONE)));
56598 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_MAX",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_MAX)));
56599 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
56600 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
56601 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
56602 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
56603 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
56604 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
56605 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
56606 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
56607 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
56608 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
56609 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
56610 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
56611 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
56612 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
56613 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
56614 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
56615 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
56616 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
56617 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
56618 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
56619 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
56620 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
56621 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
56622 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
56623 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
56624 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
56625 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
56626 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
56627 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
56628 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
56629 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
56630 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
56631 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
56632 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
56633 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
56634 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
56635 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
56636 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
56637 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
56638 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
56639 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
56640 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
56641 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
56642 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
56643 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
56644 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
56645 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
56646 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
56647 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
56648 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
56649 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
56650 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
56651 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
56652 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
56653 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
56654 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
56655 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
56656 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
56657 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
56658 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
56659 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
56660 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
56661 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
56662 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
56663 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
56664 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
56665 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
56666 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
56667 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
56668 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
56669 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
56670 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
56671 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
56672 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
56673 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
56674 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
56675 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
56676 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
56677 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
56678 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
56679 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
56680 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
56681 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
56682 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
56683 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_LOST", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_LOST));
56684 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
56685 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
56686 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
56687 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
56688 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
56689 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
56690 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
56691 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
56692 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
56693 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
56694 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
56695 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
56696 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
56697 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
56698 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
56699 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
56700 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
56701 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
56702 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
56703 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
56704 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
56705 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
56706 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
56707 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_COPY", PyInt_FromLong(wxEVT_COMMAND_TEXT_COPY));
56708 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_CUT", PyInt_FromLong(wxEVT_COMMAND_TEXT_CUT));
56709 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_PASTE", PyInt_FromLong(wxEVT_COMMAND_TEXT_PASTE));
56710 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
56711 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
56712 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
56713 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
56714 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
56715 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
56716 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
56717 SWIG_Python_SetConstant(d, "MOUSE_BTN_ANY",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_ANY)));
56718 SWIG_Python_SetConstant(d, "MOUSE_BTN_NONE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_NONE)));
56719 SWIG_Python_SetConstant(d, "MOUSE_BTN_LEFT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_LEFT)));
56720 SWIG_Python_SetConstant(d, "MOUSE_BTN_MIDDLE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_MIDDLE)));
56721 SWIG_Python_SetConstant(d, "MOUSE_BTN_RIGHT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_RIGHT)));
56722 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_ALL)));
56723 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_SPECIFIED)));
56724 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsBackward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsBackward)));
56725 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsForward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsForward)));
56726 SWIG_Python_SetConstant(d, "NavigationKeyEvent_WinChange",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::WinChange)));
56727 SWIG_Python_SetConstant(d, "NavigationKeyEvent_FromTab",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::FromTab)));
56728 SWIG_Python_SetConstant(d, "IDLE_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_ALL)));
56729 SWIG_Python_SetConstant(d, "IDLE_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_SPECIFIED)));
56730 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
56731 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_SUPPRESS",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_SUPPRESS)));
56732 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_EXCEPTION",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_EXCEPTION)));
56733 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_DIALOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_DIALOG)));
56734 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_LOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_LOG)));
56735 SWIG_Python_SetConstant(d, "PRINT_WINDOWS",SWIG_From_int(static_cast< int >(wxPRINT_WINDOWS)));
56736 SWIG_Python_SetConstant(d, "PRINT_POSTSCRIPT",SWIG_From_int(static_cast< int >(wxPRINT_POSTSCRIPT)));
56737 SWIG_addvarlink(SWIG_globals(),(char*)"NullAcceleratorTable",NullAcceleratorTable_get, NullAcceleratorTable_set);
56738 SWIG_addvarlink(SWIG_globals(),(char*)"PanelNameStr",PanelNameStr_get, PanelNameStr_set);
56739 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_NORMAL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_NORMAL)));
56740 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_SMALL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_SMALL)));
56741 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MINI",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MINI)));
56742 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_LARGE",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_LARGE)));
56743 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MAX",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MAX)));
56744 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultValidator",DefaultValidator_get, DefaultValidator_set);
56745 SWIG_addvarlink(SWIG_globals(),(char*)"ControlNameStr",ControlNameStr_get, ControlNameStr_set);
56746 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_NONE",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_NONE)));
56747 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_SPECIFIED",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_SPECIFIED)));
56748 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_ALL",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_ALL)));
56749 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSpan",DefaultSpan_get, DefaultSpan_set);
56750 SWIG_Python_SetConstant(d, "Left",SWIG_From_int(static_cast< int >(wxLeft)));
56751 SWIG_Python_SetConstant(d, "Top",SWIG_From_int(static_cast< int >(wxTop)));
56752 SWIG_Python_SetConstant(d, "Right",SWIG_From_int(static_cast< int >(wxRight)));
56753 SWIG_Python_SetConstant(d, "Bottom",SWIG_From_int(static_cast< int >(wxBottom)));
56754 SWIG_Python_SetConstant(d, "Width",SWIG_From_int(static_cast< int >(wxWidth)));
56755 SWIG_Python_SetConstant(d, "Height",SWIG_From_int(static_cast< int >(wxHeight)));
56756 SWIG_Python_SetConstant(d, "Centre",SWIG_From_int(static_cast< int >(wxCentre)));
56757 SWIG_Python_SetConstant(d, "Center",SWIG_From_int(static_cast< int >(wxCenter)));
56758 SWIG_Python_SetConstant(d, "CentreX",SWIG_From_int(static_cast< int >(wxCentreX)));
56759 SWIG_Python_SetConstant(d, "CentreY",SWIG_From_int(static_cast< int >(wxCentreY)));
56760 SWIG_Python_SetConstant(d, "Unconstrained",SWIG_From_int(static_cast< int >(wxUnconstrained)));
56761 SWIG_Python_SetConstant(d, "AsIs",SWIG_From_int(static_cast< int >(wxAsIs)));
56762 SWIG_Python_SetConstant(d, "PercentOf",SWIG_From_int(static_cast< int >(wxPercentOf)));
56763 SWIG_Python_SetConstant(d, "Above",SWIG_From_int(static_cast< int >(wxAbove)));
56764 SWIG_Python_SetConstant(d, "Below",SWIG_From_int(static_cast< int >(wxBelow)));
56765 SWIG_Python_SetConstant(d, "LeftOf",SWIG_From_int(static_cast< int >(wxLeftOf)));
56766 SWIG_Python_SetConstant(d, "RightOf",SWIG_From_int(static_cast< int >(wxRightOf)));
56767 SWIG_Python_SetConstant(d, "SameAs",SWIG_From_int(static_cast< int >(wxSameAs)));
56768 SWIG_Python_SetConstant(d, "Absolute",SWIG_From_int(static_cast< int >(wxAbsolute)));
56769
56770 // Initialize threading, some globals and such
56771 __wxPyPreStart(d);
56772
56773
56774 // Although these are defined in __version__ they need to be here too so
56775 // that an assert can be done to ensure that the wxPython and the wxWindows
56776 // versions match.
56777 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
56778 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
56779 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
56780
56781 }
56782
wxWidgets (Impactor)