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


d5a5ee1296f41a9d133dd23f5631d5ec6714a7b8
[wxWidgets.git] / wxPython / src / gtk / _core_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.29
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
13
14 #ifdef __cplusplus
15 template<class T> class SwigValueWrapper {
16 T *tt;
17 public:
18 SwigValueWrapper() : tt(0) { }
19 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
20 SwigValueWrapper(const T& t) : tt(new T(t)) { }
21 ~SwigValueWrapper() { delete tt; }
22 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
23 operator T&() const { return *tt; }
24 T *operator&() { return tt; }
25 private:
26 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
27 };
28 #endif
29
30 /* -----------------------------------------------------------------------------
31 * This section contains generic SWIG labels for method/variable
32 * declarations/attributes, and other compiler dependent labels.
33 * ----------------------------------------------------------------------------- */
34
35 /* template workaround for compilers that cannot correctly implement the C++ standard */
36 #ifndef SWIGTEMPLATEDISAMBIGUATOR
37 # if defined(__SUNPRO_CC)
38 # if (__SUNPRO_CC <= 0x560)
39 # define SWIGTEMPLATEDISAMBIGUATOR template
40 # else
41 # define SWIGTEMPLATEDISAMBIGUATOR
42 # endif
43 # else
44 # define SWIGTEMPLATEDISAMBIGUATOR
45 # endif
46 #endif
47
48 /* inline attribute */
49 #ifndef SWIGINLINE
50 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
51 # define SWIGINLINE inline
52 # else
53 # define SWIGINLINE
54 # endif
55 #endif
56
57 /* attribute recognised by some compilers to avoid 'unused' warnings */
58 #ifndef SWIGUNUSED
59 # if defined(__GNUC__)
60 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
61 # define SWIGUNUSED __attribute__ ((__unused__))
62 # else
63 # define SWIGUNUSED
64 # endif
65 # elif defined(__ICC)
66 # define SWIGUNUSED __attribute__ ((__unused__))
67 # else
68 # define SWIGUNUSED
69 # endif
70 #endif
71
72 #ifndef SWIGUNUSEDPARM
73 # ifdef __cplusplus
74 # define SWIGUNUSEDPARM(p)
75 # else
76 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
77 # endif
78 #endif
79
80 /* internal SWIG method */
81 #ifndef SWIGINTERN
82 # define SWIGINTERN static SWIGUNUSED
83 #endif
84
85 /* internal inline SWIG method */
86 #ifndef SWIGINTERNINLINE
87 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
88 #endif
89
90 /* exporting methods */
91 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
92 # ifndef GCC_HASCLASSVISIBILITY
93 # define GCC_HASCLASSVISIBILITY
94 # endif
95 #endif
96
97 #ifndef SWIGEXPORT
98 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
99 # if defined(STATIC_LINKED)
100 # define SWIGEXPORT
101 # else
102 # define SWIGEXPORT __declspec(dllexport)
103 # endif
104 # else
105 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
106 # define SWIGEXPORT __attribute__ ((visibility("default")))
107 # else
108 # define SWIGEXPORT
109 # endif
110 # endif
111 #endif
112
113 /* calling conventions for Windows */
114 #ifndef SWIGSTDCALL
115 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
116 # define SWIGSTDCALL __stdcall
117 # else
118 # define SWIGSTDCALL
119 # endif
120 #endif
121
122 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
123 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
124 # define _CRT_SECURE_NO_DEPRECATE
125 #endif
126
127
128 /* Python.h has to appear first */
129 #include <Python.h>
130
131 /* -----------------------------------------------------------------------------
132 * swigrun.swg
133 *
134 * This file contains generic CAPI SWIG runtime support for pointer
135 * type checking.
136 * ----------------------------------------------------------------------------- */
137
138 /* This should only be incremented when either the layout of swig_type_info changes,
139 or for whatever reason, the runtime changes incompatibly */
140 #define SWIG_RUNTIME_VERSION "2"
141
142 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
143 #ifdef SWIG_TYPE_TABLE
144 # define SWIG_QUOTE_STRING(x) #x
145 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
146 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
147 #else
148 # define SWIG_TYPE_TABLE_NAME
149 #endif
150
151 /*
152 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
153 creating a static or dynamic library from the swig runtime code.
154 In 99.9% of the cases, swig just needs to declare them as 'static'.
155
156 But only do this if is strictly necessary, ie, if you have problems
157 with your compiler or so.
158 */
159
160 #ifndef SWIGRUNTIME
161 # define SWIGRUNTIME SWIGINTERN
162 #endif
163
164 #ifndef SWIGRUNTIMEINLINE
165 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
166 #endif
167
168 /* Generic buffer size */
169 #ifndef SWIG_BUFFER_SIZE
170 # define SWIG_BUFFER_SIZE 1024
171 #endif
172
173 /* Flags for pointer conversions */
174 #define SWIG_POINTER_DISOWN 0x1
175
176 /* Flags for new pointer objects */
177 #define SWIG_POINTER_OWN 0x1
178
179
180 /*
181 Flags/methods for returning states.
182
183 The swig conversion methods, as ConvertPtr, return and integer
184 that tells if the conversion was successful or not. And if not,
185 an error code can be returned (see swigerrors.swg for the codes).
186
187 Use the following macros/flags to set or process the returning
188 states.
189
190 In old swig versions, you usually write code as:
191
192 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
193 // success code
194 } else {
195 //fail code
196 }
197
198 Now you can be more explicit as:
199
200 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
201 if (SWIG_IsOK(res)) {
202 // success code
203 } else {
204 // fail code
205 }
206
207 that seems to be the same, but now you can also do
208
209 Type *ptr;
210 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
211 if (SWIG_IsOK(res)) {
212 // success code
213 if (SWIG_IsNewObj(res) {
214 ...
215 delete *ptr;
216 } else {
217 ...
218 }
219 } else {
220 // fail code
221 }
222
223 I.e., now SWIG_ConvertPtr can return new objects and you can
224 identify the case and take care of the deallocation. Of course that
225 requires also to SWIG_ConvertPtr to return new result values, as
226
227 int SWIG_ConvertPtr(obj, ptr,...) {
228 if (<obj is ok>) {
229 if (<need new object>) {
230 *ptr = <ptr to new allocated object>;
231 return SWIG_NEWOBJ;
232 } else {
233 *ptr = <ptr to old object>;
234 return SWIG_OLDOBJ;
235 }
236 } else {
237 return SWIG_BADOBJ;
238 }
239 }
240
241 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
242 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
243 swig errors code.
244
245 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
246 allows to return the 'cast rank', for example, if you have this
247
248 int food(double)
249 int fooi(int);
250
251 and you call
252
253 food(1) // cast rank '1' (1 -> 1.0)
254 fooi(1) // cast rank '0'
255
256 just use the SWIG_AddCast()/SWIG_CheckState()
257
258
259 */
260 #define SWIG_OK (0)
261 #define SWIG_ERROR (-1)
262 #define SWIG_IsOK(r) (r >= 0)
263 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
264
265 /* The CastRankLimit says how many bits are used for the cast rank */
266 #define SWIG_CASTRANKLIMIT (1 << 8)
267 /* The NewMask denotes the object was created (using new/malloc) */
268 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
269 /* The TmpMask is for in/out typemaps that use temporal objects */
270 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
271 /* Simple returning values */
272 #define SWIG_BADOBJ (SWIG_ERROR)
273 #define SWIG_OLDOBJ (SWIG_OK)
274 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
275 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
276 /* Check, add and del mask methods */
277 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
278 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
279 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
280 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
281 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
282 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
283
284
285 /* Cast-Rank Mode */
286 #if defined(SWIG_CASTRANK_MODE)
287 # ifndef SWIG_TypeRank
288 # define SWIG_TypeRank unsigned long
289 # endif
290 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
291 # define SWIG_MAXCASTRANK (2)
292 # endif
293 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
294 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
295 SWIGINTERNINLINE int SWIG_AddCast(int r) {
296 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
297 }
298 SWIGINTERNINLINE int SWIG_CheckState(int r) {
299 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
300 }
301 #else /* no cast-rank mode */
302 # define SWIG_AddCast
303 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
304 #endif
305
306
307
308
309 #include <string.h>
310
311 #ifdef __cplusplus
312 extern "C" {
313 #endif
314
315 typedef void *(*swig_converter_func)(void *);
316 typedef struct swig_type_info *(*swig_dycast_func)(void **);
317
318 /* Structure to store inforomation on one type */
319 typedef struct swig_type_info {
320 const char *name; /* mangled name of this type */
321 const char *str; /* human readable name of this type */
322 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
323 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
324 void *clientdata; /* language specific type data */
325 int owndata; /* flag if the structure owns the clientdata */
326 } swig_type_info;
327
328 /* Structure to store a type and conversion function used for casting */
329 typedef struct swig_cast_info {
330 swig_type_info *type; /* pointer to type that is equivalent to this type */
331 swig_converter_func converter; /* function to cast the void pointers */
332 struct swig_cast_info *next; /* pointer to next cast in linked list */
333 struct swig_cast_info *prev; /* pointer to the previous cast */
334 } swig_cast_info;
335
336 /* Structure used to store module information
337 * Each module generates one structure like this, and the runtime collects
338 * all of these structures and stores them in a circularly linked list.*/
339 typedef struct swig_module_info {
340 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
341 size_t size; /* Number of types in this module */
342 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
343 swig_type_info **type_initial; /* Array of initially generated type structures */
344 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
345 void *clientdata; /* Language specific module data */
346 } swig_module_info;
347
348 /*
349 Compare two type names skipping the space characters, therefore
350 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
351
352 Return 0 when the two name types are equivalent, as in
353 strncmp, but skipping ' '.
354 */
355 SWIGRUNTIME int
356 SWIG_TypeNameComp(const char *f1, const char *l1,
357 const char *f2, const char *l2) {
358 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
359 while ((*f1 == ' ') && (f1 != l1)) ++f1;
360 while ((*f2 == ' ') && (f2 != l2)) ++f2;
361 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
362 }
363 return (l1 - f1) - (l2 - f2);
364 }
365
366 /*
367 Check type equivalence in a name list like <name1>|<name2>|...
368 Return 0 if not equal, 1 if equal
369 */
370 SWIGRUNTIME int
371 SWIG_TypeEquiv(const char *nb, const char *tb) {
372 int equiv = 0;
373 const char* te = tb + strlen(tb);
374 const char* ne = nb;
375 while (!equiv && *ne) {
376 for (nb = ne; *ne; ++ne) {
377 if (*ne == '|') break;
378 }
379 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
380 if (*ne) ++ne;
381 }
382 return equiv;
383 }
384
385 /*
386 Check type equivalence in a name list like <name1>|<name2>|...
387 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
388 */
389 SWIGRUNTIME int
390 SWIG_TypeCompare(const char *nb, const char *tb) {
391 int equiv = 0;
392 const char* te = tb + strlen(tb);
393 const char* ne = nb;
394 while (!equiv && *ne) {
395 for (nb = ne; *ne; ++ne) {
396 if (*ne == '|') break;
397 }
398 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
399 if (*ne) ++ne;
400 }
401 return equiv;
402 }
403
404
405 /* think of this as a c++ template<> or a scheme macro */
406 #define SWIG_TypeCheck_Template(comparison, ty) \
407 if (ty) { \
408 swig_cast_info *iter = ty->cast; \
409 while (iter) { \
410 if (comparison) { \
411 if (iter == ty->cast) return iter; \
412 /* Move iter to the top of the linked list */ \
413 iter->prev->next = iter->next; \
414 if (iter->next) \
415 iter->next->prev = iter->prev; \
416 iter->next = ty->cast; \
417 iter->prev = 0; \
418 if (ty->cast) ty->cast->prev = iter; \
419 ty->cast = iter; \
420 return iter; \
421 } \
422 iter = iter->next; \
423 } \
424 } \
425 return 0
426
427 /*
428 Check the typename
429 */
430 SWIGRUNTIME swig_cast_info *
431 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
432 SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
433 }
434
435 /* Same as previous function, except strcmp is replaced with a pointer comparison */
436 SWIGRUNTIME swig_cast_info *
437 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
438 SWIG_TypeCheck_Template(iter->type == from, into);
439 }
440
441 /*
442 Cast a pointer up an inheritance hierarchy
443 */
444 SWIGRUNTIMEINLINE void *
445 SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
446 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
447 }
448
449 /*
450 Dynamic pointer casting. Down an inheritance hierarchy
451 */
452 SWIGRUNTIME swig_type_info *
453 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
454 swig_type_info *lastty = ty;
455 if (!ty || !ty->dcast) return ty;
456 while (ty && (ty->dcast)) {
457 ty = (*ty->dcast)(ptr);
458 if (ty) lastty = ty;
459 }
460 return lastty;
461 }
462
463 /*
464 Return the name associated with this type
465 */
466 SWIGRUNTIMEINLINE const char *
467 SWIG_TypeName(const swig_type_info *ty) {
468 return ty->name;
469 }
470
471 /*
472 Return the pretty name associated with this type,
473 that is an unmangled type name in a form presentable to the user.
474 */
475 SWIGRUNTIME const char *
476 SWIG_TypePrettyName(const swig_type_info *type) {
477 /* The "str" field contains the equivalent pretty names of the
478 type, separated by vertical-bar characters. We choose
479 to print the last name, as it is often (?) the most
480 specific. */
481 if (!type) return NULL;
482 if (type->str != NULL) {
483 const char *last_name = type->str;
484 const char *s;
485 for (s = type->str; *s; s++)
486 if (*s == '|') last_name = s+1;
487 return last_name;
488 }
489 else
490 return type->name;
491 }
492
493 /*
494 Set the clientdata field for a type
495 */
496 SWIGRUNTIME void
497 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
498 swig_cast_info *cast = ti->cast;
499 /* if (ti->clientdata == clientdata) return; */
500 ti->clientdata = clientdata;
501
502 while (cast) {
503 if (!cast->converter) {
504 swig_type_info *tc = cast->type;
505 if (!tc->clientdata) {
506 SWIG_TypeClientData(tc, clientdata);
507 }
508 }
509 cast = cast->next;
510 }
511 }
512 SWIGRUNTIME void
513 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
514 SWIG_TypeClientData(ti, clientdata);
515 ti->owndata = 1;
516 }
517
518 /*
519 Search for a swig_type_info structure only by mangled name
520 Search is a O(log #types)
521
522 We start searching at module start, and finish searching when start == end.
523 Note: if start == end at the beginning of the function, we go all the way around
524 the circular list.
525 */
526 SWIGRUNTIME swig_type_info *
527 SWIG_MangledTypeQueryModule(swig_module_info *start,
528 swig_module_info *end,
529 const char *name) {
530 swig_module_info *iter = start;
531 do {
532 if (iter->size) {
533 register size_t l = 0;
534 register size_t r = iter->size - 1;
535 do {
536 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
537 register size_t i = (l + r) >> 1;
538 const char *iname = iter->types[i]->name;
539 if (iname) {
540 register int compare = strcmp(name, iname);
541 if (compare == 0) {
542 return iter->types[i];
543 } else if (compare < 0) {
544 if (i) {
545 r = i - 1;
546 } else {
547 break;
548 }
549 } else if (compare > 0) {
550 l = i + 1;
551 }
552 } else {
553 break; /* should never happen */
554 }
555 } while (l <= r);
556 }
557 iter = iter->next;
558 } while (iter != end);
559 return 0;
560 }
561
562 /*
563 Search for a swig_type_info structure for either a mangled name or a human readable name.
564 It first searches the mangled names of the types, which is a O(log #types)
565 If a type is not found it then searches the human readable names, which is O(#types).
566
567 We start searching at module start, and finish searching when start == end.
568 Note: if start == end at the beginning of the function, we go all the way around
569 the circular list.
570 */
571 SWIGRUNTIME swig_type_info *
572 SWIG_TypeQueryModule(swig_module_info *start,
573 swig_module_info *end,
574 const char *name) {
575 /* STEP 1: Search the name field using binary search */
576 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
577 if (ret) {
578 return ret;
579 } else {
580 /* STEP 2: If the type hasn't been found, do a complete search
581 of the str field (the human readable name) */
582 swig_module_info *iter = start;
583 do {
584 register size_t i = 0;
585 for (; i < iter->size; ++i) {
586 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
587 return iter->types[i];
588 }
589 iter = iter->next;
590 } while (iter != end);
591 }
592
593 /* neither found a match */
594 return 0;
595 }
596
597 /*
598 Pack binary data into a string
599 */
600 SWIGRUNTIME char *
601 SWIG_PackData(char *c, void *ptr, size_t sz) {
602 static const char hex[17] = "0123456789abcdef";
603 register const unsigned char *u = (unsigned char *) ptr;
604 register const unsigned char *eu = u + sz;
605 for (; u != eu; ++u) {
606 register unsigned char uu = *u;
607 *(c++) = hex[(uu & 0xf0) >> 4];
608 *(c++) = hex[uu & 0xf];
609 }
610 return c;
611 }
612
613 /*
614 Unpack binary data from a string
615 */
616 SWIGRUNTIME const char *
617 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
618 register unsigned char *u = (unsigned char *) ptr;
619 register const unsigned char *eu = u + sz;
620 for (; u != eu; ++u) {
621 register char d = *(c++);
622 register unsigned char uu;
623 if ((d >= '0') && (d <= '9'))
624 uu = ((d - '0') << 4);
625 else if ((d >= 'a') && (d <= 'f'))
626 uu = ((d - ('a'-10)) << 4);
627 else
628 return (char *) 0;
629 d = *(c++);
630 if ((d >= '0') && (d <= '9'))
631 uu |= (d - '0');
632 else if ((d >= 'a') && (d <= 'f'))
633 uu |= (d - ('a'-10));
634 else
635 return (char *) 0;
636 *u = uu;
637 }
638 return c;
639 }
640
641 /*
642 Pack 'void *' into a string buffer.
643 */
644 SWIGRUNTIME char *
645 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
646 char *r = buff;
647 if ((2*sizeof(void *) + 2) > bsz) return 0;
648 *(r++) = '_';
649 r = SWIG_PackData(r,&ptr,sizeof(void *));
650 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
651 strcpy(r,name);
652 return buff;
653 }
654
655 SWIGRUNTIME const char *
656 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
657 if (*c != '_') {
658 if (strcmp(c,"NULL") == 0) {
659 *ptr = (void *) 0;
660 return name;
661 } else {
662 return 0;
663 }
664 }
665 return SWIG_UnpackData(++c,ptr,sizeof(void *));
666 }
667
668 SWIGRUNTIME char *
669 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
670 char *r = buff;
671 size_t lname = (name ? strlen(name) : 0);
672 if ((2*sz + 2 + lname) > bsz) return 0;
673 *(r++) = '_';
674 r = SWIG_PackData(r,ptr,sz);
675 if (lname) {
676 strncpy(r,name,lname+1);
677 } else {
678 *r = 0;
679 }
680 return buff;
681 }
682
683 SWIGRUNTIME const char *
684 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
685 if (*c != '_') {
686 if (strcmp(c,"NULL") == 0) {
687 memset(ptr,0,sz);
688 return name;
689 } else {
690 return 0;
691 }
692 }
693 return SWIG_UnpackData(++c,ptr,sz);
694 }
695
696 #ifdef __cplusplus
697 }
698 #endif
699
700 /* Errors in SWIG */
701 #define SWIG_UnknownError -1
702 #define SWIG_IOError -2
703 #define SWIG_RuntimeError -3
704 #define SWIG_IndexError -4
705 #define SWIG_TypeError -5
706 #define SWIG_DivisionByZero -6
707 #define SWIG_OverflowError -7
708 #define SWIG_SyntaxError -8
709 #define SWIG_ValueError -9
710 #define SWIG_SystemError -10
711 #define SWIG_AttributeError -11
712 #define SWIG_MemoryError -12
713 #define SWIG_NullReferenceError -13
714
715
716
717 /* Python.h has to appear first */
718 #include <Python.h>
719
720 /* Add PyOS_snprintf for old Pythons */
721 #if PY_VERSION_HEX < 0x02020000
722 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
723 # define PyOS_snprintf _snprintf
724 # else
725 # define PyOS_snprintf snprintf
726 # endif
727 #endif
728
729 /* A crude PyString_FromFormat implementation for old Pythons */
730 #if PY_VERSION_HEX < 0x02020000
731
732 #ifndef SWIG_PYBUFFER_SIZE
733 # define SWIG_PYBUFFER_SIZE 1024
734 #endif
735
736 static PyObject *
737 PyString_FromFormat(const char *fmt, ...) {
738 va_list ap;
739 char buf[SWIG_PYBUFFER_SIZE * 2];
740 int res;
741 va_start(ap, fmt);
742 res = vsnprintf(buf, sizeof(buf), fmt, ap);
743 va_end(ap);
744 return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
745 }
746 #endif
747
748 /* Add PyObject_Del for old Pythons */
749 #if PY_VERSION_HEX < 0x01060000
750 # define PyObject_Del(op) PyMem_DEL((op))
751 #endif
752 #ifndef PyObject_DEL
753 # define PyObject_DEL PyObject_Del
754 #endif
755
756 /* A crude PyExc_StopIteration exception for old Pythons */
757 #if PY_VERSION_HEX < 0x02020000
758 # ifndef PyExc_StopIteration
759 # define PyExc_StopIteration PyExc_RuntimeError
760 # endif
761 # ifndef PyObject_GenericGetAttr
762 # define PyObject_GenericGetAttr 0
763 # endif
764 #endif
765 /* Py_NotImplemented is defined in 2.1 and up. */
766 #if PY_VERSION_HEX < 0x02010000
767 # ifndef Py_NotImplemented
768 # define Py_NotImplemented PyExc_RuntimeError
769 # endif
770 #endif
771
772
773 /* A crude PyString_AsStringAndSize implementation for old Pythons */
774 #if PY_VERSION_HEX < 0x02010000
775 # ifndef PyString_AsStringAndSize
776 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
777 # endif
778 #endif
779
780 /* PySequence_Size for old Pythons */
781 #if PY_VERSION_HEX < 0x02000000
782 # ifndef PySequence_Size
783 # define PySequence_Size PySequence_Length
784 # endif
785 #endif
786
787
788 /* PyBool_FromLong for old Pythons */
789 #if PY_VERSION_HEX < 0x02030000
790 static
791 PyObject *PyBool_FromLong(long ok)
792 {
793 PyObject *result = ok ? Py_True : Py_False;
794 Py_INCREF(result);
795 return result;
796 }
797 #endif
798
799
800 /* -----------------------------------------------------------------------------
801 * error manipulation
802 * ----------------------------------------------------------------------------- */
803
804 SWIGRUNTIME PyObject*
805 SWIG_Python_ErrorType(int code) {
806 PyObject* type = 0;
807 switch(code) {
808 case SWIG_MemoryError:
809 type = PyExc_MemoryError;
810 break;
811 case SWIG_IOError:
812 type = PyExc_IOError;
813 break;
814 case SWIG_RuntimeError:
815 type = PyExc_RuntimeError;
816 break;
817 case SWIG_IndexError:
818 type = PyExc_IndexError;
819 break;
820 case SWIG_TypeError:
821 type = PyExc_TypeError;
822 break;
823 case SWIG_DivisionByZero:
824 type = PyExc_ZeroDivisionError;
825 break;
826 case SWIG_OverflowError:
827 type = PyExc_OverflowError;
828 break;
829 case SWIG_SyntaxError:
830 type = PyExc_SyntaxError;
831 break;
832 case SWIG_ValueError:
833 type = PyExc_ValueError;
834 break;
835 case SWIG_SystemError:
836 type = PyExc_SystemError;
837 break;
838 case SWIG_AttributeError:
839 type = PyExc_AttributeError;
840 break;
841 default:
842 type = PyExc_RuntimeError;
843 }
844 return type;
845 }
846
847
848 SWIGRUNTIME void
849 SWIG_Python_AddErrorMsg(const char* mesg)
850 {
851 PyObject *type = 0;
852 PyObject *value = 0;
853 PyObject *traceback = 0;
854
855 if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
856 if (value) {
857 PyObject *old_str = PyObject_Str(value);
858 PyErr_Clear();
859 Py_XINCREF(type);
860 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
861 Py_DECREF(old_str);
862 Py_DECREF(value);
863 } else {
864 PyErr_Format(PyExc_RuntimeError, mesg);
865 }
866 }
867
868
869
870 #if defined(SWIG_PYTHON_NO_THREADS)
871 # if defined(SWIG_PYTHON_THREADS)
872 # undef SWIG_PYTHON_THREADS
873 # endif
874 #endif
875 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
876 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
877 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
878 # define SWIG_PYTHON_USE_GIL
879 # endif
880 # endif
881 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
882 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
883 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
884 # endif
885 # ifdef __cplusplus /* C++ code */
886 class SWIG_Python_Thread_Block {
887 bool status;
888 PyGILState_STATE state;
889 public:
890 void end() { if (status) { PyGILState_Release(state); status = false;} }
891 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
892 ~SWIG_Python_Thread_Block() { end(); }
893 };
894 class SWIG_Python_Thread_Allow {
895 bool status;
896 PyThreadState *save;
897 public:
898 void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
899 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
900 ~SWIG_Python_Thread_Allow() { end(); }
901 };
902 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
903 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
904 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
905 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
906 # else /* C code */
907 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
908 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
909 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
910 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
911 # endif
912 # else /* Old thread way, not implemented, user must provide it */
913 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
914 # define SWIG_PYTHON_INITIALIZE_THREADS
915 # endif
916 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
917 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
918 # endif
919 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
920 # define SWIG_PYTHON_THREAD_END_BLOCK
921 # endif
922 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
923 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
924 # endif
925 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
926 # define SWIG_PYTHON_THREAD_END_ALLOW
927 # endif
928 # endif
929 #else /* No thread support */
930 # define SWIG_PYTHON_INITIALIZE_THREADS
931 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
932 # define SWIG_PYTHON_THREAD_END_BLOCK
933 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
934 # define SWIG_PYTHON_THREAD_END_ALLOW
935 #endif
936
937 /* -----------------------------------------------------------------------------
938 * Python API portion that goes into the runtime
939 * ----------------------------------------------------------------------------- */
940
941 #ifdef __cplusplus
942 extern "C" {
943 #if 0
944 } /* cc-mode */
945 #endif
946 #endif
947
948 /* -----------------------------------------------------------------------------
949 * Constant declarations
950 * ----------------------------------------------------------------------------- */
951
952 /* Constant Types */
953 #define SWIG_PY_POINTER 4
954 #define SWIG_PY_BINARY 5
955
956 /* Constant information structure */
957 typedef struct swig_const_info {
958 int type;
959 char *name;
960 long lvalue;
961 double dvalue;
962 void *pvalue;
963 swig_type_info **ptype;
964 } swig_const_info;
965
966 #ifdef __cplusplus
967 #if 0
968 { /* cc-mode */
969 #endif
970 }
971 #endif
972
973
974 /* -----------------------------------------------------------------------------
975 * See the LICENSE file for information on copyright, usage and redistribution
976 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
977 *
978 * pyrun.swg
979 *
980 * This file contains the runtime support for Python modules
981 * and includes code for managing global variables and pointer
982 * type checking.
983 *
984 * ----------------------------------------------------------------------------- */
985
986 /* Common SWIG API */
987
988 /* for raw pointers */
989 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
990 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
991 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
992 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
993 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
994 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
995 #define swig_owntype int
996
997 /* for raw packed data */
998 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
999 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1000
1001 /* for class or struct pointers */
1002 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1003 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1004
1005 /* for C or C++ function pointers */
1006 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1007 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
1008
1009 /* for C++ member pointers, ie, member methods */
1010 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1011 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1012
1013
1014 /* Runtime API */
1015
1016 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1017 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1018 #define SWIG_NewClientData(obj) PySwigClientData_New(obj)
1019
1020 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1021 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1022 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1023 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1024 #define SWIG_fail goto fail
1025
1026
1027 /* Runtime API implementation */
1028
1029 /* Error manipulation */
1030
1031 SWIGINTERN void
1032 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1033 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1034 PyErr_SetObject(errtype, obj);
1035 Py_DECREF(obj);
1036 SWIG_PYTHON_THREAD_END_BLOCK;
1037 }
1038
1039 SWIGINTERN void
1040 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1041 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1042 PyErr_SetString(errtype, (char *) msg);
1043 SWIG_PYTHON_THREAD_END_BLOCK;
1044 }
1045
1046 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1047
1048 /* Set a constant value */
1049
1050 SWIGINTERN void
1051 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1052 PyDict_SetItemString(d, (char*) name, obj);
1053 Py_DECREF(obj);
1054 }
1055
1056 /* Append a value to the result obj */
1057
1058 SWIGINTERN PyObject*
1059 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1060 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1061 if (!result) {
1062 result = obj;
1063 } else if (result == Py_None) {
1064 Py_DECREF(result);
1065 result = obj;
1066 } else {
1067 if (!PyList_Check(result)) {
1068 PyObject *o2 = result;
1069 result = PyList_New(1);
1070 PyList_SetItem(result, 0, o2);
1071 }
1072 PyList_Append(result,obj);
1073 Py_DECREF(obj);
1074 }
1075 return result;
1076 #else
1077 PyObject* o2;
1078 PyObject* o3;
1079 if (!result) {
1080 result = obj;
1081 } else if (result == Py_None) {
1082 Py_DECREF(result);
1083 result = obj;
1084 } else {
1085 if (!PyTuple_Check(result)) {
1086 o2 = result;
1087 result = PyTuple_New(1);
1088 PyTuple_SET_ITEM(result, 0, o2);
1089 }
1090 o3 = PyTuple_New(1);
1091 PyTuple_SET_ITEM(o3, 0, obj);
1092 o2 = result;
1093 result = PySequence_Concat(o2, o3);
1094 Py_DECREF(o2);
1095 Py_DECREF(o3);
1096 }
1097 return result;
1098 #endif
1099 }
1100
1101 /* Unpack the argument tuple */
1102
1103 SWIGINTERN int
1104 SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs)
1105 {
1106 if (!args) {
1107 if (!min && !max) {
1108 return 1;
1109 } else {
1110 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1111 name, (min == max ? "" : "at least "), min);
1112 return 0;
1113 }
1114 }
1115 if (!PyTuple_Check(args)) {
1116 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1117 return 0;
1118 } else {
1119 register int l = PyTuple_GET_SIZE(args);
1120 if (l < min) {
1121 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1122 name, (min == max ? "" : "at least "), min, l);
1123 return 0;
1124 } else if (l > max) {
1125 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1126 name, (min == max ? "" : "at most "), max, l);
1127 return 0;
1128 } else {
1129 register int i;
1130 for (i = 0; i < l; ++i) {
1131 objs[i] = PyTuple_GET_ITEM(args, i);
1132 }
1133 for (; l < max; ++l) {
1134 objs[l] = 0;
1135 }
1136 return i + 1;
1137 }
1138 }
1139 }
1140
1141 /* A functor is a function object with one single object argument */
1142 #if PY_VERSION_HEX >= 0x02020000
1143 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1144 #else
1145 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1146 #endif
1147
1148 /*
1149 Helper for static pointer initialization for both C and C++ code, for example
1150 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1151 */
1152 #ifdef __cplusplus
1153 #define SWIG_STATIC_POINTER(var) var
1154 #else
1155 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1156 #endif
1157
1158 /* -----------------------------------------------------------------------------
1159 * Pointer declarations
1160 * ----------------------------------------------------------------------------- */
1161
1162 /* Flags for new pointer objects */
1163 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1164 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1165
1166 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1167
1168 #ifdef __cplusplus
1169 extern "C" {
1170 #if 0
1171 } /* cc-mode */
1172 #endif
1173 #endif
1174
1175 /* How to access Py_None */
1176 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1177 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1178 # ifndef SWIG_PYTHON_BUILD_NONE
1179 # define SWIG_PYTHON_BUILD_NONE
1180 # endif
1181 # endif
1182 #endif
1183
1184 #ifdef SWIG_PYTHON_BUILD_NONE
1185 # ifdef Py_None
1186 # undef Py_None
1187 # define Py_None SWIG_Py_None()
1188 # endif
1189 SWIGRUNTIMEINLINE PyObject *
1190 _SWIG_Py_None(void)
1191 {
1192 PyObject *none = Py_BuildValue("");
1193 Py_DECREF(none);
1194 return none;
1195 }
1196 SWIGRUNTIME PyObject *
1197 SWIG_Py_None(void)
1198 {
1199 static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1200 return none;
1201 }
1202 #endif
1203
1204 /* The python void return value */
1205
1206 SWIGRUNTIMEINLINE PyObject *
1207 SWIG_Py_Void(void)
1208 {
1209 PyObject *none = Py_None;
1210 Py_INCREF(none);
1211 return none;
1212 }
1213
1214 /* PySwigClientData */
1215
1216 typedef struct {
1217 PyObject *klass;
1218 PyObject *newraw;
1219 PyObject *newargs;
1220 PyObject *destroy;
1221 int delargs;
1222 int implicitconv;
1223 } PySwigClientData;
1224
1225 SWIGRUNTIMEINLINE int
1226 SWIG_Python_CheckImplicit(swig_type_info *ty)
1227 {
1228 PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1229 return data ? data->implicitconv : 0;
1230 }
1231
1232 SWIGRUNTIMEINLINE PyObject *
1233 SWIG_Python_ExceptionType(swig_type_info *desc) {
1234 PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1235 PyObject *klass = data ? data->klass : 0;
1236 return (klass ? klass : PyExc_RuntimeError);
1237 }
1238
1239
1240 SWIGRUNTIME PySwigClientData *
1241 PySwigClientData_New(PyObject* obj)
1242 {
1243 if (!obj) {
1244 return 0;
1245 } else {
1246 PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1247 /* the klass element */
1248 data->klass = obj;
1249 Py_INCREF(data->klass);
1250 /* the newraw method and newargs arguments used to create a new raw instance */
1251 if (PyClass_Check(obj)) {
1252 data->newraw = 0;
1253 data->newargs = obj;
1254 Py_INCREF(obj);
1255 } else {
1256 #if (PY_VERSION_HEX < 0x02020000)
1257 data->newraw = 0;
1258 #else
1259 data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1260 #endif
1261 if (data->newraw) {
1262 Py_INCREF(data->newraw);
1263 data->newargs = PyTuple_New(1);
1264 PyTuple_SetItem(data->newargs, 0, obj);
1265 } else {
1266 data->newargs = obj;
1267 }
1268 Py_INCREF(data->newargs);
1269 }
1270 /* the destroy method, aka as the C++ delete method */
1271 data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1272 if (PyErr_Occurred()) {
1273 PyErr_Clear();
1274 data->destroy = 0;
1275 }
1276 if (data->destroy) {
1277 int flags;
1278 Py_INCREF(data->destroy);
1279 flags = PyCFunction_GET_FLAGS(data->destroy);
1280 #ifdef METH_O
1281 data->delargs = !(flags & (METH_O));
1282 #else
1283 data->delargs = 0;
1284 #endif
1285 } else {
1286 data->delargs = 0;
1287 }
1288 data->implicitconv = 0;
1289 return data;
1290 }
1291 }
1292
1293 SWIGRUNTIME void
1294 PySwigClientData_Del(PySwigClientData* data)
1295 {
1296 Py_XDECREF(data->newraw);
1297 Py_XDECREF(data->newargs);
1298 Py_XDECREF(data->destroy);
1299 }
1300
1301 /* =============== PySwigObject =====================*/
1302
1303 typedef struct {
1304 PyObject_HEAD
1305 void *ptr;
1306 swig_type_info *ty;
1307 int own;
1308 PyObject *next;
1309 } PySwigObject;
1310
1311 SWIGRUNTIME PyObject *
1312 PySwigObject_long(PySwigObject *v)
1313 {
1314 return PyLong_FromVoidPtr(v->ptr);
1315 }
1316
1317 SWIGRUNTIME PyObject *
1318 PySwigObject_format(const char* fmt, PySwigObject *v)
1319 {
1320 PyObject *res = NULL;
1321 PyObject *args = PyTuple_New(1);
1322 if (args) {
1323 if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1324 PyObject *ofmt = PyString_FromString(fmt);
1325 if (ofmt) {
1326 res = PyString_Format(ofmt,args);
1327 Py_DECREF(ofmt);
1328 }
1329 Py_DECREF(args);
1330 }
1331 }
1332 return res;
1333 }
1334
1335 SWIGRUNTIME PyObject *
1336 PySwigObject_oct(PySwigObject *v)
1337 {
1338 return PySwigObject_format("%o",v);
1339 }
1340
1341 SWIGRUNTIME PyObject *
1342 PySwigObject_hex(PySwigObject *v)
1343 {
1344 return PySwigObject_format("%x",v);
1345 }
1346
1347 SWIGRUNTIME PyObject *
1348 #ifdef METH_NOARGS
1349 PySwigObject_repr(PySwigObject *v)
1350 #else
1351 PySwigObject_repr(PySwigObject *v, PyObject *args)
1352 #endif
1353 {
1354 const char *name = SWIG_TypePrettyName(v->ty);
1355 PyObject *hex = PySwigObject_hex(v);
1356 PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1357 Py_DECREF(hex);
1358 if (v->next) {
1359 #ifdef METH_NOARGS
1360 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1361 #else
1362 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1363 #endif
1364 PyString_ConcatAndDel(&repr,nrep);
1365 }
1366 return repr;
1367 }
1368
1369 SWIGRUNTIME int
1370 PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1371 {
1372 #ifdef METH_NOARGS
1373 PyObject *repr = PySwigObject_repr(v);
1374 #else
1375 PyObject *repr = PySwigObject_repr(v, NULL);
1376 #endif
1377 if (repr) {
1378 fputs(PyString_AsString(repr), fp);
1379 Py_DECREF(repr);
1380 return 0;
1381 } else {
1382 return 1;
1383 }
1384 }
1385
1386 SWIGRUNTIME PyObject *
1387 PySwigObject_str(PySwigObject *v)
1388 {
1389 char result[SWIG_BUFFER_SIZE];
1390 return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1391 PyString_FromString(result) : 0;
1392 }
1393
1394 SWIGRUNTIME int
1395 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1396 {
1397 void *i = v->ptr;
1398 void *j = w->ptr;
1399 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1400 }
1401
1402 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1403
1404 SWIGRUNTIME PyTypeObject*
1405 PySwigObject_type(void) {
1406 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1407 return type;
1408 }
1409
1410 SWIGRUNTIMEINLINE int
1411 PySwigObject_Check(PyObject *op) {
1412 return ((op)->ob_type == PySwigObject_type())
1413 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1414 }
1415
1416 SWIGRUNTIME PyObject *
1417 PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1418
1419 SWIGRUNTIME void
1420 PySwigObject_dealloc(PyObject *v)
1421 {
1422 PySwigObject *sobj = (PySwigObject *) v;
1423 PyObject *next = sobj->next;
1424 if (sobj->own) {
1425 swig_type_info *ty = sobj->ty;
1426 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1427 PyObject *destroy = data ? data->destroy : 0;
1428 if (destroy) {
1429 /* destroy is always a VARARGS method */
1430 PyObject *res;
1431 if (data->delargs) {
1432 /* we need to create a temporal object to carry the destroy operation */
1433 PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1434 res = SWIG_Python_CallFunctor(destroy, tmp);
1435 Py_DECREF(tmp);
1436 } else {
1437 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1438 PyObject *mself = PyCFunction_GET_SELF(destroy);
1439 res = ((*meth)(mself, v));
1440 }
1441 Py_XDECREF(res);
1442 } else {
1443 const char *name = SWIG_TypePrettyName(ty);
1444 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1445 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
1446 #endif
1447 }
1448 }
1449 Py_XDECREF(next);
1450 PyObject_DEL(v);
1451 }
1452
1453 SWIGRUNTIME PyObject*
1454 PySwigObject_append(PyObject* v, PyObject* next)
1455 {
1456 PySwigObject *sobj = (PySwigObject *) v;
1457 #ifndef METH_O
1458 PyObject *tmp = 0;
1459 if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1460 next = tmp;
1461 #endif
1462 if (!PySwigObject_Check(next)) {
1463 return NULL;
1464 }
1465 sobj->next = next;
1466 Py_INCREF(next);
1467 return SWIG_Py_Void();
1468 }
1469
1470 SWIGRUNTIME PyObject*
1471 #ifdef METH_NOARGS
1472 PySwigObject_next(PyObject* v)
1473 #else
1474 PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1475 #endif
1476 {
1477 PySwigObject *sobj = (PySwigObject *) v;
1478 if (sobj->next) {
1479 Py_INCREF(sobj->next);
1480 return sobj->next;
1481 } else {
1482 return SWIG_Py_Void();
1483 }
1484 }
1485
1486 SWIGINTERN PyObject*
1487 #ifdef METH_NOARGS
1488 PySwigObject_disown(PyObject *v)
1489 #else
1490 PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1491 #endif
1492 {
1493 PySwigObject *sobj = (PySwigObject *)v;
1494 sobj->own = 0;
1495 return SWIG_Py_Void();
1496 }
1497
1498 SWIGINTERN PyObject*
1499 #ifdef METH_NOARGS
1500 PySwigObject_acquire(PyObject *v)
1501 #else
1502 PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1503 #endif
1504 {
1505 PySwigObject *sobj = (PySwigObject *)v;
1506 sobj->own = SWIG_POINTER_OWN;
1507 return SWIG_Py_Void();
1508 }
1509
1510 SWIGINTERN PyObject*
1511 PySwigObject_own(PyObject *v, PyObject *args)
1512 {
1513 PyObject *val = 0;
1514 #if (PY_VERSION_HEX < 0x02020000)
1515 if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1516 #else
1517 if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1518 #endif
1519 {
1520 return NULL;
1521 }
1522 else
1523 {
1524 PySwigObject *sobj = (PySwigObject *)v;
1525 PyObject *obj = PyBool_FromLong(sobj->own);
1526 if (val) {
1527 #ifdef METH_NOARGS
1528 if (PyObject_IsTrue(val)) {
1529 PySwigObject_acquire(v);
1530 } else {
1531 PySwigObject_disown(v);
1532 }
1533 #else
1534 if (PyObject_IsTrue(val)) {
1535 PySwigObject_acquire(v,args);
1536 } else {
1537 PySwigObject_disown(v,args);
1538 }
1539 #endif
1540 }
1541 return obj;
1542 }
1543 }
1544
1545 #ifdef METH_O
1546 static PyMethodDef
1547 swigobject_methods[] = {
1548 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1549 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
1550 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1551 {(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"},
1552 {(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1553 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"},
1554 {0, 0, 0, 0}
1555 };
1556 #else
1557 static PyMethodDef
1558 swigobject_methods[] = {
1559 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1560 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1561 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1562 {(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1563 {(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1564 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"},
1565 {0, 0, 0, 0}
1566 };
1567 #endif
1568
1569 #if PY_VERSION_HEX < 0x02020000
1570 SWIGINTERN PyObject *
1571 PySwigObject_getattr(PySwigObject *sobj,char *name)
1572 {
1573 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1574 }
1575 #endif
1576
1577 SWIGRUNTIME PyTypeObject*
1578 _PySwigObject_type(void) {
1579 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1580
1581 static PyNumberMethods PySwigObject_as_number = {
1582 (binaryfunc)0, /*nb_add*/
1583 (binaryfunc)0, /*nb_subtract*/
1584 (binaryfunc)0, /*nb_multiply*/
1585 (binaryfunc)0, /*nb_divide*/
1586 (binaryfunc)0, /*nb_remainder*/
1587 (binaryfunc)0, /*nb_divmod*/
1588 (ternaryfunc)0,/*nb_power*/
1589 (unaryfunc)0, /*nb_negative*/
1590 (unaryfunc)0, /*nb_positive*/
1591 (unaryfunc)0, /*nb_absolute*/
1592 (inquiry)0, /*nb_nonzero*/
1593 0, /*nb_invert*/
1594 0, /*nb_lshift*/
1595 0, /*nb_rshift*/
1596 0, /*nb_and*/
1597 0, /*nb_xor*/
1598 0, /*nb_or*/
1599 (coercion)0, /*nb_coerce*/
1600 (unaryfunc)PySwigObject_long, /*nb_int*/
1601 (unaryfunc)PySwigObject_long, /*nb_long*/
1602 (unaryfunc)0, /*nb_float*/
1603 (unaryfunc)PySwigObject_oct, /*nb_oct*/
1604 (unaryfunc)PySwigObject_hex, /*nb_hex*/
1605 #if PY_VERSION_HEX >= 0x02020000
1606 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1607 #elif PY_VERSION_HEX >= 0x02000000
1608 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1609 #endif
1610 };
1611
1612 static PyTypeObject pyswigobject_type;
1613 static int type_init = 0;
1614 if (!type_init) {
1615 const PyTypeObject tmp
1616 = {
1617 PyObject_HEAD_INIT(NULL)
1618 0, /* ob_size */
1619 (char *)"PySwigObject", /* tp_name */
1620 sizeof(PySwigObject), /* tp_basicsize */
1621 0, /* tp_itemsize */
1622 (destructor)PySwigObject_dealloc, /* tp_dealloc */
1623 (printfunc)PySwigObject_print, /* tp_print */
1624 #if PY_VERSION_HEX < 0x02020000
1625 (getattrfunc)PySwigObject_getattr, /* tp_getattr */
1626 #else
1627 (getattrfunc)0, /* tp_getattr */
1628 #endif
1629 (setattrfunc)0, /* tp_setattr */
1630 (cmpfunc)PySwigObject_compare, /* tp_compare */
1631 (reprfunc)PySwigObject_repr, /* tp_repr */
1632 &PySwigObject_as_number, /* tp_as_number */
1633 0, /* tp_as_sequence */
1634 0, /* tp_as_mapping */
1635 (hashfunc)0, /* tp_hash */
1636 (ternaryfunc)0, /* tp_call */
1637 (reprfunc)PySwigObject_str, /* tp_str */
1638 PyObject_GenericGetAttr, /* tp_getattro */
1639 0, /* tp_setattro */
1640 0, /* tp_as_buffer */
1641 Py_TPFLAGS_DEFAULT, /* tp_flags */
1642 swigobject_doc, /* tp_doc */
1643 0, /* tp_traverse */
1644 0, /* tp_clear */
1645 0, /* tp_richcompare */
1646 0, /* tp_weaklistoffset */
1647 #if PY_VERSION_HEX >= 0x02020000
1648 0, /* tp_iter */
1649 0, /* tp_iternext */
1650 swigobject_methods, /* tp_methods */
1651 0, /* tp_members */
1652 0, /* tp_getset */
1653 0, /* tp_base */
1654 0, /* tp_dict */
1655 0, /* tp_descr_get */
1656 0, /* tp_descr_set */
1657 0, /* tp_dictoffset */
1658 0, /* tp_init */
1659 0, /* tp_alloc */
1660 0, /* tp_new */
1661 0, /* tp_free */
1662 0, /* tp_is_gc */
1663 0, /* tp_bases */
1664 0, /* tp_mro */
1665 0, /* tp_cache */
1666 0, /* tp_subclasses */
1667 0, /* tp_weaklist */
1668 #endif
1669 #if PY_VERSION_HEX >= 0x02030000
1670 0, /* tp_del */
1671 #endif
1672 #ifdef COUNT_ALLOCS
1673 0,0,0,0 /* tp_alloc -> tp_next */
1674 #endif
1675 };
1676 pyswigobject_type = tmp;
1677 pyswigobject_type.ob_type = &PyType_Type;
1678 type_init = 1;
1679 }
1680 return &pyswigobject_type;
1681 }
1682
1683 SWIGRUNTIME PyObject *
1684 PySwigObject_New(void *ptr, swig_type_info *ty, int own)
1685 {
1686 PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1687 if (sobj) {
1688 sobj->ptr = ptr;
1689 sobj->ty = ty;
1690 sobj->own = own;
1691 sobj->next = 0;
1692 }
1693 return (PyObject *)sobj;
1694 }
1695
1696 /* -----------------------------------------------------------------------------
1697 * Implements a simple Swig Packed type, and use it instead of string
1698 * ----------------------------------------------------------------------------- */
1699
1700 typedef struct {
1701 PyObject_HEAD
1702 void *pack;
1703 swig_type_info *ty;
1704 size_t size;
1705 } PySwigPacked;
1706
1707 SWIGRUNTIME int
1708 PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1709 {
1710 char result[SWIG_BUFFER_SIZE];
1711 fputs("<Swig Packed ", fp);
1712 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1713 fputs("at ", fp);
1714 fputs(result, fp);
1715 }
1716 fputs(v->ty->name,fp);
1717 fputs(">", fp);
1718 return 0;
1719 }
1720
1721 SWIGRUNTIME PyObject *
1722 PySwigPacked_repr(PySwigPacked *v)
1723 {
1724 char result[SWIG_BUFFER_SIZE];
1725 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1726 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1727 } else {
1728 return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
1729 }
1730 }
1731
1732 SWIGRUNTIME PyObject *
1733 PySwigPacked_str(PySwigPacked *v)
1734 {
1735 char result[SWIG_BUFFER_SIZE];
1736 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1737 return PyString_FromFormat("%s%s", result, v->ty->name);
1738 } else {
1739 return PyString_FromString(v->ty->name);
1740 }
1741 }
1742
1743 SWIGRUNTIME int
1744 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
1745 {
1746 size_t i = v->size;
1747 size_t j = w->size;
1748 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1749 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1750 }
1751
1752 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1753
1754 SWIGRUNTIME PyTypeObject*
1755 PySwigPacked_type(void) {
1756 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1757 return type;
1758 }
1759
1760 SWIGRUNTIMEINLINE int
1761 PySwigPacked_Check(PyObject *op) {
1762 return ((op)->ob_type == _PySwigPacked_type())
1763 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1764 }
1765
1766 SWIGRUNTIME void
1767 PySwigPacked_dealloc(PyObject *v)
1768 {
1769 if (PySwigPacked_Check(v)) {
1770 PySwigPacked *sobj = (PySwigPacked *) v;
1771 free(sobj->pack);
1772 }
1773 PyObject_DEL(v);
1774 }
1775
1776 SWIGRUNTIME PyTypeObject*
1777 _PySwigPacked_type(void) {
1778 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1779 static PyTypeObject pyswigpacked_type;
1780 static int type_init = 0;
1781 if (!type_init) {
1782 const PyTypeObject tmp
1783 = {
1784 PyObject_HEAD_INIT(NULL)
1785 0, /* ob_size */
1786 (char *)"PySwigPacked", /* tp_name */
1787 sizeof(PySwigPacked), /* tp_basicsize */
1788 0, /* tp_itemsize */
1789 (destructor)PySwigPacked_dealloc, /* tp_dealloc */
1790 (printfunc)PySwigPacked_print, /* tp_print */
1791 (getattrfunc)0, /* tp_getattr */
1792 (setattrfunc)0, /* tp_setattr */
1793 (cmpfunc)PySwigPacked_compare, /* tp_compare */
1794 (reprfunc)PySwigPacked_repr, /* tp_repr */
1795 0, /* tp_as_number */
1796 0, /* tp_as_sequence */
1797 0, /* tp_as_mapping */
1798 (hashfunc)0, /* tp_hash */
1799 (ternaryfunc)0, /* tp_call */
1800 (reprfunc)PySwigPacked_str, /* tp_str */
1801 PyObject_GenericGetAttr, /* tp_getattro */
1802 0, /* tp_setattro */
1803 0, /* tp_as_buffer */
1804 Py_TPFLAGS_DEFAULT, /* tp_flags */
1805 swigpacked_doc, /* tp_doc */
1806 0, /* tp_traverse */
1807 0, /* tp_clear */
1808 0, /* tp_richcompare */
1809 0, /* tp_weaklistoffset */
1810 #if PY_VERSION_HEX >= 0x02020000
1811 0, /* tp_iter */
1812 0, /* tp_iternext */
1813 0, /* tp_methods */
1814 0, /* tp_members */
1815 0, /* tp_getset */
1816 0, /* tp_base */
1817 0, /* tp_dict */
1818 0, /* tp_descr_get */
1819 0, /* tp_descr_set */
1820 0, /* tp_dictoffset */
1821 0, /* tp_init */
1822 0, /* tp_alloc */
1823 0, /* tp_new */
1824 0, /* tp_free */
1825 0, /* tp_is_gc */
1826 0, /* tp_bases */
1827 0, /* tp_mro */
1828 0, /* tp_cache */
1829 0, /* tp_subclasses */
1830 0, /* tp_weaklist */
1831 #endif
1832 #if PY_VERSION_HEX >= 0x02030000
1833 0, /* tp_del */
1834 #endif
1835 #ifdef COUNT_ALLOCS
1836 0,0,0,0 /* tp_alloc -> tp_next */
1837 #endif
1838 };
1839 pyswigpacked_type = tmp;
1840 pyswigpacked_type.ob_type = &PyType_Type;
1841 type_init = 1;
1842 }
1843 return &pyswigpacked_type;
1844 }
1845
1846 SWIGRUNTIME PyObject *
1847 PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
1848 {
1849 PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1850 if (sobj) {
1851 void *pack = malloc(size);
1852 if (pack) {
1853 memcpy(pack, ptr, size);
1854 sobj->pack = pack;
1855 sobj->ty = ty;
1856 sobj->size = size;
1857 } else {
1858 PyObject_DEL((PyObject *) sobj);
1859 sobj = 0;
1860 }
1861 }
1862 return (PyObject *) sobj;
1863 }
1864
1865 SWIGRUNTIME swig_type_info *
1866 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1867 {
1868 if (PySwigPacked_Check(obj)) {
1869 PySwigPacked *sobj = (PySwigPacked *)obj;
1870 if (sobj->size != size) return 0;
1871 memcpy(ptr, sobj->pack, size);
1872 return sobj->ty;
1873 } else {
1874 return 0;
1875 }
1876 }
1877
1878 /* -----------------------------------------------------------------------------
1879 * pointers/data manipulation
1880 * ----------------------------------------------------------------------------- */
1881
1882 SWIGRUNTIMEINLINE PyObject *
1883 _SWIG_This(void)
1884 {
1885 return PyString_FromString("this");
1886 }
1887
1888 SWIGRUNTIME PyObject *
1889 SWIG_This(void)
1890 {
1891 static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1892 return swig_this;
1893 }
1894
1895 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1896
1897 SWIGRUNTIME PySwigObject *
1898 SWIG_Python_GetSwigThis(PyObject *pyobj)
1899 {
1900 if (PySwigObject_Check(pyobj)) {
1901 return (PySwigObject *) pyobj;
1902 } else {
1903 PyObject *obj = 0;
1904 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1905 if (PyInstance_Check(pyobj)) {
1906 obj = _PyInstance_Lookup(pyobj, SWIG_This());
1907 } else {
1908 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1909 if (dictptr != NULL) {
1910 PyObject *dict = *dictptr;
1911 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1912 } else {
1913 #ifdef PyWeakref_CheckProxy
1914 if (PyWeakref_CheckProxy(pyobj)) {
1915 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1916 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1917 }
1918 #endif
1919 obj = PyObject_GetAttr(pyobj,SWIG_This());
1920 if (obj) {
1921 Py_DECREF(obj);
1922 } else {
1923 if (PyErr_Occurred()) PyErr_Clear();
1924 return 0;
1925 }
1926 }
1927 }
1928 #else
1929 obj = PyObject_GetAttr(pyobj,SWIG_This());
1930 if (obj) {
1931 Py_DECREF(obj);
1932 } else {
1933 if (PyErr_Occurred()) PyErr_Clear();
1934 return 0;
1935 }
1936 #endif
1937 if (obj && !PySwigObject_Check(obj)) {
1938 /* a PyObject is called 'this', try to get the 'real this'
1939 PySwigObject from it */
1940 return SWIG_Python_GetSwigThis(obj);
1941 }
1942 return (PySwigObject *)obj;
1943 }
1944 }
1945
1946 /* Acquire a pointer value */
1947
1948 SWIGRUNTIME int
1949 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1950 if (own) {
1951 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1952 if (sobj) {
1953 int oldown = sobj->own;
1954 sobj->own = own;
1955 return oldown;
1956 }
1957 }
1958 return 0;
1959 }
1960
1961 /* Convert a pointer value */
1962
1963 SWIGRUNTIME int
1964 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1965 if (!obj) return SWIG_ERROR;
1966 if (obj == Py_None) {
1967 if (ptr) *ptr = 0;
1968 return SWIG_OK;
1969 } else {
1970 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1971 while (sobj) {
1972 void *vptr = sobj->ptr;
1973 if (ty) {
1974 swig_type_info *to = sobj->ty;
1975 if (to == ty) {
1976 /* no type cast needed */
1977 if (ptr) *ptr = vptr;
1978 break;
1979 } else {
1980 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1981 if (!tc) {
1982 sobj = (PySwigObject *)sobj->next;
1983 } else {
1984 if (ptr) *ptr = SWIG_TypeCast(tc,vptr);
1985 break;
1986 }
1987 }
1988 } else {
1989 if (ptr) *ptr = vptr;
1990 break;
1991 }
1992 }
1993 if (sobj) {
1994 if (own) *own = sobj->own;
1995 if (flags & SWIG_POINTER_DISOWN) {
1996 sobj->own = 0;
1997 }
1998 return SWIG_OK;
1999 } else {
2000 int res = SWIG_ERROR;
2001 if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2002 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2003 if (data && !data->implicitconv) {
2004 PyObject *klass = data->klass;
2005 if (klass) {
2006 PyObject *impconv;
2007 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2008 impconv = SWIG_Python_CallFunctor(klass, obj);
2009 data->implicitconv = 0;
2010 if (PyErr_Occurred()) {
2011 PyErr_Clear();
2012 impconv = 0;
2013 }
2014 if (impconv) {
2015 PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2016 if (iobj) {
2017 void *vptr;
2018 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2019 if (SWIG_IsOK(res)) {
2020 if (ptr) {
2021 *ptr = vptr;
2022 /* transfer the ownership to 'ptr' */
2023 iobj->own = 0;
2024 res = SWIG_AddCast(res);
2025 res = SWIG_AddNewMask(res);
2026 } else {
2027 res = SWIG_AddCast(res);
2028 }
2029 }
2030 }
2031 Py_DECREF(impconv);
2032 }
2033 }
2034 }
2035 }
2036 return res;
2037 }
2038 }
2039 }
2040
2041 /* Convert a function ptr value */
2042
2043 SWIGRUNTIME int
2044 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2045 if (!PyCFunction_Check(obj)) {
2046 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2047 } else {
2048 void *vptr = 0;
2049
2050 /* here we get the method pointer for callbacks */
2051 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2052 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2053 if (desc) {
2054 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2055 if (!desc) return SWIG_ERROR;
2056 }
2057 if (ty) {
2058 swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2059 if (!tc) return SWIG_ERROR;
2060 *ptr = SWIG_TypeCast(tc,vptr);
2061 } else {
2062 *ptr = vptr;
2063 }
2064 return SWIG_OK;
2065 }
2066 }
2067
2068 /* Convert a packed value value */
2069
2070 SWIGRUNTIME int
2071 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2072 swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2073 if (!to) return SWIG_ERROR;
2074 if (ty) {
2075 if (to != ty) {
2076 /* check type cast? */
2077 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2078 if (!tc) return SWIG_ERROR;
2079 }
2080 }
2081 return SWIG_OK;
2082 }
2083
2084 /* -----------------------------------------------------------------------------
2085 * Create a new pointer object
2086 * ----------------------------------------------------------------------------- */
2087
2088 /*
2089 Create a new instance object, whitout calling __init__, and set the
2090 'this' attribute.
2091 */
2092
2093 SWIGRUNTIME PyObject*
2094 SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2095 {
2096 #if (PY_VERSION_HEX >= 0x02020000)
2097 PyObject *inst = 0;
2098 PyObject *newraw = data->newraw;
2099 if (newraw) {
2100 inst = PyObject_Call(newraw, data->newargs, NULL);
2101 if (inst) {
2102 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2103 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2104 if (dictptr != NULL) {
2105 PyObject *dict = *dictptr;
2106 if (dict == NULL) {
2107 dict = PyDict_New();
2108 *dictptr = dict;
2109 PyDict_SetItem(dict, SWIG_This(), swig_this);
2110 }
2111 }
2112 #else
2113 PyObject *key = SWIG_This();
2114 PyObject_SetAttr(inst, key, swig_this);
2115 #endif
2116 }
2117 } else {
2118 PyObject *dict = PyDict_New();
2119 PyDict_SetItem(dict, SWIG_This(), swig_this);
2120 inst = PyInstance_NewRaw(data->newargs, dict);
2121 Py_DECREF(dict);
2122 }
2123 return inst;
2124 #else
2125 #if (PY_VERSION_HEX >= 0x02010000)
2126 PyObject *inst;
2127 PyObject *dict = PyDict_New();
2128 PyDict_SetItem(dict, SWIG_This(), swig_this);
2129 inst = PyInstance_NewRaw(data->newargs, dict);
2130 Py_DECREF(dict);
2131 return (PyObject *) inst;
2132 #else
2133 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2134 if (inst == NULL) {
2135 return NULL;
2136 }
2137 inst->in_class = (PyClassObject *)data->newargs;
2138 Py_INCREF(inst->in_class);
2139 inst->in_dict = PyDict_New();
2140 if (inst->in_dict == NULL) {
2141 Py_DECREF(inst);
2142 return NULL;
2143 }
2144 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2145 inst->in_weakreflist = NULL;
2146 #endif
2147 #ifdef Py_TPFLAGS_GC
2148 PyObject_GC_Init(inst);
2149 #endif
2150 PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2151 return (PyObject *) inst;
2152 #endif
2153 #endif
2154 }
2155
2156 SWIGRUNTIME void
2157 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2158 {
2159 PyObject *dict;
2160 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2161 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2162 if (dictptr != NULL) {
2163 dict = *dictptr;
2164 if (dict == NULL) {
2165 dict = PyDict_New();
2166 *dictptr = dict;
2167 }
2168 PyDict_SetItem(dict, SWIG_This(), swig_this);
2169 return;
2170 }
2171 #endif
2172 dict = PyObject_GetAttrString(inst, "__dict__");
2173 PyDict_SetItem(dict, SWIG_This(), swig_this);
2174 Py_DECREF(dict);
2175 }
2176
2177
2178 SWIGINTERN PyObject *
2179 SWIG_Python_InitShadowInstance(PyObject *args) {
2180 PyObject *obj[2];
2181 if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2182 return NULL;
2183 } else {
2184 PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2185 if (sthis) {
2186 PySwigObject_append((PyObject*) sthis, obj[1]);
2187 } else {
2188 SWIG_Python_SetSwigThis(obj[0], obj[1]);
2189 }
2190 return SWIG_Py_Void();
2191 }
2192 }
2193
2194 /* Create a new pointer object */
2195
2196 SWIGRUNTIME PyObject *
2197 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2198 if (!ptr) {
2199 return SWIG_Py_Void();
2200 } else {
2201 int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2202 PyObject *robj = PySwigObject_New(ptr, type, own);
2203 PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2204 if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2205 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2206 if (inst) {
2207 Py_DECREF(robj);
2208 robj = inst;
2209 }
2210 }
2211 return robj;
2212 }
2213 }
2214
2215 /* Create a new packed object */
2216
2217 SWIGRUNTIMEINLINE PyObject *
2218 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2219 return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2220 }
2221
2222 /* -----------------------------------------------------------------------------*
2223 * Get type list
2224 * -----------------------------------------------------------------------------*/
2225
2226 #ifdef SWIG_LINK_RUNTIME
2227 void *SWIG_ReturnGlobalTypeList(void *);
2228 #endif
2229
2230 SWIGRUNTIME swig_module_info *
2231 SWIG_Python_GetModule(void) {
2232 static void *type_pointer = (void *)0;
2233 /* first check if module already created */
2234 if (!type_pointer) {
2235 #ifdef SWIG_LINK_RUNTIME
2236 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2237 #else
2238 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2239 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2240 if (PyErr_Occurred()) {
2241 PyErr_Clear();
2242 type_pointer = (void *)0;
2243 }
2244 #endif
2245 }
2246 return (swig_module_info *) type_pointer;
2247 }
2248
2249 #if PY_MAJOR_VERSION < 2
2250 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2251 is copied out of Python/modsupport.c in python version 2.3.4 */
2252 SWIGINTERN int
2253 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2254 {
2255 PyObject *dict;
2256 if (!PyModule_Check(m)) {
2257 PyErr_SetString(PyExc_TypeError,
2258 "PyModule_AddObject() needs module as first arg");
2259 return SWIG_ERROR;
2260 }
2261 if (!o) {
2262 PyErr_SetString(PyExc_TypeError,
2263 "PyModule_AddObject() needs non-NULL value");
2264 return SWIG_ERROR;
2265 }
2266
2267 dict = PyModule_GetDict(m);
2268 if (dict == NULL) {
2269 /* Internal error -- modules must have a dict! */
2270 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2271 PyModule_GetName(m));
2272 return SWIG_ERROR;
2273 }
2274 if (PyDict_SetItemString(dict, name, o))
2275 return SWIG_ERROR;
2276 Py_DECREF(o);
2277 return SWIG_OK;
2278 }
2279 #endif
2280
2281 SWIGRUNTIME void
2282 SWIG_Python_DestroyModule(void *vptr)
2283 {
2284 swig_module_info *swig_module = (swig_module_info *) vptr;
2285 swig_type_info **types = swig_module->types;
2286 size_t i;
2287 for (i =0; i < swig_module->size; ++i) {
2288 swig_type_info *ty = types[i];
2289 if (ty->owndata) {
2290 PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2291 if (data) PySwigClientData_Del(data);
2292 }
2293 }
2294 Py_DECREF(SWIG_This());
2295 }
2296
2297 SWIGRUNTIME void
2298 SWIG_Python_SetModule(swig_module_info *swig_module) {
2299 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2300
2301 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2302 swig_empty_runtime_method_table);
2303 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2304 if (pointer && module) {
2305 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2306 } else {
2307 Py_XDECREF(pointer);
2308 }
2309 }
2310
2311 /* The python cached type query */
2312 SWIGRUNTIME PyObject *
2313 SWIG_Python_TypeCache() {
2314 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2315 return cache;
2316 }
2317
2318 SWIGRUNTIME swig_type_info *
2319 SWIG_Python_TypeQuery(const char *type)
2320 {
2321 PyObject *cache = SWIG_Python_TypeCache();
2322 PyObject *key = PyString_FromString(type);
2323 PyObject *obj = PyDict_GetItem(cache, key);
2324 swig_type_info *descriptor;
2325 if (obj) {
2326 descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2327 } else {
2328 swig_module_info *swig_module = SWIG_Python_GetModule();
2329 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2330 if (descriptor) {
2331 obj = PyCObject_FromVoidPtr(descriptor, NULL);
2332 PyDict_SetItem(cache, key, obj);
2333 Py_DECREF(obj);
2334 }
2335 }
2336 Py_DECREF(key);
2337 return descriptor;
2338 }
2339
2340 /*
2341 For backward compatibility only
2342 */
2343 #define SWIG_POINTER_EXCEPTION 0
2344 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2345 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2346
2347 SWIGRUNTIME int
2348 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2349 {
2350 if (PyErr_Occurred()) {
2351 PyObject *type = 0;
2352 PyObject *value = 0;
2353 PyObject *traceback = 0;
2354 PyErr_Fetch(&type, &value, &traceback);
2355 if (value) {
2356 PyObject *old_str = PyObject_Str(value);
2357 Py_XINCREF(type);
2358 PyErr_Clear();
2359 if (infront) {
2360 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2361 } else {
2362 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2363 }
2364 Py_DECREF(old_str);
2365 }
2366 return 1;
2367 } else {
2368 return 0;
2369 }
2370 }
2371
2372 SWIGRUNTIME int
2373 SWIG_Python_ArgFail(int argnum)
2374 {
2375 if (PyErr_Occurred()) {
2376 /* add information about failing argument */
2377 char mesg[256];
2378 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2379 return SWIG_Python_AddErrMesg(mesg, 1);
2380 } else {
2381 return 0;
2382 }
2383 }
2384
2385 SWIGRUNTIMEINLINE const char *
2386 PySwigObject_GetDesc(PyObject *self)
2387 {
2388 PySwigObject *v = (PySwigObject *)self;
2389 swig_type_info *ty = v ? v->ty : 0;
2390 return ty ? ty->str : (char*)"";
2391 }
2392
2393 SWIGRUNTIME void
2394 SWIG_Python_TypeError(const char *type, PyObject *obj)
2395 {
2396 if (type) {
2397 #if defined(SWIG_COBJECT_TYPES)
2398 if (obj && PySwigObject_Check(obj)) {
2399 const char *otype = (const char *) PySwigObject_GetDesc(obj);
2400 if (otype) {
2401 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2402 type, otype);
2403 return;
2404 }
2405 } else
2406 #endif
2407 {
2408 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2409 if (otype) {
2410 PyObject *str = PyObject_Str(obj);
2411 const char *cstr = str ? PyString_AsString(str) : 0;
2412 if (cstr) {
2413 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2414 type, otype, cstr);
2415 } else {
2416 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2417 type, otype);
2418 }
2419 Py_XDECREF(str);
2420 return;
2421 }
2422 }
2423 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2424 } else {
2425 PyErr_Format(PyExc_TypeError, "unexpected type is received");
2426 }
2427 }
2428
2429
2430 /* Convert a pointer value, signal an exception on a type mismatch */
2431 SWIGRUNTIME void *
2432 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2433 void *result;
2434 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2435 PyErr_Clear();
2436 if (flags & SWIG_POINTER_EXCEPTION) {
2437 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2438 SWIG_Python_ArgFail(argnum);
2439 }
2440 }
2441 return result;
2442 }
2443
2444
2445 #ifdef __cplusplus
2446 #if 0
2447 { /* cc-mode */
2448 #endif
2449 }
2450 #endif
2451
2452
2453
2454 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2455
2456 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2457
2458
2459
2460 /* -------- TYPES TABLE (BEGIN) -------- */
2461
2462 #define SWIGTYPE_p_buffer swig_types[0]
2463 #define SWIGTYPE_p_char swig_types[1]
2464 #define SWIGTYPE_p_form_ops_t swig_types[2]
2465 #define SWIGTYPE_p_int swig_types[3]
2466 #define SWIGTYPE_p_long swig_types[4]
2467 #define SWIGTYPE_p_unsigned_char swig_types[5]
2468 #define SWIGTYPE_p_unsigned_int swig_types[6]
2469 #define SWIGTYPE_p_unsigned_long swig_types[7]
2470 #define SWIGTYPE_p_wxANIHandler swig_types[8]
2471 #define SWIGTYPE_p_wxAcceleratorEntry swig_types[9]
2472 #define SWIGTYPE_p_wxAcceleratorTable swig_types[10]
2473 #define SWIGTYPE_p_wxActivateEvent swig_types[11]
2474 #define SWIGTYPE_p_wxAppTraits swig_types[12]
2475 #define SWIGTYPE_p_wxArrayString swig_types[13]
2476 #define SWIGTYPE_p_wxBMPHandler swig_types[14]
2477 #define SWIGTYPE_p_wxBitmap swig_types[15]
2478 #define SWIGTYPE_p_wxBoxSizer swig_types[16]
2479 #define SWIGTYPE_p_wxButton swig_types[17]
2480 #define SWIGTYPE_p_wxCURHandler swig_types[18]
2481 #define SWIGTYPE_p_wxCaret swig_types[19]
2482 #define SWIGTYPE_p_wxChildFocusEvent swig_types[20]
2483 #define SWIGTYPE_p_wxClipboardTextEvent swig_types[21]
2484 #define SWIGTYPE_p_wxCloseEvent swig_types[22]
2485 #define SWIGTYPE_p_wxColour swig_types[23]
2486 #define SWIGTYPE_p_wxCommandEvent swig_types[24]
2487 #define SWIGTYPE_p_wxContextMenuEvent swig_types[25]
2488 #define SWIGTYPE_p_wxControl swig_types[26]
2489 #define SWIGTYPE_p_wxControlWithItems swig_types[27]
2490 #define SWIGTYPE_p_wxCursor swig_types[28]
2491 #define SWIGTYPE_p_wxDC swig_types[29]
2492 #define SWIGTYPE_p_wxDateEvent swig_types[30]
2493 #define SWIGTYPE_p_wxDateTime swig_types[31]
2494 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[32]
2495 #define SWIGTYPE_p_wxDropFilesEvent swig_types[33]
2496 #define SWIGTYPE_p_wxDuplexMode swig_types[34]
2497 #define SWIGTYPE_p_wxEraseEvent swig_types[35]
2498 #define SWIGTYPE_p_wxEvent swig_types[36]
2499 #define SWIGTYPE_p_wxEventLoop swig_types[37]
2500 #define SWIGTYPE_p_wxEventLoopActivator swig_types[38]
2501 #define SWIGTYPE_p_wxEvtHandler swig_types[39]
2502 #define SWIGTYPE_p_wxFSFile swig_types[40]
2503 #define SWIGTYPE_p_wxFileSystem swig_types[41]
2504 #define SWIGTYPE_p_wxFileSystemHandler swig_types[42]
2505 #define SWIGTYPE_p_wxFlexGridSizer swig_types[43]
2506 #define SWIGTYPE_p_wxFocusEvent swig_types[44]
2507 #define SWIGTYPE_p_wxFont swig_types[45]
2508 #define SWIGTYPE_p_wxFrame swig_types[46]
2509 #define SWIGTYPE_p_wxGBPosition swig_types[47]
2510 #define SWIGTYPE_p_wxGBSizerItem swig_types[48]
2511 #define SWIGTYPE_p_wxGBSpan swig_types[49]
2512 #define SWIGTYPE_p_wxGIFHandler swig_types[50]
2513 #define SWIGTYPE_p_wxGridBagSizer swig_types[51]
2514 #define SWIGTYPE_p_wxGridSizer swig_types[52]
2515 #define SWIGTYPE_p_wxHelpEvent__Origin swig_types[53]
2516 #define SWIGTYPE_p_wxICOHandler swig_types[54]
2517 #define SWIGTYPE_p_wxIconizeEvent swig_types[55]
2518 #define SWIGTYPE_p_wxIdleEvent swig_types[56]
2519 #define SWIGTYPE_p_wxImage swig_types[57]
2520 #define SWIGTYPE_p_wxImageHandler swig_types[58]
2521 #define SWIGTYPE_p_wxImageHistogram swig_types[59]
2522 #define SWIGTYPE_p_wxImage_HSVValue swig_types[60]
2523 #define SWIGTYPE_p_wxImage_RGBValue swig_types[61]
2524 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[62]
2525 #define SWIGTYPE_p_wxInitDialogEvent swig_types[63]
2526 #define SWIGTYPE_p_wxInputStream swig_types[64]
2527 #define SWIGTYPE_p_wxInternetFSHandler swig_types[65]
2528 #define SWIGTYPE_p_wxItemContainer swig_types[66]
2529 #define SWIGTYPE_p_wxJPEGHandler swig_types[67]
2530 #define SWIGTYPE_p_wxKeyEvent swig_types[68]
2531 #define SWIGTYPE_p_wxLayoutConstraints swig_types[69]
2532 #define SWIGTYPE_p_wxMaximizeEvent swig_types[70]
2533 #define SWIGTYPE_p_wxMemoryFSHandler swig_types[71]
2534 #define SWIGTYPE_p_wxMenu swig_types[72]
2535 #define SWIGTYPE_p_wxMenuBar swig_types[73]
2536 #define SWIGTYPE_p_wxMenuBarBase swig_types[74]
2537 #define SWIGTYPE_p_wxMenuEvent swig_types[75]
2538 #define SWIGTYPE_p_wxMenuItem swig_types[76]
2539 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[77]
2540 #define SWIGTYPE_p_wxMouseEvent swig_types[78]
2541 #define SWIGTYPE_p_wxMoveEvent swig_types[79]
2542 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[80]
2543 #define SWIGTYPE_p_wxNcPaintEvent swig_types[81]
2544 #define SWIGTYPE_p_wxNotifyEvent swig_types[82]
2545 #define SWIGTYPE_p_wxObject swig_types[83]
2546 #define SWIGTYPE_p_wxOutputStream swig_types[84]
2547 #define SWIGTYPE_p_wxPCXHandler swig_types[85]
2548 #define SWIGTYPE_p_wxPNGHandler swig_types[86]
2549 #define SWIGTYPE_p_wxPNMHandler swig_types[87]
2550 #define SWIGTYPE_p_wxPaintEvent swig_types[88]
2551 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[89]
2552 #define SWIGTYPE_p_wxPaperSize swig_types[90]
2553 #define SWIGTYPE_p_wxPoint swig_types[91]
2554 #define SWIGTYPE_p_wxPoint2D swig_types[92]
2555 #define SWIGTYPE_p_wxPropagateOnce swig_types[93]
2556 #define SWIGTYPE_p_wxPropagationDisabler swig_types[94]
2557 #define SWIGTYPE_p_wxPyApp swig_types[95]
2558 #define SWIGTYPE_p_wxPyCommandEvent swig_types[96]
2559 #define SWIGTYPE_p_wxPyDropTarget swig_types[97]
2560 #define SWIGTYPE_p_wxPyEvent swig_types[98]
2561 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[99]
2562 #define SWIGTYPE_p_wxPyImageHandler swig_types[100]
2563 #define SWIGTYPE_p_wxPyInputStream swig_types[101]
2564 #define SWIGTYPE_p_wxPySizer swig_types[102]
2565 #define SWIGTYPE_p_wxPyValidator swig_types[103]
2566 #define SWIGTYPE_p_wxQuantize swig_types[104]
2567 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[105]
2568 #define SWIGTYPE_p_wxRealPoint swig_types[106]
2569 #define SWIGTYPE_p_wxRect swig_types[107]
2570 #define SWIGTYPE_p_wxRegion swig_types[108]
2571 #define SWIGTYPE_p_wxScrollEvent swig_types[109]
2572 #define SWIGTYPE_p_wxScrollWinEvent swig_types[110]
2573 #define SWIGTYPE_p_wxSetCursorEvent swig_types[111]
2574 #define SWIGTYPE_p_wxShowEvent swig_types[112]
2575 #define SWIGTYPE_p_wxSize swig_types[113]
2576 #define SWIGTYPE_p_wxSizeEvent swig_types[114]
2577 #define SWIGTYPE_p_wxSizer swig_types[115]
2578 #define SWIGTYPE_p_wxSizerItem swig_types[116]
2579 #define SWIGTYPE_p_wxStaticBox swig_types[117]
2580 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[118]
2581 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[119]
2582 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[120]
2583 #define SWIGTYPE_p_wxTIFFHandler swig_types[121]
2584 #define SWIGTYPE_p_wxToolTip swig_types[122]
2585 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[123]
2586 #define SWIGTYPE_p_wxValidator swig_types[124]
2587 #define SWIGTYPE_p_wxVisualAttributes swig_types[125]
2588 #define SWIGTYPE_p_wxWindow swig_types[126]
2589 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[127]
2590 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[128]
2591 #define SWIGTYPE_p_wxXPMHandler swig_types[129]
2592 #define SWIGTYPE_p_wxZipFSHandler swig_types[130]
2593 static swig_type_info *swig_types[132];
2594 static swig_module_info swig_module = {swig_types, 131, 0, 0, 0, 0};
2595 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2596 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2597
2598 /* -------- TYPES TABLE (END) -------- */
2599
2600 #if (PY_VERSION_HEX <= 0x02000000)
2601 # if !defined(SWIG_PYTHON_CLASSIC)
2602 # error "This python version requires to use swig with the '-classic' option"
2603 # endif
2604 #endif
2605 #if (PY_VERSION_HEX <= 0x02020000)
2606 # error "This python version requires to use swig with the '-nomodern' option"
2607 #endif
2608 #if (PY_VERSION_HEX <= 0x02020000)
2609 # error "This python version requires to use swig with the '-nomodernargs' option"
2610 #endif
2611 #ifndef METH_O
2612 # error "This python version requires to use swig with the '-nofastunpack' option"
2613 #endif
2614
2615 /*-----------------------------------------------
2616 @(target):= _core_.so
2617 ------------------------------------------------*/
2618 #define SWIG_init init_core_
2619
2620 #define SWIG_name "_core_"
2621
2622 #define SWIGVERSION 0x010329
2623
2624
2625 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2626 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2627
2628
2629 #include <stdexcept>
2630
2631
2632 namespace swig {
2633 class PyObject_ptr {
2634 protected:
2635 PyObject *_obj;
2636
2637 public:
2638 PyObject_ptr() :_obj(0)
2639 {
2640 }
2641
2642 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2643 {
2644 Py_XINCREF(_obj);
2645 }
2646
2647 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2648 {
2649 if (initial_ref) Py_XINCREF(_obj);
2650 }
2651
2652 PyObject_ptr & operator=(const PyObject_ptr& item)
2653 {
2654 Py_XINCREF(item._obj);
2655 Py_XDECREF(_obj);
2656 _obj = item._obj;
2657 return *this;
2658 }
2659
2660 ~PyObject_ptr()
2661 {
2662 Py_XDECREF(_obj);
2663 }
2664
2665 operator PyObject *() const
2666 {
2667 return _obj;
2668 }
2669
2670 PyObject *operator->() const
2671 {
2672 return _obj;
2673 }
2674 };
2675 }
2676
2677
2678 namespace swig {
2679 struct PyObject_var : PyObject_ptr {
2680 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2681
2682 PyObject_var & operator = (PyObject* obj)
2683 {
2684 Py_XDECREF(_obj);
2685 _obj = obj;
2686 return *this;
2687 }
2688 };
2689 }
2690
2691
2692 #include "wx/wxPython/wxPython_int.h"
2693 #include "wx/wxPython/pyclasses.h"
2694 #include "wx/wxPython/twoitem.h"
2695
2696
2697 #ifndef wxPyUSE_EXPORT
2698 // Helper functions for dealing with SWIG objects and such. These are
2699 // located here so they know about the SWIG types and functions declared
2700 // in the wrapper code.
2701
2702 #include <wx/hashmap.h>
2703 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
2704
2705
2706 // Maintains a hashmap of className to swig_type_info pointers. Given the
2707 // name of a class either looks up the type info in the cache, or scans the
2708 // SWIG tables for it.
2709 extern PyObject* wxPyPtrTypeMap;
2710 static
2711 swig_type_info* wxPyFindSwigType(const wxChar* className) {
2712
2713 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
2714
2715 if (typeInfoCache == NULL)
2716 typeInfoCache = new wxPyTypeInfoHashMap;
2717
2718 wxString name(className);
2719 swig_type_info* swigType = (*typeInfoCache)[name];
2720
2721 if (! swigType) {
2722 // it wasn't in the cache, so look it up from SWIG
2723 name.Append(wxT(" *"));
2724 swigType = SWIG_TypeQuery(name.mb_str());
2725
2726 // if it still wasn't found, try looking for a mapped name
2727 if (!swigType) {
2728 PyObject* item;
2729 name = className;
2730
2731 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
2732 (char*)(const char*)name.mbc_str())) != NULL) {
2733 name = wxString(PyString_AsString(item), *wxConvCurrent);
2734 name.Append(wxT(" *"));
2735 swigType = SWIG_TypeQuery(name.mb_str());
2736 }
2737 }
2738 if (swigType) {
2739 // and add it to the map if found
2740 (*typeInfoCache)[className] = swigType;
2741 }
2742 }
2743 return swigType;
2744 }
2745
2746
2747 // Check if a class name is a type known to SWIG
2748 bool wxPyCheckSwigType(const wxChar* className) {
2749
2750 swig_type_info* swigType = wxPyFindSwigType(className);
2751 return swigType != NULL;
2752 }
2753
2754
2755 // Given a pointer to a C++ object and a class name, construct a Python proxy
2756 // object for it.
2757 PyObject* wxPyConstructObject(void* ptr,
2758 const wxChar* className,
2759 int setThisOwn) {
2760
2761 swig_type_info* swigType = wxPyFindSwigType(className);
2762 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
2763
2764 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
2765 }
2766
2767
2768 // Extract a pointer to the wrapped C++ object from a Python proxy object.
2769 // Ensures that the proxy object is of the specified (or derived) type. If
2770 // not able to perform the conversion then a Python exception is set and the
2771 // error should be handled properly in the caller. Returns True on success.
2772 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
2773 const wxChar* className) {
2774
2775 swig_type_info* swigType = wxPyFindSwigType(className);
2776 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
2777
2778 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
2779 }
2780
2781
2782
2783 // Make a SWIGified pointer object suitable for a .this attribute
2784 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
2785
2786 PyObject* robj = NULL;
2787
2788 swig_type_info* swigType = wxPyFindSwigType(className);
2789 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyMakeSwigPtr"));
2790
2791 robj = PySwigObject_New(ptr, swigType, 0);
2792 return robj;
2793 }
2794
2795
2796 // Python's PyInstance_Check does not return True for instances of new-style
2797 // classes. This should get close enough for both new and old classes but I
2798 // should re-evaluate the need for doing instance checks...
2799 bool wxPyInstance_Check(PyObject* obj) {
2800 return PyObject_HasAttrString(obj, "__class__") != 0;
2801 }
2802
2803
2804 // This one checks if the object is an instance of a SWIG proxy class (it has
2805 // a .this attribute, and the .this attribute is a PySwigObject.)
2806 bool wxPySwigInstance_Check(PyObject* obj) {
2807 static PyObject* this_str = NULL;
2808 if (this_str == NULL)
2809 this_str = PyString_FromString("this");
2810
2811 PyObject* this_attr = PyObject_GetAttr(obj, this_str);
2812 if (this_attr) {
2813 bool retval = (PySwigObject_Check(this_attr) != 0);
2814 Py_DECREF(this_attr);
2815 return retval;
2816 }
2817
2818 PyErr_Clear();
2819 return false;
2820 }
2821
2822
2823 // Export a C API in a struct. Other modules will be able to load this from
2824 // the wx._core_ module and will then have safe access to these functions,
2825 // even if they are located in another shared library.
2826 static wxPyCoreAPI API = {
2827
2828 wxPyCheckSwigType,
2829 wxPyConstructObject,
2830 wxPyConvertSwigPtr,
2831 wxPyMakeSwigPtr,
2832
2833 wxPyBeginAllowThreads,
2834 wxPyEndAllowThreads,
2835 wxPyBeginBlockThreads,
2836 wxPyEndBlockThreads,
2837
2838 wxPy_ConvertList,
2839
2840 wxString_in_helper,
2841 Py2wxString,
2842 wx2PyString,
2843
2844 byte_LIST_helper,
2845 int_LIST_helper,
2846 long_LIST_helper,
2847 string_LIST_helper,
2848 wxPoint_LIST_helper,
2849 wxBitmap_LIST_helper,
2850 wxString_LIST_helper,
2851 wxAcceleratorEntry_LIST_helper,
2852
2853 wxSize_helper,
2854 wxPoint_helper,
2855 wxRealPoint_helper,
2856 wxRect_helper,
2857 wxColour_helper,
2858 wxPoint2D_helper,
2859
2860 wxPySimple_typecheck,
2861 wxColour_typecheck,
2862
2863 wxPyCBH_setCallbackInfo,
2864 wxPyCBH_findCallback,
2865 wxPyCBH_callCallback,
2866 wxPyCBH_callCallbackObj,
2867 wxPyCBH_delete,
2868
2869 wxPyMake_wxObject,
2870 wxPyMake_wxSizer,
2871 wxPyPtrTypeMap_Add,
2872 wxPy2int_seq_helper,
2873 wxPy4int_seq_helper,
2874 wxArrayString2PyList_helper,
2875 wxArrayInt2PyList_helper,
2876
2877 wxPyClientData_dtor,
2878 wxPyUserData_dtor,
2879 wxPyOORClientData_dtor,
2880
2881 wxPyCBInputStream_create,
2882 wxPyCBInputStream_copy,
2883
2884 wxPyInstance_Check,
2885 wxPySwigInstance_Check,
2886
2887 wxPyCheckForApp
2888
2889 };
2890
2891 #endif
2892
2893
2894 #if !WXWIN_COMPATIBILITY_2_4
2895 #define wxHIDE_READONLY 0
2896 #endif
2897
2898
2899 #define SWIG_From_long PyInt_FromLong
2900
2901
2902 SWIGINTERNINLINE PyObject *
2903 SWIG_From_int (int value)
2904 {
2905 return SWIG_From_long (value);
2906 }
2907
2908 static const wxString wxPyEmptyString(wxEmptyString);
2909 SWIGINTERN wxString wxObject_GetClassName(wxObject *self){
2910 return self->GetClassInfo()->GetClassName();
2911 }
2912 SWIGINTERN void wxObject_Destroy(wxObject *self){
2913 delete self;
2914 }
2915
2916 #ifndef __WXMAC__
2917 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
2918 #endif
2919
2920
2921 #include <limits.h>
2922 #ifndef LLONG_MIN
2923 # define LLONG_MIN LONG_LONG_MIN
2924 #endif
2925 #ifndef LLONG_MAX
2926 # define LLONG_MAX LONG_LONG_MAX
2927 #endif
2928 #ifndef ULLONG_MAX
2929 # define ULLONG_MAX ULONG_LONG_MAX
2930 #endif
2931
2932
2933 SWIGINTERN int
2934 SWIG_AsVal_long (PyObject* obj, long* val)
2935 {
2936 if (PyNumber_Check(obj)) {
2937 if (val) *val = PyInt_AsLong(obj);
2938 return SWIG_OK;
2939 }
2940 return SWIG_TypeError;
2941 }
2942
2943
2944 SWIGINTERN int
2945 SWIG_AsVal_int (PyObject * obj, int *val)
2946 {
2947 long v;
2948 int res = SWIG_AsVal_long (obj, &v);
2949 if (SWIG_IsOK(res)) {
2950 if ((v < INT_MIN || v > INT_MAX)) {
2951 return SWIG_OverflowError;
2952 } else {
2953 if (val) *val = static_cast< int >(v);
2954 }
2955 }
2956 return res;
2957 }
2958
2959 SWIGINTERN bool wxSize___eq__(wxSize *self,PyObject *other){
2960 wxSize temp, *obj = &temp;
2961 if ( other == Py_None ) return false;
2962 if ( ! wxSize_helper(other, &obj) ) {
2963 PyErr_Clear();
2964 return false;
2965 }
2966 return self->operator==(*obj);
2967 }
2968 SWIGINTERN bool wxSize___ne__(wxSize *self,PyObject *other){
2969 wxSize temp, *obj = &temp;
2970 if ( other == Py_None ) return true;
2971 if ( ! wxSize_helper(other, &obj)) {
2972 PyErr_Clear();
2973 return true;
2974 }
2975 return self->operator!=(*obj);
2976 }
2977 SWIGINTERN PyObject *wxSize_Get(wxSize *self){
2978 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2979 PyObject* tup = PyTuple_New(2);
2980 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
2981 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
2982 wxPyEndBlockThreads(blocked);
2983 return tup;
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 #define SWIG_From_double PyFloat_FromDouble
2998
2999 SWIGINTERN bool wxRealPoint___eq__(wxRealPoint *self,PyObject *other){
3000 wxRealPoint temp, *obj = &temp;
3001 if ( other == Py_None ) return false;
3002 if ( ! wxRealPoint_helper(other, &obj) ) {
3003 PyErr_Clear();
3004 return false;
3005 }
3006 return self->operator==(*obj);
3007 }
3008 SWIGINTERN bool wxRealPoint___ne__(wxRealPoint *self,PyObject *other){
3009 wxRealPoint temp, *obj = &temp;
3010 if ( other == Py_None ) return true;
3011 if ( ! wxRealPoint_helper(other, &obj)) {
3012 PyErr_Clear();
3013 return true;
3014 }
3015 return self->operator!=(*obj);
3016 }
3017 SWIGINTERN void wxRealPoint_Set(wxRealPoint *self,double x,double y){
3018 self->x = x;
3019 self->y = y;
3020 }
3021 SWIGINTERN PyObject *wxRealPoint_Get(wxRealPoint *self){
3022 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3023 PyObject* tup = PyTuple_New(2);
3024 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
3025 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
3026 wxPyEndBlockThreads(blocked);
3027 return tup;
3028 }
3029 SWIGINTERN bool wxPoint___eq__(wxPoint *self,PyObject *other){
3030 wxPoint temp, *obj = &temp;
3031 if ( other == Py_None ) return false;
3032 if ( ! wxPoint_helper(other, &obj) ) {
3033 PyErr_Clear();
3034 return false;
3035 }
3036 return self->operator==(*obj);
3037 }
3038 SWIGINTERN bool wxPoint___ne__(wxPoint *self,PyObject *other){
3039 wxPoint temp, *obj = &temp;
3040 if ( other == Py_None ) return true;
3041 if ( ! wxPoint_helper(other, &obj)) {
3042 PyErr_Clear();
3043 return true;
3044 }
3045 return self->operator!=(*obj);
3046 }
3047 SWIGINTERN void wxPoint_Set(wxPoint *self,long x,long y){
3048 self->x = x;
3049 self->y = y;
3050 }
3051 SWIGINTERN PyObject *wxPoint_Get(wxPoint *self){
3052 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3053 PyObject* tup = PyTuple_New(2);
3054 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3055 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3056 wxPyEndBlockThreads(blocked);
3057 return tup;
3058 }
3059 SWIGINTERN bool wxRect___eq__(wxRect *self,PyObject *other){
3060 wxRect temp, *obj = &temp;
3061 if ( other == Py_None ) return false;
3062 if ( ! wxRect_helper(other, &obj) ) {
3063 PyErr_Clear();
3064 return false;
3065 }
3066 return self->operator==(*obj);
3067 }
3068 SWIGINTERN bool wxRect___ne__(wxRect *self,PyObject *other){
3069 wxRect temp, *obj = &temp;
3070 if ( other == Py_None ) return true;
3071 if ( ! wxRect_helper(other, &obj)) {
3072 PyErr_Clear();
3073 return true;
3074 }
3075 return self->operator!=(*obj);
3076 }
3077 SWIGINTERN void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
3078 self->x = x;
3079 self->y = y;
3080 self->width = width;
3081 self->height = height;
3082 }
3083 SWIGINTERN PyObject *wxRect_Get(wxRect *self){
3084 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3085 PyObject* tup = PyTuple_New(4);
3086 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3087 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3088 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
3089 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
3090 wxPyEndBlockThreads(blocked);
3091 return tup;
3092 }
3093
3094 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
3095 wxRegion reg1(*r1);
3096 wxRegion reg2(*r2);
3097 wxRect dest(0,0,0,0);
3098 PyObject* obj;
3099
3100 reg1.Intersect(reg2);
3101 dest = reg1.GetBox();
3102
3103 if (dest != wxRect(0,0,0,0)) {
3104 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3105 wxRect* newRect = new wxRect(dest);
3106 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
3107 wxPyEndBlockThreads(blocked);
3108 return obj;
3109 }
3110 Py_INCREF(Py_None);
3111 return Py_None;
3112 }
3113
3114 SWIGINTERN bool wxPoint2D___eq__(wxPoint2D *self,PyObject *other){
3115 wxPoint2D temp, *obj = &temp;
3116 if ( other == Py_None ) return false;
3117 if ( ! wxPoint2D_helper(other, &obj) ) {
3118 PyErr_Clear();
3119 return false;
3120 }
3121 return self->operator==(*obj);
3122 }
3123 SWIGINTERN bool wxPoint2D___ne__(wxPoint2D *self,PyObject *other){
3124 wxPoint2D temp, *obj = &temp;
3125 if ( other == Py_None ) return true;
3126 if ( ! wxPoint2D_helper(other, &obj)) {
3127 PyErr_Clear();
3128 return true;
3129 }
3130 return self->operator!=(*obj);
3131 }
3132 SWIGINTERN void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
3133 self->m_x = x;
3134 self->m_y = y;
3135 }
3136 SWIGINTERN PyObject *wxPoint2D_Get(wxPoint2D *self){
3137 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3138 PyObject* tup = PyTuple_New(2);
3139 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
3140 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
3141 wxPyEndBlockThreads(blocked);
3142 return tup;
3143 }
3144
3145 #include "wx/wxPython/pyistream.h"
3146
3147 SWIGINTERN wxPyInputStream *new_wxPyInputStream(PyObject *p){
3148 wxInputStream* wxis = wxPyCBInputStream::create(p);
3149 if (wxis)
3150 return new wxPyInputStream(wxis);
3151 else
3152 return NULL;
3153 }
3154
3155 SWIGINTERN swig_type_info*
3156 SWIG_pchar_descriptor()
3157 {
3158 static int init = 0;
3159 static swig_type_info* info = 0;
3160 if (!init) {
3161 info = SWIG_TypeQuery("_p_char");
3162 init = 1;
3163 }
3164 return info;
3165 }
3166
3167
3168 SWIGINTERNINLINE PyObject *
3169 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3170 {
3171 if (carray) {
3172 if (size > INT_MAX) {
3173 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3174 return pchar_descriptor ?
3175 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3176 } else {
3177 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3178 }
3179 } else {
3180 return SWIG_Py_Void();
3181 }
3182 }
3183
3184
3185 SWIGINTERNINLINE PyObject *
3186 SWIG_From_char (char c)
3187 {
3188 return SWIG_FromCharPtrAndSize(&c,1);
3189 }
3190
3191
3192 SWIGINTERNINLINE PyObject*
3193 SWIG_From_unsigned_SS_long (unsigned long value)
3194 {
3195 return (value > LONG_MAX) ?
3196 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
3197 }
3198
3199
3200 SWIGINTERNINLINE PyObject *
3201 SWIG_From_size_t (size_t value)
3202 {
3203 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
3204 }
3205
3206
3207 SWIGINTERN int
3208 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
3209 {
3210 if (PyString_Check(obj)) {
3211 char *cstr; int len;
3212 PyString_AsStringAndSize(obj, &cstr, &len);
3213 if (cptr) {
3214 if (alloc) {
3215 /*
3216 In python the user should not be able to modify the inner
3217 string representation. To warranty that, if you define
3218 SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
3219 buffer is always returned.
3220
3221 The default behavior is just to return the pointer value,
3222 so, be careful.
3223 */
3224 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
3225 if (*alloc != SWIG_OLDOBJ)
3226 #else
3227 if (*alloc == SWIG_NEWOBJ)
3228 #endif
3229 {
3230 *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
3231 *alloc = SWIG_NEWOBJ;
3232 }
3233 else {
3234 *cptr = cstr;
3235 *alloc = SWIG_OLDOBJ;
3236 }
3237 } else {
3238 *cptr = PyString_AsString(obj);
3239 }
3240 }
3241 if (psize) *psize = len + 1;
3242 return SWIG_OK;
3243 } else {
3244 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3245 if (pchar_descriptor) {
3246 void* vptr = 0;
3247 if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3248 if (cptr) *cptr = (char *) vptr;
3249 if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3250 if (alloc) *alloc = SWIG_OLDOBJ;
3251 return SWIG_OK;
3252 }
3253 }
3254 }
3255 return SWIG_TypeError;
3256 }
3257
3258
3259 SWIGINTERN int
3260 SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
3261 {
3262 char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3263 int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3264 if (SWIG_IsOK(res)) {
3265 if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
3266 if (csize <= size) {
3267 if (val) {
3268 if (csize) memcpy(val, cptr, csize*sizeof(char));
3269 if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3270 }
3271 if (alloc == SWIG_NEWOBJ) {
3272 delete[] cptr;
3273 res = SWIG_DelNewMask(res);
3274 }
3275 return res;
3276 }
3277 if (alloc == SWIG_NEWOBJ) delete[] cptr;
3278 }
3279 return SWIG_TypeError;
3280 }
3281
3282
3283 SWIGINTERN int
3284 SWIG_AsVal_char (PyObject * obj, char *val)
3285 {
3286 int res = SWIG_AsCharArray(obj, val, 1);
3287 if (!SWIG_IsOK(res)) {
3288 long v;
3289 res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3290 if (SWIG_IsOK(res)) {
3291 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3292 if (val) *val = static_cast< char >(v);
3293 } else {
3294 res = SWIG_OverflowError;
3295 }
3296 }
3297 }
3298 return res;
3299 }
3300
3301 SWIGINTERN void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
3302 // We use only strings for the streams, not unicode
3303 PyObject* str = PyObject_Str(obj);
3304 if (! str) {
3305 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
3306 return;
3307 }
3308 self->Write(PyString_AS_STRING(str),
3309 PyString_GET_SIZE(str));
3310 Py_DECREF(str);
3311 }
3312
3313 #include "wx/wxPython/pyistream.h"
3314
3315
3316 class wxPyFileSystemHandler : public wxFileSystemHandler
3317 {
3318 public:
3319 wxPyFileSystemHandler() : wxFileSystemHandler() {}
3320
3321 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
3322 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
3323 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
3324 DEC_PYCALLBACK_STRING__pure(FindNext);
3325
3326 wxString GetProtocol(const wxString& location) {
3327 return wxFileSystemHandler::GetProtocol(location);
3328 }
3329
3330 wxString GetLeftLocation(const wxString& location) {
3331 return wxFileSystemHandler::GetLeftLocation(location);
3332 }
3333
3334 wxString GetAnchor(const wxString& location) {
3335 return wxFileSystemHandler::GetAnchor(location);
3336 }
3337
3338 wxString GetRightLocation(const wxString& location) {
3339 return wxFileSystemHandler::GetRightLocation(location);
3340 }
3341
3342 wxString GetMimeTypeFromExt(const wxString& location) {
3343 return wxFileSystemHandler::GetMimeTypeFromExt(location);
3344 }
3345
3346 PYPRIVATE;
3347 };
3348
3349
3350 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
3351 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
3352 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
3353 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
3354
3355
3356 SWIGINTERN int
3357 SWIG_AsVal_bool (PyObject *obj, bool *val)
3358 {
3359 if (obj == Py_True) {
3360 if (val) *val = true;
3361 return SWIG_OK;
3362 } else if (obj == Py_False) {
3363 if (val) *val = false;
3364 return SWIG_OK;
3365 } else {
3366 long v = 0;
3367 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
3368 if (SWIG_IsOK(res) && val) *val = v ? true : false;
3369 return res;
3370 }
3371 }
3372
3373 SWIGINTERN wxString wxFileSystem_URLToFileName(wxString const &url){
3374 wxFileName fname = wxFileSystem::URLToFileName(url);
3375 return fname.GetFullPath();
3376 }
3377
3378 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
3379 wxImage& image,
3380 long type) {
3381 wxMemoryFSHandler::AddFile(filename, image, type);
3382 }
3383
3384 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
3385 const wxBitmap& bitmap,
3386 long type) {
3387 wxMemoryFSHandler::AddFile(filename, bitmap, type);
3388 }
3389
3390 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
3391 PyObject* data) {
3392 if (! PyString_Check(data)) {
3393 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
3394 "Expected string object"));
3395 return;
3396 }
3397
3398 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3399 void* ptr = (void*)PyString_AsString(data);
3400 size_t size = PyString_Size(data);
3401 wxPyEndBlockThreads(blocked);
3402
3403 wxMemoryFSHandler::AddFile(filename, ptr, size);
3404 }
3405
3406
3407 #include "wx/wxPython/pyistream.h"
3408
3409
3410 SWIGINTERN int
3411 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
3412 {
3413 long v = 0;
3414 if (SWIG_AsVal_long(obj, &v) && v < 0) {
3415 return SWIG_TypeError;
3416 }
3417 else if (val)
3418 *val = (unsigned long)v;
3419 return SWIG_OK;
3420 }
3421
3422
3423 SWIGINTERN int
3424 SWIG_AsVal_unsigned_SS_char (PyObject * obj, unsigned char *val)
3425 {
3426 unsigned long v;
3427 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3428 if (SWIG_IsOK(res)) {
3429 if ((v > UCHAR_MAX)) {
3430 return SWIG_OverflowError;
3431 } else {
3432 if (val) *val = static_cast< unsigned char >(v);
3433 }
3434 }
3435 return res;
3436 }
3437
3438
3439 SWIGINTERNINLINE PyObject *
3440 SWIG_From_unsigned_SS_char (unsigned char value)
3441 {
3442 return SWIG_From_unsigned_SS_long (value);
3443 }
3444
3445 SWIGINTERN unsigned long wxImageHistogram_GetCount(wxImageHistogram *self,unsigned long key){
3446 wxImageHistogramEntry e = (*self)[key];
3447 return e.value;
3448 }
3449 SWIGINTERN unsigned long wxImageHistogram_GetCountRGB(wxImageHistogram *self,byte r,byte g,byte b){
3450 unsigned long key = wxImageHistogram::MakeKey(r, g, b);
3451 wxImageHistogramEntry e = (*self)[key];
3452 return e.value;
3453 }
3454 SWIGINTERN unsigned long wxImageHistogram_GetCountColour(wxImageHistogram *self,wxColour const &colour){
3455 unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
3456 colour.Green(),
3457 colour.Blue());
3458 wxImageHistogramEntry e = (*self)[key];
3459 return e.value;
3460 }
3461
3462 typedef unsigned char* buffer;
3463
3464
3465 // Pull the nested class out to the top level for SWIG's sake
3466 #define wxImage_RGBValue wxImage::RGBValue
3467 #define wxImage_HSVValue wxImage::HSVValue
3468
3469 SWIGINTERN wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
3470 if (width > 0 && height > 0)
3471 return new wxImage(width, height, clear);
3472 else
3473 return new wxImage;
3474 }
3475 SWIGINTERN wxImage *new_wxImage(wxBitmap const &bitmap){
3476 return new wxImage(bitmap.ConvertToImage());
3477 }
3478 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE){
3479 if (DATASIZE != width*height*3) {
3480 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3481 return NULL;
3482 }
3483
3484 // Copy the source data so the wxImage can clean it up later
3485 buffer copy = (buffer)malloc(DATASIZE);
3486 if (copy == NULL) {
3487 wxPyBLOCK_THREADS(PyErr_NoMemory());
3488 return NULL;
3489 }
3490 memcpy(copy, data, DATASIZE);
3491 return new wxImage(width, height, copy, false);
3492 }
3493 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE,buffer alpha,int ALPHASIZE){
3494 if (DATASIZE != width*height*3) {
3495 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3496 return NULL;
3497 }
3498 if (ALPHASIZE != width*height) {
3499 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3500 return NULL;
3501 }
3502
3503 // Copy the source data so the wxImage can clean it up later
3504 buffer dcopy = (buffer)malloc(DATASIZE);
3505 if (dcopy == NULL) {
3506 wxPyBLOCK_THREADS(PyErr_NoMemory());
3507 return NULL;
3508 }
3509 memcpy(dcopy, data, DATASIZE);
3510
3511 buffer acopy = (buffer)malloc(ALPHASIZE);
3512 if (acopy == NULL) {
3513 wxPyBLOCK_THREADS(PyErr_NoMemory());
3514 return NULL;
3515 }
3516 memcpy(acopy, alpha, ALPHASIZE);
3517
3518 return new wxImage(width, height, dcopy, acopy, false);
3519 }
3520 SWIGINTERN wxSize wxImage_GetSize(wxImage *self){
3521 wxSize size(self->GetWidth(), self->GetHeight());
3522 return size;
3523 }
3524 SWIGINTERN PyObject *wxImage_GetData(wxImage *self){
3525 buffer data = self->GetData();
3526 int len = self->GetWidth() * self->GetHeight() * 3;
3527 PyObject* rv;
3528 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
3529 return rv;
3530 }
3531 SWIGINTERN void wxImage_SetData(wxImage *self,buffer data,int DATASIZE){
3532 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3533 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3534 return;
3535 }
3536 buffer copy = (buffer)malloc(DATASIZE);
3537 if (copy == NULL) {
3538 wxPyBLOCK_THREADS(PyErr_NoMemory());
3539 return;
3540 }
3541 memcpy(copy, data, DATASIZE);
3542 self->SetData(copy, false);
3543 // wxImage takes ownership of copy...
3544 }
3545 SWIGINTERN PyObject *wxImage_GetDataBuffer(wxImage *self){
3546 buffer data = self->GetData();
3547 int len = self->GetWidth() * self->GetHeight() * 3;
3548 PyObject* rv;
3549 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3550 return rv;
3551 }
3552 SWIGINTERN void wxImage_SetDataBuffer(wxImage *self,buffer data,int DATASIZE){
3553 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3554 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3555 return;
3556 }
3557 self->SetData(data, true);
3558 }
3559 SWIGINTERN PyObject *wxImage_GetAlphaData(wxImage *self){
3560 buffer data = self->GetAlpha();
3561 if (! data) {
3562 RETURN_NONE();
3563 } else {
3564 int len = self->GetWidth() * self->GetHeight();
3565 PyObject* rv;
3566 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
3567 return rv;
3568 }
3569 }
3570 SWIGINTERN void wxImage_SetAlphaData(wxImage *self,buffer alpha,int ALPHASIZE){
3571 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3572 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3573 return;
3574 }
3575 buffer acopy = (buffer)malloc(ALPHASIZE);
3576 if (acopy == NULL) {
3577 wxPyBLOCK_THREADS(PyErr_NoMemory());
3578 return;
3579 }
3580 memcpy(acopy, alpha, ALPHASIZE);
3581 self->SetAlpha(acopy, false);
3582 // wxImage takes ownership of acopy...
3583 }
3584 SWIGINTERN PyObject *wxImage_GetAlphaBuffer(wxImage *self){
3585 buffer data = self->GetAlpha();
3586 int len = self->GetWidth() * self->GetHeight();
3587 PyObject* rv;
3588 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3589 return rv;
3590 }
3591 SWIGINTERN void wxImage_SetAlphaBuffer(wxImage *self,buffer alpha,int ALPHASIZE){
3592 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3593 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3594 return;
3595 }
3596 self->SetAlpha(alpha, true);
3597 }
3598 SWIGINTERN PyObject *wxImage_GetHandlers(){
3599 wxList& list = wxImage::GetHandlers();
3600 return wxPy_ConvertList(&list);
3601 }
3602 SWIGINTERN wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
3603 wxBitmap bitmap(*self, depth);
3604 return bitmap;
3605 }
3606 SWIGINTERN wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,byte red,byte green,byte blue){
3607 wxImage mono = self->ConvertToMono( red, green, blue );
3608 wxBitmap bitmap( mono, 1 );
3609 return bitmap;
3610 }
3611 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
3612 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
3613 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
3614 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
3615 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
3616 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
3617 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
3618 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
3619 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
3620 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
3621 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
3622 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
3623 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
3624 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
3625 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
3626
3627 #include <wx/quantize.h>
3628
3629 SWIGINTERN bool wxQuantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
3630 return wxQuantize::Quantize(src, dest,
3631 //NULL, // palette
3632 desiredNoColours,
3633 NULL, // eightBitData
3634 flags);
3635 }
3636 SWIGINTERN void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
3637 if (PyCallable_Check(func)) {
3638 self->Connect(id, lastId, eventType,
3639 (wxObjectEventFunction) &wxPyCallback::EventThunker,
3640 new wxPyCallback(func));
3641 }
3642 else if (func == Py_None) {
3643 self->Disconnect(id, lastId, eventType,
3644 (wxObjectEventFunction)
3645 &wxPyCallback::EventThunker);
3646 }
3647 else {
3648 wxPyBLOCK_THREADS(
3649 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
3650 }
3651 }
3652 SWIGINTERN bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
3653 return self->Disconnect(id, lastId, eventType,
3654 (wxObjectEventFunction)
3655 &wxPyCallback::EventThunker);
3656 }
3657 SWIGINTERN void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
3658 if (_self && _self != Py_None) {
3659 self->SetClientObject(new wxPyOORClientData(_self, incref));
3660 }
3661 else {
3662 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
3663 if (data) {
3664 self->SetClientObject(NULL); // This will delete it too
3665 }
3666 }
3667 }
3668
3669 #if ! wxUSE_HOTKEY
3670 #define wxEVT_HOTKEY -9999
3671 #endif
3672
3673 SWIGINTERN PyObject *wxCommandEvent_GetClientData(wxCommandEvent *self){
3674 wxPyClientData* data = (wxPyClientData*)self->GetClientObject();
3675 if (data) {
3676 Py_INCREF(data->m_obj);
3677 return data->m_obj;
3678 } else {
3679 Py_INCREF(Py_None);
3680 return Py_None;
3681 }
3682 }
3683 SWIGINTERN void wxCommandEvent_SetClientData(wxCommandEvent *self,PyObject *clientData){
3684 wxPyClientData* data = new wxPyClientData(clientData);
3685 self->SetClientObject(data);
3686 }
3687 SWIGINTERN int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
3688 #if wxUSE_UNICODE
3689 return self->GetUnicodeKey();
3690 #else
3691 return 0;
3692 #endif
3693 }
3694 SWIGINTERN void wxKeyEvent_SetUnicodeKey(wxKeyEvent *self,int uniChar){
3695 #if wxUSE_UNICODE
3696 self->m_uniChar = uniChar;
3697 #endif
3698 }
3699
3700 SWIGINTERNINLINE PyObject *
3701 SWIG_From_unsigned_SS_int (unsigned int value)
3702 {
3703 return SWIG_From_unsigned_SS_long (value);
3704 }
3705
3706
3707 SWIGINTERN int
3708 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3709 {
3710 unsigned long v;
3711 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3712 if (SWIG_IsOK(res)) {
3713 if ((v > UINT_MAX)) {
3714 return SWIG_OverflowError;
3715 } else {
3716 if (val) *val = static_cast< unsigned int >(v);
3717 }
3718 }
3719 return res;
3720 }
3721
3722 SWIGINTERN void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
3723 self->m_size = size;
3724 }
3725 SWIGINTERN PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
3726 int count = self->GetNumberOfFiles();
3727 wxString* files = self->GetFiles();
3728 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3729 PyObject* list = PyList_New(count);
3730
3731 if (!list) {
3732 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
3733 wxPyEndBlockThreads(blocked);
3734 return NULL;
3735 }
3736
3737 for (int i=0; i<count; i++) {
3738 PyList_SetItem(list, i, wx2PyString(files[i]));
3739 }
3740 wxPyEndBlockThreads(blocked);
3741 return list;
3742 }
3743
3744
3745 SWIGINTERN wxPyApp *new_wxPyApp(){
3746 wxPythonApp = new wxPyApp();
3747 return wxPythonApp;
3748 }
3749 SWIGINTERN int wxPyApp_GetComCtl32Version(){ wxPyRaiseNotImplemented(); return 0; }
3750
3751 void wxApp_CleanUp() {
3752 __wxPyCleanup();
3753 }
3754
3755
3756 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
3757
3758
3759
3760
3761
3762 SWIGINTERNINLINE PyObject *
3763 SWIG_FromCharPtr(const char *cptr)
3764 {
3765 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3766 }
3767
3768
3769 #if 0 // #ifdef __WXMAC__
3770
3771 // A dummy class that raises an exception if used...
3772 class wxEventLoop
3773 {
3774 public:
3775 wxEventLoop() { wxPyRaiseNotImplemented(); }
3776 int Run() { return 0; }
3777 void Exit(int rc = 0) {}
3778 bool Pending() const { return false; }
3779 bool Dispatch() { return false; }
3780 bool IsRunning() const { return false; }
3781 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
3782 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
3783 };
3784
3785 #else
3786
3787 #include <wx/evtloop.h>
3788
3789 #endif
3790
3791
3792
3793 static const wxString wxPyPanelNameStr(wxPanelNameStr);
3794 SWIGINTERN wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
3795 SWIGINTERN void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
3796 SWIGINTERN PyObject *wxWindow_GetChildren(wxWindow *self){
3797 wxWindowList& list = self->GetChildren();
3798 return wxPy_ConvertList(&list);
3799 }
3800 SWIGINTERN bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
3801 #if wxUSE_HOTKEY
3802 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
3803 #else
3804 return false;
3805 #endif
3806 }
3807 SWIGINTERN bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
3808
3809
3810
3811 return false;
3812
3813 }
3814 SWIGINTERN long wxWindow_GetHandle(wxWindow *self){
3815 return wxPyGetWinHandle(self);
3816 }
3817 SWIGINTERN void wxWindow_AssociateHandle(wxWindow *self,long handle){
3818 self->AssociateHandle((WXWidget)handle);
3819 }
3820 SWIGINTERN void wxWindow_DragAcceptFiles(wxWindow *self,bool accept){}
3821
3822 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
3823 return wxWindow::FindWindowById(id, parent);
3824 }
3825
3826 wxWindow* wxFindWindowByName( const wxString& name,
3827 const wxWindow *parent = NULL ) {
3828 return wxWindow::FindWindowByName(name, parent);
3829 }
3830
3831 wxWindow* wxFindWindowByLabel( const wxString& label,
3832 const wxWindow *parent = NULL ) {
3833 return wxWindow::FindWindowByLabel(label, parent);
3834 }
3835
3836
3837 #ifdef __WXMSW__
3838 #include <wx/msw/private.h> // to get wxGetWindowId
3839 #endif
3840
3841
3842 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
3843 #ifdef __WXMSW__
3844 WXHWND hWnd = (WXHWND)_hWnd;
3845 long id = wxGetWindowId(hWnd);
3846 wxWindow* win = new wxWindow;
3847 if (parent)
3848 parent->AddChild(win);
3849 win->SetEventHandler(win);
3850 win->SetHWND(hWnd);
3851 win->SetId(id);
3852 win->SubclassWin(hWnd);
3853 win->AdoptAttributesFromHWND();
3854 win->SetupColours();
3855 return win;
3856 #else
3857 wxPyRaiseNotImplemented();
3858 return NULL;
3859 #endif
3860 }
3861
3862
3863 PyObject* GetTopLevelWindows() {
3864 return wxPy_ConvertList(&wxTopLevelWindows);
3865 }
3866
3867
3868 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
3869 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
3870 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
3871
3872 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
3873
3874
3875 SWIGINTERNINLINE int
3876 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3877 {
3878 unsigned long v;
3879 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3880 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3881 return res;
3882 }
3883
3884 SWIGINTERN void wxMenu_Destroy(wxMenu *self){ delete self; }
3885 SWIGINTERN PyObject *wxMenu_GetMenuItems(wxMenu *self){
3886 wxMenuItemList& list = self->GetMenuItems();
3887 return wxPy_ConvertList(&list);
3888 }
3889 SWIGINTERN void wxMenuBar_SetAutoWindowMenu(bool enable){}
3890 SWIGINTERN bool wxMenuBar_GetAutoWindowMenu(){ return false; }
3891 SWIGINTERN void wxMenuItem_SetFont(wxMenuItem *self,wxFont const &font){}
3892 SWIGINTERN wxFont wxMenuItem_GetFont(wxMenuItem *self){ return wxNullFont; }
3893 SWIGINTERN void wxMenuItem_SetTextColour(wxMenuItem *self,wxColour const &colText){}
3894 SWIGINTERN wxColour wxMenuItem_GetTextColour(wxMenuItem *self){ return wxNullColour; }
3895 SWIGINTERN void wxMenuItem_SetBackgroundColour(wxMenuItem *self,wxColour const &colBack){}
3896 SWIGINTERN wxColour wxMenuItem_GetBackgroundColour(wxMenuItem *self){ return wxNullColour; }
3897 SWIGINTERN void wxMenuItem_SetBitmaps(wxMenuItem *self,wxBitmap const &bmpChecked,wxBitmap const &bmpUnchecked=wxNullBitmap){ self->SetBitmap( bmpChecked ); }
3898 SWIGINTERN void wxMenuItem_SetDisabledBitmap(wxMenuItem *self,wxBitmap const &bmpDisabled){}
3899 SWIGINTERN wxBitmap const &wxMenuItem_GetDisabledBitmap(wxMenuItem const *self){ return wxNullBitmap; }
3900 SWIGINTERN void wxMenuItem_SetMarginWidth(wxMenuItem *self,int nWidth){}
3901 SWIGINTERN int wxMenuItem_GetMarginWidth(wxMenuItem *self){ return 0; }
3902 SWIGINTERN int wxMenuItem_GetDefaultMarginWidth(){ return 0; }
3903 SWIGINTERN bool wxMenuItem_IsOwnerDrawn(wxMenuItem *self){ return false; }
3904 SWIGINTERN void wxMenuItem_SetOwnerDrawn(wxMenuItem *self,bool ownerDrawn=true){}
3905 SWIGINTERN void wxMenuItem_ResetOwnerDrawn(wxMenuItem *self){}
3906 static const wxString wxPyControlNameStr(wxControlNameStr);
3907 SWIGINTERN int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
3908 if (clientData) {
3909 wxPyClientData* data = new wxPyClientData(clientData);
3910 return self->Append(item, data);
3911 } else
3912 return self->Append(item);
3913 }
3914 SWIGINTERN int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,unsigned int pos,PyObject *clientData=NULL){
3915 if (clientData) {
3916 wxPyClientData* data = new wxPyClientData(clientData);
3917 return self->Insert(item, pos, data);
3918 } else
3919 return self->Insert(item, pos);
3920 }
3921 SWIGINTERN PyObject *wxItemContainer_GetClientData(wxItemContainer *self,unsigned int n){
3922 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
3923 if (data) {
3924 Py_INCREF(data->m_obj);
3925 return data->m_obj;
3926 } else {
3927 Py_INCREF(Py_None);
3928 return Py_None;
3929 }
3930 }
3931 SWIGINTERN void wxItemContainer_SetClientData(wxItemContainer *self,unsigned int n,PyObject *clientData){
3932 wxPyClientData* data = new wxPyClientData(clientData);
3933 self->SetClientObject(n, data);
3934 }
3935
3936
3937 SWIGINTERN wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
3938 wxPyUserData* data = NULL;
3939 if ( userData ) {
3940 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3941 data = new wxPyUserData(userData);
3942 wxPyEndBlockThreads(blocked);
3943 }
3944 return new wxSizerItem(window, proportion, flag, border, data);
3945 }
3946 SWIGINTERN wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
3947 wxPyUserData* data = NULL;
3948 if ( userData ) {
3949 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3950 data = new wxPyUserData(userData);
3951 wxPyEndBlockThreads(blocked);
3952 }
3953 return new wxSizerItem(width, height, proportion, flag, border, data);
3954 }
3955 SWIGINTERN wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
3956 wxPyUserData* data = NULL;
3957 if ( userData ) {
3958 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3959 data = new wxPyUserData(userData);
3960 wxPyEndBlockThreads(blocked);
3961 }
3962 return new wxSizerItem(sizer, proportion, flag, border, data);
3963 }
3964
3965 #include <float.h>
3966
3967
3968 SWIGINTERN int
3969 SWIG_AsVal_float (PyObject * obj, float *val)
3970 {
3971 double v;
3972 int res = SWIG_AsVal_double (obj, &v);
3973 if (SWIG_IsOK(res)) {
3974 if ((v < -FLT_MAX || v > FLT_MAX)) {
3975 return SWIG_OverflowError;
3976 } else {
3977 if (val) *val = static_cast< float >(v);
3978 }
3979 }
3980 return res;
3981 }
3982
3983
3984 SWIGINTERNINLINE PyObject *
3985 SWIG_From_float (float value)
3986 {
3987 return SWIG_From_double (value);
3988 }
3989
3990 SWIGINTERN PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
3991 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
3992 if (data) {
3993 Py_INCREF(data->m_obj);
3994 return data->m_obj;
3995 } else {
3996 Py_INCREF(Py_None);
3997 return Py_None;
3998 }
3999 }
4000 SWIGINTERN void wxSizerItem_SetUserData(wxSizerItem *self,PyObject *userData){
4001 wxPyUserData* data = NULL;
4002 if ( userData ) {
4003 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4004 data = new wxPyUserData(userData);
4005 wxPyEndBlockThreads(blocked);
4006 }
4007 self->SetUserData(data);
4008 }
4009
4010 // Figure out the type of the sizer item
4011
4012 struct wxPySizerItemInfo {
4013 wxPySizerItemInfo()
4014 : window(NULL), sizer(NULL), gotSize(false),
4015 size(wxDefaultSize), gotPos(false), pos(-1)
4016 {}
4017
4018 wxWindow* window;
4019 wxSizer* sizer;
4020 bool gotSize;
4021 wxSize size;
4022 bool gotPos;
4023 int pos;
4024 };
4025
4026 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
4027
4028 wxPySizerItemInfo info;
4029 wxSize size;
4030 wxSize* sizePtr = &size;
4031
4032 // Find out what the type of the item is
4033 // try wxWindow
4034 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
4035 PyErr_Clear();
4036 info.window = NULL;
4037
4038 // try wxSizer
4039 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
4040 PyErr_Clear();
4041 info.sizer = NULL;
4042
4043 // try wxSize or (w,h)
4044 if ( checkSize && wxSize_helper(item, &sizePtr)) {
4045 info.size = *sizePtr;
4046 info.gotSize = true;
4047 }
4048
4049 // or a single int
4050 if (checkIdx && PyInt_Check(item)) {
4051 info.pos = PyInt_AsLong(item);
4052 info.gotPos = true;
4053 }
4054 }
4055 }
4056
4057 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
4058 // no expected type, figure out what kind of error message to generate
4059 if ( !checkSize && !checkIdx )
4060 PyErr_SetString(PyExc_TypeError, "wx.Window or wx.Sizer expected for item");
4061 else if ( checkSize && !checkIdx )
4062 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) expected for item");
4063 else if ( !checkSize && checkIdx)
4064 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer or int (position) expected for item");
4065 else
4066 // can this one happen?
4067 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) or int (position) expected for item");
4068 }
4069
4070 return info;
4071 }
4072
4073 SWIGINTERN void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
4074 if (!self->GetClientObject())
4075 self->SetClientObject(new wxPyOORClientData(_self));
4076 }
4077 SWIGINTERN wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4078
4079 wxPyUserData* data = NULL;
4080 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4081 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4082 if ( userData && (info.window || info.sizer || info.gotSize) )
4083 data = new wxPyUserData(userData);
4084 if ( info.sizer )
4085 PyObject_SetAttrString(item,"thisown",Py_False);
4086 wxPyEndBlockThreads(blocked);
4087
4088 // Now call the real Add method if a valid item type was found
4089 if ( info.window )
4090 return self->Add(info.window, proportion, flag, border, data);
4091 else if ( info.sizer )
4092 return self->Add(info.sizer, proportion, flag, border, data);
4093 else if (info.gotSize)
4094 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
4095 proportion, flag, border, data);
4096 else
4097 return NULL;
4098 }
4099 SWIGINTERN wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4100
4101 wxPyUserData* data = NULL;
4102 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4103 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4104 if ( userData && (info.window || info.sizer || info.gotSize) )
4105 data = new wxPyUserData(userData);
4106 if ( info.sizer )
4107 PyObject_SetAttrString(item,"thisown",Py_False);
4108 wxPyEndBlockThreads(blocked);
4109
4110 // Now call the real Insert method if a valid item type was found
4111 if ( info.window )
4112 return self->Insert(before, info.window, proportion, flag, border, data);
4113 else if ( info.sizer )
4114 return self->Insert(before, info.sizer, proportion, flag, border, data);
4115 else if (info.gotSize)
4116 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
4117 proportion, flag, border, data);
4118 else
4119 return NULL;
4120 }
4121 SWIGINTERN wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4122
4123 wxPyUserData* data = NULL;
4124 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4125 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4126 if ( userData && (info.window || info.sizer || info.gotSize) )
4127 data = new wxPyUserData(userData);
4128 if ( info.sizer )
4129 PyObject_SetAttrString(item,"thisown",Py_False);
4130 wxPyEndBlockThreads(blocked);
4131
4132 // Now call the real Prepend method if a valid item type was found
4133 if ( info.window )
4134 return self->Prepend(info.window, proportion, flag, border, data);
4135 else if ( info.sizer )
4136 return self->Prepend(info.sizer, proportion, flag, border, data);
4137 else if (info.gotSize)
4138 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
4139 proportion, flag, border, data);
4140 else
4141 return NULL;
4142 }
4143 SWIGINTERN bool wxSizer_Remove(wxSizer *self,PyObject *item){
4144 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4145 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4146 wxPyEndBlockThreads(blocked);
4147 if ( info.window )
4148 return self->Remove(info.window);
4149 else if ( info.sizer )
4150 return self->Remove(info.sizer);
4151 else if ( info.gotPos )
4152 return self->Remove(info.pos);
4153 else
4154 return false;
4155 }
4156 SWIGINTERN bool wxSizer_Detach(wxSizer *self,PyObject *item){
4157 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4158 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4159 wxPyEndBlockThreads(blocked);
4160 if ( info.window )
4161 return self->Detach(info.window);
4162 else if ( info.sizer )
4163 return self->Detach(info.sizer);
4164 else if ( info.gotPos )
4165 return self->Detach(info.pos);
4166 else
4167 return false;
4168 }
4169 SWIGINTERN wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
4170 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4171 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4172 wxPyEndBlockThreads(blocked);
4173 if ( info.window )
4174 return self->GetItem(info.window);
4175 else if ( info.sizer )
4176 return self->GetItem(info.sizer);
4177 else if ( info.gotPos )
4178 return self->GetItem(info.pos);
4179 else
4180 return NULL;
4181 }
4182 SWIGINTERN void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
4183 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4184 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4185 wxPyEndBlockThreads(blocked);
4186 if ( info.window )
4187 self->SetItemMinSize(info.window, size);
4188 else if ( info.sizer )
4189 self->SetItemMinSize(info.sizer, size);
4190 else if ( info.gotPos )
4191 self->SetItemMinSize(info.pos, size);
4192 }
4193 SWIGINTERN PyObject *wxSizer_GetChildren(wxSizer *self){
4194 wxSizerItemList& list = self->GetChildren();
4195 return wxPy_ConvertList(&list);
4196 }
4197 SWIGINTERN bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
4198 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4199 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4200 wxPyEndBlockThreads(blocked);
4201 if ( info.window )
4202 return self->Show(info.window, show, recursive);
4203 else if ( info.sizer )
4204 return self->Show(info.sizer, show, recursive);
4205 else if ( info.gotPos )
4206 return self->Show(info.pos, show);
4207 else
4208 return false;
4209 }
4210 SWIGINTERN bool wxSizer_IsShown(wxSizer *self,PyObject *item){
4211 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4212 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
4213 wxPyEndBlockThreads(blocked);
4214 if ( info.window )
4215 return self->IsShown(info.window);
4216 else if ( info.sizer )
4217 return self->IsShown(info.sizer);
4218 else if ( info.gotPos )
4219 return self->IsShown(info.pos);
4220 else
4221 return false;
4222 }
4223
4224 // See pyclasses.h
4225 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
4226 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
4227 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
4228
4229
4230
4231
4232 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
4233 {
4234 if (source == Py_None) {
4235 **obj = wxGBPosition(-1,-1);
4236 return true;
4237 }
4238 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
4239 }
4240
4241 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
4242 {
4243 if (source == Py_None) {
4244 **obj = wxGBSpan(-1,-1);
4245 return true;
4246 }
4247 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
4248 }
4249
4250
4251 SWIGINTERN bool wxGBPosition___eq__(wxGBPosition *self,PyObject *other){
4252 wxGBPosition temp, *obj = &temp;
4253 if ( other == Py_None ) return false;
4254 if ( ! wxGBPosition_helper(other, &obj) ) {
4255 PyErr_Clear();
4256 return false;
4257 }
4258 return self->operator==(*obj);
4259 }
4260 SWIGINTERN bool wxGBPosition___ne__(wxGBPosition *self,PyObject *other){
4261 wxGBPosition temp, *obj = &temp;
4262 if ( other == Py_None ) return true;
4263 if ( ! wxGBPosition_helper(other, &obj)) {
4264 PyErr_Clear();
4265 return true;
4266 }
4267 return self->operator!=(*obj);
4268 }
4269 SWIGINTERN void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
4270 self->SetRow(row);
4271 self->SetCol(col);
4272 }
4273 SWIGINTERN PyObject *wxGBPosition_Get(wxGBPosition *self){
4274 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4275 PyObject* tup = PyTuple_New(2);
4276 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
4277 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
4278 wxPyEndBlockThreads(blocked);
4279 return tup;
4280 }
4281 SWIGINTERN bool wxGBSpan___eq__(wxGBSpan *self,PyObject *other){
4282 wxGBSpan temp, *obj = &temp;
4283 if ( other == Py_None ) return false;
4284 if ( ! wxGBSpan_helper(other, &obj) ) {
4285 PyErr_Clear();
4286 return false;
4287 }
4288 return self->operator==(*obj);
4289 }
4290 SWIGINTERN bool wxGBSpan___ne__(wxGBSpan *self,PyObject *other){
4291 wxGBSpan temp, *obj = &temp;
4292 if ( other == Py_None ) return true;
4293 if ( ! wxGBSpan_helper(other, &obj)) {
4294 PyErr_Clear();
4295 return true;
4296 }
4297 return self->operator!=(*obj);
4298 }
4299 SWIGINTERN void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
4300 self->SetRowspan(rowspan);
4301 self->SetColspan(colspan);
4302 }
4303 SWIGINTERN PyObject *wxGBSpan_Get(wxGBSpan *self){
4304 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4305 PyObject* tup = PyTuple_New(2);
4306 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
4307 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
4308 wxPyEndBlockThreads(blocked);
4309 return tup;
4310 }
4311 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4312 wxPyUserData* data = NULL;
4313 if ( userData ) {
4314 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4315 data = new wxPyUserData(userData);
4316 wxPyEndBlockThreads(blocked);
4317 }
4318 return new wxGBSizerItem(window, pos, span, flag, border, data);
4319 }
4320 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4321 wxPyUserData* data = NULL;
4322 if ( userData ) {
4323 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4324 data = new wxPyUserData(userData);
4325 wxPyEndBlockThreads(blocked);
4326 }
4327 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
4328 }
4329 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4330 wxPyUserData* data = NULL;
4331 if ( userData ) {
4332 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4333 data = new wxPyUserData(userData);
4334 wxPyEndBlockThreads(blocked);
4335 }
4336 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
4337 }
4338 SWIGINTERN wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
4339 int row, col;
4340 self->GetEndPos(row, col);
4341 return wxGBPosition(row, col);
4342 }
4343 SWIGINTERN wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
4344
4345 wxPyUserData* data = NULL;
4346 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4347 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4348 if ( userData && (info.window || info.sizer || info.gotSize) )
4349 data = new wxPyUserData(userData);
4350 if ( info.sizer )
4351 PyObject_SetAttrString(item,"thisown",Py_False);
4352 wxPyEndBlockThreads(blocked);
4353
4354 // Now call the real Add method if a valid item type was found
4355 if ( info.window )
4356 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
4357 else if ( info.sizer )
4358 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
4359 else if (info.gotSize)
4360 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
4361 pos, span, flag, border, data);
4362 return NULL;
4363 }
4364
4365
4366 #ifdef __cplusplus
4367 extern "C" {
4368 #endif
4369 SWIGINTERN int EmptyString_set(PyObject *) {
4370 SWIG_Error(SWIG_AttributeError,"Variable EmptyString is read-only.");
4371 return 1;
4372 }
4373
4374
4375 SWIGINTERN PyObject *EmptyString_get(void) {
4376 PyObject *pyobj = 0;
4377
4378 {
4379 #if wxUSE_UNICODE
4380 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4381 #else
4382 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4383 #endif
4384 }
4385 return pyobj;
4386 }
4387
4388
4389 SWIGINTERN PyObject *_wrap_Object_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4390 PyObject *resultobj = 0;
4391 wxObject *arg1 = (wxObject *) 0 ;
4392 wxString result;
4393 void *argp1 = 0 ;
4394 int res1 = 0 ;
4395 PyObject *swig_obj[1] ;
4396
4397 if (!args) SWIG_fail;
4398 swig_obj[0] = args;
4399 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4400 if (!SWIG_IsOK(res1)) {
4401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_GetClassName" "', expected argument " "1"" of type '" "wxObject *""'");
4402 }
4403 arg1 = reinterpret_cast< wxObject * >(argp1);
4404 {
4405 PyThreadState* __tstate = wxPyBeginAllowThreads();
4406 result = wxObject_GetClassName(arg1);
4407 wxPyEndAllowThreads(__tstate);
4408 if (PyErr_Occurred()) SWIG_fail;
4409 }
4410 {
4411 #if wxUSE_UNICODE
4412 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4413 #else
4414 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4415 #endif
4416 }
4417 return resultobj;
4418 fail:
4419 return NULL;
4420 }
4421
4422
4423 SWIGINTERN PyObject *_wrap_Object_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4424 PyObject *resultobj = 0;
4425 wxObject *arg1 = (wxObject *) 0 ;
4426 void *argp1 = 0 ;
4427 int res1 = 0 ;
4428 PyObject *swig_obj[1] ;
4429
4430 if (!args) SWIG_fail;
4431 swig_obj[0] = args;
4432 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4433 if (!SWIG_IsOK(res1)) {
4434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_Destroy" "', expected argument " "1"" of type '" "wxObject *""'");
4435 }
4436 arg1 = reinterpret_cast< wxObject * >(argp1);
4437 {
4438 PyThreadState* __tstate = wxPyBeginAllowThreads();
4439 wxObject_Destroy(arg1);
4440 wxPyEndAllowThreads(__tstate);
4441 if (PyErr_Occurred()) SWIG_fail;
4442 }
4443 resultobj = SWIG_Py_Void();
4444 return resultobj;
4445 fail:
4446 return NULL;
4447 }
4448
4449
4450 SWIGINTERN PyObject *Object_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4451 PyObject *obj;
4452 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4453 SWIG_TypeNewClientData(SWIGTYPE_p_wxObject, SWIG_NewClientData(obj));
4454 return SWIG_Py_Void();
4455 }
4456
4457 SWIGINTERN PyObject *_wrap_Size_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4458 PyObject *resultobj = 0;
4459 wxSize *arg1 = (wxSize *) 0 ;
4460 int arg2 ;
4461 void *argp1 = 0 ;
4462 int res1 = 0 ;
4463 int val2 ;
4464 int ecode2 = 0 ;
4465 PyObject *swig_obj[2] ;
4466
4467 if (!SWIG_Python_UnpackTuple(args,"Size_width_set",2,2,swig_obj)) SWIG_fail;
4468 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4469 if (!SWIG_IsOK(res1)) {
4470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_set" "', expected argument " "1"" of type '" "wxSize *""'");
4471 }
4472 arg1 = reinterpret_cast< wxSize * >(argp1);
4473 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4474 if (!SWIG_IsOK(ecode2)) {
4475 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_width_set" "', expected argument " "2"" of type '" "int""'");
4476 }
4477 arg2 = static_cast< int >(val2);
4478 if (arg1) (arg1)->x = arg2;
4479
4480 resultobj = SWIG_Py_Void();
4481 return resultobj;
4482 fail:
4483 return NULL;
4484 }
4485
4486
4487 SWIGINTERN PyObject *_wrap_Size_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4488 PyObject *resultobj = 0;
4489 wxSize *arg1 = (wxSize *) 0 ;
4490 int result;
4491 void *argp1 = 0 ;
4492 int res1 = 0 ;
4493 PyObject *swig_obj[1] ;
4494
4495 if (!args) SWIG_fail;
4496 swig_obj[0] = args;
4497 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4498 if (!SWIG_IsOK(res1)) {
4499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_get" "', expected argument " "1"" of type '" "wxSize *""'");
4500 }
4501 arg1 = reinterpret_cast< wxSize * >(argp1);
4502 result = (int) ((arg1)->x);
4503 resultobj = SWIG_From_int(static_cast< int >(result));
4504 return resultobj;
4505 fail:
4506 return NULL;
4507 }
4508
4509
4510 SWIGINTERN PyObject *_wrap_Size_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4511 PyObject *resultobj = 0;
4512 wxSize *arg1 = (wxSize *) 0 ;
4513 int arg2 ;
4514 void *argp1 = 0 ;
4515 int res1 = 0 ;
4516 int val2 ;
4517 int ecode2 = 0 ;
4518 PyObject *swig_obj[2] ;
4519
4520 if (!SWIG_Python_UnpackTuple(args,"Size_height_set",2,2,swig_obj)) SWIG_fail;
4521 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4522 if (!SWIG_IsOK(res1)) {
4523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_set" "', expected argument " "1"" of type '" "wxSize *""'");
4524 }
4525 arg1 = reinterpret_cast< wxSize * >(argp1);
4526 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4527 if (!SWIG_IsOK(ecode2)) {
4528 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_height_set" "', expected argument " "2"" of type '" "int""'");
4529 }
4530 arg2 = static_cast< int >(val2);
4531 if (arg1) (arg1)->y = arg2;
4532
4533 resultobj = SWIG_Py_Void();
4534 return resultobj;
4535 fail:
4536 return NULL;
4537 }
4538
4539
4540 SWIGINTERN PyObject *_wrap_Size_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4541 PyObject *resultobj = 0;
4542 wxSize *arg1 = (wxSize *) 0 ;
4543 int result;
4544 void *argp1 = 0 ;
4545 int res1 = 0 ;
4546 PyObject *swig_obj[1] ;
4547
4548 if (!args) SWIG_fail;
4549 swig_obj[0] = args;
4550 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4551 if (!SWIG_IsOK(res1)) {
4552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_get" "', expected argument " "1"" of type '" "wxSize *""'");
4553 }
4554 arg1 = reinterpret_cast< wxSize * >(argp1);
4555 result = (int) ((arg1)->y);
4556 resultobj = SWIG_From_int(static_cast< int >(result));
4557 return resultobj;
4558 fail:
4559 return NULL;
4560 }
4561
4562
4563 SWIGINTERN PyObject *_wrap_new_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4564 PyObject *resultobj = 0;
4565 int arg1 = (int) 0 ;
4566 int arg2 = (int) 0 ;
4567 wxSize *result = 0 ;
4568 int val1 ;
4569 int ecode1 = 0 ;
4570 int val2 ;
4571 int ecode2 = 0 ;
4572 PyObject * obj0 = 0 ;
4573 PyObject * obj1 = 0 ;
4574 char * kwnames[] = {
4575 (char *) "w",(char *) "h", NULL
4576 };
4577
4578 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) SWIG_fail;
4579 if (obj0) {
4580 ecode1 = SWIG_AsVal_int(obj0, &val1);
4581 if (!SWIG_IsOK(ecode1)) {
4582 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Size" "', expected argument " "1"" of type '" "int""'");
4583 }
4584 arg1 = static_cast< int >(val1);
4585 }
4586 if (obj1) {
4587 ecode2 = SWIG_AsVal_int(obj1, &val2);
4588 if (!SWIG_IsOK(ecode2)) {
4589 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Size" "', expected argument " "2"" of type '" "int""'");
4590 }
4591 arg2 = static_cast< int >(val2);
4592 }
4593 {
4594 PyThreadState* __tstate = wxPyBeginAllowThreads();
4595 result = (wxSize *)new wxSize(arg1,arg2);
4596 wxPyEndAllowThreads(__tstate);
4597 if (PyErr_Occurred()) SWIG_fail;
4598 }
4599 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, SWIG_POINTER_NEW | 0 );
4600 return resultobj;
4601 fail:
4602 return NULL;
4603 }
4604
4605
4606 SWIGINTERN PyObject *_wrap_delete_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4607 PyObject *resultobj = 0;
4608 wxSize *arg1 = (wxSize *) 0 ;
4609 void *argp1 = 0 ;
4610 int res1 = 0 ;
4611 PyObject *swig_obj[1] ;
4612
4613 if (!args) SWIG_fail;
4614 swig_obj[0] = args;
4615 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, SWIG_POINTER_DISOWN | 0 );
4616 if (!SWIG_IsOK(res1)) {
4617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Size" "', expected argument " "1"" of type '" "wxSize *""'");
4618 }
4619 arg1 = reinterpret_cast< wxSize * >(argp1);
4620 {
4621 PyThreadState* __tstate = wxPyBeginAllowThreads();
4622 delete arg1;
4623
4624 wxPyEndAllowThreads(__tstate);
4625 if (PyErr_Occurred()) SWIG_fail;
4626 }
4627 resultobj = SWIG_Py_Void();
4628 return resultobj;
4629 fail:
4630 return NULL;
4631 }
4632
4633
4634 SWIGINTERN PyObject *_wrap_Size___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4635 PyObject *resultobj = 0;
4636 wxSize *arg1 = (wxSize *) 0 ;
4637 PyObject *arg2 = (PyObject *) 0 ;
4638 bool result;
4639 void *argp1 = 0 ;
4640 int res1 = 0 ;
4641 PyObject * obj0 = 0 ;
4642 PyObject * obj1 = 0 ;
4643 char * kwnames[] = {
4644 (char *) "self",(char *) "other", NULL
4645 };
4646
4647 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
4648 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4649 if (!SWIG_IsOK(res1)) {
4650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___eq__" "', expected argument " "1"" of type '" "wxSize *""'");
4651 }
4652 arg1 = reinterpret_cast< wxSize * >(argp1);
4653 arg2 = obj1;
4654 {
4655 result = (bool)wxSize___eq__(arg1,arg2);
4656 if (PyErr_Occurred()) SWIG_fail;
4657 }
4658 {
4659 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4660 }
4661 return resultobj;
4662 fail:
4663 return NULL;
4664 }
4665
4666
4667 SWIGINTERN PyObject *_wrap_Size___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4668 PyObject *resultobj = 0;
4669 wxSize *arg1 = (wxSize *) 0 ;
4670 PyObject *arg2 = (PyObject *) 0 ;
4671 bool result;
4672 void *argp1 = 0 ;
4673 int res1 = 0 ;
4674 PyObject * obj0 = 0 ;
4675 PyObject * obj1 = 0 ;
4676 char * kwnames[] = {
4677 (char *) "self",(char *) "other", NULL
4678 };
4679
4680 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
4681 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4682 if (!SWIG_IsOK(res1)) {
4683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___ne__" "', expected argument " "1"" of type '" "wxSize *""'");
4684 }
4685 arg1 = reinterpret_cast< wxSize * >(argp1);
4686 arg2 = obj1;
4687 {
4688 result = (bool)wxSize___ne__(arg1,arg2);
4689 if (PyErr_Occurred()) SWIG_fail;
4690 }
4691 {
4692 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4693 }
4694 return resultobj;
4695 fail:
4696 return NULL;
4697 }
4698
4699
4700 SWIGINTERN PyObject *_wrap_Size___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4701 PyObject *resultobj = 0;
4702 wxSize *arg1 = (wxSize *) 0 ;
4703 wxSize *arg2 = 0 ;
4704 wxSize result;
4705 void *argp1 = 0 ;
4706 int res1 = 0 ;
4707 wxSize temp2 ;
4708 PyObject * obj0 = 0 ;
4709 PyObject * obj1 = 0 ;
4710 char * kwnames[] = {
4711 (char *) "self",(char *) "sz", NULL
4712 };
4713
4714 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) SWIG_fail;
4715 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4716 if (!SWIG_IsOK(res1)) {
4717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___add__" "', expected argument " "1"" of type '" "wxSize *""'");
4718 }
4719 arg1 = reinterpret_cast< wxSize * >(argp1);
4720 {
4721 arg2 = &temp2;
4722 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4723 }
4724 {
4725 PyThreadState* __tstate = wxPyBeginAllowThreads();
4726 result = (arg1)->operator +((wxSize const &)*arg2);
4727 wxPyEndAllowThreads(__tstate);
4728 if (PyErr_Occurred()) SWIG_fail;
4729 }
4730 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4731 return resultobj;
4732 fail:
4733 return NULL;
4734 }
4735
4736
4737 SWIGINTERN PyObject *_wrap_Size___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4738 PyObject *resultobj = 0;
4739 wxSize *arg1 = (wxSize *) 0 ;
4740 wxSize *arg2 = 0 ;
4741 wxSize result;
4742 void *argp1 = 0 ;
4743 int res1 = 0 ;
4744 wxSize temp2 ;
4745 PyObject * obj0 = 0 ;
4746 PyObject * obj1 = 0 ;
4747 char * kwnames[] = {
4748 (char *) "self",(char *) "sz", NULL
4749 };
4750
4751 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
4752 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4753 if (!SWIG_IsOK(res1)) {
4754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___sub__" "', expected argument " "1"" of type '" "wxSize *""'");
4755 }
4756 arg1 = reinterpret_cast< wxSize * >(argp1);
4757 {
4758 arg2 = &temp2;
4759 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4760 }
4761 {
4762 PyThreadState* __tstate = wxPyBeginAllowThreads();
4763 result = (arg1)->operator -((wxSize const &)*arg2);
4764 wxPyEndAllowThreads(__tstate);
4765 if (PyErr_Occurred()) SWIG_fail;
4766 }
4767 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4768 return resultobj;
4769 fail:
4770 return NULL;
4771 }
4772
4773
4774 SWIGINTERN PyObject *_wrap_Size_IncTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4775 PyObject *resultobj = 0;
4776 wxSize *arg1 = (wxSize *) 0 ;
4777 wxSize *arg2 = 0 ;
4778 void *argp1 = 0 ;
4779 int res1 = 0 ;
4780 wxSize temp2 ;
4781 PyObject * obj0 = 0 ;
4782 PyObject * obj1 = 0 ;
4783 char * kwnames[] = {
4784 (char *) "self",(char *) "sz", NULL
4785 };
4786
4787 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) SWIG_fail;
4788 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4789 if (!SWIG_IsOK(res1)) {
4790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncTo" "', expected argument " "1"" of type '" "wxSize *""'");
4791 }
4792 arg1 = reinterpret_cast< wxSize * >(argp1);
4793 {
4794 arg2 = &temp2;
4795 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4796 }
4797 {
4798 PyThreadState* __tstate = wxPyBeginAllowThreads();
4799 (arg1)->IncTo((wxSize const &)*arg2);
4800 wxPyEndAllowThreads(__tstate);
4801 if (PyErr_Occurred()) SWIG_fail;
4802 }
4803 resultobj = SWIG_Py_Void();
4804 return resultobj;
4805 fail:
4806 return NULL;
4807 }
4808
4809
4810 SWIGINTERN PyObject *_wrap_Size_DecTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4811 PyObject *resultobj = 0;
4812 wxSize *arg1 = (wxSize *) 0 ;
4813 wxSize *arg2 = 0 ;
4814 void *argp1 = 0 ;
4815 int res1 = 0 ;
4816 wxSize temp2 ;
4817 PyObject * obj0 = 0 ;
4818 PyObject * obj1 = 0 ;
4819 char * kwnames[] = {
4820 (char *) "self",(char *) "sz", NULL
4821 };
4822
4823 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) SWIG_fail;
4824 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4825 if (!SWIG_IsOK(res1)) {
4826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecTo" "', expected argument " "1"" of type '" "wxSize *""'");
4827 }
4828 arg1 = reinterpret_cast< wxSize * >(argp1);
4829 {
4830 arg2 = &temp2;
4831 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4832 }
4833 {
4834 PyThreadState* __tstate = wxPyBeginAllowThreads();
4835 (arg1)->DecTo((wxSize const &)*arg2);
4836 wxPyEndAllowThreads(__tstate);
4837 if (PyErr_Occurred()) SWIG_fail;
4838 }
4839 resultobj = SWIG_Py_Void();
4840 return resultobj;
4841 fail:
4842 return NULL;
4843 }
4844
4845
4846 SWIGINTERN PyObject *_wrap_Size_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4847 PyObject *resultobj = 0;
4848 wxSize *arg1 = (wxSize *) 0 ;
4849 int arg2 ;
4850 int arg3 ;
4851 void *argp1 = 0 ;
4852 int res1 = 0 ;
4853 int val2 ;
4854 int ecode2 = 0 ;
4855 int val3 ;
4856 int ecode3 = 0 ;
4857 PyObject * obj0 = 0 ;
4858 PyObject * obj1 = 0 ;
4859 PyObject * obj2 = 0 ;
4860 char * kwnames[] = {
4861 (char *) "self",(char *) "w",(char *) "h", NULL
4862 };
4863
4864 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4865 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4866 if (!SWIG_IsOK(res1)) {
4867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Set" "', expected argument " "1"" of type '" "wxSize *""'");
4868 }
4869 arg1 = reinterpret_cast< wxSize * >(argp1);
4870 ecode2 = SWIG_AsVal_int(obj1, &val2);
4871 if (!SWIG_IsOK(ecode2)) {
4872 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Set" "', expected argument " "2"" of type '" "int""'");
4873 }
4874 arg2 = static_cast< int >(val2);
4875 ecode3 = SWIG_AsVal_int(obj2, &val3);
4876 if (!SWIG_IsOK(ecode3)) {
4877 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Set" "', expected argument " "3"" of type '" "int""'");
4878 }
4879 arg3 = static_cast< int >(val3);
4880 {
4881 PyThreadState* __tstate = wxPyBeginAllowThreads();
4882 (arg1)->Set(arg2,arg3);
4883 wxPyEndAllowThreads(__tstate);
4884 if (PyErr_Occurred()) SWIG_fail;
4885 }
4886 resultobj = SWIG_Py_Void();
4887 return resultobj;
4888 fail:
4889 return NULL;
4890 }
4891
4892
4893 SWIGINTERN PyObject *_wrap_Size_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4894 PyObject *resultobj = 0;
4895 wxSize *arg1 = (wxSize *) 0 ;
4896 int arg2 ;
4897 void *argp1 = 0 ;
4898 int res1 = 0 ;
4899 int val2 ;
4900 int ecode2 = 0 ;
4901 PyObject * obj0 = 0 ;
4902 PyObject * obj1 = 0 ;
4903 char * kwnames[] = {
4904 (char *) "self",(char *) "w", NULL
4905 };
4906
4907 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
4908 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4909 if (!SWIG_IsOK(res1)) {
4910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetWidth" "', expected argument " "1"" of type '" "wxSize *""'");
4911 }
4912 arg1 = reinterpret_cast< wxSize * >(argp1);
4913 ecode2 = SWIG_AsVal_int(obj1, &val2);
4914 if (!SWIG_IsOK(ecode2)) {
4915 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetWidth" "', expected argument " "2"" of type '" "int""'");
4916 }
4917 arg2 = static_cast< int >(val2);
4918 {
4919 PyThreadState* __tstate = wxPyBeginAllowThreads();
4920 (arg1)->SetWidth(arg2);
4921 wxPyEndAllowThreads(__tstate);
4922 if (PyErr_Occurred()) SWIG_fail;
4923 }
4924 resultobj = SWIG_Py_Void();
4925 return resultobj;
4926 fail:
4927 return NULL;
4928 }
4929
4930
4931 SWIGINTERN PyObject *_wrap_Size_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4932 PyObject *resultobj = 0;
4933 wxSize *arg1 = (wxSize *) 0 ;
4934 int arg2 ;
4935 void *argp1 = 0 ;
4936 int res1 = 0 ;
4937 int val2 ;
4938 int ecode2 = 0 ;
4939 PyObject * obj0 = 0 ;
4940 PyObject * obj1 = 0 ;
4941 char * kwnames[] = {
4942 (char *) "self",(char *) "h", NULL
4943 };
4944
4945 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
4946 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4947 if (!SWIG_IsOK(res1)) {
4948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetHeight" "', expected argument " "1"" of type '" "wxSize *""'");
4949 }
4950 arg1 = reinterpret_cast< wxSize * >(argp1);
4951 ecode2 = SWIG_AsVal_int(obj1, &val2);
4952 if (!SWIG_IsOK(ecode2)) {
4953 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetHeight" "', expected argument " "2"" of type '" "int""'");
4954 }
4955 arg2 = static_cast< int >(val2);
4956 {
4957 PyThreadState* __tstate = wxPyBeginAllowThreads();
4958 (arg1)->SetHeight(arg2);
4959 wxPyEndAllowThreads(__tstate);
4960 if (PyErr_Occurred()) SWIG_fail;
4961 }
4962 resultobj = SWIG_Py_Void();
4963 return resultobj;
4964 fail:
4965 return NULL;
4966 }
4967
4968
4969 SWIGINTERN PyObject *_wrap_Size_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4970 PyObject *resultobj = 0;
4971 wxSize *arg1 = (wxSize *) 0 ;
4972 int result;
4973 void *argp1 = 0 ;
4974 int res1 = 0 ;
4975 PyObject *swig_obj[1] ;
4976
4977 if (!args) SWIG_fail;
4978 swig_obj[0] = args;
4979 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4980 if (!SWIG_IsOK(res1)) {
4981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetWidth" "', expected argument " "1"" of type '" "wxSize const *""'");
4982 }
4983 arg1 = reinterpret_cast< wxSize * >(argp1);
4984 {
4985 PyThreadState* __tstate = wxPyBeginAllowThreads();
4986 result = (int)((wxSize const *)arg1)->GetWidth();
4987 wxPyEndAllowThreads(__tstate);
4988 if (PyErr_Occurred()) SWIG_fail;
4989 }
4990 resultobj = SWIG_From_int(static_cast< int >(result));
4991 return resultobj;
4992 fail:
4993 return NULL;
4994 }
4995
4996
4997 SWIGINTERN PyObject *_wrap_Size_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4998 PyObject *resultobj = 0;
4999 wxSize *arg1 = (wxSize *) 0 ;
5000 int result;
5001 void *argp1 = 0 ;
5002 int res1 = 0 ;
5003 PyObject *swig_obj[1] ;
5004
5005 if (!args) SWIG_fail;
5006 swig_obj[0] = args;
5007 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5008 if (!SWIG_IsOK(res1)) {
5009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetHeight" "', expected argument " "1"" of type '" "wxSize const *""'");
5010 }
5011 arg1 = reinterpret_cast< wxSize * >(argp1);
5012 {
5013 PyThreadState* __tstate = wxPyBeginAllowThreads();
5014 result = (int)((wxSize const *)arg1)->GetHeight();
5015 wxPyEndAllowThreads(__tstate);
5016 if (PyErr_Occurred()) SWIG_fail;
5017 }
5018 resultobj = SWIG_From_int(static_cast< int >(result));
5019 return resultobj;
5020 fail:
5021 return NULL;
5022 }
5023
5024
5025 SWIGINTERN PyObject *_wrap_Size_IsFullySpecified(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5026 PyObject *resultobj = 0;
5027 wxSize *arg1 = (wxSize *) 0 ;
5028 bool result;
5029 void *argp1 = 0 ;
5030 int res1 = 0 ;
5031 PyObject *swig_obj[1] ;
5032
5033 if (!args) SWIG_fail;
5034 swig_obj[0] = args;
5035 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5036 if (!SWIG_IsOK(res1)) {
5037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IsFullySpecified" "', expected argument " "1"" of type '" "wxSize const *""'");
5038 }
5039 arg1 = reinterpret_cast< wxSize * >(argp1);
5040 {
5041 PyThreadState* __tstate = wxPyBeginAllowThreads();
5042 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
5043 wxPyEndAllowThreads(__tstate);
5044 if (PyErr_Occurred()) SWIG_fail;
5045 }
5046 {
5047 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5048 }
5049 return resultobj;
5050 fail:
5051 return NULL;
5052 }
5053
5054
5055 SWIGINTERN PyObject *_wrap_Size_SetDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5056 PyObject *resultobj = 0;
5057 wxSize *arg1 = (wxSize *) 0 ;
5058 wxSize *arg2 = 0 ;
5059 void *argp1 = 0 ;
5060 int res1 = 0 ;
5061 wxSize temp2 ;
5062 PyObject * obj0 = 0 ;
5063 PyObject * obj1 = 0 ;
5064 char * kwnames[] = {
5065 (char *) "self",(char *) "size", NULL
5066 };
5067
5068 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
5069 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5070 if (!SWIG_IsOK(res1)) {
5071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetDefaults" "', expected argument " "1"" of type '" "wxSize *""'");
5072 }
5073 arg1 = reinterpret_cast< wxSize * >(argp1);
5074 {
5075 arg2 = &temp2;
5076 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5077 }
5078 {
5079 PyThreadState* __tstate = wxPyBeginAllowThreads();
5080 (arg1)->SetDefaults((wxSize const &)*arg2);
5081 wxPyEndAllowThreads(__tstate);
5082 if (PyErr_Occurred()) SWIG_fail;
5083 }
5084 resultobj = SWIG_Py_Void();
5085 return resultobj;
5086 fail:
5087 return NULL;
5088 }
5089
5090
5091 SWIGINTERN PyObject *_wrap_Size_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5092 PyObject *resultobj = 0;
5093 wxSize *arg1 = (wxSize *) 0 ;
5094 PyObject *result = 0 ;
5095 void *argp1 = 0 ;
5096 int res1 = 0 ;
5097 PyObject *swig_obj[1] ;
5098
5099 if (!args) SWIG_fail;
5100 swig_obj[0] = args;
5101 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5102 if (!SWIG_IsOK(res1)) {
5103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Get" "', expected argument " "1"" of type '" "wxSize *""'");
5104 }
5105 arg1 = reinterpret_cast< wxSize * >(argp1);
5106 {
5107 PyThreadState* __tstate = wxPyBeginAllowThreads();
5108 result = (PyObject *)wxSize_Get(arg1);
5109 wxPyEndAllowThreads(__tstate);
5110 if (PyErr_Occurred()) SWIG_fail;
5111 }
5112 resultobj = result;
5113 return resultobj;
5114 fail:
5115 return NULL;
5116 }
5117
5118
5119 SWIGINTERN PyObject *Size_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5120 PyObject *obj;
5121 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5122 SWIG_TypeNewClientData(SWIGTYPE_p_wxSize, SWIG_NewClientData(obj));
5123 return SWIG_Py_Void();
5124 }
5125
5126 SWIGINTERN PyObject *Size_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5127 return SWIG_Python_InitShadowInstance(args);
5128 }
5129
5130 SWIGINTERN PyObject *_wrap_RealPoint_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5131 PyObject *resultobj = 0;
5132 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5133 double arg2 ;
5134 void *argp1 = 0 ;
5135 int res1 = 0 ;
5136 double val2 ;
5137 int ecode2 = 0 ;
5138 PyObject *swig_obj[2] ;
5139
5140 if (!SWIG_Python_UnpackTuple(args,"RealPoint_x_set",2,2,swig_obj)) SWIG_fail;
5141 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5142 if (!SWIG_IsOK(res1)) {
5143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5144 }
5145 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5146 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5147 if (!SWIG_IsOK(ecode2)) {
5148 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_x_set" "', expected argument " "2"" of type '" "double""'");
5149 }
5150 arg2 = static_cast< double >(val2);
5151 if (arg1) (arg1)->x = arg2;
5152
5153 resultobj = SWIG_Py_Void();
5154 return resultobj;
5155 fail:
5156 return NULL;
5157 }
5158
5159
5160 SWIGINTERN PyObject *_wrap_RealPoint_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5161 PyObject *resultobj = 0;
5162 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5163 double result;
5164 void *argp1 = 0 ;
5165 int res1 = 0 ;
5166 PyObject *swig_obj[1] ;
5167
5168 if (!args) SWIG_fail;
5169 swig_obj[0] = args;
5170 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5171 if (!SWIG_IsOK(res1)) {
5172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5173 }
5174 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5175 result = (double) ((arg1)->x);
5176 resultobj = SWIG_From_double(static_cast< double >(result));
5177 return resultobj;
5178 fail:
5179 return NULL;
5180 }
5181
5182
5183 SWIGINTERN PyObject *_wrap_RealPoint_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5184 PyObject *resultobj = 0;
5185 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5186 double arg2 ;
5187 void *argp1 = 0 ;
5188 int res1 = 0 ;
5189 double val2 ;
5190 int ecode2 = 0 ;
5191 PyObject *swig_obj[2] ;
5192
5193 if (!SWIG_Python_UnpackTuple(args,"RealPoint_y_set",2,2,swig_obj)) SWIG_fail;
5194 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5195 if (!SWIG_IsOK(res1)) {
5196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5197 }
5198 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5199 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5200 if (!SWIG_IsOK(ecode2)) {
5201 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_y_set" "', expected argument " "2"" of type '" "double""'");
5202 }
5203 arg2 = static_cast< double >(val2);
5204 if (arg1) (arg1)->y = arg2;
5205
5206 resultobj = SWIG_Py_Void();
5207 return resultobj;
5208 fail:
5209 return NULL;
5210 }
5211
5212
5213 SWIGINTERN PyObject *_wrap_RealPoint_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5214 PyObject *resultobj = 0;
5215 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5216 double result;
5217 void *argp1 = 0 ;
5218 int res1 = 0 ;
5219 PyObject *swig_obj[1] ;
5220
5221 if (!args) SWIG_fail;
5222 swig_obj[0] = args;
5223 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5224 if (!SWIG_IsOK(res1)) {
5225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5226 }
5227 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5228 result = (double) ((arg1)->y);
5229 resultobj = SWIG_From_double(static_cast< double >(result));
5230 return resultobj;
5231 fail:
5232 return NULL;
5233 }
5234
5235
5236 SWIGINTERN PyObject *_wrap_new_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5237 PyObject *resultobj = 0;
5238 double arg1 = (double) 0.0 ;
5239 double arg2 = (double) 0.0 ;
5240 wxRealPoint *result = 0 ;
5241 double val1 ;
5242 int ecode1 = 0 ;
5243 double val2 ;
5244 int ecode2 = 0 ;
5245 PyObject * obj0 = 0 ;
5246 PyObject * obj1 = 0 ;
5247 char * kwnames[] = {
5248 (char *) "x",(char *) "y", NULL
5249 };
5250
5251 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) SWIG_fail;
5252 if (obj0) {
5253 ecode1 = SWIG_AsVal_double(obj0, &val1);
5254 if (!SWIG_IsOK(ecode1)) {
5255 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RealPoint" "', expected argument " "1"" of type '" "double""'");
5256 }
5257 arg1 = static_cast< double >(val1);
5258 }
5259 if (obj1) {
5260 ecode2 = SWIG_AsVal_double(obj1, &val2);
5261 if (!SWIG_IsOK(ecode2)) {
5262 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RealPoint" "', expected argument " "2"" of type '" "double""'");
5263 }
5264 arg2 = static_cast< double >(val2);
5265 }
5266 {
5267 PyThreadState* __tstate = wxPyBeginAllowThreads();
5268 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
5269 wxPyEndAllowThreads(__tstate);
5270 if (PyErr_Occurred()) SWIG_fail;
5271 }
5272 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_NEW | 0 );
5273 return resultobj;
5274 fail:
5275 return NULL;
5276 }
5277
5278
5279 SWIGINTERN PyObject *_wrap_delete_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5280 PyObject *resultobj = 0;
5281 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5282 void *argp1 = 0 ;
5283 int res1 = 0 ;
5284 PyObject *swig_obj[1] ;
5285
5286 if (!args) SWIG_fail;
5287 swig_obj[0] = args;
5288 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, SWIG_POINTER_DISOWN | 0 );
5289 if (!SWIG_IsOK(res1)) {
5290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RealPoint" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5291 }
5292 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5293 {
5294 PyThreadState* __tstate = wxPyBeginAllowThreads();
5295 delete arg1;
5296
5297 wxPyEndAllowThreads(__tstate);
5298 if (PyErr_Occurred()) SWIG_fail;
5299 }
5300 resultobj = SWIG_Py_Void();
5301 return resultobj;
5302 fail:
5303 return NULL;
5304 }
5305
5306
5307 SWIGINTERN PyObject *_wrap_RealPoint___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5308 PyObject *resultobj = 0;
5309 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5310 PyObject *arg2 = (PyObject *) 0 ;
5311 bool result;
5312 void *argp1 = 0 ;
5313 int res1 = 0 ;
5314 PyObject * obj0 = 0 ;
5315 PyObject * obj1 = 0 ;
5316 char * kwnames[] = {
5317 (char *) "self",(char *) "other", NULL
5318 };
5319
5320 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5321 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5322 if (!SWIG_IsOK(res1)) {
5323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___eq__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5324 }
5325 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5326 arg2 = obj1;
5327 {
5328 result = (bool)wxRealPoint___eq__(arg1,arg2);
5329 if (PyErr_Occurred()) SWIG_fail;
5330 }
5331 {
5332 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5333 }
5334 return resultobj;
5335 fail:
5336 return NULL;
5337 }
5338
5339
5340 SWIGINTERN PyObject *_wrap_RealPoint___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5341 PyObject *resultobj = 0;
5342 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5343 PyObject *arg2 = (PyObject *) 0 ;
5344 bool result;
5345 void *argp1 = 0 ;
5346 int res1 = 0 ;
5347 PyObject * obj0 = 0 ;
5348 PyObject * obj1 = 0 ;
5349 char * kwnames[] = {
5350 (char *) "self",(char *) "other", NULL
5351 };
5352
5353 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5354 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5355 if (!SWIG_IsOK(res1)) {
5356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___ne__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5357 }
5358 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5359 arg2 = obj1;
5360 {
5361 result = (bool)wxRealPoint___ne__(arg1,arg2);
5362 if (PyErr_Occurred()) SWIG_fail;
5363 }
5364 {
5365 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5366 }
5367 return resultobj;
5368 fail:
5369 return NULL;
5370 }
5371
5372
5373 SWIGINTERN PyObject *_wrap_RealPoint___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5374 PyObject *resultobj = 0;
5375 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5376 wxRealPoint *arg2 = 0 ;
5377 wxRealPoint result;
5378 void *argp1 = 0 ;
5379 int res1 = 0 ;
5380 wxRealPoint temp2 ;
5381 PyObject * obj0 = 0 ;
5382 PyObject * obj1 = 0 ;
5383 char * kwnames[] = {
5384 (char *) "self",(char *) "pt", NULL
5385 };
5386
5387 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5388 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5389 if (!SWIG_IsOK(res1)) {
5390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___add__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5391 }
5392 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5393 {
5394 arg2 = &temp2;
5395 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5396 }
5397 {
5398 PyThreadState* __tstate = wxPyBeginAllowThreads();
5399 result = (arg1)->operator +((wxRealPoint const &)*arg2);
5400 wxPyEndAllowThreads(__tstate);
5401 if (PyErr_Occurred()) SWIG_fail;
5402 }
5403 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5404 return resultobj;
5405 fail:
5406 return NULL;
5407 }
5408
5409
5410 SWIGINTERN PyObject *_wrap_RealPoint___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5411 PyObject *resultobj = 0;
5412 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5413 wxRealPoint *arg2 = 0 ;
5414 wxRealPoint result;
5415 void *argp1 = 0 ;
5416 int res1 = 0 ;
5417 wxRealPoint temp2 ;
5418 PyObject * obj0 = 0 ;
5419 PyObject * obj1 = 0 ;
5420 char * kwnames[] = {
5421 (char *) "self",(char *) "pt", NULL
5422 };
5423
5424 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5425 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5426 if (!SWIG_IsOK(res1)) {
5427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___sub__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5428 }
5429 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5430 {
5431 arg2 = &temp2;
5432 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5433 }
5434 {
5435 PyThreadState* __tstate = wxPyBeginAllowThreads();
5436 result = (arg1)->operator -((wxRealPoint const &)*arg2);
5437 wxPyEndAllowThreads(__tstate);
5438 if (PyErr_Occurred()) SWIG_fail;
5439 }
5440 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5441 return resultobj;
5442 fail:
5443 return NULL;
5444 }
5445
5446
5447 SWIGINTERN PyObject *_wrap_RealPoint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5448 PyObject *resultobj = 0;
5449 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5450 double arg2 ;
5451 double arg3 ;
5452 void *argp1 = 0 ;
5453 int res1 = 0 ;
5454 double val2 ;
5455 int ecode2 = 0 ;
5456 double val3 ;
5457 int ecode3 = 0 ;
5458 PyObject * obj0 = 0 ;
5459 PyObject * obj1 = 0 ;
5460 PyObject * obj2 = 0 ;
5461 char * kwnames[] = {
5462 (char *) "self",(char *) "x",(char *) "y", NULL
5463 };
5464
5465 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5466 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5467 if (!SWIG_IsOK(res1)) {
5468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5469 }
5470 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5471 ecode2 = SWIG_AsVal_double(obj1, &val2);
5472 if (!SWIG_IsOK(ecode2)) {
5473 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_Set" "', expected argument " "2"" of type '" "double""'");
5474 }
5475 arg2 = static_cast< double >(val2);
5476 ecode3 = SWIG_AsVal_double(obj2, &val3);
5477 if (!SWIG_IsOK(ecode3)) {
5478 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RealPoint_Set" "', expected argument " "3"" of type '" "double""'");
5479 }
5480 arg3 = static_cast< double >(val3);
5481 {
5482 PyThreadState* __tstate = wxPyBeginAllowThreads();
5483 wxRealPoint_Set(arg1,arg2,arg3);
5484 wxPyEndAllowThreads(__tstate);
5485 if (PyErr_Occurred()) SWIG_fail;
5486 }
5487 resultobj = SWIG_Py_Void();
5488 return resultobj;
5489 fail:
5490 return NULL;
5491 }
5492
5493
5494 SWIGINTERN PyObject *_wrap_RealPoint_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5495 PyObject *resultobj = 0;
5496 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5497 PyObject *result = 0 ;
5498 void *argp1 = 0 ;
5499 int res1 = 0 ;
5500 PyObject *swig_obj[1] ;
5501
5502 if (!args) SWIG_fail;
5503 swig_obj[0] = args;
5504 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5505 if (!SWIG_IsOK(res1)) {
5506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5507 }
5508 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5509 {
5510 PyThreadState* __tstate = wxPyBeginAllowThreads();
5511 result = (PyObject *)wxRealPoint_Get(arg1);
5512 wxPyEndAllowThreads(__tstate);
5513 if (PyErr_Occurred()) SWIG_fail;
5514 }
5515 resultobj = result;
5516 return resultobj;
5517 fail:
5518 return NULL;
5519 }
5520
5521
5522 SWIGINTERN PyObject *RealPoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5523 PyObject *obj;
5524 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5525 SWIG_TypeNewClientData(SWIGTYPE_p_wxRealPoint, SWIG_NewClientData(obj));
5526 return SWIG_Py_Void();
5527 }
5528
5529 SWIGINTERN PyObject *RealPoint_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5530 return SWIG_Python_InitShadowInstance(args);
5531 }
5532
5533 SWIGINTERN PyObject *_wrap_Point_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5534 PyObject *resultobj = 0;
5535 wxPoint *arg1 = (wxPoint *) 0 ;
5536 int arg2 ;
5537 void *argp1 = 0 ;
5538 int res1 = 0 ;
5539 int val2 ;
5540 int ecode2 = 0 ;
5541 PyObject *swig_obj[2] ;
5542
5543 if (!SWIG_Python_UnpackTuple(args,"Point_x_set",2,2,swig_obj)) SWIG_fail;
5544 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5545 if (!SWIG_IsOK(res1)) {
5546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5547 }
5548 arg1 = reinterpret_cast< wxPoint * >(argp1);
5549 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5550 if (!SWIG_IsOK(ecode2)) {
5551 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_x_set" "', expected argument " "2"" of type '" "int""'");
5552 }
5553 arg2 = static_cast< int >(val2);
5554 if (arg1) (arg1)->x = arg2;
5555
5556 resultobj = SWIG_Py_Void();
5557 return resultobj;
5558 fail:
5559 return NULL;
5560 }
5561
5562
5563 SWIGINTERN PyObject *_wrap_Point_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5564 PyObject *resultobj = 0;
5565 wxPoint *arg1 = (wxPoint *) 0 ;
5566 int result;
5567 void *argp1 = 0 ;
5568 int res1 = 0 ;
5569 PyObject *swig_obj[1] ;
5570
5571 if (!args) SWIG_fail;
5572 swig_obj[0] = args;
5573 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5574 if (!SWIG_IsOK(res1)) {
5575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5576 }
5577 arg1 = reinterpret_cast< wxPoint * >(argp1);
5578 result = (int) ((arg1)->x);
5579 resultobj = SWIG_From_int(static_cast< int >(result));
5580 return resultobj;
5581 fail:
5582 return NULL;
5583 }
5584
5585
5586 SWIGINTERN PyObject *_wrap_Point_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5587 PyObject *resultobj = 0;
5588 wxPoint *arg1 = (wxPoint *) 0 ;
5589 int arg2 ;
5590 void *argp1 = 0 ;
5591 int res1 = 0 ;
5592 int val2 ;
5593 int ecode2 = 0 ;
5594 PyObject *swig_obj[2] ;
5595
5596 if (!SWIG_Python_UnpackTuple(args,"Point_y_set",2,2,swig_obj)) SWIG_fail;
5597 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5598 if (!SWIG_IsOK(res1)) {
5599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5600 }
5601 arg1 = reinterpret_cast< wxPoint * >(argp1);
5602 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5603 if (!SWIG_IsOK(ecode2)) {
5604 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_y_set" "', expected argument " "2"" of type '" "int""'");
5605 }
5606 arg2 = static_cast< int >(val2);
5607 if (arg1) (arg1)->y = arg2;
5608
5609 resultobj = SWIG_Py_Void();
5610 return resultobj;
5611 fail:
5612 return NULL;
5613 }
5614
5615
5616 SWIGINTERN PyObject *_wrap_Point_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5617 PyObject *resultobj = 0;
5618 wxPoint *arg1 = (wxPoint *) 0 ;
5619 int result;
5620 void *argp1 = 0 ;
5621 int res1 = 0 ;
5622 PyObject *swig_obj[1] ;
5623
5624 if (!args) SWIG_fail;
5625 swig_obj[0] = args;
5626 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5627 if (!SWIG_IsOK(res1)) {
5628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5629 }
5630 arg1 = reinterpret_cast< wxPoint * >(argp1);
5631 result = (int) ((arg1)->y);
5632 resultobj = SWIG_From_int(static_cast< int >(result));
5633 return resultobj;
5634 fail:
5635 return NULL;
5636 }
5637
5638
5639 SWIGINTERN PyObject *_wrap_new_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5640 PyObject *resultobj = 0;
5641 int arg1 = (int) 0 ;
5642 int arg2 = (int) 0 ;
5643 wxPoint *result = 0 ;
5644 int val1 ;
5645 int ecode1 = 0 ;
5646 int val2 ;
5647 int ecode2 = 0 ;
5648 PyObject * obj0 = 0 ;
5649 PyObject * obj1 = 0 ;
5650 char * kwnames[] = {
5651 (char *) "x",(char *) "y", NULL
5652 };
5653
5654 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) SWIG_fail;
5655 if (obj0) {
5656 ecode1 = SWIG_AsVal_int(obj0, &val1);
5657 if (!SWIG_IsOK(ecode1)) {
5658 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point" "', expected argument " "1"" of type '" "int""'");
5659 }
5660 arg1 = static_cast< int >(val1);
5661 }
5662 if (obj1) {
5663 ecode2 = SWIG_AsVal_int(obj1, &val2);
5664 if (!SWIG_IsOK(ecode2)) {
5665 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point" "', expected argument " "2"" of type '" "int""'");
5666 }
5667 arg2 = static_cast< int >(val2);
5668 }
5669 {
5670 PyThreadState* __tstate = wxPyBeginAllowThreads();
5671 result = (wxPoint *)new wxPoint(arg1,arg2);
5672 wxPyEndAllowThreads(__tstate);
5673 if (PyErr_Occurred()) SWIG_fail;
5674 }
5675 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_NEW | 0 );
5676 return resultobj;
5677 fail:
5678 return NULL;
5679 }
5680
5681
5682 SWIGINTERN PyObject *_wrap_delete_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5683 PyObject *resultobj = 0;
5684 wxPoint *arg1 = (wxPoint *) 0 ;
5685 void *argp1 = 0 ;
5686 int res1 = 0 ;
5687 PyObject *swig_obj[1] ;
5688
5689 if (!args) SWIG_fail;
5690 swig_obj[0] = args;
5691 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5692 if (!SWIG_IsOK(res1)) {
5693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point" "', expected argument " "1"" of type '" "wxPoint *""'");
5694 }
5695 arg1 = reinterpret_cast< wxPoint * >(argp1);
5696 {
5697 PyThreadState* __tstate = wxPyBeginAllowThreads();
5698 delete arg1;
5699
5700 wxPyEndAllowThreads(__tstate);
5701 if (PyErr_Occurred()) SWIG_fail;
5702 }
5703 resultobj = SWIG_Py_Void();
5704 return resultobj;
5705 fail:
5706 return NULL;
5707 }
5708
5709
5710 SWIGINTERN PyObject *_wrap_Point___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5711 PyObject *resultobj = 0;
5712 wxPoint *arg1 = (wxPoint *) 0 ;
5713 PyObject *arg2 = (PyObject *) 0 ;
5714 bool result;
5715 void *argp1 = 0 ;
5716 int res1 = 0 ;
5717 PyObject * obj0 = 0 ;
5718 PyObject * obj1 = 0 ;
5719 char * kwnames[] = {
5720 (char *) "self",(char *) "other", NULL
5721 };
5722
5723 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5724 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5725 if (!SWIG_IsOK(res1)) {
5726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___eq__" "', expected argument " "1"" of type '" "wxPoint *""'");
5727 }
5728 arg1 = reinterpret_cast< wxPoint * >(argp1);
5729 arg2 = obj1;
5730 {
5731 result = (bool)wxPoint___eq__(arg1,arg2);
5732 if (PyErr_Occurred()) SWIG_fail;
5733 }
5734 {
5735 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5736 }
5737 return resultobj;
5738 fail:
5739 return NULL;
5740 }
5741
5742
5743 SWIGINTERN PyObject *_wrap_Point___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5744 PyObject *resultobj = 0;
5745 wxPoint *arg1 = (wxPoint *) 0 ;
5746 PyObject *arg2 = (PyObject *) 0 ;
5747 bool result;
5748 void *argp1 = 0 ;
5749 int res1 = 0 ;
5750 PyObject * obj0 = 0 ;
5751 PyObject * obj1 = 0 ;
5752 char * kwnames[] = {
5753 (char *) "self",(char *) "other", NULL
5754 };
5755
5756 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5757 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5758 if (!SWIG_IsOK(res1)) {
5759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___ne__" "', expected argument " "1"" of type '" "wxPoint *""'");
5760 }
5761 arg1 = reinterpret_cast< wxPoint * >(argp1);
5762 arg2 = obj1;
5763 {
5764 result = (bool)wxPoint___ne__(arg1,arg2);
5765 if (PyErr_Occurred()) SWIG_fail;
5766 }
5767 {
5768 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5769 }
5770 return resultobj;
5771 fail:
5772 return NULL;
5773 }
5774
5775
5776 SWIGINTERN PyObject *_wrap_Point___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5777 PyObject *resultobj = 0;
5778 wxPoint *arg1 = (wxPoint *) 0 ;
5779 wxPoint *arg2 = 0 ;
5780 wxPoint result;
5781 void *argp1 = 0 ;
5782 int res1 = 0 ;
5783 wxPoint temp2 ;
5784 PyObject * obj0 = 0 ;
5785 PyObject * obj1 = 0 ;
5786 char * kwnames[] = {
5787 (char *) "self",(char *) "pt", NULL
5788 };
5789
5790 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5791 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5792 if (!SWIG_IsOK(res1)) {
5793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___add__" "', expected argument " "1"" of type '" "wxPoint *""'");
5794 }
5795 arg1 = reinterpret_cast< wxPoint * >(argp1);
5796 {
5797 arg2 = &temp2;
5798 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5799 }
5800 {
5801 PyThreadState* __tstate = wxPyBeginAllowThreads();
5802 result = (arg1)->operator +((wxPoint const &)*arg2);
5803 wxPyEndAllowThreads(__tstate);
5804 if (PyErr_Occurred()) SWIG_fail;
5805 }
5806 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5807 return resultobj;
5808 fail:
5809 return NULL;
5810 }
5811
5812
5813 SWIGINTERN PyObject *_wrap_Point___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5814 PyObject *resultobj = 0;
5815 wxPoint *arg1 = (wxPoint *) 0 ;
5816 wxPoint *arg2 = 0 ;
5817 wxPoint result;
5818 void *argp1 = 0 ;
5819 int res1 = 0 ;
5820 wxPoint temp2 ;
5821 PyObject * obj0 = 0 ;
5822 PyObject * obj1 = 0 ;
5823 char * kwnames[] = {
5824 (char *) "self",(char *) "pt", NULL
5825 };
5826
5827 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5828 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5829 if (!SWIG_IsOK(res1)) {
5830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___sub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5831 }
5832 arg1 = reinterpret_cast< wxPoint * >(argp1);
5833 {
5834 arg2 = &temp2;
5835 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5836 }
5837 {
5838 PyThreadState* __tstate = wxPyBeginAllowThreads();
5839 result = (arg1)->operator -((wxPoint const &)*arg2);
5840 wxPyEndAllowThreads(__tstate);
5841 if (PyErr_Occurred()) SWIG_fail;
5842 }
5843 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5844 return resultobj;
5845 fail:
5846 return NULL;
5847 }
5848
5849
5850 SWIGINTERN PyObject *_wrap_Point___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5851 PyObject *resultobj = 0;
5852 wxPoint *arg1 = (wxPoint *) 0 ;
5853 wxPoint *arg2 = 0 ;
5854 wxPoint *result = 0 ;
5855 void *argp1 = 0 ;
5856 int res1 = 0 ;
5857 wxPoint temp2 ;
5858 PyObject * obj0 = 0 ;
5859 PyObject * obj1 = 0 ;
5860 char * kwnames[] = {
5861 (char *) "self",(char *) "pt", NULL
5862 };
5863
5864 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
5865 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5866 if (!SWIG_IsOK(res1)) {
5867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___iadd__" "', expected argument " "1"" of type '" "wxPoint *""'");
5868 }
5869 arg1 = reinterpret_cast< wxPoint * >(argp1);
5870 {
5871 arg2 = &temp2;
5872 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5873 }
5874 {
5875 PyThreadState* __tstate = wxPyBeginAllowThreads();
5876 {
5877 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
5878 result = (wxPoint *) &_result_ref;
5879 }
5880 wxPyEndAllowThreads(__tstate);
5881 if (PyErr_Occurred()) SWIG_fail;
5882 }
5883 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5884 return resultobj;
5885 fail:
5886 return NULL;
5887 }
5888
5889
5890 SWIGINTERN PyObject *_wrap_Point___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5891 PyObject *resultobj = 0;
5892 wxPoint *arg1 = (wxPoint *) 0 ;
5893 wxPoint *arg2 = 0 ;
5894 wxPoint *result = 0 ;
5895 void *argp1 = 0 ;
5896 int res1 = 0 ;
5897 wxPoint temp2 ;
5898 PyObject * obj0 = 0 ;
5899 PyObject * obj1 = 0 ;
5900 char * kwnames[] = {
5901 (char *) "self",(char *) "pt", NULL
5902 };
5903
5904 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
5905 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5906 if (!SWIG_IsOK(res1)) {
5907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___isub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5908 }
5909 arg1 = reinterpret_cast< wxPoint * >(argp1);
5910 {
5911 arg2 = &temp2;
5912 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5913 }
5914 {
5915 PyThreadState* __tstate = wxPyBeginAllowThreads();
5916 {
5917 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
5918 result = (wxPoint *) &_result_ref;
5919 }
5920 wxPyEndAllowThreads(__tstate);
5921 if (PyErr_Occurred()) SWIG_fail;
5922 }
5923 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5924 return resultobj;
5925 fail:
5926 return NULL;
5927 }
5928
5929
5930 SWIGINTERN PyObject *_wrap_Point_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5931 PyObject *resultobj = 0;
5932 wxPoint *arg1 = (wxPoint *) 0 ;
5933 long arg2 ;
5934 long arg3 ;
5935 void *argp1 = 0 ;
5936 int res1 = 0 ;
5937 long val2 ;
5938 int ecode2 = 0 ;
5939 long val3 ;
5940 int ecode3 = 0 ;
5941 PyObject * obj0 = 0 ;
5942 PyObject * obj1 = 0 ;
5943 PyObject * obj2 = 0 ;
5944 char * kwnames[] = {
5945 (char *) "self",(char *) "x",(char *) "y", NULL
5946 };
5947
5948 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5949 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5950 if (!SWIG_IsOK(res1)) {
5951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Set" "', expected argument " "1"" of type '" "wxPoint *""'");
5952 }
5953 arg1 = reinterpret_cast< wxPoint * >(argp1);
5954 ecode2 = SWIG_AsVal_long(obj1, &val2);
5955 if (!SWIG_IsOK(ecode2)) {
5956 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_Set" "', expected argument " "2"" of type '" "long""'");
5957 }
5958 arg2 = static_cast< long >(val2);
5959 ecode3 = SWIG_AsVal_long(obj2, &val3);
5960 if (!SWIG_IsOK(ecode3)) {
5961 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point_Set" "', expected argument " "3"" of type '" "long""'");
5962 }
5963 arg3 = static_cast< long >(val3);
5964 {
5965 PyThreadState* __tstate = wxPyBeginAllowThreads();
5966 wxPoint_Set(arg1,arg2,arg3);
5967 wxPyEndAllowThreads(__tstate);
5968 if (PyErr_Occurred()) SWIG_fail;
5969 }
5970 resultobj = SWIG_Py_Void();
5971 return resultobj;
5972 fail:
5973 return NULL;
5974 }
5975
5976
5977 SWIGINTERN PyObject *_wrap_Point_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5978 PyObject *resultobj = 0;
5979 wxPoint *arg1 = (wxPoint *) 0 ;
5980 PyObject *result = 0 ;
5981 void *argp1 = 0 ;
5982 int res1 = 0 ;
5983 PyObject *swig_obj[1] ;
5984
5985 if (!args) SWIG_fail;
5986 swig_obj[0] = args;
5987 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5988 if (!SWIG_IsOK(res1)) {
5989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Get" "', expected argument " "1"" of type '" "wxPoint *""'");
5990 }
5991 arg1 = reinterpret_cast< wxPoint * >(argp1);
5992 {
5993 PyThreadState* __tstate = wxPyBeginAllowThreads();
5994 result = (PyObject *)wxPoint_Get(arg1);
5995 wxPyEndAllowThreads(__tstate);
5996 if (PyErr_Occurred()) SWIG_fail;
5997 }
5998 resultobj = result;
5999 return resultobj;
6000 fail:
6001 return NULL;
6002 }
6003
6004
6005 SWIGINTERN PyObject *Point_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6006 PyObject *obj;
6007 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
6008 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint, SWIG_NewClientData(obj));
6009 return SWIG_Py_Void();
6010 }
6011
6012 SWIGINTERN PyObject *Point_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6013 return SWIG_Python_InitShadowInstance(args);
6014 }
6015
6016 SWIGINTERN PyObject *_wrap_new_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6017 PyObject *resultobj = 0;
6018 int arg1 = (int) 0 ;
6019 int arg2 = (int) 0 ;
6020 int arg3 = (int) 0 ;
6021 int arg4 = (int) 0 ;
6022 wxRect *result = 0 ;
6023 int val1 ;
6024 int ecode1 = 0 ;
6025 int val2 ;
6026 int ecode2 = 0 ;
6027 int val3 ;
6028 int ecode3 = 0 ;
6029 int val4 ;
6030 int ecode4 = 0 ;
6031 PyObject * obj0 = 0 ;
6032 PyObject * obj1 = 0 ;
6033 PyObject * obj2 = 0 ;
6034 PyObject * obj3 = 0 ;
6035 char * kwnames[] = {
6036 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6037 };
6038
6039 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6040 if (obj0) {
6041 ecode1 = SWIG_AsVal_int(obj0, &val1);
6042 if (!SWIG_IsOK(ecode1)) {
6043 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Rect" "', expected argument " "1"" of type '" "int""'");
6044 }
6045 arg1 = static_cast< int >(val1);
6046 }
6047 if (obj1) {
6048 ecode2 = SWIG_AsVal_int(obj1, &val2);
6049 if (!SWIG_IsOK(ecode2)) {
6050 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Rect" "', expected argument " "2"" of type '" "int""'");
6051 }
6052 arg2 = static_cast< int >(val2);
6053 }
6054 if (obj2) {
6055 ecode3 = SWIG_AsVal_int(obj2, &val3);
6056 if (!SWIG_IsOK(ecode3)) {
6057 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Rect" "', expected argument " "3"" of type '" "int""'");
6058 }
6059 arg3 = static_cast< int >(val3);
6060 }
6061 if (obj3) {
6062 ecode4 = SWIG_AsVal_int(obj3, &val4);
6063 if (!SWIG_IsOK(ecode4)) {
6064 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Rect" "', expected argument " "4"" of type '" "int""'");
6065 }
6066 arg4 = static_cast< int >(val4);
6067 }
6068 {
6069 PyThreadState* __tstate = wxPyBeginAllowThreads();
6070 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
6071 wxPyEndAllowThreads(__tstate);
6072 if (PyErr_Occurred()) SWIG_fail;
6073 }
6074 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_NEW | 0 );
6075 return resultobj;
6076 fail:
6077 return NULL;
6078 }
6079
6080
6081 SWIGINTERN PyObject *_wrap_new_RectPP(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6082 PyObject *resultobj = 0;
6083 wxPoint *arg1 = 0 ;
6084 wxPoint *arg2 = 0 ;
6085 wxRect *result = 0 ;
6086 wxPoint temp1 ;
6087 wxPoint temp2 ;
6088 PyObject * obj0 = 0 ;
6089 PyObject * obj1 = 0 ;
6090 char * kwnames[] = {
6091 (char *) "topLeft",(char *) "bottomRight", NULL
6092 };
6093
6094 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) SWIG_fail;
6095 {
6096 arg1 = &temp1;
6097 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6098 }
6099 {
6100 arg2 = &temp2;
6101 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6102 }
6103 {
6104 PyThreadState* __tstate = wxPyBeginAllowThreads();
6105 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
6106 wxPyEndAllowThreads(__tstate);
6107 if (PyErr_Occurred()) SWIG_fail;
6108 }
6109 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6110 return resultobj;
6111 fail:
6112 return NULL;
6113 }
6114
6115
6116 SWIGINTERN PyObject *_wrap_new_RectPS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6117 PyObject *resultobj = 0;
6118 wxPoint *arg1 = 0 ;
6119 wxSize *arg2 = 0 ;
6120 wxRect *result = 0 ;
6121 wxPoint temp1 ;
6122 wxSize temp2 ;
6123 PyObject * obj0 = 0 ;
6124 PyObject * obj1 = 0 ;
6125 char * kwnames[] = {
6126 (char *) "pos",(char *) "size", NULL
6127 };
6128
6129 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) SWIG_fail;
6130 {
6131 arg1 = &temp1;
6132 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6133 }
6134 {
6135 arg2 = &temp2;
6136 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6137 }
6138 {
6139 PyThreadState* __tstate = wxPyBeginAllowThreads();
6140 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
6141 wxPyEndAllowThreads(__tstate);
6142 if (PyErr_Occurred()) SWIG_fail;
6143 }
6144 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6145 return resultobj;
6146 fail:
6147 return NULL;
6148 }
6149
6150
6151 SWIGINTERN PyObject *_wrap_new_RectS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6152 PyObject *resultobj = 0;
6153 wxSize *arg1 = 0 ;
6154 wxRect *result = 0 ;
6155 wxSize temp1 ;
6156 PyObject * obj0 = 0 ;
6157 char * kwnames[] = {
6158 (char *) "size", NULL
6159 };
6160
6161 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) SWIG_fail;
6162 {
6163 arg1 = &temp1;
6164 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
6165 }
6166 {
6167 PyThreadState* __tstate = wxPyBeginAllowThreads();
6168 result = (wxRect *)new wxRect((wxSize const &)*arg1);
6169 wxPyEndAllowThreads(__tstate);
6170 if (PyErr_Occurred()) SWIG_fail;
6171 }
6172 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6173 return resultobj;
6174 fail:
6175 return NULL;
6176 }
6177
6178
6179 SWIGINTERN PyObject *_wrap_delete_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6180 PyObject *resultobj = 0;
6181 wxRect *arg1 = (wxRect *) 0 ;
6182 void *argp1 = 0 ;
6183 int res1 = 0 ;
6184 PyObject *swig_obj[1] ;
6185
6186 if (!args) SWIG_fail;
6187 swig_obj[0] = args;
6188 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
6189 if (!SWIG_IsOK(res1)) {
6190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect" "', expected argument " "1"" of type '" "wxRect *""'");
6191 }
6192 arg1 = reinterpret_cast< wxRect * >(argp1);
6193 {
6194 PyThreadState* __tstate = wxPyBeginAllowThreads();
6195 delete arg1;
6196
6197 wxPyEndAllowThreads(__tstate);
6198 if (PyErr_Occurred()) SWIG_fail;
6199 }
6200 resultobj = SWIG_Py_Void();
6201 return resultobj;
6202 fail:
6203 return NULL;
6204 }
6205
6206
6207 SWIGINTERN PyObject *_wrap_Rect_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6208 PyObject *resultobj = 0;
6209 wxRect *arg1 = (wxRect *) 0 ;
6210 int result;
6211 void *argp1 = 0 ;
6212 int res1 = 0 ;
6213 PyObject *swig_obj[1] ;
6214
6215 if (!args) SWIG_fail;
6216 swig_obj[0] = args;
6217 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6218 if (!SWIG_IsOK(res1)) {
6219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetX" "', expected argument " "1"" of type '" "wxRect const *""'");
6220 }
6221 arg1 = reinterpret_cast< wxRect * >(argp1);
6222 {
6223 PyThreadState* __tstate = wxPyBeginAllowThreads();
6224 result = (int)((wxRect const *)arg1)->GetX();
6225 wxPyEndAllowThreads(__tstate);
6226 if (PyErr_Occurred()) SWIG_fail;
6227 }
6228 resultobj = SWIG_From_int(static_cast< int >(result));
6229 return resultobj;
6230 fail:
6231 return NULL;
6232 }
6233
6234
6235 SWIGINTERN PyObject *_wrap_Rect_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6236 PyObject *resultobj = 0;
6237 wxRect *arg1 = (wxRect *) 0 ;
6238 int arg2 ;
6239 void *argp1 = 0 ;
6240 int res1 = 0 ;
6241 int val2 ;
6242 int ecode2 = 0 ;
6243 PyObject * obj0 = 0 ;
6244 PyObject * obj1 = 0 ;
6245 char * kwnames[] = {
6246 (char *) "self",(char *) "x", NULL
6247 };
6248
6249 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
6250 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6251 if (!SWIG_IsOK(res1)) {
6252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetX" "', expected argument " "1"" of type '" "wxRect *""'");
6253 }
6254 arg1 = reinterpret_cast< wxRect * >(argp1);
6255 ecode2 = SWIG_AsVal_int(obj1, &val2);
6256 if (!SWIG_IsOK(ecode2)) {
6257 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetX" "', expected argument " "2"" of type '" "int""'");
6258 }
6259 arg2 = static_cast< int >(val2);
6260 {
6261 PyThreadState* __tstate = wxPyBeginAllowThreads();
6262 (arg1)->SetX(arg2);
6263 wxPyEndAllowThreads(__tstate);
6264 if (PyErr_Occurred()) SWIG_fail;
6265 }
6266 resultobj = SWIG_Py_Void();
6267 return resultobj;
6268 fail:
6269 return NULL;
6270 }
6271
6272
6273 SWIGINTERN PyObject *_wrap_Rect_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6274 PyObject *resultobj = 0;
6275 wxRect *arg1 = (wxRect *) 0 ;
6276 int result;
6277 void *argp1 = 0 ;
6278 int res1 = 0 ;
6279 PyObject *swig_obj[1] ;
6280
6281 if (!args) SWIG_fail;
6282 swig_obj[0] = args;
6283 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6284 if (!SWIG_IsOK(res1)) {
6285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetY" "', expected argument " "1"" of type '" "wxRect *""'");
6286 }
6287 arg1 = reinterpret_cast< wxRect * >(argp1);
6288 {
6289 PyThreadState* __tstate = wxPyBeginAllowThreads();
6290 result = (int)(arg1)->GetY();
6291 wxPyEndAllowThreads(__tstate);
6292 if (PyErr_Occurred()) SWIG_fail;
6293 }
6294 resultobj = SWIG_From_int(static_cast< int >(result));
6295 return resultobj;
6296 fail:
6297 return NULL;
6298 }
6299
6300
6301 SWIGINTERN PyObject *_wrap_Rect_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6302 PyObject *resultobj = 0;
6303 wxRect *arg1 = (wxRect *) 0 ;
6304 int arg2 ;
6305 void *argp1 = 0 ;
6306 int res1 = 0 ;
6307 int val2 ;
6308 int ecode2 = 0 ;
6309 PyObject * obj0 = 0 ;
6310 PyObject * obj1 = 0 ;
6311 char * kwnames[] = {
6312 (char *) "self",(char *) "y", NULL
6313 };
6314
6315 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
6316 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6317 if (!SWIG_IsOK(res1)) {
6318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetY" "', expected argument " "1"" of type '" "wxRect *""'");
6319 }
6320 arg1 = reinterpret_cast< wxRect * >(argp1);
6321 ecode2 = SWIG_AsVal_int(obj1, &val2);
6322 if (!SWIG_IsOK(ecode2)) {
6323 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetY" "', expected argument " "2"" of type '" "int""'");
6324 }
6325 arg2 = static_cast< int >(val2);
6326 {
6327 PyThreadState* __tstate = wxPyBeginAllowThreads();
6328 (arg1)->SetY(arg2);
6329 wxPyEndAllowThreads(__tstate);
6330 if (PyErr_Occurred()) SWIG_fail;
6331 }
6332 resultobj = SWIG_Py_Void();
6333 return resultobj;
6334 fail:
6335 return NULL;
6336 }
6337
6338
6339 SWIGINTERN PyObject *_wrap_Rect_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6340 PyObject *resultobj = 0;
6341 wxRect *arg1 = (wxRect *) 0 ;
6342 int result;
6343 void *argp1 = 0 ;
6344 int res1 = 0 ;
6345 PyObject *swig_obj[1] ;
6346
6347 if (!args) SWIG_fail;
6348 swig_obj[0] = args;
6349 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6350 if (!SWIG_IsOK(res1)) {
6351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetWidth" "', expected argument " "1"" of type '" "wxRect const *""'");
6352 }
6353 arg1 = reinterpret_cast< wxRect * >(argp1);
6354 {
6355 PyThreadState* __tstate = wxPyBeginAllowThreads();
6356 result = (int)((wxRect const *)arg1)->GetWidth();
6357 wxPyEndAllowThreads(__tstate);
6358 if (PyErr_Occurred()) SWIG_fail;
6359 }
6360 resultobj = SWIG_From_int(static_cast< int >(result));
6361 return resultobj;
6362 fail:
6363 return NULL;
6364 }
6365
6366
6367 SWIGINTERN PyObject *_wrap_Rect_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6368 PyObject *resultobj = 0;
6369 wxRect *arg1 = (wxRect *) 0 ;
6370 int arg2 ;
6371 void *argp1 = 0 ;
6372 int res1 = 0 ;
6373 int val2 ;
6374 int ecode2 = 0 ;
6375 PyObject * obj0 = 0 ;
6376 PyObject * obj1 = 0 ;
6377 char * kwnames[] = {
6378 (char *) "self",(char *) "w", NULL
6379 };
6380
6381 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
6382 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6383 if (!SWIG_IsOK(res1)) {
6384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetWidth" "', expected argument " "1"" of type '" "wxRect *""'");
6385 }
6386 arg1 = reinterpret_cast< wxRect * >(argp1);
6387 ecode2 = SWIG_AsVal_int(obj1, &val2);
6388 if (!SWIG_IsOK(ecode2)) {
6389 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetWidth" "', expected argument " "2"" of type '" "int""'");
6390 }
6391 arg2 = static_cast< int >(val2);
6392 {
6393 PyThreadState* __tstate = wxPyBeginAllowThreads();
6394 (arg1)->SetWidth(arg2);
6395 wxPyEndAllowThreads(__tstate);
6396 if (PyErr_Occurred()) SWIG_fail;
6397 }
6398 resultobj = SWIG_Py_Void();
6399 return resultobj;
6400 fail:
6401 return NULL;
6402 }
6403
6404
6405 SWIGINTERN PyObject *_wrap_Rect_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6406 PyObject *resultobj = 0;
6407 wxRect *arg1 = (wxRect *) 0 ;
6408 int result;
6409 void *argp1 = 0 ;
6410 int res1 = 0 ;
6411 PyObject *swig_obj[1] ;
6412
6413 if (!args) SWIG_fail;
6414 swig_obj[0] = args;
6415 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6416 if (!SWIG_IsOK(res1)) {
6417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetHeight" "', expected argument " "1"" of type '" "wxRect const *""'");
6418 }
6419 arg1 = reinterpret_cast< wxRect * >(argp1);
6420 {
6421 PyThreadState* __tstate = wxPyBeginAllowThreads();
6422 result = (int)((wxRect const *)arg1)->GetHeight();
6423 wxPyEndAllowThreads(__tstate);
6424 if (PyErr_Occurred()) SWIG_fail;
6425 }
6426 resultobj = SWIG_From_int(static_cast< int >(result));
6427 return resultobj;
6428 fail:
6429 return NULL;
6430 }
6431
6432
6433 SWIGINTERN PyObject *_wrap_Rect_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6434 PyObject *resultobj = 0;
6435 wxRect *arg1 = (wxRect *) 0 ;
6436 int arg2 ;
6437 void *argp1 = 0 ;
6438 int res1 = 0 ;
6439 int val2 ;
6440 int ecode2 = 0 ;
6441 PyObject * obj0 = 0 ;
6442 PyObject * obj1 = 0 ;
6443 char * kwnames[] = {
6444 (char *) "self",(char *) "h", NULL
6445 };
6446
6447 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
6448 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6449 if (!SWIG_IsOK(res1)) {
6450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetHeight" "', expected argument " "1"" of type '" "wxRect *""'");
6451 }
6452 arg1 = reinterpret_cast< wxRect * >(argp1);
6453 ecode2 = SWIG_AsVal_int(obj1, &val2);
6454 if (!SWIG_IsOK(ecode2)) {
6455 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetHeight" "', expected argument " "2"" of type '" "int""'");
6456 }
6457 arg2 = static_cast< int >(val2);
6458 {
6459 PyThreadState* __tstate = wxPyBeginAllowThreads();
6460 (arg1)->SetHeight(arg2);
6461 wxPyEndAllowThreads(__tstate);
6462 if (PyErr_Occurred()) SWIG_fail;
6463 }
6464 resultobj = SWIG_Py_Void();
6465 return resultobj;
6466 fail:
6467 return NULL;
6468 }
6469
6470
6471 SWIGINTERN PyObject *_wrap_Rect_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6472 PyObject *resultobj = 0;
6473 wxRect *arg1 = (wxRect *) 0 ;
6474 wxPoint result;
6475 void *argp1 = 0 ;
6476 int res1 = 0 ;
6477 PyObject *swig_obj[1] ;
6478
6479 if (!args) SWIG_fail;
6480 swig_obj[0] = args;
6481 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6482 if (!SWIG_IsOK(res1)) {
6483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetPosition" "', expected argument " "1"" of type '" "wxRect const *""'");
6484 }
6485 arg1 = reinterpret_cast< wxRect * >(argp1);
6486 {
6487 PyThreadState* __tstate = wxPyBeginAllowThreads();
6488 result = ((wxRect const *)arg1)->GetPosition();
6489 wxPyEndAllowThreads(__tstate);
6490 if (PyErr_Occurred()) SWIG_fail;
6491 }
6492 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6493 return resultobj;
6494 fail:
6495 return NULL;
6496 }
6497
6498
6499 SWIGINTERN PyObject *_wrap_Rect_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6500 PyObject *resultobj = 0;
6501 wxRect *arg1 = (wxRect *) 0 ;
6502 wxPoint *arg2 = 0 ;
6503 void *argp1 = 0 ;
6504 int res1 = 0 ;
6505 wxPoint temp2 ;
6506 PyObject * obj0 = 0 ;
6507 PyObject * obj1 = 0 ;
6508 char * kwnames[] = {
6509 (char *) "self",(char *) "p", NULL
6510 };
6511
6512 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
6513 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6514 if (!SWIG_IsOK(res1)) {
6515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetPosition" "', expected argument " "1"" of type '" "wxRect *""'");
6516 }
6517 arg1 = reinterpret_cast< wxRect * >(argp1);
6518 {
6519 arg2 = &temp2;
6520 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6521 }
6522 {
6523 PyThreadState* __tstate = wxPyBeginAllowThreads();
6524 (arg1)->SetPosition((wxPoint const &)*arg2);
6525 wxPyEndAllowThreads(__tstate);
6526 if (PyErr_Occurred()) SWIG_fail;
6527 }
6528 resultobj = SWIG_Py_Void();
6529 return resultobj;
6530 fail:
6531 return NULL;
6532 }
6533
6534
6535 SWIGINTERN PyObject *_wrap_Rect_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6536 PyObject *resultobj = 0;
6537 wxRect *arg1 = (wxRect *) 0 ;
6538 wxSize result;
6539 void *argp1 = 0 ;
6540 int res1 = 0 ;
6541 PyObject *swig_obj[1] ;
6542
6543 if (!args) SWIG_fail;
6544 swig_obj[0] = args;
6545 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6546 if (!SWIG_IsOK(res1)) {
6547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetSize" "', expected argument " "1"" of type '" "wxRect const *""'");
6548 }
6549 arg1 = reinterpret_cast< wxRect * >(argp1);
6550 {
6551 PyThreadState* __tstate = wxPyBeginAllowThreads();
6552 result = ((wxRect const *)arg1)->GetSize();
6553 wxPyEndAllowThreads(__tstate);
6554 if (PyErr_Occurred()) SWIG_fail;
6555 }
6556 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6557 return resultobj;
6558 fail:
6559 return NULL;
6560 }
6561
6562
6563 SWIGINTERN PyObject *_wrap_Rect_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6564 PyObject *resultobj = 0;
6565 wxRect *arg1 = (wxRect *) 0 ;
6566 wxSize *arg2 = 0 ;
6567 void *argp1 = 0 ;
6568 int res1 = 0 ;
6569 wxSize temp2 ;
6570 PyObject * obj0 = 0 ;
6571 PyObject * obj1 = 0 ;
6572 char * kwnames[] = {
6573 (char *) "self",(char *) "s", NULL
6574 };
6575
6576 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
6577 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6578 if (!SWIG_IsOK(res1)) {
6579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetSize" "', expected argument " "1"" of type '" "wxRect *""'");
6580 }
6581 arg1 = reinterpret_cast< wxRect * >(argp1);
6582 {
6583 arg2 = &temp2;
6584 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6585 }
6586 {
6587 PyThreadState* __tstate = wxPyBeginAllowThreads();
6588 (arg1)->SetSize((wxSize const &)*arg2);
6589 wxPyEndAllowThreads(__tstate);
6590 if (PyErr_Occurred()) SWIG_fail;
6591 }
6592 resultobj = SWIG_Py_Void();
6593 return resultobj;
6594 fail:
6595 return NULL;
6596 }
6597
6598
6599 SWIGINTERN PyObject *_wrap_Rect_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6600 PyObject *resultobj = 0;
6601 wxRect *arg1 = (wxRect *) 0 ;
6602 bool result;
6603 void *argp1 = 0 ;
6604 int res1 = 0 ;
6605 PyObject *swig_obj[1] ;
6606
6607 if (!args) SWIG_fail;
6608 swig_obj[0] = args;
6609 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6610 if (!SWIG_IsOK(res1)) {
6611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_IsEmpty" "', expected argument " "1"" of type '" "wxRect const *""'");
6612 }
6613 arg1 = reinterpret_cast< wxRect * >(argp1);
6614 {
6615 PyThreadState* __tstate = wxPyBeginAllowThreads();
6616 result = (bool)((wxRect const *)arg1)->IsEmpty();
6617 wxPyEndAllowThreads(__tstate);
6618 if (PyErr_Occurred()) SWIG_fail;
6619 }
6620 {
6621 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6622 }
6623 return resultobj;
6624 fail:
6625 return NULL;
6626 }
6627
6628
6629 SWIGINTERN PyObject *_wrap_Rect_GetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6630 PyObject *resultobj = 0;
6631 wxRect *arg1 = (wxRect *) 0 ;
6632 wxPoint result;
6633 void *argp1 = 0 ;
6634 int res1 = 0 ;
6635 PyObject *swig_obj[1] ;
6636
6637 if (!args) SWIG_fail;
6638 swig_obj[0] = args;
6639 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6640 if (!SWIG_IsOK(res1)) {
6641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6642 }
6643 arg1 = reinterpret_cast< wxRect * >(argp1);
6644 {
6645 PyThreadState* __tstate = wxPyBeginAllowThreads();
6646 result = ((wxRect const *)arg1)->GetTopLeft();
6647 wxPyEndAllowThreads(__tstate);
6648 if (PyErr_Occurred()) SWIG_fail;
6649 }
6650 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6651 return resultobj;
6652 fail:
6653 return NULL;
6654 }
6655
6656
6657 SWIGINTERN PyObject *_wrap_Rect_SetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6658 PyObject *resultobj = 0;
6659 wxRect *arg1 = (wxRect *) 0 ;
6660 wxPoint *arg2 = 0 ;
6661 void *argp1 = 0 ;
6662 int res1 = 0 ;
6663 wxPoint temp2 ;
6664 PyObject * obj0 = 0 ;
6665 PyObject * obj1 = 0 ;
6666 char * kwnames[] = {
6667 (char *) "self",(char *) "p", NULL
6668 };
6669
6670 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6671 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6672 if (!SWIG_IsOK(res1)) {
6673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6674 }
6675 arg1 = reinterpret_cast< wxRect * >(argp1);
6676 {
6677 arg2 = &temp2;
6678 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6679 }
6680 {
6681 PyThreadState* __tstate = wxPyBeginAllowThreads();
6682 (arg1)->SetTopLeft((wxPoint const &)*arg2);
6683 wxPyEndAllowThreads(__tstate);
6684 if (PyErr_Occurred()) SWIG_fail;
6685 }
6686 resultobj = SWIG_Py_Void();
6687 return resultobj;
6688 fail:
6689 return NULL;
6690 }
6691
6692
6693 SWIGINTERN PyObject *_wrap_Rect_GetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6694 PyObject *resultobj = 0;
6695 wxRect *arg1 = (wxRect *) 0 ;
6696 wxPoint result;
6697 void *argp1 = 0 ;
6698 int res1 = 0 ;
6699 PyObject *swig_obj[1] ;
6700
6701 if (!args) SWIG_fail;
6702 swig_obj[0] = args;
6703 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6704 if (!SWIG_IsOK(res1)) {
6705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6706 }
6707 arg1 = reinterpret_cast< wxRect * >(argp1);
6708 {
6709 PyThreadState* __tstate = wxPyBeginAllowThreads();
6710 result = ((wxRect const *)arg1)->GetBottomRight();
6711 wxPyEndAllowThreads(__tstate);
6712 if (PyErr_Occurred()) SWIG_fail;
6713 }
6714 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6715 return resultobj;
6716 fail:
6717 return NULL;
6718 }
6719
6720
6721 SWIGINTERN PyObject *_wrap_Rect_SetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6722 PyObject *resultobj = 0;
6723 wxRect *arg1 = (wxRect *) 0 ;
6724 wxPoint *arg2 = 0 ;
6725 void *argp1 = 0 ;
6726 int res1 = 0 ;
6727 wxPoint temp2 ;
6728 PyObject * obj0 = 0 ;
6729 PyObject * obj1 = 0 ;
6730 char * kwnames[] = {
6731 (char *) "self",(char *) "p", NULL
6732 };
6733
6734 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) SWIG_fail;
6735 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6736 if (!SWIG_IsOK(res1)) {
6737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomRight" "', expected argument " "1"" of type '" "wxRect *""'");
6738 }
6739 arg1 = reinterpret_cast< wxRect * >(argp1);
6740 {
6741 arg2 = &temp2;
6742 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6743 }
6744 {
6745 PyThreadState* __tstate = wxPyBeginAllowThreads();
6746 (arg1)->SetBottomRight((wxPoint const &)*arg2);
6747 wxPyEndAllowThreads(__tstate);
6748 if (PyErr_Occurred()) SWIG_fail;
6749 }
6750 resultobj = SWIG_Py_Void();
6751 return resultobj;
6752 fail:
6753 return NULL;
6754 }
6755
6756
6757 SWIGINTERN PyObject *_wrap_Rect_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6758 PyObject *resultobj = 0;
6759 wxRect *arg1 = (wxRect *) 0 ;
6760 int result;
6761 void *argp1 = 0 ;
6762 int res1 = 0 ;
6763 PyObject *swig_obj[1] ;
6764
6765 if (!args) SWIG_fail;
6766 swig_obj[0] = args;
6767 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6768 if (!SWIG_IsOK(res1)) {
6769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6770 }
6771 arg1 = reinterpret_cast< wxRect * >(argp1);
6772 {
6773 PyThreadState* __tstate = wxPyBeginAllowThreads();
6774 result = (int)((wxRect const *)arg1)->GetLeft();
6775 wxPyEndAllowThreads(__tstate);
6776 if (PyErr_Occurred()) SWIG_fail;
6777 }
6778 resultobj = SWIG_From_int(static_cast< int >(result));
6779 return resultobj;
6780 fail:
6781 return NULL;
6782 }
6783
6784
6785 SWIGINTERN PyObject *_wrap_Rect_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6786 PyObject *resultobj = 0;
6787 wxRect *arg1 = (wxRect *) 0 ;
6788 int result;
6789 void *argp1 = 0 ;
6790 int res1 = 0 ;
6791 PyObject *swig_obj[1] ;
6792
6793 if (!args) SWIG_fail;
6794 swig_obj[0] = args;
6795 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6796 if (!SWIG_IsOK(res1)) {
6797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTop" "', expected argument " "1"" of type '" "wxRect const *""'");
6798 }
6799 arg1 = reinterpret_cast< wxRect * >(argp1);
6800 {
6801 PyThreadState* __tstate = wxPyBeginAllowThreads();
6802 result = (int)((wxRect const *)arg1)->GetTop();
6803 wxPyEndAllowThreads(__tstate);
6804 if (PyErr_Occurred()) SWIG_fail;
6805 }
6806 resultobj = SWIG_From_int(static_cast< int >(result));
6807 return resultobj;
6808 fail:
6809 return NULL;
6810 }
6811
6812
6813 SWIGINTERN PyObject *_wrap_Rect_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6814 PyObject *resultobj = 0;
6815 wxRect *arg1 = (wxRect *) 0 ;
6816 int result;
6817 void *argp1 = 0 ;
6818 int res1 = 0 ;
6819 PyObject *swig_obj[1] ;
6820
6821 if (!args) SWIG_fail;
6822 swig_obj[0] = args;
6823 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6824 if (!SWIG_IsOK(res1)) {
6825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottom" "', expected argument " "1"" of type '" "wxRect const *""'");
6826 }
6827 arg1 = reinterpret_cast< wxRect * >(argp1);
6828 {
6829 PyThreadState* __tstate = wxPyBeginAllowThreads();
6830 result = (int)((wxRect const *)arg1)->GetBottom();
6831 wxPyEndAllowThreads(__tstate);
6832 if (PyErr_Occurred()) SWIG_fail;
6833 }
6834 resultobj = SWIG_From_int(static_cast< int >(result));
6835 return resultobj;
6836 fail:
6837 return NULL;
6838 }
6839
6840
6841 SWIGINTERN PyObject *_wrap_Rect_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6842 PyObject *resultobj = 0;
6843 wxRect *arg1 = (wxRect *) 0 ;
6844 int result;
6845 void *argp1 = 0 ;
6846 int res1 = 0 ;
6847 PyObject *swig_obj[1] ;
6848
6849 if (!args) SWIG_fail;
6850 swig_obj[0] = args;
6851 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6852 if (!SWIG_IsOK(res1)) {
6853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6854 }
6855 arg1 = reinterpret_cast< wxRect * >(argp1);
6856 {
6857 PyThreadState* __tstate = wxPyBeginAllowThreads();
6858 result = (int)((wxRect const *)arg1)->GetRight();
6859 wxPyEndAllowThreads(__tstate);
6860 if (PyErr_Occurred()) SWIG_fail;
6861 }
6862 resultobj = SWIG_From_int(static_cast< int >(result));
6863 return resultobj;
6864 fail:
6865 return NULL;
6866 }
6867
6868
6869 SWIGINTERN PyObject *_wrap_Rect_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6870 PyObject *resultobj = 0;
6871 wxRect *arg1 = (wxRect *) 0 ;
6872 int arg2 ;
6873 void *argp1 = 0 ;
6874 int res1 = 0 ;
6875 int val2 ;
6876 int ecode2 = 0 ;
6877 PyObject * obj0 = 0 ;
6878 PyObject * obj1 = 0 ;
6879 char * kwnames[] = {
6880 (char *) "self",(char *) "left", NULL
6881 };
6882
6883 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6884 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6885 if (!SWIG_IsOK(res1)) {
6886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6887 }
6888 arg1 = reinterpret_cast< wxRect * >(argp1);
6889 ecode2 = SWIG_AsVal_int(obj1, &val2);
6890 if (!SWIG_IsOK(ecode2)) {
6891 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetLeft" "', expected argument " "2"" of type '" "int""'");
6892 }
6893 arg2 = static_cast< int >(val2);
6894 {
6895 PyThreadState* __tstate = wxPyBeginAllowThreads();
6896 (arg1)->SetLeft(arg2);
6897 wxPyEndAllowThreads(__tstate);
6898 if (PyErr_Occurred()) SWIG_fail;
6899 }
6900 resultobj = SWIG_Py_Void();
6901 return resultobj;
6902 fail:
6903 return NULL;
6904 }
6905
6906
6907 SWIGINTERN PyObject *_wrap_Rect_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6908 PyObject *resultobj = 0;
6909 wxRect *arg1 = (wxRect *) 0 ;
6910 int arg2 ;
6911 void *argp1 = 0 ;
6912 int res1 = 0 ;
6913 int val2 ;
6914 int ecode2 = 0 ;
6915 PyObject * obj0 = 0 ;
6916 PyObject * obj1 = 0 ;
6917 char * kwnames[] = {
6918 (char *) "self",(char *) "right", NULL
6919 };
6920
6921 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
6922 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6923 if (!SWIG_IsOK(res1)) {
6924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetRight" "', expected argument " "1"" of type '" "wxRect *""'");
6925 }
6926 arg1 = reinterpret_cast< wxRect * >(argp1);
6927 ecode2 = SWIG_AsVal_int(obj1, &val2);
6928 if (!SWIG_IsOK(ecode2)) {
6929 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetRight" "', expected argument " "2"" of type '" "int""'");
6930 }
6931 arg2 = static_cast< int >(val2);
6932 {
6933 PyThreadState* __tstate = wxPyBeginAllowThreads();
6934 (arg1)->SetRight(arg2);
6935 wxPyEndAllowThreads(__tstate);
6936 if (PyErr_Occurred()) SWIG_fail;
6937 }
6938 resultobj = SWIG_Py_Void();
6939 return resultobj;
6940 fail:
6941 return NULL;
6942 }
6943
6944
6945 SWIGINTERN PyObject *_wrap_Rect_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6946 PyObject *resultobj = 0;
6947 wxRect *arg1 = (wxRect *) 0 ;
6948 int arg2 ;
6949 void *argp1 = 0 ;
6950 int res1 = 0 ;
6951 int val2 ;
6952 int ecode2 = 0 ;
6953 PyObject * obj0 = 0 ;
6954 PyObject * obj1 = 0 ;
6955 char * kwnames[] = {
6956 (char *) "self",(char *) "top", NULL
6957 };
6958
6959 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
6960 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6961 if (!SWIG_IsOK(res1)) {
6962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTop" "', expected argument " "1"" of type '" "wxRect *""'");
6963 }
6964 arg1 = reinterpret_cast< wxRect * >(argp1);
6965 ecode2 = SWIG_AsVal_int(obj1, &val2);
6966 if (!SWIG_IsOK(ecode2)) {
6967 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetTop" "', expected argument " "2"" of type '" "int""'");
6968 }
6969 arg2 = static_cast< int >(val2);
6970 {
6971 PyThreadState* __tstate = wxPyBeginAllowThreads();
6972 (arg1)->SetTop(arg2);
6973 wxPyEndAllowThreads(__tstate);
6974 if (PyErr_Occurred()) SWIG_fail;
6975 }
6976 resultobj = SWIG_Py_Void();
6977 return resultobj;
6978 fail:
6979 return NULL;
6980 }
6981
6982
6983 SWIGINTERN PyObject *_wrap_Rect_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6984 PyObject *resultobj = 0;
6985 wxRect *arg1 = (wxRect *) 0 ;
6986 int arg2 ;
6987 void *argp1 = 0 ;
6988 int res1 = 0 ;
6989 int val2 ;
6990 int ecode2 = 0 ;
6991 PyObject * obj0 = 0 ;
6992 PyObject * obj1 = 0 ;
6993 char * kwnames[] = {
6994 (char *) "self",(char *) "bottom", NULL
6995 };
6996
6997 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
6998 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6999 if (!SWIG_IsOK(res1)) {
7000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottom" "', expected argument " "1"" of type '" "wxRect *""'");
7001 }
7002 arg1 = reinterpret_cast< wxRect * >(argp1);
7003 ecode2 = SWIG_AsVal_int(obj1, &val2);
7004 if (!SWIG_IsOK(ecode2)) {
7005 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetBottom" "', expected argument " "2"" of type '" "int""'");
7006 }
7007 arg2 = static_cast< int >(val2);
7008 {
7009 PyThreadState* __tstate = wxPyBeginAllowThreads();
7010 (arg1)->SetBottom(arg2);
7011 wxPyEndAllowThreads(__tstate);
7012 if (PyErr_Occurred()) SWIG_fail;
7013 }
7014 resultobj = SWIG_Py_Void();
7015 return resultobj;
7016 fail:
7017 return NULL;
7018 }
7019
7020
7021 SWIGINTERN PyObject *_wrap_Rect_Inflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7022 PyObject *resultobj = 0;
7023 wxRect *arg1 = (wxRect *) 0 ;
7024 int arg2 ;
7025 int arg3 ;
7026 wxRect *result = 0 ;
7027 void *argp1 = 0 ;
7028 int res1 = 0 ;
7029 int val2 ;
7030 int ecode2 = 0 ;
7031 int val3 ;
7032 int ecode3 = 0 ;
7033 PyObject * obj0 = 0 ;
7034 PyObject * obj1 = 0 ;
7035 PyObject * obj2 = 0 ;
7036 char * kwnames[] = {
7037 (char *) "self",(char *) "dx",(char *) "dy", NULL
7038 };
7039
7040 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7041 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7042 if (!SWIG_IsOK(res1)) {
7043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inflate" "', expected argument " "1"" of type '" "wxRect *""'");
7044 }
7045 arg1 = reinterpret_cast< wxRect * >(argp1);
7046 ecode2 = SWIG_AsVal_int(obj1, &val2);
7047 if (!SWIG_IsOK(ecode2)) {
7048 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Inflate" "', expected argument " "2"" of type '" "int""'");
7049 }
7050 arg2 = static_cast< int >(val2);
7051 ecode3 = SWIG_AsVal_int(obj2, &val3);
7052 if (!SWIG_IsOK(ecode3)) {
7053 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Inflate" "', expected argument " "3"" of type '" "int""'");
7054 }
7055 arg3 = static_cast< int >(val3);
7056 {
7057 PyThreadState* __tstate = wxPyBeginAllowThreads();
7058 {
7059 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
7060 result = (wxRect *) &_result_ref;
7061 }
7062 wxPyEndAllowThreads(__tstate);
7063 if (PyErr_Occurred()) SWIG_fail;
7064 }
7065 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7066 return resultobj;
7067 fail:
7068 return NULL;
7069 }
7070
7071
7072 SWIGINTERN PyObject *_wrap_Rect_Deflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7073 PyObject *resultobj = 0;
7074 wxRect *arg1 = (wxRect *) 0 ;
7075 int arg2 ;
7076 int arg3 ;
7077 wxRect *result = 0 ;
7078 void *argp1 = 0 ;
7079 int res1 = 0 ;
7080 int val2 ;
7081 int ecode2 = 0 ;
7082 int val3 ;
7083 int ecode3 = 0 ;
7084 PyObject * obj0 = 0 ;
7085 PyObject * obj1 = 0 ;
7086 PyObject * obj2 = 0 ;
7087 char * kwnames[] = {
7088 (char *) "self",(char *) "dx",(char *) "dy", NULL
7089 };
7090
7091 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7092 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7093 if (!SWIG_IsOK(res1)) {
7094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Deflate" "', expected argument " "1"" of type '" "wxRect *""'");
7095 }
7096 arg1 = reinterpret_cast< wxRect * >(argp1);
7097 ecode2 = SWIG_AsVal_int(obj1, &val2);
7098 if (!SWIG_IsOK(ecode2)) {
7099 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Deflate" "', expected argument " "2"" of type '" "int""'");
7100 }
7101 arg2 = static_cast< int >(val2);
7102 ecode3 = SWIG_AsVal_int(obj2, &val3);
7103 if (!SWIG_IsOK(ecode3)) {
7104 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Deflate" "', expected argument " "3"" of type '" "int""'");
7105 }
7106 arg3 = static_cast< int >(val3);
7107 {
7108 PyThreadState* __tstate = wxPyBeginAllowThreads();
7109 {
7110 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
7111 result = (wxRect *) &_result_ref;
7112 }
7113 wxPyEndAllowThreads(__tstate);
7114 if (PyErr_Occurred()) SWIG_fail;
7115 }
7116 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7117 return resultobj;
7118 fail:
7119 return NULL;
7120 }
7121
7122
7123 SWIGINTERN PyObject *_wrap_Rect_OffsetXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7124 PyObject *resultobj = 0;
7125 wxRect *arg1 = (wxRect *) 0 ;
7126 int arg2 ;
7127 int arg3 ;
7128 void *argp1 = 0 ;
7129 int res1 = 0 ;
7130 int val2 ;
7131 int ecode2 = 0 ;
7132 int val3 ;
7133 int ecode3 = 0 ;
7134 PyObject * obj0 = 0 ;
7135 PyObject * obj1 = 0 ;
7136 PyObject * obj2 = 0 ;
7137 char * kwnames[] = {
7138 (char *) "self",(char *) "dx",(char *) "dy", NULL
7139 };
7140
7141 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7142 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7143 if (!SWIG_IsOK(res1)) {
7144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_OffsetXY" "', expected argument " "1"" of type '" "wxRect *""'");
7145 }
7146 arg1 = reinterpret_cast< wxRect * >(argp1);
7147 ecode2 = SWIG_AsVal_int(obj1, &val2);
7148 if (!SWIG_IsOK(ecode2)) {
7149 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_OffsetXY" "', expected argument " "2"" of type '" "int""'");
7150 }
7151 arg2 = static_cast< int >(val2);
7152 ecode3 = SWIG_AsVal_int(obj2, &val3);
7153 if (!SWIG_IsOK(ecode3)) {
7154 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_OffsetXY" "', expected argument " "3"" of type '" "int""'");
7155 }
7156 arg3 = static_cast< int >(val3);
7157 {
7158 PyThreadState* __tstate = wxPyBeginAllowThreads();
7159 (arg1)->Offset(arg2,arg3);
7160 wxPyEndAllowThreads(__tstate);
7161 if (PyErr_Occurred()) SWIG_fail;
7162 }
7163 resultobj = SWIG_Py_Void();
7164 return resultobj;
7165 fail:
7166 return NULL;
7167 }
7168
7169
7170 SWIGINTERN PyObject *_wrap_Rect_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7171 PyObject *resultobj = 0;
7172 wxRect *arg1 = (wxRect *) 0 ;
7173 wxPoint *arg2 = 0 ;
7174 void *argp1 = 0 ;
7175 int res1 = 0 ;
7176 wxPoint temp2 ;
7177 PyObject * obj0 = 0 ;
7178 PyObject * obj1 = 0 ;
7179 char * kwnames[] = {
7180 (char *) "self",(char *) "pt", NULL
7181 };
7182
7183 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
7184 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7185 if (!SWIG_IsOK(res1)) {
7186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Offset" "', expected argument " "1"" of type '" "wxRect *""'");
7187 }
7188 arg1 = reinterpret_cast< wxRect * >(argp1);
7189 {
7190 arg2 = &temp2;
7191 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7192 }
7193 {
7194 PyThreadState* __tstate = wxPyBeginAllowThreads();
7195 (arg1)->Offset((wxPoint const &)*arg2);
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_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7207 PyObject *resultobj = 0;
7208 wxRect *arg1 = (wxRect *) 0 ;
7209 wxRect *arg2 = 0 ;
7210 wxRect result;
7211 void *argp1 = 0 ;
7212 int res1 = 0 ;
7213 wxRect temp2 ;
7214 PyObject * obj0 = 0 ;
7215 PyObject * obj1 = 0 ;
7216 char * kwnames[] = {
7217 (char *) "self",(char *) "rect", NULL
7218 };
7219
7220 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
7221 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7222 if (!SWIG_IsOK(res1)) {
7223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersect" "', expected argument " "1"" of type '" "wxRect *""'");
7224 }
7225 arg1 = reinterpret_cast< wxRect * >(argp1);
7226 {
7227 arg2 = &temp2;
7228 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7229 }
7230 {
7231 PyThreadState* __tstate = wxPyBeginAllowThreads();
7232 result = (arg1)->Intersect((wxRect const &)*arg2);
7233 wxPyEndAllowThreads(__tstate);
7234 if (PyErr_Occurred()) SWIG_fail;
7235 }
7236 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7237 return resultobj;
7238 fail:
7239 return NULL;
7240 }
7241
7242
7243 SWIGINTERN PyObject *_wrap_Rect_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7244 PyObject *resultobj = 0;
7245 wxRect *arg1 = (wxRect *) 0 ;
7246 wxRect *arg2 = 0 ;
7247 wxRect result;
7248 void *argp1 = 0 ;
7249 int res1 = 0 ;
7250 wxRect temp2 ;
7251 PyObject * obj0 = 0 ;
7252 PyObject * obj1 = 0 ;
7253 char * kwnames[] = {
7254 (char *) "self",(char *) "rect", NULL
7255 };
7256
7257 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) SWIG_fail;
7258 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7259 if (!SWIG_IsOK(res1)) {
7260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Union" "', expected argument " "1"" of type '" "wxRect *""'");
7261 }
7262 arg1 = reinterpret_cast< wxRect * >(argp1);
7263 {
7264 arg2 = &temp2;
7265 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7266 }
7267 {
7268 PyThreadState* __tstate = wxPyBeginAllowThreads();
7269 result = (arg1)->Union((wxRect const &)*arg2);
7270 wxPyEndAllowThreads(__tstate);
7271 if (PyErr_Occurred()) SWIG_fail;
7272 }
7273 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7274 return resultobj;
7275 fail:
7276 return NULL;
7277 }
7278
7279
7280 SWIGINTERN PyObject *_wrap_Rect___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7281 PyObject *resultobj = 0;
7282 wxRect *arg1 = (wxRect *) 0 ;
7283 wxRect *arg2 = 0 ;
7284 wxRect result;
7285 void *argp1 = 0 ;
7286 int res1 = 0 ;
7287 wxRect temp2 ;
7288 PyObject * obj0 = 0 ;
7289 PyObject * obj1 = 0 ;
7290 char * kwnames[] = {
7291 (char *) "self",(char *) "rect", NULL
7292 };
7293
7294 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) SWIG_fail;
7295 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7296 if (!SWIG_IsOK(res1)) {
7297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___add__" "', expected argument " "1"" of type '" "wxRect const *""'");
7298 }
7299 arg1 = reinterpret_cast< wxRect * >(argp1);
7300 {
7301 arg2 = &temp2;
7302 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7303 }
7304 {
7305 PyThreadState* __tstate = wxPyBeginAllowThreads();
7306 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
7307 wxPyEndAllowThreads(__tstate);
7308 if (PyErr_Occurred()) SWIG_fail;
7309 }
7310 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7311 return resultobj;
7312 fail:
7313 return NULL;
7314 }
7315
7316
7317 SWIGINTERN PyObject *_wrap_Rect___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7318 PyObject *resultobj = 0;
7319 wxRect *arg1 = (wxRect *) 0 ;
7320 wxRect *arg2 = 0 ;
7321 wxRect *result = 0 ;
7322 void *argp1 = 0 ;
7323 int res1 = 0 ;
7324 wxRect temp2 ;
7325 PyObject * obj0 = 0 ;
7326 PyObject * obj1 = 0 ;
7327 char * kwnames[] = {
7328 (char *) "self",(char *) "rect", NULL
7329 };
7330
7331 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
7332 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
7333 if (!SWIG_IsOK(res1)) {
7334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___iadd__" "', expected argument " "1"" of type '" "wxRect *""'");
7335 }
7336 arg1 = reinterpret_cast< wxRect * >(argp1);
7337 {
7338 arg2 = &temp2;
7339 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7340 }
7341 {
7342 PyThreadState* __tstate = wxPyBeginAllowThreads();
7343 {
7344 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
7345 result = (wxRect *) &_result_ref;
7346 }
7347 wxPyEndAllowThreads(__tstate);
7348 if (PyErr_Occurred()) SWIG_fail;
7349 }
7350 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7351 return resultobj;
7352 fail:
7353 return NULL;
7354 }
7355
7356
7357 SWIGINTERN PyObject *_wrap_Rect___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7358 PyObject *resultobj = 0;
7359 wxRect *arg1 = (wxRect *) 0 ;
7360 PyObject *arg2 = (PyObject *) 0 ;
7361 bool result;
7362 void *argp1 = 0 ;
7363 int res1 = 0 ;
7364 PyObject * obj0 = 0 ;
7365 PyObject * obj1 = 0 ;
7366 char * kwnames[] = {
7367 (char *) "self",(char *) "other", NULL
7368 };
7369
7370 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
7371 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7372 if (!SWIG_IsOK(res1)) {
7373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___eq__" "', expected argument " "1"" of type '" "wxRect *""'");
7374 }
7375 arg1 = reinterpret_cast< wxRect * >(argp1);
7376 arg2 = obj1;
7377 {
7378 result = (bool)wxRect___eq__(arg1,arg2);
7379 if (PyErr_Occurred()) SWIG_fail;
7380 }
7381 {
7382 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7383 }
7384 return resultobj;
7385 fail:
7386 return NULL;
7387 }
7388
7389
7390 SWIGINTERN PyObject *_wrap_Rect___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7391 PyObject *resultobj = 0;
7392 wxRect *arg1 = (wxRect *) 0 ;
7393 PyObject *arg2 = (PyObject *) 0 ;
7394 bool result;
7395 void *argp1 = 0 ;
7396 int res1 = 0 ;
7397 PyObject * obj0 = 0 ;
7398 PyObject * obj1 = 0 ;
7399 char * kwnames[] = {
7400 (char *) "self",(char *) "other", NULL
7401 };
7402
7403 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
7404 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7405 if (!SWIG_IsOK(res1)) {
7406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___ne__" "', expected argument " "1"" of type '" "wxRect *""'");
7407 }
7408 arg1 = reinterpret_cast< wxRect * >(argp1);
7409 arg2 = obj1;
7410 {
7411 result = (bool)wxRect___ne__(arg1,arg2);
7412 if (PyErr_Occurred()) SWIG_fail;
7413 }
7414 {
7415 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7416 }
7417 return resultobj;
7418 fail:
7419 return NULL;
7420 }
7421
7422
7423 SWIGINTERN PyObject *_wrap_Rect_InsideXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7424 PyObject *resultobj = 0;
7425 wxRect *arg1 = (wxRect *) 0 ;
7426 int arg2 ;
7427 int arg3 ;
7428 bool result;
7429 void *argp1 = 0 ;
7430 int res1 = 0 ;
7431 int val2 ;
7432 int ecode2 = 0 ;
7433 int val3 ;
7434 int ecode3 = 0 ;
7435 PyObject * obj0 = 0 ;
7436 PyObject * obj1 = 0 ;
7437 PyObject * obj2 = 0 ;
7438 char * kwnames[] = {
7439 (char *) "self",(char *) "x",(char *) "y", NULL
7440 };
7441
7442 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_InsideXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7443 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7444 if (!SWIG_IsOK(res1)) {
7445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_InsideXY" "', expected argument " "1"" of type '" "wxRect const *""'");
7446 }
7447 arg1 = reinterpret_cast< wxRect * >(argp1);
7448 ecode2 = SWIG_AsVal_int(obj1, &val2);
7449 if (!SWIG_IsOK(ecode2)) {
7450 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_InsideXY" "', expected argument " "2"" of type '" "int""'");
7451 }
7452 arg2 = static_cast< int >(val2);
7453 ecode3 = SWIG_AsVal_int(obj2, &val3);
7454 if (!SWIG_IsOK(ecode3)) {
7455 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_InsideXY" "', expected argument " "3"" of type '" "int""'");
7456 }
7457 arg3 = static_cast< int >(val3);
7458 {
7459 PyThreadState* __tstate = wxPyBeginAllowThreads();
7460 result = (bool)((wxRect const *)arg1)->Inside(arg2,arg3);
7461 wxPyEndAllowThreads(__tstate);
7462 if (PyErr_Occurred()) SWIG_fail;
7463 }
7464 {
7465 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7466 }
7467 return resultobj;
7468 fail:
7469 return NULL;
7470 }
7471
7472
7473 SWIGINTERN PyObject *_wrap_Rect_Inside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7474 PyObject *resultobj = 0;
7475 wxRect *arg1 = (wxRect *) 0 ;
7476 wxPoint *arg2 = 0 ;
7477 bool result;
7478 void *argp1 = 0 ;
7479 int res1 = 0 ;
7480 wxPoint temp2 ;
7481 PyObject * obj0 = 0 ;
7482 PyObject * obj1 = 0 ;
7483 char * kwnames[] = {
7484 (char *) "self",(char *) "pt", NULL
7485 };
7486
7487 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Inside",kwnames,&obj0,&obj1)) SWIG_fail;
7488 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7489 if (!SWIG_IsOK(res1)) {
7490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inside" "', expected argument " "1"" of type '" "wxRect const *""'");
7491 }
7492 arg1 = reinterpret_cast< wxRect * >(argp1);
7493 {
7494 arg2 = &temp2;
7495 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7496 }
7497 {
7498 PyThreadState* __tstate = wxPyBeginAllowThreads();
7499 result = (bool)((wxRect const *)arg1)->Inside((wxPoint const &)*arg2);
7500 wxPyEndAllowThreads(__tstate);
7501 if (PyErr_Occurred()) SWIG_fail;
7502 }
7503 {
7504 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7505 }
7506 return resultobj;
7507 fail:
7508 return NULL;
7509 }
7510
7511
7512 SWIGINTERN PyObject *_wrap_Rect_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7513 PyObject *resultobj = 0;
7514 wxRect *arg1 = (wxRect *) 0 ;
7515 wxRect *arg2 = 0 ;
7516 bool result;
7517 void *argp1 = 0 ;
7518 int res1 = 0 ;
7519 wxRect temp2 ;
7520 PyObject * obj0 = 0 ;
7521 PyObject * obj1 = 0 ;
7522 char * kwnames[] = {
7523 (char *) "self",(char *) "rect", NULL
7524 };
7525
7526 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
7527 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7528 if (!SWIG_IsOK(res1)) {
7529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersects" "', expected argument " "1"" of type '" "wxRect const *""'");
7530 }
7531 arg1 = reinterpret_cast< wxRect * >(argp1);
7532 {
7533 arg2 = &temp2;
7534 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7535 }
7536 {
7537 PyThreadState* __tstate = wxPyBeginAllowThreads();
7538 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
7539 wxPyEndAllowThreads(__tstate);
7540 if (PyErr_Occurred()) SWIG_fail;
7541 }
7542 {
7543 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7544 }
7545 return resultobj;
7546 fail:
7547 return NULL;
7548 }
7549
7550
7551 SWIGINTERN PyObject *_wrap_Rect_CenterIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7552 PyObject *resultobj = 0;
7553 wxRect *arg1 = (wxRect *) 0 ;
7554 wxRect *arg2 = 0 ;
7555 int arg3 = (int) wxBOTH ;
7556 wxRect result;
7557 void *argp1 = 0 ;
7558 int res1 = 0 ;
7559 wxRect temp2 ;
7560 int val3 ;
7561 int ecode3 = 0 ;
7562 PyObject * obj0 = 0 ;
7563 PyObject * obj1 = 0 ;
7564 PyObject * obj2 = 0 ;
7565 char * kwnames[] = {
7566 (char *) "self",(char *) "r",(char *) "dir", NULL
7567 };
7568
7569 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Rect_CenterIn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7570 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7571 if (!SWIG_IsOK(res1)) {
7572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_CenterIn" "', expected argument " "1"" of type '" "wxRect *""'");
7573 }
7574 arg1 = reinterpret_cast< wxRect * >(argp1);
7575 {
7576 arg2 = &temp2;
7577 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7578 }
7579 if (obj2) {
7580 ecode3 = SWIG_AsVal_int(obj2, &val3);
7581 if (!SWIG_IsOK(ecode3)) {
7582 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_CenterIn" "', expected argument " "3"" of type '" "int""'");
7583 }
7584 arg3 = static_cast< int >(val3);
7585 }
7586 {
7587 PyThreadState* __tstate = wxPyBeginAllowThreads();
7588 result = (arg1)->CenterIn((wxRect const &)*arg2,arg3);
7589 wxPyEndAllowThreads(__tstate);
7590 if (PyErr_Occurred()) SWIG_fail;
7591 }
7592 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7593 return resultobj;
7594 fail:
7595 return NULL;
7596 }
7597
7598
7599 SWIGINTERN PyObject *_wrap_Rect_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7600 PyObject *resultobj = 0;
7601 wxRect *arg1 = (wxRect *) 0 ;
7602 int arg2 ;
7603 void *argp1 = 0 ;
7604 int res1 = 0 ;
7605 int val2 ;
7606 int ecode2 = 0 ;
7607 PyObject *swig_obj[2] ;
7608
7609 if (!SWIG_Python_UnpackTuple(args,"Rect_x_set",2,2,swig_obj)) SWIG_fail;
7610 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7611 if (!SWIG_IsOK(res1)) {
7612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_set" "', expected argument " "1"" of type '" "wxRect *""'");
7613 }
7614 arg1 = reinterpret_cast< wxRect * >(argp1);
7615 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7616 if (!SWIG_IsOK(ecode2)) {
7617 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_x_set" "', expected argument " "2"" of type '" "int""'");
7618 }
7619 arg2 = static_cast< int >(val2);
7620 if (arg1) (arg1)->x = arg2;
7621
7622 resultobj = SWIG_Py_Void();
7623 return resultobj;
7624 fail:
7625 return NULL;
7626 }
7627
7628
7629 SWIGINTERN PyObject *_wrap_Rect_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7630 PyObject *resultobj = 0;
7631 wxRect *arg1 = (wxRect *) 0 ;
7632 int result;
7633 void *argp1 = 0 ;
7634 int res1 = 0 ;
7635 PyObject *swig_obj[1] ;
7636
7637 if (!args) SWIG_fail;
7638 swig_obj[0] = args;
7639 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7640 if (!SWIG_IsOK(res1)) {
7641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_get" "', expected argument " "1"" of type '" "wxRect *""'");
7642 }
7643 arg1 = reinterpret_cast< wxRect * >(argp1);
7644 result = (int) ((arg1)->x);
7645 resultobj = SWIG_From_int(static_cast< int >(result));
7646 return resultobj;
7647 fail:
7648 return NULL;
7649 }
7650
7651
7652 SWIGINTERN PyObject *_wrap_Rect_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7653 PyObject *resultobj = 0;
7654 wxRect *arg1 = (wxRect *) 0 ;
7655 int arg2 ;
7656 void *argp1 = 0 ;
7657 int res1 = 0 ;
7658 int val2 ;
7659 int ecode2 = 0 ;
7660 PyObject *swig_obj[2] ;
7661
7662 if (!SWIG_Python_UnpackTuple(args,"Rect_y_set",2,2,swig_obj)) SWIG_fail;
7663 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7664 if (!SWIG_IsOK(res1)) {
7665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_set" "', expected argument " "1"" of type '" "wxRect *""'");
7666 }
7667 arg1 = reinterpret_cast< wxRect * >(argp1);
7668 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7669 if (!SWIG_IsOK(ecode2)) {
7670 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_y_set" "', expected argument " "2"" of type '" "int""'");
7671 }
7672 arg2 = static_cast< int >(val2);
7673 if (arg1) (arg1)->y = arg2;
7674
7675 resultobj = SWIG_Py_Void();
7676 return resultobj;
7677 fail:
7678 return NULL;
7679 }
7680
7681
7682 SWIGINTERN PyObject *_wrap_Rect_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7683 PyObject *resultobj = 0;
7684 wxRect *arg1 = (wxRect *) 0 ;
7685 int result;
7686 void *argp1 = 0 ;
7687 int res1 = 0 ;
7688 PyObject *swig_obj[1] ;
7689
7690 if (!args) SWIG_fail;
7691 swig_obj[0] = args;
7692 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7693 if (!SWIG_IsOK(res1)) {
7694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_get" "', expected argument " "1"" of type '" "wxRect *""'");
7695 }
7696 arg1 = reinterpret_cast< wxRect * >(argp1);
7697 result = (int) ((arg1)->y);
7698 resultobj = SWIG_From_int(static_cast< int >(result));
7699 return resultobj;
7700 fail:
7701 return NULL;
7702 }
7703
7704
7705 SWIGINTERN PyObject *_wrap_Rect_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7706 PyObject *resultobj = 0;
7707 wxRect *arg1 = (wxRect *) 0 ;
7708 int arg2 ;
7709 void *argp1 = 0 ;
7710 int res1 = 0 ;
7711 int val2 ;
7712 int ecode2 = 0 ;
7713 PyObject *swig_obj[2] ;
7714
7715 if (!SWIG_Python_UnpackTuple(args,"Rect_width_set",2,2,swig_obj)) SWIG_fail;
7716 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7717 if (!SWIG_IsOK(res1)) {
7718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_set" "', expected argument " "1"" of type '" "wxRect *""'");
7719 }
7720 arg1 = reinterpret_cast< wxRect * >(argp1);
7721 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7722 if (!SWIG_IsOK(ecode2)) {
7723 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_width_set" "', expected argument " "2"" of type '" "int""'");
7724 }
7725 arg2 = static_cast< int >(val2);
7726 if (arg1) (arg1)->width = arg2;
7727
7728 resultobj = SWIG_Py_Void();
7729 return resultobj;
7730 fail:
7731 return NULL;
7732 }
7733
7734
7735 SWIGINTERN PyObject *_wrap_Rect_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7736 PyObject *resultobj = 0;
7737 wxRect *arg1 = (wxRect *) 0 ;
7738 int result;
7739 void *argp1 = 0 ;
7740 int res1 = 0 ;
7741 PyObject *swig_obj[1] ;
7742
7743 if (!args) SWIG_fail;
7744 swig_obj[0] = args;
7745 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7746 if (!SWIG_IsOK(res1)) {
7747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_get" "', expected argument " "1"" of type '" "wxRect *""'");
7748 }
7749 arg1 = reinterpret_cast< wxRect * >(argp1);
7750 result = (int) ((arg1)->width);
7751 resultobj = SWIG_From_int(static_cast< int >(result));
7752 return resultobj;
7753 fail:
7754 return NULL;
7755 }
7756
7757
7758 SWIGINTERN PyObject *_wrap_Rect_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7759 PyObject *resultobj = 0;
7760 wxRect *arg1 = (wxRect *) 0 ;
7761 int arg2 ;
7762 void *argp1 = 0 ;
7763 int res1 = 0 ;
7764 int val2 ;
7765 int ecode2 = 0 ;
7766 PyObject *swig_obj[2] ;
7767
7768 if (!SWIG_Python_UnpackTuple(args,"Rect_height_set",2,2,swig_obj)) SWIG_fail;
7769 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7770 if (!SWIG_IsOK(res1)) {
7771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_set" "', expected argument " "1"" of type '" "wxRect *""'");
7772 }
7773 arg1 = reinterpret_cast< wxRect * >(argp1);
7774 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7775 if (!SWIG_IsOK(ecode2)) {
7776 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_height_set" "', expected argument " "2"" of type '" "int""'");
7777 }
7778 arg2 = static_cast< int >(val2);
7779 if (arg1) (arg1)->height = arg2;
7780
7781 resultobj = SWIG_Py_Void();
7782 return resultobj;
7783 fail:
7784 return NULL;
7785 }
7786
7787
7788 SWIGINTERN PyObject *_wrap_Rect_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7789 PyObject *resultobj = 0;
7790 wxRect *arg1 = (wxRect *) 0 ;
7791 int result;
7792 void *argp1 = 0 ;
7793 int res1 = 0 ;
7794 PyObject *swig_obj[1] ;
7795
7796 if (!args) SWIG_fail;
7797 swig_obj[0] = args;
7798 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7799 if (!SWIG_IsOK(res1)) {
7800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_get" "', expected argument " "1"" of type '" "wxRect *""'");
7801 }
7802 arg1 = reinterpret_cast< wxRect * >(argp1);
7803 result = (int) ((arg1)->height);
7804 resultobj = SWIG_From_int(static_cast< int >(result));
7805 return resultobj;
7806 fail:
7807 return NULL;
7808 }
7809
7810
7811 SWIGINTERN PyObject *_wrap_Rect_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7812 PyObject *resultobj = 0;
7813 wxRect *arg1 = (wxRect *) 0 ;
7814 int arg2 = (int) 0 ;
7815 int arg3 = (int) 0 ;
7816 int arg4 = (int) 0 ;
7817 int arg5 = (int) 0 ;
7818 void *argp1 = 0 ;
7819 int res1 = 0 ;
7820 int val2 ;
7821 int ecode2 = 0 ;
7822 int val3 ;
7823 int ecode3 = 0 ;
7824 int val4 ;
7825 int ecode4 = 0 ;
7826 int val5 ;
7827 int ecode5 = 0 ;
7828 PyObject * obj0 = 0 ;
7829 PyObject * obj1 = 0 ;
7830 PyObject * obj2 = 0 ;
7831 PyObject * obj3 = 0 ;
7832 PyObject * obj4 = 0 ;
7833 char * kwnames[] = {
7834 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
7835 };
7836
7837 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
7838 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7839 if (!SWIG_IsOK(res1)) {
7840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Set" "', expected argument " "1"" of type '" "wxRect *""'");
7841 }
7842 arg1 = reinterpret_cast< wxRect * >(argp1);
7843 if (obj1) {
7844 ecode2 = SWIG_AsVal_int(obj1, &val2);
7845 if (!SWIG_IsOK(ecode2)) {
7846 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Set" "', expected argument " "2"" of type '" "int""'");
7847 }
7848 arg2 = static_cast< int >(val2);
7849 }
7850 if (obj2) {
7851 ecode3 = SWIG_AsVal_int(obj2, &val3);
7852 if (!SWIG_IsOK(ecode3)) {
7853 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Set" "', expected argument " "3"" of type '" "int""'");
7854 }
7855 arg3 = static_cast< int >(val3);
7856 }
7857 if (obj3) {
7858 ecode4 = SWIG_AsVal_int(obj3, &val4);
7859 if (!SWIG_IsOK(ecode4)) {
7860 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Rect_Set" "', expected argument " "4"" of type '" "int""'");
7861 }
7862 arg4 = static_cast< int >(val4);
7863 }
7864 if (obj4) {
7865 ecode5 = SWIG_AsVal_int(obj4, &val5);
7866 if (!SWIG_IsOK(ecode5)) {
7867 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Rect_Set" "', expected argument " "5"" of type '" "int""'");
7868 }
7869 arg5 = static_cast< int >(val5);
7870 }
7871 {
7872 PyThreadState* __tstate = wxPyBeginAllowThreads();
7873 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
7874 wxPyEndAllowThreads(__tstate);
7875 if (PyErr_Occurred()) SWIG_fail;
7876 }
7877 resultobj = SWIG_Py_Void();
7878 return resultobj;
7879 fail:
7880 return NULL;
7881 }
7882
7883
7884 SWIGINTERN PyObject *_wrap_Rect_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7885 PyObject *resultobj = 0;
7886 wxRect *arg1 = (wxRect *) 0 ;
7887 PyObject *result = 0 ;
7888 void *argp1 = 0 ;
7889 int res1 = 0 ;
7890 PyObject *swig_obj[1] ;
7891
7892 if (!args) SWIG_fail;
7893 swig_obj[0] = args;
7894 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7895 if (!SWIG_IsOK(res1)) {
7896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Get" "', expected argument " "1"" of type '" "wxRect *""'");
7897 }
7898 arg1 = reinterpret_cast< wxRect * >(argp1);
7899 {
7900 PyThreadState* __tstate = wxPyBeginAllowThreads();
7901 result = (PyObject *)wxRect_Get(arg1);
7902 wxPyEndAllowThreads(__tstate);
7903 if (PyErr_Occurred()) SWIG_fail;
7904 }
7905 resultobj = result;
7906 return resultobj;
7907 fail:
7908 return NULL;
7909 }
7910
7911
7912 SWIGINTERN PyObject *Rect_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7913 PyObject *obj;
7914 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7915 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect, SWIG_NewClientData(obj));
7916 return SWIG_Py_Void();
7917 }
7918
7919 SWIGINTERN PyObject *Rect_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7920 return SWIG_Python_InitShadowInstance(args);
7921 }
7922
7923 SWIGINTERN PyObject *_wrap_IntersectRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7924 PyObject *resultobj = 0;
7925 wxRect *arg1 = (wxRect *) 0 ;
7926 wxRect *arg2 = (wxRect *) 0 ;
7927 PyObject *result = 0 ;
7928 void *argp1 = 0 ;
7929 int res1 = 0 ;
7930 void *argp2 = 0 ;
7931 int res2 = 0 ;
7932 PyObject * obj0 = 0 ;
7933 PyObject * obj1 = 0 ;
7934 char * kwnames[] = {
7935 (char *) "r1",(char *) "r2", NULL
7936 };
7937
7938 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) SWIG_fail;
7939 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7940 if (!SWIG_IsOK(res1)) {
7941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntersectRect" "', expected argument " "1"" of type '" "wxRect *""'");
7942 }
7943 arg1 = reinterpret_cast< wxRect * >(argp1);
7944 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
7945 if (!SWIG_IsOK(res2)) {
7946 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntersectRect" "', expected argument " "2"" of type '" "wxRect *""'");
7947 }
7948 arg2 = reinterpret_cast< wxRect * >(argp2);
7949 {
7950 if (!wxPyCheckForApp()) SWIG_fail;
7951 PyThreadState* __tstate = wxPyBeginAllowThreads();
7952 result = (PyObject *)wxIntersectRect(arg1,arg2);
7953 wxPyEndAllowThreads(__tstate);
7954 if (PyErr_Occurred()) SWIG_fail;
7955 }
7956 resultobj = result;
7957 return resultobj;
7958 fail:
7959 return NULL;
7960 }
7961
7962
7963 SWIGINTERN PyObject *_wrap_new_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7964 PyObject *resultobj = 0;
7965 double arg1 = (double) 0.0 ;
7966 double arg2 = (double) 0.0 ;
7967 wxPoint2D *result = 0 ;
7968 double val1 ;
7969 int ecode1 = 0 ;
7970 double val2 ;
7971 int ecode2 = 0 ;
7972 PyObject * obj0 = 0 ;
7973 PyObject * obj1 = 0 ;
7974 char * kwnames[] = {
7975 (char *) "x",(char *) "y", NULL
7976 };
7977
7978 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) SWIG_fail;
7979 if (obj0) {
7980 ecode1 = SWIG_AsVal_double(obj0, &val1);
7981 if (!SWIG_IsOK(ecode1)) {
7982 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point2D" "', expected argument " "1"" of type '" "double""'");
7983 }
7984 arg1 = static_cast< double >(val1);
7985 }
7986 if (obj1) {
7987 ecode2 = SWIG_AsVal_double(obj1, &val2);
7988 if (!SWIG_IsOK(ecode2)) {
7989 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point2D" "', expected argument " "2"" of type '" "double""'");
7990 }
7991 arg2 = static_cast< double >(val2);
7992 }
7993 {
7994 PyThreadState* __tstate = wxPyBeginAllowThreads();
7995 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
7996 wxPyEndAllowThreads(__tstate);
7997 if (PyErr_Occurred()) SWIG_fail;
7998 }
7999 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_NEW | 0 );
8000 return resultobj;
8001 fail:
8002 return NULL;
8003 }
8004
8005
8006 SWIGINTERN PyObject *_wrap_new_Point2DCopy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8007 PyObject *resultobj = 0;
8008 wxPoint2D *arg1 = 0 ;
8009 wxPoint2D *result = 0 ;
8010 wxPoint2D temp1 ;
8011 PyObject * obj0 = 0 ;
8012 char * kwnames[] = {
8013 (char *) "pt", NULL
8014 };
8015
8016 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) SWIG_fail;
8017 {
8018 arg1 = &temp1;
8019 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
8020 }
8021 {
8022 PyThreadState* __tstate = wxPyBeginAllowThreads();
8023 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
8024 wxPyEndAllowThreads(__tstate);
8025 if (PyErr_Occurred()) SWIG_fail;
8026 }
8027 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8028 return resultobj;
8029 fail:
8030 return NULL;
8031 }
8032
8033
8034 SWIGINTERN PyObject *_wrap_new_Point2DFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8035 PyObject *resultobj = 0;
8036 wxPoint *arg1 = 0 ;
8037 wxPoint2D *result = 0 ;
8038 wxPoint temp1 ;
8039 PyObject * obj0 = 0 ;
8040 char * kwnames[] = {
8041 (char *) "pt", NULL
8042 };
8043
8044 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) SWIG_fail;
8045 {
8046 arg1 = &temp1;
8047 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
8048 }
8049 {
8050 PyThreadState* __tstate = wxPyBeginAllowThreads();
8051 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
8052 wxPyEndAllowThreads(__tstate);
8053 if (PyErr_Occurred()) SWIG_fail;
8054 }
8055 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8056 return resultobj;
8057 fail:
8058 return NULL;
8059 }
8060
8061
8062 SWIGINTERN PyObject *_wrap_Point2D_GetFloor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8063 PyObject *resultobj = 0;
8064 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8065 int *arg2 = (int *) 0 ;
8066 int *arg3 = (int *) 0 ;
8067 void *argp1 = 0 ;
8068 int res1 = 0 ;
8069 int temp2 ;
8070 int res2 = SWIG_TMPOBJ ;
8071 int temp3 ;
8072 int res3 = SWIG_TMPOBJ ;
8073 PyObject *swig_obj[1] ;
8074
8075 arg2 = &temp2;
8076 arg3 = &temp3;
8077 if (!args) SWIG_fail;
8078 swig_obj[0] = args;
8079 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8080 if (!SWIG_IsOK(res1)) {
8081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetFloor" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8082 }
8083 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8084 {
8085 PyThreadState* __tstate = wxPyBeginAllowThreads();
8086 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
8087 wxPyEndAllowThreads(__tstate);
8088 if (PyErr_Occurred()) SWIG_fail;
8089 }
8090 resultobj = SWIG_Py_Void();
8091 if (SWIG_IsTmpObj(res2)) {
8092 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8093 } else {
8094 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8095 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8096 }
8097 if (SWIG_IsTmpObj(res3)) {
8098 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8099 } else {
8100 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8101 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8102 }
8103 return resultobj;
8104 fail:
8105 return NULL;
8106 }
8107
8108
8109 SWIGINTERN PyObject *_wrap_Point2D_GetRounded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8110 PyObject *resultobj = 0;
8111 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8112 int *arg2 = (int *) 0 ;
8113 int *arg3 = (int *) 0 ;
8114 void *argp1 = 0 ;
8115 int res1 = 0 ;
8116 int temp2 ;
8117 int res2 = SWIG_TMPOBJ ;
8118 int temp3 ;
8119 int res3 = SWIG_TMPOBJ ;
8120 PyObject *swig_obj[1] ;
8121
8122 arg2 = &temp2;
8123 arg3 = &temp3;
8124 if (!args) SWIG_fail;
8125 swig_obj[0] = args;
8126 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8127 if (!SWIG_IsOK(res1)) {
8128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetRounded" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8129 }
8130 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8131 {
8132 PyThreadState* __tstate = wxPyBeginAllowThreads();
8133 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
8134 wxPyEndAllowThreads(__tstate);
8135 if (PyErr_Occurred()) SWIG_fail;
8136 }
8137 resultobj = SWIG_Py_Void();
8138 if (SWIG_IsTmpObj(res2)) {
8139 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8140 } else {
8141 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8142 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8143 }
8144 if (SWIG_IsTmpObj(res3)) {
8145 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8146 } else {
8147 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8148 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8149 }
8150 return resultobj;
8151 fail:
8152 return NULL;
8153 }
8154
8155
8156 SWIGINTERN PyObject *_wrap_Point2D_GetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8157 PyObject *resultobj = 0;
8158 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8159 double result;
8160 void *argp1 = 0 ;
8161 int res1 = 0 ;
8162 PyObject *swig_obj[1] ;
8163
8164 if (!args) SWIG_fail;
8165 swig_obj[0] = args;
8166 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8167 if (!SWIG_IsOK(res1)) {
8168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8169 }
8170 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8171 {
8172 PyThreadState* __tstate = wxPyBeginAllowThreads();
8173 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
8174 wxPyEndAllowThreads(__tstate);
8175 if (PyErr_Occurred()) SWIG_fail;
8176 }
8177 resultobj = SWIG_From_double(static_cast< double >(result));
8178 return resultobj;
8179 fail:
8180 return NULL;
8181 }
8182
8183
8184 SWIGINTERN PyObject *_wrap_Point2D_GetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8185 PyObject *resultobj = 0;
8186 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8187 double result;
8188 void *argp1 = 0 ;
8189 int res1 = 0 ;
8190 PyObject *swig_obj[1] ;
8191
8192 if (!args) SWIG_fail;
8193 swig_obj[0] = args;
8194 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8195 if (!SWIG_IsOK(res1)) {
8196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8197 }
8198 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8199 {
8200 PyThreadState* __tstate = wxPyBeginAllowThreads();
8201 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
8202 wxPyEndAllowThreads(__tstate);
8203 if (PyErr_Occurred()) SWIG_fail;
8204 }
8205 resultobj = SWIG_From_double(static_cast< double >(result));
8206 return resultobj;
8207 fail:
8208 return NULL;
8209 }
8210
8211
8212 SWIGINTERN PyObject *_wrap_Point2D_SetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8213 PyObject *resultobj = 0;
8214 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8215 double arg2 ;
8216 void *argp1 = 0 ;
8217 int res1 = 0 ;
8218 double val2 ;
8219 int ecode2 = 0 ;
8220 PyObject * obj0 = 0 ;
8221 PyObject * obj1 = 0 ;
8222 char * kwnames[] = {
8223 (char *) "self",(char *) "length", NULL
8224 };
8225
8226 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) SWIG_fail;
8227 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8228 if (!SWIG_IsOK(res1)) {
8229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8230 }
8231 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8232 ecode2 = SWIG_AsVal_double(obj1, &val2);
8233 if (!SWIG_IsOK(ecode2)) {
8234 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorLength" "', expected argument " "2"" of type '" "double""'");
8235 }
8236 arg2 = static_cast< double >(val2);
8237 {
8238 PyThreadState* __tstate = wxPyBeginAllowThreads();
8239 (arg1)->SetVectorLength(arg2);
8240 wxPyEndAllowThreads(__tstate);
8241 if (PyErr_Occurred()) SWIG_fail;
8242 }
8243 resultobj = SWIG_Py_Void();
8244 return resultobj;
8245 fail:
8246 return NULL;
8247 }
8248
8249
8250 SWIGINTERN PyObject *_wrap_Point2D_SetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8251 PyObject *resultobj = 0;
8252 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8253 double arg2 ;
8254 void *argp1 = 0 ;
8255 int res1 = 0 ;
8256 double val2 ;
8257 int ecode2 = 0 ;
8258 PyObject * obj0 = 0 ;
8259 PyObject * obj1 = 0 ;
8260 char * kwnames[] = {
8261 (char *) "self",(char *) "degrees", NULL
8262 };
8263
8264 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) SWIG_fail;
8265 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8266 if (!SWIG_IsOK(res1)) {
8267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8268 }
8269 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8270 ecode2 = SWIG_AsVal_double(obj1, &val2);
8271 if (!SWIG_IsOK(ecode2)) {
8272 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorAngle" "', expected argument " "2"" of type '" "double""'");
8273 }
8274 arg2 = static_cast< double >(val2);
8275 {
8276 PyThreadState* __tstate = wxPyBeginAllowThreads();
8277 (arg1)->SetVectorAngle(arg2);
8278 wxPyEndAllowThreads(__tstate);
8279 if (PyErr_Occurred()) SWIG_fail;
8280 }
8281 resultobj = SWIG_Py_Void();
8282 return resultobj;
8283 fail:
8284 return NULL;
8285 }
8286
8287
8288 SWIGINTERN PyObject *_wrap_Point2D_GetDistance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8289 PyObject *resultobj = 0;
8290 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8291 wxPoint2D *arg2 = 0 ;
8292 double result;
8293 void *argp1 = 0 ;
8294 int res1 = 0 ;
8295 wxPoint2D temp2 ;
8296 PyObject * obj0 = 0 ;
8297 PyObject * obj1 = 0 ;
8298 char * kwnames[] = {
8299 (char *) "self",(char *) "pt", NULL
8300 };
8301
8302 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) SWIG_fail;
8303 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8304 if (!SWIG_IsOK(res1)) {
8305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistance" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8306 }
8307 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8308 {
8309 arg2 = &temp2;
8310 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8311 }
8312 {
8313 PyThreadState* __tstate = wxPyBeginAllowThreads();
8314 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
8315 wxPyEndAllowThreads(__tstate);
8316 if (PyErr_Occurred()) SWIG_fail;
8317 }
8318 resultobj = SWIG_From_double(static_cast< double >(result));
8319 return resultobj;
8320 fail:
8321 return NULL;
8322 }
8323
8324
8325 SWIGINTERN PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8326 PyObject *resultobj = 0;
8327 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8328 wxPoint2D *arg2 = 0 ;
8329 double result;
8330 void *argp1 = 0 ;
8331 int res1 = 0 ;
8332 wxPoint2D temp2 ;
8333 PyObject * obj0 = 0 ;
8334 PyObject * obj1 = 0 ;
8335 char * kwnames[] = {
8336 (char *) "self",(char *) "pt", NULL
8337 };
8338
8339 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) SWIG_fail;
8340 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8341 if (!SWIG_IsOK(res1)) {
8342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistanceSquare" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8343 }
8344 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8345 {
8346 arg2 = &temp2;
8347 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8348 }
8349 {
8350 PyThreadState* __tstate = wxPyBeginAllowThreads();
8351 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
8352 wxPyEndAllowThreads(__tstate);
8353 if (PyErr_Occurred()) SWIG_fail;
8354 }
8355 resultobj = SWIG_From_double(static_cast< double >(result));
8356 return resultobj;
8357 fail:
8358 return NULL;
8359 }
8360
8361
8362 SWIGINTERN PyObject *_wrap_Point2D_GetDotProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8363 PyObject *resultobj = 0;
8364 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8365 wxPoint2D *arg2 = 0 ;
8366 double result;
8367 void *argp1 = 0 ;
8368 int res1 = 0 ;
8369 wxPoint2D temp2 ;
8370 PyObject * obj0 = 0 ;
8371 PyObject * obj1 = 0 ;
8372 char * kwnames[] = {
8373 (char *) "self",(char *) "vec", NULL
8374 };
8375
8376 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8377 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8378 if (!SWIG_IsOK(res1)) {
8379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDotProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8380 }
8381 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8382 {
8383 arg2 = &temp2;
8384 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8385 }
8386 {
8387 PyThreadState* __tstate = wxPyBeginAllowThreads();
8388 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
8389 wxPyEndAllowThreads(__tstate);
8390 if (PyErr_Occurred()) SWIG_fail;
8391 }
8392 resultobj = SWIG_From_double(static_cast< double >(result));
8393 return resultobj;
8394 fail:
8395 return NULL;
8396 }
8397
8398
8399 SWIGINTERN PyObject *_wrap_Point2D_GetCrossProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8400 PyObject *resultobj = 0;
8401 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8402 wxPoint2D *arg2 = 0 ;
8403 double result;
8404 void *argp1 = 0 ;
8405 int res1 = 0 ;
8406 wxPoint2D temp2 ;
8407 PyObject * obj0 = 0 ;
8408 PyObject * obj1 = 0 ;
8409 char * kwnames[] = {
8410 (char *) "self",(char *) "vec", NULL
8411 };
8412
8413 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8414 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8415 if (!SWIG_IsOK(res1)) {
8416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetCrossProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8417 }
8418 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8419 {
8420 arg2 = &temp2;
8421 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8422 }
8423 {
8424 PyThreadState* __tstate = wxPyBeginAllowThreads();
8425 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
8426 wxPyEndAllowThreads(__tstate);
8427 if (PyErr_Occurred()) SWIG_fail;
8428 }
8429 resultobj = SWIG_From_double(static_cast< double >(result));
8430 return resultobj;
8431 fail:
8432 return NULL;
8433 }
8434
8435
8436 SWIGINTERN PyObject *_wrap_Point2D___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8437 PyObject *resultobj = 0;
8438 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8439 wxPoint2D result;
8440 void *argp1 = 0 ;
8441 int res1 = 0 ;
8442 PyObject *swig_obj[1] ;
8443
8444 if (!args) SWIG_fail;
8445 swig_obj[0] = args;
8446 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8447 if (!SWIG_IsOK(res1)) {
8448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___neg__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8449 }
8450 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8451 {
8452 PyThreadState* __tstate = wxPyBeginAllowThreads();
8453 result = (arg1)->operator -();
8454 wxPyEndAllowThreads(__tstate);
8455 if (PyErr_Occurred()) SWIG_fail;
8456 }
8457 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8458 return resultobj;
8459 fail:
8460 return NULL;
8461 }
8462
8463
8464 SWIGINTERN PyObject *_wrap_Point2D___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8465 PyObject *resultobj = 0;
8466 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8467 wxPoint2D *arg2 = 0 ;
8468 wxPoint2D *result = 0 ;
8469 void *argp1 = 0 ;
8470 int res1 = 0 ;
8471 wxPoint2D temp2 ;
8472 PyObject * obj0 = 0 ;
8473 PyObject * obj1 = 0 ;
8474 char * kwnames[] = {
8475 (char *) "self",(char *) "pt", NULL
8476 };
8477
8478 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
8479 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8480 if (!SWIG_IsOK(res1)) {
8481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___iadd__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8482 }
8483 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8484 {
8485 arg2 = &temp2;
8486 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8487 }
8488 {
8489 PyThreadState* __tstate = wxPyBeginAllowThreads();
8490 {
8491 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
8492 result = (wxPoint2D *) &_result_ref;
8493 }
8494 wxPyEndAllowThreads(__tstate);
8495 if (PyErr_Occurred()) SWIG_fail;
8496 }
8497 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8498 return resultobj;
8499 fail:
8500 return NULL;
8501 }
8502
8503
8504 SWIGINTERN PyObject *_wrap_Point2D___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8505 PyObject *resultobj = 0;
8506 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8507 wxPoint2D *arg2 = 0 ;
8508 wxPoint2D *result = 0 ;
8509 void *argp1 = 0 ;
8510 int res1 = 0 ;
8511 wxPoint2D temp2 ;
8512 PyObject * obj0 = 0 ;
8513 PyObject * obj1 = 0 ;
8514 char * kwnames[] = {
8515 (char *) "self",(char *) "pt", NULL
8516 };
8517
8518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
8519 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8520 if (!SWIG_IsOK(res1)) {
8521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___isub__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8522 }
8523 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8524 {
8525 arg2 = &temp2;
8526 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8527 }
8528 {
8529 PyThreadState* __tstate = wxPyBeginAllowThreads();
8530 {
8531 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
8532 result = (wxPoint2D *) &_result_ref;
8533 }
8534 wxPyEndAllowThreads(__tstate);
8535 if (PyErr_Occurred()) SWIG_fail;
8536 }
8537 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8538 return resultobj;
8539 fail:
8540 return NULL;
8541 }
8542
8543
8544 SWIGINTERN PyObject *_wrap_Point2D___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8545 PyObject *resultobj = 0;
8546 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8547 wxPoint2D *arg2 = 0 ;
8548 wxPoint2D *result = 0 ;
8549 void *argp1 = 0 ;
8550 int res1 = 0 ;
8551 wxPoint2D temp2 ;
8552 PyObject * obj0 = 0 ;
8553 PyObject * obj1 = 0 ;
8554 char * kwnames[] = {
8555 (char *) "self",(char *) "pt", NULL
8556 };
8557
8558 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
8559 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8560 if (!SWIG_IsOK(res1)) {
8561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___imul__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8562 }
8563 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8564 {
8565 arg2 = &temp2;
8566 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8567 }
8568 {
8569 PyThreadState* __tstate = wxPyBeginAllowThreads();
8570 {
8571 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
8572 result = (wxPoint2D *) &_result_ref;
8573 }
8574 wxPyEndAllowThreads(__tstate);
8575 if (PyErr_Occurred()) SWIG_fail;
8576 }
8577 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8578 return resultobj;
8579 fail:
8580 return NULL;
8581 }
8582
8583
8584 SWIGINTERN PyObject *_wrap_Point2D___idiv__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8585 PyObject *resultobj = 0;
8586 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8587 wxPoint2D *arg2 = 0 ;
8588 wxPoint2D *result = 0 ;
8589 void *argp1 = 0 ;
8590 int res1 = 0 ;
8591 wxPoint2D temp2 ;
8592 PyObject * obj0 = 0 ;
8593 PyObject * obj1 = 0 ;
8594 char * kwnames[] = {
8595 (char *) "self",(char *) "pt", NULL
8596 };
8597
8598 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) SWIG_fail;
8599 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8600 if (!SWIG_IsOK(res1)) {
8601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___idiv__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8602 }
8603 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8604 {
8605 arg2 = &temp2;
8606 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8607 }
8608 {
8609 PyThreadState* __tstate = wxPyBeginAllowThreads();
8610 {
8611 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
8612 result = (wxPoint2D *) &_result_ref;
8613 }
8614 wxPyEndAllowThreads(__tstate);
8615 if (PyErr_Occurred()) SWIG_fail;
8616 }
8617 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8618 return resultobj;
8619 fail:
8620 return NULL;
8621 }
8622
8623
8624 SWIGINTERN PyObject *_wrap_Point2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8625 PyObject *resultobj = 0;
8626 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8627 PyObject *arg2 = (PyObject *) 0 ;
8628 bool result;
8629 void *argp1 = 0 ;
8630 int res1 = 0 ;
8631 PyObject * obj0 = 0 ;
8632 PyObject * obj1 = 0 ;
8633 char * kwnames[] = {
8634 (char *) "self",(char *) "other", NULL
8635 };
8636
8637 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
8638 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8639 if (!SWIG_IsOK(res1)) {
8640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___eq__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8641 }
8642 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8643 arg2 = obj1;
8644 {
8645 result = (bool)wxPoint2D___eq__(arg1,arg2);
8646 if (PyErr_Occurred()) SWIG_fail;
8647 }
8648 {
8649 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8650 }
8651 return resultobj;
8652 fail:
8653 return NULL;
8654 }
8655
8656
8657 SWIGINTERN PyObject *_wrap_Point2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8658 PyObject *resultobj = 0;
8659 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8660 PyObject *arg2 = (PyObject *) 0 ;
8661 bool result;
8662 void *argp1 = 0 ;
8663 int res1 = 0 ;
8664 PyObject * obj0 = 0 ;
8665 PyObject * obj1 = 0 ;
8666 char * kwnames[] = {
8667 (char *) "self",(char *) "other", NULL
8668 };
8669
8670 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
8671 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8672 if (!SWIG_IsOK(res1)) {
8673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___ne__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8674 }
8675 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8676 arg2 = obj1;
8677 {
8678 result = (bool)wxPoint2D___ne__(arg1,arg2);
8679 if (PyErr_Occurred()) SWIG_fail;
8680 }
8681 {
8682 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8683 }
8684 return resultobj;
8685 fail:
8686 return NULL;
8687 }
8688
8689
8690 SWIGINTERN PyObject *_wrap_Point2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8691 PyObject *resultobj = 0;
8692 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8693 double arg2 ;
8694 void *argp1 = 0 ;
8695 int res1 = 0 ;
8696 double val2 ;
8697 int ecode2 = 0 ;
8698 PyObject *swig_obj[2] ;
8699
8700 if (!SWIG_Python_UnpackTuple(args,"Point2D_x_set",2,2,swig_obj)) SWIG_fail;
8701 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8702 if (!SWIG_IsOK(res1)) {
8703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8704 }
8705 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8706 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8707 if (!SWIG_IsOK(ecode2)) {
8708 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_x_set" "', expected argument " "2"" of type '" "double""'");
8709 }
8710 arg2 = static_cast< double >(val2);
8711 if (arg1) (arg1)->m_x = arg2;
8712
8713 resultobj = SWIG_Py_Void();
8714 return resultobj;
8715 fail:
8716 return NULL;
8717 }
8718
8719
8720 SWIGINTERN PyObject *_wrap_Point2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8721 PyObject *resultobj = 0;
8722 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8723 double result;
8724 void *argp1 = 0 ;
8725 int res1 = 0 ;
8726 PyObject *swig_obj[1] ;
8727
8728 if (!args) SWIG_fail;
8729 swig_obj[0] = args;
8730 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8731 if (!SWIG_IsOK(res1)) {
8732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8733 }
8734 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8735 result = (double) ((arg1)->m_x);
8736 resultobj = SWIG_From_double(static_cast< double >(result));
8737 return resultobj;
8738 fail:
8739 return NULL;
8740 }
8741
8742
8743 SWIGINTERN PyObject *_wrap_Point2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8744 PyObject *resultobj = 0;
8745 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8746 double arg2 ;
8747 void *argp1 = 0 ;
8748 int res1 = 0 ;
8749 double val2 ;
8750 int ecode2 = 0 ;
8751 PyObject *swig_obj[2] ;
8752
8753 if (!SWIG_Python_UnpackTuple(args,"Point2D_y_set",2,2,swig_obj)) SWIG_fail;
8754 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8755 if (!SWIG_IsOK(res1)) {
8756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8757 }
8758 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8759 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8760 if (!SWIG_IsOK(ecode2)) {
8761 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_y_set" "', expected argument " "2"" of type '" "double""'");
8762 }
8763 arg2 = static_cast< double >(val2);
8764 if (arg1) (arg1)->m_y = arg2;
8765
8766 resultobj = SWIG_Py_Void();
8767 return resultobj;
8768 fail:
8769 return NULL;
8770 }
8771
8772
8773 SWIGINTERN PyObject *_wrap_Point2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8774 PyObject *resultobj = 0;
8775 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8776 double result;
8777 void *argp1 = 0 ;
8778 int res1 = 0 ;
8779 PyObject *swig_obj[1] ;
8780
8781 if (!args) SWIG_fail;
8782 swig_obj[0] = args;
8783 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8784 if (!SWIG_IsOK(res1)) {
8785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8786 }
8787 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8788 result = (double) ((arg1)->m_y);
8789 resultobj = SWIG_From_double(static_cast< double >(result));
8790 return resultobj;
8791 fail:
8792 return NULL;
8793 }
8794
8795
8796 SWIGINTERN PyObject *_wrap_Point2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8797 PyObject *resultobj = 0;
8798 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8799 double arg2 = (double) 0 ;
8800 double arg3 = (double) 0 ;
8801 void *argp1 = 0 ;
8802 int res1 = 0 ;
8803 double val2 ;
8804 int ecode2 = 0 ;
8805 double val3 ;
8806 int ecode3 = 0 ;
8807 PyObject * obj0 = 0 ;
8808 PyObject * obj1 = 0 ;
8809 PyObject * obj2 = 0 ;
8810 char * kwnames[] = {
8811 (char *) "self",(char *) "x",(char *) "y", NULL
8812 };
8813
8814 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8815 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8816 if (!SWIG_IsOK(res1)) {
8817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8818 }
8819 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8820 if (obj1) {
8821 ecode2 = SWIG_AsVal_double(obj1, &val2);
8822 if (!SWIG_IsOK(ecode2)) {
8823 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_Set" "', expected argument " "2"" of type '" "double""'");
8824 }
8825 arg2 = static_cast< double >(val2);
8826 }
8827 if (obj2) {
8828 ecode3 = SWIG_AsVal_double(obj2, &val3);
8829 if (!SWIG_IsOK(ecode3)) {
8830 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point2D_Set" "', expected argument " "3"" of type '" "double""'");
8831 }
8832 arg3 = static_cast< double >(val3);
8833 }
8834 {
8835 PyThreadState* __tstate = wxPyBeginAllowThreads();
8836 wxPoint2D_Set(arg1,arg2,arg3);
8837 wxPyEndAllowThreads(__tstate);
8838 if (PyErr_Occurred()) SWIG_fail;
8839 }
8840 resultobj = SWIG_Py_Void();
8841 return resultobj;
8842 fail:
8843 return NULL;
8844 }
8845
8846
8847 SWIGINTERN PyObject *_wrap_Point2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8848 PyObject *resultobj = 0;
8849 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8850 PyObject *result = 0 ;
8851 void *argp1 = 0 ;
8852 int res1 = 0 ;
8853 PyObject *swig_obj[1] ;
8854
8855 if (!args) SWIG_fail;
8856 swig_obj[0] = args;
8857 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8858 if (!SWIG_IsOK(res1)) {
8859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8860 }
8861 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8862 {
8863 PyThreadState* __tstate = wxPyBeginAllowThreads();
8864 result = (PyObject *)wxPoint2D_Get(arg1);
8865 wxPyEndAllowThreads(__tstate);
8866 if (PyErr_Occurred()) SWIG_fail;
8867 }
8868 resultobj = result;
8869 return resultobj;
8870 fail:
8871 return NULL;
8872 }
8873
8874
8875 SWIGINTERN PyObject *Point2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8876 PyObject *obj;
8877 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8878 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint2D, SWIG_NewClientData(obj));
8879 return SWIG_Py_Void();
8880 }
8881
8882 SWIGINTERN PyObject *Point2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8883 return SWIG_Python_InitShadowInstance(args);
8884 }
8885
8886 SWIGINTERN int DefaultPosition_set(PyObject *) {
8887 SWIG_Error(SWIG_AttributeError,"Variable DefaultPosition is read-only.");
8888 return 1;
8889 }
8890
8891
8892 SWIGINTERN PyObject *DefaultPosition_get(void) {
8893 PyObject *pyobj = 0;
8894
8895 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0 );
8896 return pyobj;
8897 }
8898
8899
8900 SWIGINTERN int DefaultSize_set(PyObject *) {
8901 SWIG_Error(SWIG_AttributeError,"Variable DefaultSize is read-only.");
8902 return 1;
8903 }
8904
8905
8906 SWIGINTERN PyObject *DefaultSize_get(void) {
8907 PyObject *pyobj = 0;
8908
8909 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSize), SWIGTYPE_p_wxSize, 0 );
8910 return pyobj;
8911 }
8912
8913
8914 SWIGINTERN PyObject *_wrap_new_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8915 PyObject *resultobj = 0;
8916 PyObject *arg1 = (PyObject *) 0 ;
8917 wxPyInputStream *result = 0 ;
8918 PyObject * obj0 = 0 ;
8919 char * kwnames[] = {
8920 (char *) "p", NULL
8921 };
8922
8923 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) SWIG_fail;
8924 arg1 = obj0;
8925 {
8926 PyThreadState* __tstate = wxPyBeginAllowThreads();
8927 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
8928 wxPyEndAllowThreads(__tstate);
8929 if (PyErr_Occurred()) SWIG_fail;
8930 }
8931 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_NEW | 0 );
8932 return resultobj;
8933 fail:
8934 return NULL;
8935 }
8936
8937
8938 SWIGINTERN PyObject *_wrap_delete_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8939 PyObject *resultobj = 0;
8940 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8941 void *argp1 = 0 ;
8942 int res1 = 0 ;
8943 PyObject *swig_obj[1] ;
8944
8945 if (!args) SWIG_fail;
8946 swig_obj[0] = args;
8947 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_DISOWN | 0 );
8948 if (!SWIG_IsOK(res1)) {
8949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InputStream" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
8950 }
8951 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
8952 {
8953 PyThreadState* __tstate = wxPyBeginAllowThreads();
8954 delete arg1;
8955
8956 wxPyEndAllowThreads(__tstate);
8957 if (PyErr_Occurred()) SWIG_fail;
8958 }
8959 resultobj = SWIG_Py_Void();
8960 return resultobj;
8961 fail:
8962 return NULL;
8963 }
8964
8965
8966 SWIGINTERN PyObject *_wrap_InputStream_close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8967 PyObject *resultobj = 0;
8968 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8969 void *argp1 = 0 ;
8970 int res1 = 0 ;
8971 PyObject *swig_obj[1] ;
8972
8973 if (!args) SWIG_fail;
8974 swig_obj[0] = args;
8975 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
8976 if (!SWIG_IsOK(res1)) {
8977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_close" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
8978 }
8979 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
8980 {
8981 PyThreadState* __tstate = wxPyBeginAllowThreads();
8982 (arg1)->close();
8983 wxPyEndAllowThreads(__tstate);
8984 if (PyErr_Occurred()) SWIG_fail;
8985 }
8986 resultobj = SWIG_Py_Void();
8987 return resultobj;
8988 fail:
8989 return NULL;
8990 }
8991
8992
8993 SWIGINTERN PyObject *_wrap_InputStream_flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8994 PyObject *resultobj = 0;
8995 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8996 void *argp1 = 0 ;
8997 int res1 = 0 ;
8998 PyObject *swig_obj[1] ;
8999
9000 if (!args) SWIG_fail;
9001 swig_obj[0] = args;
9002 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9003 if (!SWIG_IsOK(res1)) {
9004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_flush" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9005 }
9006 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9007 {
9008 PyThreadState* __tstate = wxPyBeginAllowThreads();
9009 (arg1)->flush();
9010 wxPyEndAllowThreads(__tstate);
9011 if (PyErr_Occurred()) SWIG_fail;
9012 }
9013 resultobj = SWIG_Py_Void();
9014 return resultobj;
9015 fail:
9016 return NULL;
9017 }
9018
9019
9020 SWIGINTERN PyObject *_wrap_InputStream_eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9021 PyObject *resultobj = 0;
9022 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9023 bool result;
9024 void *argp1 = 0 ;
9025 int res1 = 0 ;
9026 PyObject *swig_obj[1] ;
9027
9028 if (!args) SWIG_fail;
9029 swig_obj[0] = args;
9030 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9031 if (!SWIG_IsOK(res1)) {
9032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9033 }
9034 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9035 {
9036 PyThreadState* __tstate = wxPyBeginAllowThreads();
9037 result = (bool)(arg1)->eof();
9038 wxPyEndAllowThreads(__tstate);
9039 if (PyErr_Occurred()) SWIG_fail;
9040 }
9041 {
9042 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9043 }
9044 return resultobj;
9045 fail:
9046 return NULL;
9047 }
9048
9049
9050 SWIGINTERN PyObject *_wrap_InputStream_read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9051 PyObject *resultobj = 0;
9052 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9053 int arg2 = (int) -1 ;
9054 PyObject *result = 0 ;
9055 void *argp1 = 0 ;
9056 int res1 = 0 ;
9057 int val2 ;
9058 int ecode2 = 0 ;
9059 PyObject * obj0 = 0 ;
9060 PyObject * obj1 = 0 ;
9061 char * kwnames[] = {
9062 (char *) "self",(char *) "size", NULL
9063 };
9064
9065 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) SWIG_fail;
9066 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9067 if (!SWIG_IsOK(res1)) {
9068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_read" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9069 }
9070 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9071 if (obj1) {
9072 ecode2 = SWIG_AsVal_int(obj1, &val2);
9073 if (!SWIG_IsOK(ecode2)) {
9074 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_read" "', expected argument " "2"" of type '" "int""'");
9075 }
9076 arg2 = static_cast< int >(val2);
9077 }
9078 {
9079 PyThreadState* __tstate = wxPyBeginAllowThreads();
9080 result = (PyObject *)(arg1)->read(arg2);
9081 wxPyEndAllowThreads(__tstate);
9082 if (PyErr_Occurred()) SWIG_fail;
9083 }
9084 resultobj = result;
9085 return resultobj;
9086 fail:
9087 return NULL;
9088 }
9089
9090
9091 SWIGINTERN PyObject *_wrap_InputStream_readline(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9092 PyObject *resultobj = 0;
9093 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9094 int arg2 = (int) -1 ;
9095 PyObject *result = 0 ;
9096 void *argp1 = 0 ;
9097 int res1 = 0 ;
9098 int val2 ;
9099 int ecode2 = 0 ;
9100 PyObject * obj0 = 0 ;
9101 PyObject * obj1 = 0 ;
9102 char * kwnames[] = {
9103 (char *) "self",(char *) "size", NULL
9104 };
9105
9106 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) SWIG_fail;
9107 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9108 if (!SWIG_IsOK(res1)) {
9109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readline" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9110 }
9111 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9112 if (obj1) {
9113 ecode2 = SWIG_AsVal_int(obj1, &val2);
9114 if (!SWIG_IsOK(ecode2)) {
9115 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readline" "', expected argument " "2"" of type '" "int""'");
9116 }
9117 arg2 = static_cast< int >(val2);
9118 }
9119 {
9120 PyThreadState* __tstate = wxPyBeginAllowThreads();
9121 result = (PyObject *)(arg1)->readline(arg2);
9122 wxPyEndAllowThreads(__tstate);
9123 if (PyErr_Occurred()) SWIG_fail;
9124 }
9125 resultobj = result;
9126 return resultobj;
9127 fail:
9128 return NULL;
9129 }
9130
9131
9132 SWIGINTERN PyObject *_wrap_InputStream_readlines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9133 PyObject *resultobj = 0;
9134 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9135 int arg2 = (int) -1 ;
9136 PyObject *result = 0 ;
9137 void *argp1 = 0 ;
9138 int res1 = 0 ;
9139 int val2 ;
9140 int ecode2 = 0 ;
9141 PyObject * obj0 = 0 ;
9142 PyObject * obj1 = 0 ;
9143 char * kwnames[] = {
9144 (char *) "self",(char *) "sizehint", NULL
9145 };
9146
9147 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) SWIG_fail;
9148 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9149 if (!SWIG_IsOK(res1)) {
9150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readlines" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9151 }
9152 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9153 if (obj1) {
9154 ecode2 = SWIG_AsVal_int(obj1, &val2);
9155 if (!SWIG_IsOK(ecode2)) {
9156 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readlines" "', expected argument " "2"" of type '" "int""'");
9157 }
9158 arg2 = static_cast< int >(val2);
9159 }
9160 {
9161 PyThreadState* __tstate = wxPyBeginAllowThreads();
9162 result = (PyObject *)(arg1)->readlines(arg2);
9163 wxPyEndAllowThreads(__tstate);
9164 if (PyErr_Occurred()) SWIG_fail;
9165 }
9166 resultobj = result;
9167 return resultobj;
9168 fail:
9169 return NULL;
9170 }
9171
9172
9173 SWIGINTERN PyObject *_wrap_InputStream_seek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9174 PyObject *resultobj = 0;
9175 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9176 int arg2 ;
9177 int arg3 = (int) 0 ;
9178 void *argp1 = 0 ;
9179 int res1 = 0 ;
9180 int val2 ;
9181 int ecode2 = 0 ;
9182 int val3 ;
9183 int ecode3 = 0 ;
9184 PyObject * obj0 = 0 ;
9185 PyObject * obj1 = 0 ;
9186 PyObject * obj2 = 0 ;
9187 char * kwnames[] = {
9188 (char *) "self",(char *) "offset",(char *) "whence", NULL
9189 };
9190
9191 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9192 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9193 if (!SWIG_IsOK(res1)) {
9194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_seek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9195 }
9196 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9197 ecode2 = SWIG_AsVal_int(obj1, &val2);
9198 if (!SWIG_IsOK(ecode2)) {
9199 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_seek" "', expected argument " "2"" of type '" "int""'");
9200 }
9201 arg2 = static_cast< int >(val2);
9202 if (obj2) {
9203 ecode3 = SWIG_AsVal_int(obj2, &val3);
9204 if (!SWIG_IsOK(ecode3)) {
9205 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_seek" "', expected argument " "3"" of type '" "int""'");
9206 }
9207 arg3 = static_cast< int >(val3);
9208 }
9209 {
9210 PyThreadState* __tstate = wxPyBeginAllowThreads();
9211 (arg1)->seek(arg2,arg3);
9212 wxPyEndAllowThreads(__tstate);
9213 if (PyErr_Occurred()) SWIG_fail;
9214 }
9215 resultobj = SWIG_Py_Void();
9216 return resultobj;
9217 fail:
9218 return NULL;
9219 }
9220
9221
9222 SWIGINTERN PyObject *_wrap_InputStream_tell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9223 PyObject *resultobj = 0;
9224 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9225 int result;
9226 void *argp1 = 0 ;
9227 int res1 = 0 ;
9228 PyObject *swig_obj[1] ;
9229
9230 if (!args) SWIG_fail;
9231 swig_obj[0] = args;
9232 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9233 if (!SWIG_IsOK(res1)) {
9234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_tell" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9235 }
9236 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9237 {
9238 PyThreadState* __tstate = wxPyBeginAllowThreads();
9239 result = (int)(arg1)->tell();
9240 wxPyEndAllowThreads(__tstate);
9241 if (PyErr_Occurred()) SWIG_fail;
9242 }
9243 resultobj = SWIG_From_int(static_cast< int >(result));
9244 return resultobj;
9245 fail:
9246 return NULL;
9247 }
9248
9249
9250 SWIGINTERN PyObject *_wrap_InputStream_Peek(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9251 PyObject *resultobj = 0;
9252 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9253 char result;
9254 void *argp1 = 0 ;
9255 int res1 = 0 ;
9256 PyObject *swig_obj[1] ;
9257
9258 if (!args) SWIG_fail;
9259 swig_obj[0] = args;
9260 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9261 if (!SWIG_IsOK(res1)) {
9262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Peek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9263 }
9264 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9265 {
9266 PyThreadState* __tstate = wxPyBeginAllowThreads();
9267 result = (char)(arg1)->Peek();
9268 wxPyEndAllowThreads(__tstate);
9269 if (PyErr_Occurred()) SWIG_fail;
9270 }
9271 resultobj = SWIG_From_char(static_cast< char >(result));
9272 return resultobj;
9273 fail:
9274 return NULL;
9275 }
9276
9277
9278 SWIGINTERN PyObject *_wrap_InputStream_GetC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9279 PyObject *resultobj = 0;
9280 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9281 char result;
9282 void *argp1 = 0 ;
9283 int res1 = 0 ;
9284 PyObject *swig_obj[1] ;
9285
9286 if (!args) SWIG_fail;
9287 swig_obj[0] = args;
9288 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9289 if (!SWIG_IsOK(res1)) {
9290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_GetC" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9291 }
9292 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9293 {
9294 PyThreadState* __tstate = wxPyBeginAllowThreads();
9295 result = (char)(arg1)->GetC();
9296 wxPyEndAllowThreads(__tstate);
9297 if (PyErr_Occurred()) SWIG_fail;
9298 }
9299 resultobj = SWIG_From_char(static_cast< char >(result));
9300 return resultobj;
9301 fail:
9302 return NULL;
9303 }
9304
9305
9306 SWIGINTERN PyObject *_wrap_InputStream_LastRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9307 PyObject *resultobj = 0;
9308 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9309 size_t result;
9310 void *argp1 = 0 ;
9311 int res1 = 0 ;
9312 PyObject *swig_obj[1] ;
9313
9314 if (!args) SWIG_fail;
9315 swig_obj[0] = args;
9316 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9317 if (!SWIG_IsOK(res1)) {
9318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_LastRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9319 }
9320 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9321 {
9322 PyThreadState* __tstate = wxPyBeginAllowThreads();
9323 result = (size_t)(arg1)->LastRead();
9324 wxPyEndAllowThreads(__tstate);
9325 if (PyErr_Occurred()) SWIG_fail;
9326 }
9327 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9328 return resultobj;
9329 fail:
9330 return NULL;
9331 }
9332
9333
9334 SWIGINTERN PyObject *_wrap_InputStream_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9335 PyObject *resultobj = 0;
9336 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9337 bool result;
9338 void *argp1 = 0 ;
9339 int res1 = 0 ;
9340 PyObject *swig_obj[1] ;
9341
9342 if (!args) SWIG_fail;
9343 swig_obj[0] = args;
9344 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9345 if (!SWIG_IsOK(res1)) {
9346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_CanRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9347 }
9348 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9349 {
9350 PyThreadState* __tstate = wxPyBeginAllowThreads();
9351 result = (bool)(arg1)->CanRead();
9352 wxPyEndAllowThreads(__tstate);
9353 if (PyErr_Occurred()) SWIG_fail;
9354 }
9355 {
9356 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9357 }
9358 return resultobj;
9359 fail:
9360 return NULL;
9361 }
9362
9363
9364 SWIGINTERN PyObject *_wrap_InputStream_Eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9365 PyObject *resultobj = 0;
9366 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9367 bool result;
9368 void *argp1 = 0 ;
9369 int res1 = 0 ;
9370 PyObject *swig_obj[1] ;
9371
9372 if (!args) SWIG_fail;
9373 swig_obj[0] = args;
9374 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9375 if (!SWIG_IsOK(res1)) {
9376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9377 }
9378 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9379 {
9380 PyThreadState* __tstate = wxPyBeginAllowThreads();
9381 result = (bool)(arg1)->Eof();
9382 wxPyEndAllowThreads(__tstate);
9383 if (PyErr_Occurred()) SWIG_fail;
9384 }
9385 {
9386 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9387 }
9388 return resultobj;
9389 fail:
9390 return NULL;
9391 }
9392
9393
9394 SWIGINTERN PyObject *_wrap_InputStream_Ungetch(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9395 PyObject *resultobj = 0;
9396 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9397 char arg2 ;
9398 bool result;
9399 void *argp1 = 0 ;
9400 int res1 = 0 ;
9401 char val2 ;
9402 int ecode2 = 0 ;
9403 PyObject * obj0 = 0 ;
9404 PyObject * obj1 = 0 ;
9405 char * kwnames[] = {
9406 (char *) "self",(char *) "c", NULL
9407 };
9408
9409 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) SWIG_fail;
9410 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9411 if (!SWIG_IsOK(res1)) {
9412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Ungetch" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9413 }
9414 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9415 ecode2 = SWIG_AsVal_char(obj1, &val2);
9416 if (!SWIG_IsOK(ecode2)) {
9417 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_Ungetch" "', expected argument " "2"" of type '" "char""'");
9418 }
9419 arg2 = static_cast< char >(val2);
9420 {
9421 PyThreadState* __tstate = wxPyBeginAllowThreads();
9422 result = (bool)(arg1)->Ungetch(arg2);
9423 wxPyEndAllowThreads(__tstate);
9424 if (PyErr_Occurred()) SWIG_fail;
9425 }
9426 {
9427 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9428 }
9429 return resultobj;
9430 fail:
9431 return NULL;
9432 }
9433
9434
9435 SWIGINTERN PyObject *_wrap_InputStream_SeekI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9436 PyObject *resultobj = 0;
9437 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9438 long arg2 ;
9439 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
9440 long result;
9441 void *argp1 = 0 ;
9442 int res1 = 0 ;
9443 long val2 ;
9444 int ecode2 = 0 ;
9445 int val3 ;
9446 int ecode3 = 0 ;
9447 PyObject * obj0 = 0 ;
9448 PyObject * obj1 = 0 ;
9449 PyObject * obj2 = 0 ;
9450 char * kwnames[] = {
9451 (char *) "self",(char *) "pos",(char *) "mode", NULL
9452 };
9453
9454 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9455 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9456 if (!SWIG_IsOK(res1)) {
9457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_SeekI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9458 }
9459 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9460 ecode2 = SWIG_AsVal_long(obj1, &val2);
9461 if (!SWIG_IsOK(ecode2)) {
9462 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_SeekI" "', expected argument " "2"" of type '" "long""'");
9463 }
9464 arg2 = static_cast< long >(val2);
9465 if (obj2) {
9466 ecode3 = SWIG_AsVal_int(obj2, &val3);
9467 if (!SWIG_IsOK(ecode3)) {
9468 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_SeekI" "', expected argument " "3"" of type '" "wxSeekMode""'");
9469 }
9470 arg3 = static_cast< wxSeekMode >(val3);
9471 }
9472 {
9473 PyThreadState* __tstate = wxPyBeginAllowThreads();
9474 result = (long)(arg1)->SeekI(arg2,arg3);
9475 wxPyEndAllowThreads(__tstate);
9476 if (PyErr_Occurred()) SWIG_fail;
9477 }
9478 resultobj = SWIG_From_long(static_cast< long >(result));
9479 return resultobj;
9480 fail:
9481 return NULL;
9482 }
9483
9484
9485 SWIGINTERN PyObject *_wrap_InputStream_TellI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9486 PyObject *resultobj = 0;
9487 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9488 long result;
9489 void *argp1 = 0 ;
9490 int res1 = 0 ;
9491 PyObject *swig_obj[1] ;
9492
9493 if (!args) SWIG_fail;
9494 swig_obj[0] = args;
9495 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9496 if (!SWIG_IsOK(res1)) {
9497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_TellI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9498 }
9499 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9500 {
9501 PyThreadState* __tstate = wxPyBeginAllowThreads();
9502 result = (long)(arg1)->TellI();
9503 wxPyEndAllowThreads(__tstate);
9504 if (PyErr_Occurred()) SWIG_fail;
9505 }
9506 resultobj = SWIG_From_long(static_cast< long >(result));
9507 return resultobj;
9508 fail:
9509 return NULL;
9510 }
9511
9512
9513 SWIGINTERN PyObject *InputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9514 PyObject *obj;
9515 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9516 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyInputStream, SWIG_NewClientData(obj));
9517 return SWIG_Py_Void();
9518 }
9519
9520 SWIGINTERN PyObject *InputStream_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9521 return SWIG_Python_InitShadowInstance(args);
9522 }
9523
9524 SWIGINTERN PyObject *_wrap_OutputStream_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9525 PyObject *resultobj = 0;
9526 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9527 PyObject *arg2 = (PyObject *) 0 ;
9528 void *argp1 = 0 ;
9529 int res1 = 0 ;
9530 PyObject * obj0 = 0 ;
9531 PyObject * obj1 = 0 ;
9532 char * kwnames[] = {
9533 (char *) "self",(char *) "obj", NULL
9534 };
9535
9536 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) SWIG_fail;
9537 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9538 if (!SWIG_IsOK(res1)) {
9539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_write" "', expected argument " "1"" of type '" "wxOutputStream *""'");
9540 }
9541 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9542 arg2 = obj1;
9543 {
9544 PyThreadState* __tstate = wxPyBeginAllowThreads();
9545 wxOutputStream_write(arg1,arg2);
9546 wxPyEndAllowThreads(__tstate);
9547 if (PyErr_Occurred()) SWIG_fail;
9548 }
9549 resultobj = SWIG_Py_Void();
9550 return resultobj;
9551 fail:
9552 return NULL;
9553 }
9554
9555
9556 SWIGINTERN PyObject *_wrap_OutputStream_LastWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9557 PyObject *resultobj = 0;
9558 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9559 size_t result;
9560 void *argp1 = 0 ;
9561 int res1 = 0 ;
9562 PyObject *swig_obj[1] ;
9563
9564 if (!args) SWIG_fail;
9565 swig_obj[0] = args;
9566 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9567 if (!SWIG_IsOK(res1)) {
9568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_LastWrite" "', expected argument " "1"" of type '" "wxOutputStream const *""'");
9569 }
9570 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9571 {
9572 PyThreadState* __tstate = wxPyBeginAllowThreads();
9573 result = (size_t)((wxOutputStream const *)arg1)->LastWrite();
9574 wxPyEndAllowThreads(__tstate);
9575 if (PyErr_Occurred()) SWIG_fail;
9576 }
9577 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9578 return resultobj;
9579 fail:
9580 return NULL;
9581 }
9582
9583
9584 SWIGINTERN PyObject *OutputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9585 PyObject *obj;
9586 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9587 SWIG_TypeNewClientData(SWIGTYPE_p_wxOutputStream, SWIG_NewClientData(obj));
9588 return SWIG_Py_Void();
9589 }
9590
9591 SWIGINTERN PyObject *_wrap_new_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9592 PyObject *resultobj = 0;
9593 wxInputStream *arg1 = (wxInputStream *) 0 ;
9594 wxString *arg2 = 0 ;
9595 wxString *arg3 = 0 ;
9596 wxString *arg4 = 0 ;
9597 wxDateTime arg5 ;
9598 wxFSFile *result = 0 ;
9599 wxPyInputStream *temp1 ;
9600 bool temp2 = false ;
9601 bool temp3 = false ;
9602 bool temp4 = false ;
9603 void *argp5 ;
9604 int res5 = 0 ;
9605 PyObject * obj0 = 0 ;
9606 PyObject * obj1 = 0 ;
9607 PyObject * obj2 = 0 ;
9608 PyObject * obj3 = 0 ;
9609 PyObject * obj4 = 0 ;
9610 char * kwnames[] = {
9611 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
9612 };
9613
9614 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9615 {
9616 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
9617 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
9618 } else {
9619 PyErr_Clear(); // clear the failure of the wxPyConvert above
9620 arg1 = wxPyCBInputStream_create(obj0, true);
9621 if (arg1 == NULL) {
9622 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
9623 SWIG_fail;
9624 }
9625 }
9626 }
9627 {
9628 arg2 = wxString_in_helper(obj1);
9629 if (arg2 == NULL) SWIG_fail;
9630 temp2 = true;
9631 }
9632 {
9633 arg3 = wxString_in_helper(obj2);
9634 if (arg3 == NULL) SWIG_fail;
9635 temp3 = true;
9636 }
9637 {
9638 arg4 = wxString_in_helper(obj3);
9639 if (arg4 == NULL) SWIG_fail;
9640 temp4 = true;
9641 }
9642 {
9643 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDateTime, 0 | 0);
9644 if (!SWIG_IsOK(res5)) {
9645 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9646 }
9647 if (!argp5) {
9648 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9649 } else {
9650 wxDateTime * temp = reinterpret_cast< wxDateTime * >(argp5);
9651 arg5 = *temp;
9652 if (SWIG_IsNewObj(res5)) delete temp;
9653 }
9654 }
9655 {
9656 PyThreadState* __tstate = wxPyBeginAllowThreads();
9657 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
9658 wxPyEndAllowThreads(__tstate);
9659 if (PyErr_Occurred()) SWIG_fail;
9660 }
9661 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFSFile, SWIG_POINTER_NEW | 0 );
9662 {
9663 if (temp2)
9664 delete arg2;
9665 }
9666 {
9667 if (temp3)
9668 delete arg3;
9669 }
9670 {
9671 if (temp4)
9672 delete arg4;
9673 }
9674 return resultobj;
9675 fail:
9676 {
9677 if (temp2)
9678 delete arg2;
9679 }
9680 {
9681 if (temp3)
9682 delete arg3;
9683 }
9684 {
9685 if (temp4)
9686 delete arg4;
9687 }
9688 return NULL;
9689 }
9690
9691
9692 SWIGINTERN PyObject *_wrap_delete_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9693 PyObject *resultobj = 0;
9694 wxFSFile *arg1 = (wxFSFile *) 0 ;
9695 void *argp1 = 0 ;
9696 int res1 = 0 ;
9697 PyObject *swig_obj[1] ;
9698
9699 if (!args) SWIG_fail;
9700 swig_obj[0] = args;
9701 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, SWIG_POINTER_DISOWN | 0 );
9702 if (!SWIG_IsOK(res1)) {
9703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FSFile" "', expected argument " "1"" of type '" "wxFSFile *""'");
9704 }
9705 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9706 {
9707 PyThreadState* __tstate = wxPyBeginAllowThreads();
9708 delete arg1;
9709
9710 wxPyEndAllowThreads(__tstate);
9711 if (PyErr_Occurred()) SWIG_fail;
9712 }
9713 resultobj = SWIG_Py_Void();
9714 return resultobj;
9715 fail:
9716 return NULL;
9717 }
9718
9719
9720 SWIGINTERN PyObject *_wrap_FSFile_GetStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9721 PyObject *resultobj = 0;
9722 wxFSFile *arg1 = (wxFSFile *) 0 ;
9723 wxInputStream *result = 0 ;
9724 void *argp1 = 0 ;
9725 int res1 = 0 ;
9726 PyObject *swig_obj[1] ;
9727
9728 if (!args) SWIG_fail;
9729 swig_obj[0] = args;
9730 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9731 if (!SWIG_IsOK(res1)) {
9732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
9733 }
9734 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9735 {
9736 PyThreadState* __tstate = wxPyBeginAllowThreads();
9737 result = (wxInputStream *)(arg1)->GetStream();
9738 wxPyEndAllowThreads(__tstate);
9739 if (PyErr_Occurred()) SWIG_fail;
9740 }
9741 {
9742 wxPyInputStream * _ptr = NULL;
9743
9744 if (result) {
9745 _ptr = new wxPyInputStream(result);
9746 }
9747 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
9748 }
9749 return resultobj;
9750 fail:
9751 return NULL;
9752 }
9753
9754
9755 SWIGINTERN PyObject *_wrap_FSFile_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9756 PyObject *resultobj = 0;
9757 wxFSFile *arg1 = (wxFSFile *) 0 ;
9758 wxString *result = 0 ;
9759 void *argp1 = 0 ;
9760 int res1 = 0 ;
9761 PyObject *swig_obj[1] ;
9762
9763 if (!args) SWIG_fail;
9764 swig_obj[0] = args;
9765 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9766 if (!SWIG_IsOK(res1)) {
9767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetMimeType" "', expected argument " "1"" of type '" "wxFSFile *""'");
9768 }
9769 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9770 {
9771 PyThreadState* __tstate = wxPyBeginAllowThreads();
9772 {
9773 wxString const &_result_ref = (arg1)->GetMimeType();
9774 result = (wxString *) &_result_ref;
9775 }
9776 wxPyEndAllowThreads(__tstate);
9777 if (PyErr_Occurred()) SWIG_fail;
9778 }
9779 {
9780 #if wxUSE_UNICODE
9781 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9782 #else
9783 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9784 #endif
9785 }
9786 return resultobj;
9787 fail:
9788 return NULL;
9789 }
9790
9791
9792 SWIGINTERN PyObject *_wrap_FSFile_GetLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9793 PyObject *resultobj = 0;
9794 wxFSFile *arg1 = (wxFSFile *) 0 ;
9795 wxString *result = 0 ;
9796 void *argp1 = 0 ;
9797 int res1 = 0 ;
9798 PyObject *swig_obj[1] ;
9799
9800 if (!args) SWIG_fail;
9801 swig_obj[0] = args;
9802 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9803 if (!SWIG_IsOK(res1)) {
9804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetLocation" "', expected argument " "1"" of type '" "wxFSFile *""'");
9805 }
9806 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9807 {
9808 PyThreadState* __tstate = wxPyBeginAllowThreads();
9809 {
9810 wxString const &_result_ref = (arg1)->GetLocation();
9811 result = (wxString *) &_result_ref;
9812 }
9813 wxPyEndAllowThreads(__tstate);
9814 if (PyErr_Occurred()) SWIG_fail;
9815 }
9816 {
9817 #if wxUSE_UNICODE
9818 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9819 #else
9820 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9821 #endif
9822 }
9823 return resultobj;
9824 fail:
9825 return NULL;
9826 }
9827
9828
9829 SWIGINTERN PyObject *_wrap_FSFile_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9830 PyObject *resultobj = 0;
9831 wxFSFile *arg1 = (wxFSFile *) 0 ;
9832 wxString *result = 0 ;
9833 void *argp1 = 0 ;
9834 int res1 = 0 ;
9835 PyObject *swig_obj[1] ;
9836
9837 if (!args) SWIG_fail;
9838 swig_obj[0] = args;
9839 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9840 if (!SWIG_IsOK(res1)) {
9841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetAnchor" "', expected argument " "1"" of type '" "wxFSFile *""'");
9842 }
9843 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9844 {
9845 PyThreadState* __tstate = wxPyBeginAllowThreads();
9846 {
9847 wxString const &_result_ref = (arg1)->GetAnchor();
9848 result = (wxString *) &_result_ref;
9849 }
9850 wxPyEndAllowThreads(__tstate);
9851 if (PyErr_Occurred()) SWIG_fail;
9852 }
9853 {
9854 #if wxUSE_UNICODE
9855 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9856 #else
9857 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9858 #endif
9859 }
9860 return resultobj;
9861 fail:
9862 return NULL;
9863 }
9864
9865
9866 SWIGINTERN PyObject *_wrap_FSFile_GetModificationTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9867 PyObject *resultobj = 0;
9868 wxFSFile *arg1 = (wxFSFile *) 0 ;
9869 wxDateTime result;
9870 void *argp1 = 0 ;
9871 int res1 = 0 ;
9872 PyObject *swig_obj[1] ;
9873
9874 if (!args) SWIG_fail;
9875 swig_obj[0] = args;
9876 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9877 if (!SWIG_IsOK(res1)) {
9878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetModificationTime" "', expected argument " "1"" of type '" "wxFSFile *""'");
9879 }
9880 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9881 {
9882 PyThreadState* __tstate = wxPyBeginAllowThreads();
9883 result = (arg1)->GetModificationTime();
9884 wxPyEndAllowThreads(__tstate);
9885 if (PyErr_Occurred()) SWIG_fail;
9886 }
9887 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
9888 return resultobj;
9889 fail:
9890 return NULL;
9891 }
9892
9893
9894 SWIGINTERN PyObject *FSFile_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9895 PyObject *obj;
9896 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9897 SWIG_TypeNewClientData(SWIGTYPE_p_wxFSFile, SWIG_NewClientData(obj));
9898 return SWIG_Py_Void();
9899 }
9900
9901 SWIGINTERN PyObject *FSFile_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9902 return SWIG_Python_InitShadowInstance(args);
9903 }
9904
9905 SWIGINTERN PyObject *_wrap_delete_CPPFileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9906 PyObject *resultobj = 0;
9907 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
9908 void *argp1 = 0 ;
9909 int res1 = 0 ;
9910 PyObject *swig_obj[1] ;
9911
9912 if (!args) SWIG_fail;
9913 swig_obj[0] = args;
9914 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
9915 if (!SWIG_IsOK(res1)) {
9916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CPPFileSystemHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
9917 }
9918 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
9919 {
9920 PyThreadState* __tstate = wxPyBeginAllowThreads();
9921 delete arg1;
9922
9923 wxPyEndAllowThreads(__tstate);
9924 if (PyErr_Occurred()) SWIG_fail;
9925 }
9926 resultobj = SWIG_Py_Void();
9927 return resultobj;
9928 fail:
9929 return NULL;
9930 }
9931
9932
9933 SWIGINTERN PyObject *CPPFileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9934 PyObject *obj;
9935 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9936 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystemHandler, SWIG_NewClientData(obj));
9937 return SWIG_Py_Void();
9938 }
9939
9940 SWIGINTERN PyObject *_wrap_new_FileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9941 PyObject *resultobj = 0;
9942 wxPyFileSystemHandler *result = 0 ;
9943
9944 if (!SWIG_Python_UnpackTuple(args,"new_FileSystemHandler",0,0,0)) SWIG_fail;
9945 {
9946 PyThreadState* __tstate = wxPyBeginAllowThreads();
9947 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
9948 wxPyEndAllowThreads(__tstate);
9949 if (PyErr_Occurred()) SWIG_fail;
9950 }
9951 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_NEW | 0 );
9952 return resultobj;
9953 fail:
9954 return NULL;
9955 }
9956
9957
9958 SWIGINTERN PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9959 PyObject *resultobj = 0;
9960 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
9961 PyObject *arg2 = (PyObject *) 0 ;
9962 PyObject *arg3 = (PyObject *) 0 ;
9963 void *argp1 = 0 ;
9964 int res1 = 0 ;
9965 PyObject * obj0 = 0 ;
9966 PyObject * obj1 = 0 ;
9967 PyObject * obj2 = 0 ;
9968 char * kwnames[] = {
9969 (char *) "self",(char *) "self",(char *) "_class", NULL
9970 };
9971
9972 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9973 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
9974 if (!SWIG_IsOK(res1)) {
9975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
9976 }
9977 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
9978 arg2 = obj1;
9979 arg3 = obj2;
9980 {
9981 PyThreadState* __tstate = wxPyBeginAllowThreads();
9982 (arg1)->_setCallbackInfo(arg2,arg3);
9983 wxPyEndAllowThreads(__tstate);
9984 if (PyErr_Occurred()) SWIG_fail;
9985 }
9986 resultobj = SWIG_Py_Void();
9987 return resultobj;
9988 fail:
9989 return NULL;
9990 }
9991
9992
9993 SWIGINTERN PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9994 PyObject *resultobj = 0;
9995 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
9996 wxString *arg2 = 0 ;
9997 bool result;
9998 void *argp1 = 0 ;
9999 int res1 = 0 ;
10000 bool temp2 = false ;
10001 PyObject * obj0 = 0 ;
10002 PyObject * obj1 = 0 ;
10003 char * kwnames[] = {
10004 (char *) "self",(char *) "location", NULL
10005 };
10006
10007 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
10008 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10009 if (!SWIG_IsOK(res1)) {
10010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_CanOpen" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10011 }
10012 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10013 {
10014 arg2 = wxString_in_helper(obj1);
10015 if (arg2 == NULL) SWIG_fail;
10016 temp2 = true;
10017 }
10018 {
10019 PyThreadState* __tstate = wxPyBeginAllowThreads();
10020 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
10021 wxPyEndAllowThreads(__tstate);
10022 if (PyErr_Occurred()) SWIG_fail;
10023 }
10024 {
10025 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10026 }
10027 {
10028 if (temp2)
10029 delete arg2;
10030 }
10031 return resultobj;
10032 fail:
10033 {
10034 if (temp2)
10035 delete arg2;
10036 }
10037 return NULL;
10038 }
10039
10040
10041 SWIGINTERN PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10042 PyObject *resultobj = 0;
10043 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10044 wxFileSystem *arg2 = 0 ;
10045 wxString *arg3 = 0 ;
10046 wxFSFile *result = 0 ;
10047 void *argp1 = 0 ;
10048 int res1 = 0 ;
10049 void *argp2 = 0 ;
10050 int res2 = 0 ;
10051 bool temp3 = false ;
10052 PyObject * obj0 = 0 ;
10053 PyObject * obj1 = 0 ;
10054 PyObject * obj2 = 0 ;
10055 char * kwnames[] = {
10056 (char *) "self",(char *) "fs",(char *) "location", NULL
10057 };
10058
10059 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10060 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10061 if (!SWIG_IsOK(res1)) {
10062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10063 }
10064 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10065 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
10066 if (!SWIG_IsOK(res2)) {
10067 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10068 }
10069 if (!argp2) {
10070 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10071 }
10072 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
10073 {
10074 arg3 = wxString_in_helper(obj2);
10075 if (arg3 == NULL) SWIG_fail;
10076 temp3 = true;
10077 }
10078 {
10079 PyThreadState* __tstate = wxPyBeginAllowThreads();
10080 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
10081 wxPyEndAllowThreads(__tstate);
10082 if (PyErr_Occurred()) SWIG_fail;
10083 }
10084 {
10085 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
10086 }
10087 {
10088 if (temp3)
10089 delete arg3;
10090 }
10091 return resultobj;
10092 fail:
10093 {
10094 if (temp3)
10095 delete arg3;
10096 }
10097 return NULL;
10098 }
10099
10100
10101 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10102 PyObject *resultobj = 0;
10103 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10104 wxString *arg2 = 0 ;
10105 int arg3 = (int) 0 ;
10106 wxString result;
10107 void *argp1 = 0 ;
10108 int res1 = 0 ;
10109 bool temp2 = false ;
10110 int val3 ;
10111 int ecode3 = 0 ;
10112 PyObject * obj0 = 0 ;
10113 PyObject * obj1 = 0 ;
10114 PyObject * obj2 = 0 ;
10115 char * kwnames[] = {
10116 (char *) "self",(char *) "spec",(char *) "flags", NULL
10117 };
10118
10119 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10120 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10121 if (!SWIG_IsOK(res1)) {
10122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10123 }
10124 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10125 {
10126 arg2 = wxString_in_helper(obj1);
10127 if (arg2 == NULL) SWIG_fail;
10128 temp2 = true;
10129 }
10130 if (obj2) {
10131 ecode3 = SWIG_AsVal_int(obj2, &val3);
10132 if (!SWIG_IsOK(ecode3)) {
10133 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
10134 }
10135 arg3 = static_cast< int >(val3);
10136 }
10137 {
10138 PyThreadState* __tstate = wxPyBeginAllowThreads();
10139 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10140 wxPyEndAllowThreads(__tstate);
10141 if (PyErr_Occurred()) SWIG_fail;
10142 }
10143 {
10144 #if wxUSE_UNICODE
10145 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10146 #else
10147 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10148 #endif
10149 }
10150 {
10151 if (temp2)
10152 delete arg2;
10153 }
10154 return resultobj;
10155 fail:
10156 {
10157 if (temp2)
10158 delete arg2;
10159 }
10160 return NULL;
10161 }
10162
10163
10164 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10165 PyObject *resultobj = 0;
10166 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10167 wxString result;
10168 void *argp1 = 0 ;
10169 int res1 = 0 ;
10170 PyObject *swig_obj[1] ;
10171
10172 if (!args) SWIG_fail;
10173 swig_obj[0] = args;
10174 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10175 if (!SWIG_IsOK(res1)) {
10176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindNext" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10177 }
10178 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10179 {
10180 PyThreadState* __tstate = wxPyBeginAllowThreads();
10181 result = (arg1)->FindNext();
10182 wxPyEndAllowThreads(__tstate);
10183 if (PyErr_Occurred()) SWIG_fail;
10184 }
10185 {
10186 #if wxUSE_UNICODE
10187 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10188 #else
10189 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10190 #endif
10191 }
10192 return resultobj;
10193 fail:
10194 return NULL;
10195 }
10196
10197
10198 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10199 PyObject *resultobj = 0;
10200 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10201 wxString *arg2 = 0 ;
10202 wxString result;
10203 void *argp1 = 0 ;
10204 int res1 = 0 ;
10205 bool temp2 = false ;
10206 PyObject * obj0 = 0 ;
10207 PyObject * obj1 = 0 ;
10208 char * kwnames[] = {
10209 (char *) "self",(char *) "location", NULL
10210 };
10211
10212 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) SWIG_fail;
10213 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10214 if (!SWIG_IsOK(res1)) {
10215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetProtocol" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10216 }
10217 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10218 {
10219 arg2 = wxString_in_helper(obj1);
10220 if (arg2 == NULL) SWIG_fail;
10221 temp2 = true;
10222 }
10223 {
10224 PyThreadState* __tstate = wxPyBeginAllowThreads();
10225 result = (arg1)->GetProtocol((wxString const &)*arg2);
10226 wxPyEndAllowThreads(__tstate);
10227 if (PyErr_Occurred()) SWIG_fail;
10228 }
10229 {
10230 #if wxUSE_UNICODE
10231 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10232 #else
10233 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10234 #endif
10235 }
10236 {
10237 if (temp2)
10238 delete arg2;
10239 }
10240 return resultobj;
10241 fail:
10242 {
10243 if (temp2)
10244 delete arg2;
10245 }
10246 return NULL;
10247 }
10248
10249
10250 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10251 PyObject *resultobj = 0;
10252 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10253 wxString *arg2 = 0 ;
10254 wxString result;
10255 void *argp1 = 0 ;
10256 int res1 = 0 ;
10257 bool temp2 = false ;
10258 PyObject * obj0 = 0 ;
10259 PyObject * obj1 = 0 ;
10260 char * kwnames[] = {
10261 (char *) "self",(char *) "location", NULL
10262 };
10263
10264 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10265 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10266 if (!SWIG_IsOK(res1)) {
10267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetLeftLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10268 }
10269 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10270 {
10271 arg2 = wxString_in_helper(obj1);
10272 if (arg2 == NULL) SWIG_fail;
10273 temp2 = true;
10274 }
10275 {
10276 PyThreadState* __tstate = wxPyBeginAllowThreads();
10277 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
10278 wxPyEndAllowThreads(__tstate);
10279 if (PyErr_Occurred()) SWIG_fail;
10280 }
10281 {
10282 #if wxUSE_UNICODE
10283 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10284 #else
10285 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10286 #endif
10287 }
10288 {
10289 if (temp2)
10290 delete arg2;
10291 }
10292 return resultobj;
10293 fail:
10294 {
10295 if (temp2)
10296 delete arg2;
10297 }
10298 return NULL;
10299 }
10300
10301
10302 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10303 PyObject *resultobj = 0;
10304 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10305 wxString *arg2 = 0 ;
10306 wxString result;
10307 void *argp1 = 0 ;
10308 int res1 = 0 ;
10309 bool temp2 = false ;
10310 PyObject * obj0 = 0 ;
10311 PyObject * obj1 = 0 ;
10312 char * kwnames[] = {
10313 (char *) "self",(char *) "location", NULL
10314 };
10315
10316 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) SWIG_fail;
10317 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10318 if (!SWIG_IsOK(res1)) {
10319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetAnchor" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10320 }
10321 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10322 {
10323 arg2 = wxString_in_helper(obj1);
10324 if (arg2 == NULL) SWIG_fail;
10325 temp2 = true;
10326 }
10327 {
10328 PyThreadState* __tstate = wxPyBeginAllowThreads();
10329 result = (arg1)->GetAnchor((wxString const &)*arg2);
10330 wxPyEndAllowThreads(__tstate);
10331 if (PyErr_Occurred()) SWIG_fail;
10332 }
10333 {
10334 #if wxUSE_UNICODE
10335 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10336 #else
10337 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10338 #endif
10339 }
10340 {
10341 if (temp2)
10342 delete arg2;
10343 }
10344 return resultobj;
10345 fail:
10346 {
10347 if (temp2)
10348 delete arg2;
10349 }
10350 return NULL;
10351 }
10352
10353
10354 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10355 PyObject *resultobj = 0;
10356 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10357 wxString *arg2 = 0 ;
10358 wxString result;
10359 void *argp1 = 0 ;
10360 int res1 = 0 ;
10361 bool temp2 = false ;
10362 PyObject * obj0 = 0 ;
10363 PyObject * obj1 = 0 ;
10364 char * kwnames[] = {
10365 (char *) "self",(char *) "location", NULL
10366 };
10367
10368 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10369 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10370 if (!SWIG_IsOK(res1)) {
10371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetRightLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10372 }
10373 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10374 {
10375 arg2 = wxString_in_helper(obj1);
10376 if (arg2 == NULL) SWIG_fail;
10377 temp2 = true;
10378 }
10379 {
10380 PyThreadState* __tstate = wxPyBeginAllowThreads();
10381 result = (arg1)->GetRightLocation((wxString const &)*arg2);
10382 wxPyEndAllowThreads(__tstate);
10383 if (PyErr_Occurred()) SWIG_fail;
10384 }
10385 {
10386 #if wxUSE_UNICODE
10387 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10388 #else
10389 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10390 #endif
10391 }
10392 {
10393 if (temp2)
10394 delete arg2;
10395 }
10396 return resultobj;
10397 fail:
10398 {
10399 if (temp2)
10400 delete arg2;
10401 }
10402 return NULL;
10403 }
10404
10405
10406 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10407 PyObject *resultobj = 0;
10408 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10409 wxString *arg2 = 0 ;
10410 wxString result;
10411 void *argp1 = 0 ;
10412 int res1 = 0 ;
10413 bool temp2 = false ;
10414 PyObject * obj0 = 0 ;
10415 PyObject * obj1 = 0 ;
10416 char * kwnames[] = {
10417 (char *) "self",(char *) "location", NULL
10418 };
10419
10420 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) SWIG_fail;
10421 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10422 if (!SWIG_IsOK(res1)) {
10423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetMimeTypeFromExt" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10424 }
10425 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10426 {
10427 arg2 = wxString_in_helper(obj1);
10428 if (arg2 == NULL) SWIG_fail;
10429 temp2 = true;
10430 }
10431 {
10432 PyThreadState* __tstate = wxPyBeginAllowThreads();
10433 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
10434 wxPyEndAllowThreads(__tstate);
10435 if (PyErr_Occurred()) SWIG_fail;
10436 }
10437 {
10438 #if wxUSE_UNICODE
10439 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10440 #else
10441 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10442 #endif
10443 }
10444 {
10445 if (temp2)
10446 delete arg2;
10447 }
10448 return resultobj;
10449 fail:
10450 {
10451 if (temp2)
10452 delete arg2;
10453 }
10454 return NULL;
10455 }
10456
10457
10458 SWIGINTERN PyObject *FileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10459 PyObject *obj;
10460 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10461 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileSystemHandler, SWIG_NewClientData(obj));
10462 return SWIG_Py_Void();
10463 }
10464
10465 SWIGINTERN PyObject *FileSystemHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10466 return SWIG_Python_InitShadowInstance(args);
10467 }
10468
10469 SWIGINTERN PyObject *_wrap_new_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10470 PyObject *resultobj = 0;
10471 wxFileSystem *result = 0 ;
10472
10473 if (!SWIG_Python_UnpackTuple(args,"new_FileSystem",0,0,0)) SWIG_fail;
10474 {
10475 PyThreadState* __tstate = wxPyBeginAllowThreads();
10476 result = (wxFileSystem *)new wxFileSystem();
10477 wxPyEndAllowThreads(__tstate);
10478 if (PyErr_Occurred()) SWIG_fail;
10479 }
10480 {
10481 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
10482 }
10483 return resultobj;
10484 fail:
10485 return NULL;
10486 }
10487
10488
10489 SWIGINTERN PyObject *_wrap_delete_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10490 PyObject *resultobj = 0;
10491 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10492 void *argp1 = 0 ;
10493 int res1 = 0 ;
10494 PyObject *swig_obj[1] ;
10495
10496 if (!args) SWIG_fail;
10497 swig_obj[0] = args;
10498 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, SWIG_POINTER_DISOWN | 0 );
10499 if (!SWIG_IsOK(res1)) {
10500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileSystem" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10501 }
10502 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10503 {
10504 PyThreadState* __tstate = wxPyBeginAllowThreads();
10505 delete arg1;
10506
10507 wxPyEndAllowThreads(__tstate);
10508 if (PyErr_Occurred()) SWIG_fail;
10509 }
10510 resultobj = SWIG_Py_Void();
10511 return resultobj;
10512 fail:
10513 return NULL;
10514 }
10515
10516
10517 SWIGINTERN PyObject *_wrap_FileSystem_ChangePathTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10518 PyObject *resultobj = 0;
10519 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10520 wxString *arg2 = 0 ;
10521 bool arg3 = (bool) false ;
10522 void *argp1 = 0 ;
10523 int res1 = 0 ;
10524 bool temp2 = false ;
10525 bool val3 ;
10526 int ecode3 = 0 ;
10527 PyObject * obj0 = 0 ;
10528 PyObject * obj1 = 0 ;
10529 PyObject * obj2 = 0 ;
10530 char * kwnames[] = {
10531 (char *) "self",(char *) "location",(char *) "is_dir", NULL
10532 };
10533
10534 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10535 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10536 if (!SWIG_IsOK(res1)) {
10537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_ChangePathTo" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10538 }
10539 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10540 {
10541 arg2 = wxString_in_helper(obj1);
10542 if (arg2 == NULL) SWIG_fail;
10543 temp2 = true;
10544 }
10545 if (obj2) {
10546 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10547 if (!SWIG_IsOK(ecode3)) {
10548 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_ChangePathTo" "', expected argument " "3"" of type '" "bool""'");
10549 }
10550 arg3 = static_cast< bool >(val3);
10551 }
10552 {
10553 PyThreadState* __tstate = wxPyBeginAllowThreads();
10554 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
10555 wxPyEndAllowThreads(__tstate);
10556 if (PyErr_Occurred()) SWIG_fail;
10557 }
10558 resultobj = SWIG_Py_Void();
10559 {
10560 if (temp2)
10561 delete arg2;
10562 }
10563 return resultobj;
10564 fail:
10565 {
10566 if (temp2)
10567 delete arg2;
10568 }
10569 return NULL;
10570 }
10571
10572
10573 SWIGINTERN PyObject *_wrap_FileSystem_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10574 PyObject *resultobj = 0;
10575 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10576 wxString result;
10577 void *argp1 = 0 ;
10578 int res1 = 0 ;
10579 PyObject *swig_obj[1] ;
10580
10581 if (!args) SWIG_fail;
10582 swig_obj[0] = args;
10583 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10584 if (!SWIG_IsOK(res1)) {
10585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_GetPath" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10586 }
10587 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10588 {
10589 PyThreadState* __tstate = wxPyBeginAllowThreads();
10590 result = (arg1)->GetPath();
10591 wxPyEndAllowThreads(__tstate);
10592 if (PyErr_Occurred()) SWIG_fail;
10593 }
10594 {
10595 #if wxUSE_UNICODE
10596 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10597 #else
10598 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10599 #endif
10600 }
10601 return resultobj;
10602 fail:
10603 return NULL;
10604 }
10605
10606
10607 SWIGINTERN PyObject *_wrap_FileSystem_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10608 PyObject *resultobj = 0;
10609 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10610 wxString *arg2 = 0 ;
10611 wxFSFile *result = 0 ;
10612 void *argp1 = 0 ;
10613 int res1 = 0 ;
10614 bool temp2 = false ;
10615 PyObject * obj0 = 0 ;
10616 PyObject * obj1 = 0 ;
10617 char * kwnames[] = {
10618 (char *) "self",(char *) "location", NULL
10619 };
10620
10621 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) SWIG_fail;
10622 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10623 if (!SWIG_IsOK(res1)) {
10624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_OpenFile" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10625 }
10626 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10627 {
10628 arg2 = wxString_in_helper(obj1);
10629 if (arg2 == NULL) SWIG_fail;
10630 temp2 = true;
10631 }
10632 {
10633 PyThreadState* __tstate = wxPyBeginAllowThreads();
10634 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
10635 wxPyEndAllowThreads(__tstate);
10636 if (PyErr_Occurred()) SWIG_fail;
10637 }
10638 {
10639 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
10640 }
10641 {
10642 if (temp2)
10643 delete arg2;
10644 }
10645 return resultobj;
10646 fail:
10647 {
10648 if (temp2)
10649 delete arg2;
10650 }
10651 return NULL;
10652 }
10653
10654
10655 SWIGINTERN PyObject *_wrap_FileSystem_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10656 PyObject *resultobj = 0;
10657 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10658 wxString *arg2 = 0 ;
10659 int arg3 = (int) 0 ;
10660 wxString result;
10661 void *argp1 = 0 ;
10662 int res1 = 0 ;
10663 bool temp2 = false ;
10664 int val3 ;
10665 int ecode3 = 0 ;
10666 PyObject * obj0 = 0 ;
10667 PyObject * obj1 = 0 ;
10668 PyObject * obj2 = 0 ;
10669 char * kwnames[] = {
10670 (char *) "self",(char *) "spec",(char *) "flags", NULL
10671 };
10672
10673 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10674 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10675 if (!SWIG_IsOK(res1)) {
10676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindFirst" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10677 }
10678 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10679 {
10680 arg2 = wxString_in_helper(obj1);
10681 if (arg2 == NULL) SWIG_fail;
10682 temp2 = true;
10683 }
10684 if (obj2) {
10685 ecode3 = SWIG_AsVal_int(obj2, &val3);
10686 if (!SWIG_IsOK(ecode3)) {
10687 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_FindFirst" "', expected argument " "3"" of type '" "int""'");
10688 }
10689 arg3 = static_cast< int >(val3);
10690 }
10691 {
10692 PyThreadState* __tstate = wxPyBeginAllowThreads();
10693 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10694 wxPyEndAllowThreads(__tstate);
10695 if (PyErr_Occurred()) SWIG_fail;
10696 }
10697 {
10698 #if wxUSE_UNICODE
10699 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10700 #else
10701 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10702 #endif
10703 }
10704 {
10705 if (temp2)
10706 delete arg2;
10707 }
10708 return resultobj;
10709 fail:
10710 {
10711 if (temp2)
10712 delete arg2;
10713 }
10714 return NULL;
10715 }
10716
10717
10718 SWIGINTERN PyObject *_wrap_FileSystem_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10719 PyObject *resultobj = 0;
10720 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10721 wxString result;
10722 void *argp1 = 0 ;
10723 int res1 = 0 ;
10724 PyObject *swig_obj[1] ;
10725
10726 if (!args) SWIG_fail;
10727 swig_obj[0] = args;
10728 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10729 if (!SWIG_IsOK(res1)) {
10730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindNext" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10731 }
10732 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10733 {
10734 PyThreadState* __tstate = wxPyBeginAllowThreads();
10735 result = (arg1)->FindNext();
10736 wxPyEndAllowThreads(__tstate);
10737 if (PyErr_Occurred()) SWIG_fail;
10738 }
10739 {
10740 #if wxUSE_UNICODE
10741 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10742 #else
10743 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10744 #endif
10745 }
10746 return resultobj;
10747 fail:
10748 return NULL;
10749 }
10750
10751
10752 SWIGINTERN PyObject *_wrap_FileSystem_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10753 PyObject *resultobj = 0;
10754 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
10755 int res1 = 0 ;
10756 PyObject * obj0 = 0 ;
10757 char * kwnames[] = {
10758 (char *) "handler", NULL
10759 };
10760
10761 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) SWIG_fail;
10762 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
10763 if (!SWIG_IsOK(res1)) {
10764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_AddHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
10765 }
10766 {
10767 PyThreadState* __tstate = wxPyBeginAllowThreads();
10768 wxFileSystem::AddHandler(arg1);
10769 wxPyEndAllowThreads(__tstate);
10770 if (PyErr_Occurred()) SWIG_fail;
10771 }
10772 resultobj = SWIG_Py_Void();
10773 return resultobj;
10774 fail:
10775 return NULL;
10776 }
10777
10778
10779 SWIGINTERN PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10780 PyObject *resultobj = 0;
10781
10782 if (!SWIG_Python_UnpackTuple(args,"FileSystem_CleanUpHandlers",0,0,0)) SWIG_fail;
10783 {
10784 PyThreadState* __tstate = wxPyBeginAllowThreads();
10785 wxFileSystem::CleanUpHandlers();
10786 wxPyEndAllowThreads(__tstate);
10787 if (PyErr_Occurred()) SWIG_fail;
10788 }
10789 resultobj = SWIG_Py_Void();
10790 return resultobj;
10791 fail:
10792 return NULL;
10793 }
10794
10795
10796 SWIGINTERN PyObject *_wrap_FileSystem_FileNameToURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10797 PyObject *resultobj = 0;
10798 wxString *arg1 = 0 ;
10799 wxString result;
10800 bool temp1 = false ;
10801 PyObject * obj0 = 0 ;
10802 char * kwnames[] = {
10803 (char *) "filename", NULL
10804 };
10805
10806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) SWIG_fail;
10807 {
10808 arg1 = wxString_in_helper(obj0);
10809 if (arg1 == NULL) SWIG_fail;
10810 temp1 = true;
10811 }
10812 {
10813 PyThreadState* __tstate = wxPyBeginAllowThreads();
10814 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
10815 wxPyEndAllowThreads(__tstate);
10816 if (PyErr_Occurred()) SWIG_fail;
10817 }
10818 {
10819 #if wxUSE_UNICODE
10820 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10821 #else
10822 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10823 #endif
10824 }
10825 {
10826 if (temp1)
10827 delete arg1;
10828 }
10829 return resultobj;
10830 fail:
10831 {
10832 if (temp1)
10833 delete arg1;
10834 }
10835 return NULL;
10836 }
10837
10838
10839 SWIGINTERN PyObject *_wrap_FileSystem_URLToFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10840 PyObject *resultobj = 0;
10841 wxString *arg1 = 0 ;
10842 wxString result;
10843 bool temp1 = false ;
10844 PyObject * obj0 = 0 ;
10845 char * kwnames[] = {
10846 (char *) "url", NULL
10847 };
10848
10849 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) SWIG_fail;
10850 {
10851 arg1 = wxString_in_helper(obj0);
10852 if (arg1 == NULL) SWIG_fail;
10853 temp1 = true;
10854 }
10855 {
10856 PyThreadState* __tstate = wxPyBeginAllowThreads();
10857 result = wxFileSystem_URLToFileName((wxString const &)*arg1);
10858 wxPyEndAllowThreads(__tstate);
10859 if (PyErr_Occurred()) SWIG_fail;
10860 }
10861 {
10862 #if wxUSE_UNICODE
10863 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10864 #else
10865 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10866 #endif
10867 }
10868 {
10869 if (temp1)
10870 delete arg1;
10871 }
10872 return resultobj;
10873 fail:
10874 {
10875 if (temp1)
10876 delete arg1;
10877 }
10878 return NULL;
10879 }
10880
10881
10882 SWIGINTERN PyObject *FileSystem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10883 PyObject *obj;
10884 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10885 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystem, SWIG_NewClientData(obj));
10886 return SWIG_Py_Void();
10887 }
10888
10889 SWIGINTERN PyObject *FileSystem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10890 return SWIG_Python_InitShadowInstance(args);
10891 }
10892
10893 SWIGINTERN PyObject *_wrap_new_InternetFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10894 PyObject *resultobj = 0;
10895 wxInternetFSHandler *result = 0 ;
10896
10897 if (!SWIG_Python_UnpackTuple(args,"new_InternetFSHandler",0,0,0)) SWIG_fail;
10898 {
10899 PyThreadState* __tstate = wxPyBeginAllowThreads();
10900 result = (wxInternetFSHandler *)new wxInternetFSHandler();
10901 wxPyEndAllowThreads(__tstate);
10902 if (PyErr_Occurred()) SWIG_fail;
10903 }
10904 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_NEW | 0 );
10905 return resultobj;
10906 fail:
10907 return NULL;
10908 }
10909
10910
10911 SWIGINTERN PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10912 PyObject *resultobj = 0;
10913 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
10914 wxString *arg2 = 0 ;
10915 bool result;
10916 void *argp1 = 0 ;
10917 int res1 = 0 ;
10918 bool temp2 = false ;
10919 PyObject * obj0 = 0 ;
10920 PyObject * obj1 = 0 ;
10921 char * kwnames[] = {
10922 (char *) "self",(char *) "location", NULL
10923 };
10924
10925 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
10926 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
10927 if (!SWIG_IsOK(res1)) {
10928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
10929 }
10930 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
10931 {
10932 arg2 = wxString_in_helper(obj1);
10933 if (arg2 == NULL) SWIG_fail;
10934 temp2 = true;
10935 }
10936 {
10937 PyThreadState* __tstate = wxPyBeginAllowThreads();
10938 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
10939 wxPyEndAllowThreads(__tstate);
10940 if (PyErr_Occurred()) SWIG_fail;
10941 }
10942 {
10943 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10944 }
10945 {
10946 if (temp2)
10947 delete arg2;
10948 }
10949 return resultobj;
10950 fail:
10951 {
10952 if (temp2)
10953 delete arg2;
10954 }
10955 return NULL;
10956 }
10957
10958
10959 SWIGINTERN PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10960 PyObject *resultobj = 0;
10961 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
10962 wxFileSystem *arg2 = 0 ;
10963 wxString *arg3 = 0 ;
10964 wxFSFile *result = 0 ;
10965 void *argp1 = 0 ;
10966 int res1 = 0 ;
10967 void *argp2 = 0 ;
10968 int res2 = 0 ;
10969 bool temp3 = false ;
10970 PyObject * obj0 = 0 ;
10971 PyObject * obj1 = 0 ;
10972 PyObject * obj2 = 0 ;
10973 char * kwnames[] = {
10974 (char *) "self",(char *) "fs",(char *) "location", NULL
10975 };
10976
10977 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10978 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
10979 if (!SWIG_IsOK(res1)) {
10980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
10981 }
10982 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
10983 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
10984 if (!SWIG_IsOK(res2)) {
10985 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10986 }
10987 if (!argp2) {
10988 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10989 }
10990 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
10991 {
10992 arg3 = wxString_in_helper(obj2);
10993 if (arg3 == NULL) SWIG_fail;
10994 temp3 = true;
10995 }
10996 {
10997 PyThreadState* __tstate = wxPyBeginAllowThreads();
10998 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
10999 wxPyEndAllowThreads(__tstate);
11000 if (PyErr_Occurred()) SWIG_fail;
11001 }
11002 {
11003 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11004 }
11005 {
11006 if (temp3)
11007 delete arg3;
11008 }
11009 return resultobj;
11010 fail:
11011 {
11012 if (temp3)
11013 delete arg3;
11014 }
11015 return NULL;
11016 }
11017
11018
11019 SWIGINTERN PyObject *InternetFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11020 PyObject *obj;
11021 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11022 SWIG_TypeNewClientData(SWIGTYPE_p_wxInternetFSHandler, SWIG_NewClientData(obj));
11023 return SWIG_Py_Void();
11024 }
11025
11026 SWIGINTERN PyObject *InternetFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11027 return SWIG_Python_InitShadowInstance(args);
11028 }
11029
11030 SWIGINTERN PyObject *_wrap_new_ZipFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11031 PyObject *resultobj = 0;
11032 wxZipFSHandler *result = 0 ;
11033
11034 if (!SWIG_Python_UnpackTuple(args,"new_ZipFSHandler",0,0,0)) SWIG_fail;
11035 {
11036 PyThreadState* __tstate = wxPyBeginAllowThreads();
11037 result = (wxZipFSHandler *)new wxZipFSHandler();
11038 wxPyEndAllowThreads(__tstate);
11039 if (PyErr_Occurred()) SWIG_fail;
11040 }
11041 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_NEW | 0 );
11042 return resultobj;
11043 fail:
11044 return NULL;
11045 }
11046
11047
11048 SWIGINTERN PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11049 PyObject *resultobj = 0;
11050 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11051 wxString *arg2 = 0 ;
11052 bool result;
11053 void *argp1 = 0 ;
11054 int res1 = 0 ;
11055 bool temp2 = false ;
11056 PyObject * obj0 = 0 ;
11057 PyObject * obj1 = 0 ;
11058 char * kwnames[] = {
11059 (char *) "self",(char *) "location", NULL
11060 };
11061
11062 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11063 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11064 if (!SWIG_IsOK(res1)) {
11065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11066 }
11067 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11068 {
11069 arg2 = wxString_in_helper(obj1);
11070 if (arg2 == NULL) SWIG_fail;
11071 temp2 = true;
11072 }
11073 {
11074 PyThreadState* __tstate = wxPyBeginAllowThreads();
11075 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11076 wxPyEndAllowThreads(__tstate);
11077 if (PyErr_Occurred()) SWIG_fail;
11078 }
11079 {
11080 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11081 }
11082 {
11083 if (temp2)
11084 delete arg2;
11085 }
11086 return resultobj;
11087 fail:
11088 {
11089 if (temp2)
11090 delete arg2;
11091 }
11092 return NULL;
11093 }
11094
11095
11096 SWIGINTERN PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11097 PyObject *resultobj = 0;
11098 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11099 wxFileSystem *arg2 = 0 ;
11100 wxString *arg3 = 0 ;
11101 wxFSFile *result = 0 ;
11102 void *argp1 = 0 ;
11103 int res1 = 0 ;
11104 void *argp2 = 0 ;
11105 int res2 = 0 ;
11106 bool temp3 = false ;
11107 PyObject * obj0 = 0 ;
11108 PyObject * obj1 = 0 ;
11109 PyObject * obj2 = 0 ;
11110 char * kwnames[] = {
11111 (char *) "self",(char *) "fs",(char *) "location", NULL
11112 };
11113
11114 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11115 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11116 if (!SWIG_IsOK(res1)) {
11117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11118 }
11119 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11120 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11121 if (!SWIG_IsOK(res2)) {
11122 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11123 }
11124 if (!argp2) {
11125 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11126 }
11127 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11128 {
11129 arg3 = wxString_in_helper(obj2);
11130 if (arg3 == NULL) SWIG_fail;
11131 temp3 = true;
11132 }
11133 {
11134 PyThreadState* __tstate = wxPyBeginAllowThreads();
11135 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11136 wxPyEndAllowThreads(__tstate);
11137 if (PyErr_Occurred()) SWIG_fail;
11138 }
11139 {
11140 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11141 }
11142 {
11143 if (temp3)
11144 delete arg3;
11145 }
11146 return resultobj;
11147 fail:
11148 {
11149 if (temp3)
11150 delete arg3;
11151 }
11152 return NULL;
11153 }
11154
11155
11156 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11157 PyObject *resultobj = 0;
11158 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11159 wxString *arg2 = 0 ;
11160 int arg3 = (int) 0 ;
11161 wxString result;
11162 void *argp1 = 0 ;
11163 int res1 = 0 ;
11164 bool temp2 = false ;
11165 int val3 ;
11166 int ecode3 = 0 ;
11167 PyObject * obj0 = 0 ;
11168 PyObject * obj1 = 0 ;
11169 PyObject * obj2 = 0 ;
11170 char * kwnames[] = {
11171 (char *) "self",(char *) "spec",(char *) "flags", NULL
11172 };
11173
11174 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11175 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11176 if (!SWIG_IsOK(res1)) {
11177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11178 }
11179 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11180 {
11181 arg2 = wxString_in_helper(obj1);
11182 if (arg2 == NULL) SWIG_fail;
11183 temp2 = true;
11184 }
11185 if (obj2) {
11186 ecode3 = SWIG_AsVal_int(obj2, &val3);
11187 if (!SWIG_IsOK(ecode3)) {
11188 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11189 }
11190 arg3 = static_cast< int >(val3);
11191 }
11192 {
11193 PyThreadState* __tstate = wxPyBeginAllowThreads();
11194 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11195 wxPyEndAllowThreads(__tstate);
11196 if (PyErr_Occurred()) SWIG_fail;
11197 }
11198 {
11199 #if wxUSE_UNICODE
11200 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11201 #else
11202 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11203 #endif
11204 }
11205 {
11206 if (temp2)
11207 delete arg2;
11208 }
11209 return resultobj;
11210 fail:
11211 {
11212 if (temp2)
11213 delete arg2;
11214 }
11215 return NULL;
11216 }
11217
11218
11219 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11220 PyObject *resultobj = 0;
11221 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11222 wxString result;
11223 void *argp1 = 0 ;
11224 int res1 = 0 ;
11225 PyObject *swig_obj[1] ;
11226
11227 if (!args) SWIG_fail;
11228 swig_obj[0] = args;
11229 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11230 if (!SWIG_IsOK(res1)) {
11231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindNext" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11232 }
11233 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11234 {
11235 PyThreadState* __tstate = wxPyBeginAllowThreads();
11236 result = (arg1)->FindNext();
11237 wxPyEndAllowThreads(__tstate);
11238 if (PyErr_Occurred()) SWIG_fail;
11239 }
11240 {
11241 #if wxUSE_UNICODE
11242 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11243 #else
11244 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11245 #endif
11246 }
11247 return resultobj;
11248 fail:
11249 return NULL;
11250 }
11251
11252
11253 SWIGINTERN PyObject *ZipFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11254 PyObject *obj;
11255 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11256 SWIG_TypeNewClientData(SWIGTYPE_p_wxZipFSHandler, SWIG_NewClientData(obj));
11257 return SWIG_Py_Void();
11258 }
11259
11260 SWIGINTERN PyObject *ZipFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11261 return SWIG_Python_InitShadowInstance(args);
11262 }
11263
11264 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11265 PyObject *resultobj = 0;
11266 wxString *arg1 = 0 ;
11267 wxImage *arg2 = 0 ;
11268 long arg3 ;
11269 bool temp1 = false ;
11270 void *argp2 = 0 ;
11271 int res2 = 0 ;
11272 long val3 ;
11273 int ecode3 = 0 ;
11274 PyObject * obj0 = 0 ;
11275 PyObject * obj1 = 0 ;
11276 PyObject * obj2 = 0 ;
11277 char * kwnames[] = {
11278 (char *) "filename",(char *) "image",(char *) "type", NULL
11279 };
11280
11281 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11282 {
11283 arg1 = wxString_in_helper(obj0);
11284 if (arg1 == NULL) SWIG_fail;
11285 temp1 = true;
11286 }
11287 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
11288 if (!SWIG_IsOK(res2)) {
11289 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11290 }
11291 if (!argp2) {
11292 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11293 }
11294 arg2 = reinterpret_cast< wxImage * >(argp2);
11295 ecode3 = SWIG_AsVal_long(obj2, &val3);
11296 if (!SWIG_IsOK(ecode3)) {
11297 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "3"" of type '" "long""'");
11298 }
11299 arg3 = static_cast< long >(val3);
11300 {
11301 PyThreadState* __tstate = wxPyBeginAllowThreads();
11302 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
11303 wxPyEndAllowThreads(__tstate);
11304 if (PyErr_Occurred()) SWIG_fail;
11305 }
11306 resultobj = SWIG_Py_Void();
11307 {
11308 if (temp1)
11309 delete arg1;
11310 }
11311 return resultobj;
11312 fail:
11313 {
11314 if (temp1)
11315 delete arg1;
11316 }
11317 return NULL;
11318 }
11319
11320
11321 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11322 PyObject *resultobj = 0;
11323 wxString *arg1 = 0 ;
11324 wxBitmap *arg2 = 0 ;
11325 long arg3 ;
11326 bool temp1 = false ;
11327 void *argp2 = 0 ;
11328 int res2 = 0 ;
11329 long val3 ;
11330 int ecode3 = 0 ;
11331 PyObject * obj0 = 0 ;
11332 PyObject * obj1 = 0 ;
11333 PyObject * obj2 = 0 ;
11334 char * kwnames[] = {
11335 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
11336 };
11337
11338 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11339 {
11340 arg1 = wxString_in_helper(obj0);
11341 if (arg1 == NULL) SWIG_fail;
11342 temp1 = true;
11343 }
11344 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
11345 if (!SWIG_IsOK(res2)) {
11346 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11347 }
11348 if (!argp2) {
11349 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11350 }
11351 arg2 = reinterpret_cast< wxBitmap * >(argp2);
11352 ecode3 = SWIG_AsVal_long(obj2, &val3);
11353 if (!SWIG_IsOK(ecode3)) {
11354 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "3"" of type '" "long""'");
11355 }
11356 arg3 = static_cast< long >(val3);
11357 {
11358 PyThreadState* __tstate = wxPyBeginAllowThreads();
11359 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
11360 wxPyEndAllowThreads(__tstate);
11361 if (PyErr_Occurred()) SWIG_fail;
11362 }
11363 resultobj = SWIG_Py_Void();
11364 {
11365 if (temp1)
11366 delete arg1;
11367 }
11368 return resultobj;
11369 fail:
11370 {
11371 if (temp1)
11372 delete arg1;
11373 }
11374 return NULL;
11375 }
11376
11377
11378 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11379 PyObject *resultobj = 0;
11380 wxString *arg1 = 0 ;
11381 PyObject *arg2 = (PyObject *) 0 ;
11382 bool temp1 = false ;
11383 PyObject * obj0 = 0 ;
11384 PyObject * obj1 = 0 ;
11385 char * kwnames[] = {
11386 (char *) "filename",(char *) "data", NULL
11387 };
11388
11389 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) SWIG_fail;
11390 {
11391 arg1 = wxString_in_helper(obj0);
11392 if (arg1 == NULL) SWIG_fail;
11393 temp1 = true;
11394 }
11395 arg2 = obj1;
11396 {
11397 PyThreadState* __tstate = wxPyBeginAllowThreads();
11398 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
11399 wxPyEndAllowThreads(__tstate);
11400 if (PyErr_Occurred()) SWIG_fail;
11401 }
11402 resultobj = SWIG_Py_Void();
11403 {
11404 if (temp1)
11405 delete arg1;
11406 }
11407 return resultobj;
11408 fail:
11409 {
11410 if (temp1)
11411 delete arg1;
11412 }
11413 return NULL;
11414 }
11415
11416
11417 SWIGINTERN PyObject *_wrap_new_MemoryFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11418 PyObject *resultobj = 0;
11419 wxMemoryFSHandler *result = 0 ;
11420
11421 if (!SWIG_Python_UnpackTuple(args,"new_MemoryFSHandler",0,0,0)) SWIG_fail;
11422 {
11423 PyThreadState* __tstate = wxPyBeginAllowThreads();
11424 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
11425 wxPyEndAllowThreads(__tstate);
11426 if (PyErr_Occurred()) SWIG_fail;
11427 }
11428 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_NEW | 0 );
11429 return resultobj;
11430 fail:
11431 return NULL;
11432 }
11433
11434
11435 SWIGINTERN PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11436 PyObject *resultobj = 0;
11437 wxString *arg1 = 0 ;
11438 bool temp1 = false ;
11439 PyObject * obj0 = 0 ;
11440 char * kwnames[] = {
11441 (char *) "filename", NULL
11442 };
11443
11444 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) SWIG_fail;
11445 {
11446 arg1 = wxString_in_helper(obj0);
11447 if (arg1 == NULL) SWIG_fail;
11448 temp1 = true;
11449 }
11450 {
11451 PyThreadState* __tstate = wxPyBeginAllowThreads();
11452 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
11453 wxPyEndAllowThreads(__tstate);
11454 if (PyErr_Occurred()) SWIG_fail;
11455 }
11456 resultobj = SWIG_Py_Void();
11457 {
11458 if (temp1)
11459 delete arg1;
11460 }
11461 return resultobj;
11462 fail:
11463 {
11464 if (temp1)
11465 delete arg1;
11466 }
11467 return NULL;
11468 }
11469
11470
11471 SWIGINTERN PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11472 PyObject *resultobj = 0;
11473 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11474 wxString *arg2 = 0 ;
11475 bool result;
11476 void *argp1 = 0 ;
11477 int res1 = 0 ;
11478 bool temp2 = false ;
11479 PyObject * obj0 = 0 ;
11480 PyObject * obj1 = 0 ;
11481 char * kwnames[] = {
11482 (char *) "self",(char *) "location", NULL
11483 };
11484
11485 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11486 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11487 if (!SWIG_IsOK(res1)) {
11488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11489 }
11490 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11491 {
11492 arg2 = wxString_in_helper(obj1);
11493 if (arg2 == NULL) SWIG_fail;
11494 temp2 = true;
11495 }
11496 {
11497 PyThreadState* __tstate = wxPyBeginAllowThreads();
11498 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11499 wxPyEndAllowThreads(__tstate);
11500 if (PyErr_Occurred()) SWIG_fail;
11501 }
11502 {
11503 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11504 }
11505 {
11506 if (temp2)
11507 delete arg2;
11508 }
11509 return resultobj;
11510 fail:
11511 {
11512 if (temp2)
11513 delete arg2;
11514 }
11515 return NULL;
11516 }
11517
11518
11519 SWIGINTERN PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11520 PyObject *resultobj = 0;
11521 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11522 wxFileSystem *arg2 = 0 ;
11523 wxString *arg3 = 0 ;
11524 wxFSFile *result = 0 ;
11525 void *argp1 = 0 ;
11526 int res1 = 0 ;
11527 void *argp2 = 0 ;
11528 int res2 = 0 ;
11529 bool temp3 = false ;
11530 PyObject * obj0 = 0 ;
11531 PyObject * obj1 = 0 ;
11532 PyObject * obj2 = 0 ;
11533 char * kwnames[] = {
11534 (char *) "self",(char *) "fs",(char *) "location", NULL
11535 };
11536
11537 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11538 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11539 if (!SWIG_IsOK(res1)) {
11540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11541 }
11542 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11543 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11544 if (!SWIG_IsOK(res2)) {
11545 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11546 }
11547 if (!argp2) {
11548 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11549 }
11550 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11551 {
11552 arg3 = wxString_in_helper(obj2);
11553 if (arg3 == NULL) SWIG_fail;
11554 temp3 = true;
11555 }
11556 {
11557 PyThreadState* __tstate = wxPyBeginAllowThreads();
11558 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11559 wxPyEndAllowThreads(__tstate);
11560 if (PyErr_Occurred()) SWIG_fail;
11561 }
11562 {
11563 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11564 }
11565 {
11566 if (temp3)
11567 delete arg3;
11568 }
11569 return resultobj;
11570 fail:
11571 {
11572 if (temp3)
11573 delete arg3;
11574 }
11575 return NULL;
11576 }
11577
11578
11579 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11580 PyObject *resultobj = 0;
11581 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11582 wxString *arg2 = 0 ;
11583 int arg3 = (int) 0 ;
11584 wxString result;
11585 void *argp1 = 0 ;
11586 int res1 = 0 ;
11587 bool temp2 = false ;
11588 int val3 ;
11589 int ecode3 = 0 ;
11590 PyObject * obj0 = 0 ;
11591 PyObject * obj1 = 0 ;
11592 PyObject * obj2 = 0 ;
11593 char * kwnames[] = {
11594 (char *) "self",(char *) "spec",(char *) "flags", NULL
11595 };
11596
11597 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11598 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11599 if (!SWIG_IsOK(res1)) {
11600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11601 }
11602 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11603 {
11604 arg2 = wxString_in_helper(obj1);
11605 if (arg2 == NULL) SWIG_fail;
11606 temp2 = true;
11607 }
11608 if (obj2) {
11609 ecode3 = SWIG_AsVal_int(obj2, &val3);
11610 if (!SWIG_IsOK(ecode3)) {
11611 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11612 }
11613 arg3 = static_cast< int >(val3);
11614 }
11615 {
11616 PyThreadState* __tstate = wxPyBeginAllowThreads();
11617 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11618 wxPyEndAllowThreads(__tstate);
11619 if (PyErr_Occurred()) SWIG_fail;
11620 }
11621 {
11622 #if wxUSE_UNICODE
11623 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11624 #else
11625 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11626 #endif
11627 }
11628 {
11629 if (temp2)
11630 delete arg2;
11631 }
11632 return resultobj;
11633 fail:
11634 {
11635 if (temp2)
11636 delete arg2;
11637 }
11638 return NULL;
11639 }
11640
11641
11642 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11643 PyObject *resultobj = 0;
11644 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11645 wxString result;
11646 void *argp1 = 0 ;
11647 int res1 = 0 ;
11648 PyObject *swig_obj[1] ;
11649
11650 if (!args) SWIG_fail;
11651 swig_obj[0] = args;
11652 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11653 if (!SWIG_IsOK(res1)) {
11654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindNext" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11655 }
11656 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11657 {
11658 PyThreadState* __tstate = wxPyBeginAllowThreads();
11659 result = (arg1)->FindNext();
11660 wxPyEndAllowThreads(__tstate);
11661 if (PyErr_Occurred()) SWIG_fail;
11662 }
11663 {
11664 #if wxUSE_UNICODE
11665 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11666 #else
11667 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11668 #endif
11669 }
11670 return resultobj;
11671 fail:
11672 return NULL;
11673 }
11674
11675
11676 SWIGINTERN PyObject *MemoryFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11677 PyObject *obj;
11678 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11679 SWIG_TypeNewClientData(SWIGTYPE_p_wxMemoryFSHandler, SWIG_NewClientData(obj));
11680 return SWIG_Py_Void();
11681 }
11682
11683 SWIGINTERN PyObject *MemoryFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11684 return SWIG_Python_InitShadowInstance(args);
11685 }
11686
11687 SWIGINTERN PyObject *_wrap_ImageHandler_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11688 PyObject *resultobj = 0;
11689 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11690 wxString result;
11691 void *argp1 = 0 ;
11692 int res1 = 0 ;
11693 PyObject *swig_obj[1] ;
11694
11695 if (!args) SWIG_fail;
11696 swig_obj[0] = args;
11697 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11698 if (!SWIG_IsOK(res1)) {
11699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11700 }
11701 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11702 {
11703 PyThreadState* __tstate = wxPyBeginAllowThreads();
11704 result = (arg1)->GetName();
11705 wxPyEndAllowThreads(__tstate);
11706 if (PyErr_Occurred()) SWIG_fail;
11707 }
11708 {
11709 #if wxUSE_UNICODE
11710 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11711 #else
11712 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11713 #endif
11714 }
11715 return resultobj;
11716 fail:
11717 return NULL;
11718 }
11719
11720
11721 SWIGINTERN PyObject *_wrap_ImageHandler_GetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11722 PyObject *resultobj = 0;
11723 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11724 wxString result;
11725 void *argp1 = 0 ;
11726 int res1 = 0 ;
11727 PyObject *swig_obj[1] ;
11728
11729 if (!args) SWIG_fail;
11730 swig_obj[0] = args;
11731 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11732 if (!SWIG_IsOK(res1)) {
11733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11734 }
11735 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11736 {
11737 PyThreadState* __tstate = wxPyBeginAllowThreads();
11738 result = (arg1)->GetExtension();
11739 wxPyEndAllowThreads(__tstate);
11740 if (PyErr_Occurred()) SWIG_fail;
11741 }
11742 {
11743 #if wxUSE_UNICODE
11744 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11745 #else
11746 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11747 #endif
11748 }
11749 return resultobj;
11750 fail:
11751 return NULL;
11752 }
11753
11754
11755 SWIGINTERN PyObject *_wrap_ImageHandler_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11756 PyObject *resultobj = 0;
11757 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11758 long result;
11759 void *argp1 = 0 ;
11760 int res1 = 0 ;
11761 PyObject *swig_obj[1] ;
11762
11763 if (!args) SWIG_fail;
11764 swig_obj[0] = args;
11765 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11766 if (!SWIG_IsOK(res1)) {
11767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11768 }
11769 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11770 {
11771 PyThreadState* __tstate = wxPyBeginAllowThreads();
11772 result = (long)(arg1)->GetType();
11773 wxPyEndAllowThreads(__tstate);
11774 if (PyErr_Occurred()) SWIG_fail;
11775 }
11776 resultobj = SWIG_From_long(static_cast< long >(result));
11777 return resultobj;
11778 fail:
11779 return NULL;
11780 }
11781
11782
11783 SWIGINTERN PyObject *_wrap_ImageHandler_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11784 PyObject *resultobj = 0;
11785 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11786 wxString result;
11787 void *argp1 = 0 ;
11788 int res1 = 0 ;
11789 PyObject *swig_obj[1] ;
11790
11791 if (!args) SWIG_fail;
11792 swig_obj[0] = args;
11793 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11794 if (!SWIG_IsOK(res1)) {
11795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11796 }
11797 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11798 {
11799 PyThreadState* __tstate = wxPyBeginAllowThreads();
11800 result = (arg1)->GetMimeType();
11801 wxPyEndAllowThreads(__tstate);
11802 if (PyErr_Occurred()) SWIG_fail;
11803 }
11804 {
11805 #if wxUSE_UNICODE
11806 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11807 #else
11808 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11809 #endif
11810 }
11811 return resultobj;
11812 fail:
11813 return NULL;
11814 }
11815
11816
11817 SWIGINTERN PyObject *_wrap_ImageHandler_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11818 PyObject *resultobj = 0;
11819 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11820 wxString *arg2 = 0 ;
11821 bool result;
11822 void *argp1 = 0 ;
11823 int res1 = 0 ;
11824 bool temp2 = false ;
11825 PyObject * obj0 = 0 ;
11826 PyObject * obj1 = 0 ;
11827 char * kwnames[] = {
11828 (char *) "self",(char *) "name", NULL
11829 };
11830
11831 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) SWIG_fail;
11832 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11833 if (!SWIG_IsOK(res1)) {
11834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanRead" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11835 }
11836 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11837 {
11838 arg2 = wxString_in_helper(obj1);
11839 if (arg2 == NULL) SWIG_fail;
11840 temp2 = true;
11841 }
11842 {
11843 PyThreadState* __tstate = wxPyBeginAllowThreads();
11844 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
11845 wxPyEndAllowThreads(__tstate);
11846 if (PyErr_Occurred()) SWIG_fail;
11847 }
11848 {
11849 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11850 }
11851 {
11852 if (temp2)
11853 delete arg2;
11854 }
11855 return resultobj;
11856 fail:
11857 {
11858 if (temp2)
11859 delete arg2;
11860 }
11861 return NULL;
11862 }
11863
11864
11865 SWIGINTERN PyObject *_wrap_ImageHandler_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11866 PyObject *resultobj = 0;
11867 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11868 wxInputStream *arg2 = 0 ;
11869 bool result;
11870 void *argp1 = 0 ;
11871 int res1 = 0 ;
11872 wxPyInputStream *temp2 ;
11873 bool created2 ;
11874 PyObject * obj0 = 0 ;
11875 PyObject * obj1 = 0 ;
11876 char * kwnames[] = {
11877 (char *) "self",(char *) "stream", NULL
11878 };
11879
11880 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanReadStream",kwnames,&obj0,&obj1)) SWIG_fail;
11881 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11882 if (!SWIG_IsOK(res1)) {
11883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanReadStream" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11884 }
11885 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11886 {
11887 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
11888 arg2 = temp2->m_wxis;
11889 created2 = false;
11890 } else {
11891 PyErr_Clear(); // clear the failure of the wxPyConvert above
11892 arg2 = wxPyCBInputStream_create(obj1, false);
11893 if (arg2 == NULL) {
11894 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
11895 SWIG_fail;
11896 }
11897 created2 = true;
11898 }
11899 }
11900 {
11901 PyThreadState* __tstate = wxPyBeginAllowThreads();
11902 result = (bool)(arg1)->CanRead(*arg2);
11903 wxPyEndAllowThreads(__tstate);
11904 if (PyErr_Occurred()) SWIG_fail;
11905 }
11906 {
11907 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11908 }
11909 {
11910 if (created2) delete arg2;
11911 }
11912 return resultobj;
11913 fail:
11914 {
11915 if (created2) delete arg2;
11916 }
11917 return NULL;
11918 }
11919
11920
11921 SWIGINTERN PyObject *_wrap_ImageHandler_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11922 PyObject *resultobj = 0;
11923 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11924 wxString *arg2 = 0 ;
11925 void *argp1 = 0 ;
11926 int res1 = 0 ;
11927 bool temp2 = false ;
11928 PyObject * obj0 = 0 ;
11929 PyObject * obj1 = 0 ;
11930 char * kwnames[] = {
11931 (char *) "self",(char *) "name", NULL
11932 };
11933
11934 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
11935 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11936 if (!SWIG_IsOK(res1)) {
11937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11938 }
11939 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11940 {
11941 arg2 = wxString_in_helper(obj1);
11942 if (arg2 == NULL) SWIG_fail;
11943 temp2 = true;
11944 }
11945 {
11946 PyThreadState* __tstate = wxPyBeginAllowThreads();
11947 (arg1)->SetName((wxString const &)*arg2);
11948 wxPyEndAllowThreads(__tstate);
11949 if (PyErr_Occurred()) SWIG_fail;
11950 }
11951 resultobj = SWIG_Py_Void();
11952 {
11953 if (temp2)
11954 delete arg2;
11955 }
11956 return resultobj;
11957 fail:
11958 {
11959 if (temp2)
11960 delete arg2;
11961 }
11962 return NULL;
11963 }
11964
11965
11966 SWIGINTERN PyObject *_wrap_ImageHandler_SetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11967 PyObject *resultobj = 0;
11968 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11969 wxString *arg2 = 0 ;
11970 void *argp1 = 0 ;
11971 int res1 = 0 ;
11972 bool temp2 = false ;
11973 PyObject * obj0 = 0 ;
11974 PyObject * obj1 = 0 ;
11975 char * kwnames[] = {
11976 (char *) "self",(char *) "extension", NULL
11977 };
11978
11979 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) SWIG_fail;
11980 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11981 if (!SWIG_IsOK(res1)) {
11982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11983 }
11984 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11985 {
11986 arg2 = wxString_in_helper(obj1);
11987 if (arg2 == NULL) SWIG_fail;
11988 temp2 = true;
11989 }
11990 {
11991 PyThreadState* __tstate = wxPyBeginAllowThreads();
11992 (arg1)->SetExtension((wxString const &)*arg2);
11993 wxPyEndAllowThreads(__tstate);
11994 if (PyErr_Occurred()) SWIG_fail;
11995 }
11996 resultobj = SWIG_Py_Void();
11997 {
11998 if (temp2)
11999 delete arg2;
12000 }
12001 return resultobj;
12002 fail:
12003 {
12004 if (temp2)
12005 delete arg2;
12006 }
12007 return NULL;
12008 }
12009
12010
12011 SWIGINTERN PyObject *_wrap_ImageHandler_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12012 PyObject *resultobj = 0;
12013 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12014 long arg2 ;
12015 void *argp1 = 0 ;
12016 int res1 = 0 ;
12017 long val2 ;
12018 int ecode2 = 0 ;
12019 PyObject * obj0 = 0 ;
12020 PyObject * obj1 = 0 ;
12021 char * kwnames[] = {
12022 (char *) "self",(char *) "type", NULL
12023 };
12024
12025 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
12026 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12027 if (!SWIG_IsOK(res1)) {
12028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12029 }
12030 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12031 ecode2 = SWIG_AsVal_long(obj1, &val2);
12032 if (!SWIG_IsOK(ecode2)) {
12033 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHandler_SetType" "', expected argument " "2"" of type '" "long""'");
12034 }
12035 arg2 = static_cast< long >(val2);
12036 {
12037 PyThreadState* __tstate = wxPyBeginAllowThreads();
12038 (arg1)->SetType(arg2);
12039 wxPyEndAllowThreads(__tstate);
12040 if (PyErr_Occurred()) SWIG_fail;
12041 }
12042 resultobj = SWIG_Py_Void();
12043 return resultobj;
12044 fail:
12045 return NULL;
12046 }
12047
12048
12049 SWIGINTERN PyObject *_wrap_ImageHandler_SetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12050 PyObject *resultobj = 0;
12051 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12052 wxString *arg2 = 0 ;
12053 void *argp1 = 0 ;
12054 int res1 = 0 ;
12055 bool temp2 = false ;
12056 PyObject * obj0 = 0 ;
12057 PyObject * obj1 = 0 ;
12058 char * kwnames[] = {
12059 (char *) "self",(char *) "mimetype", NULL
12060 };
12061
12062 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
12063 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12064 if (!SWIG_IsOK(res1)) {
12065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12066 }
12067 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12068 {
12069 arg2 = wxString_in_helper(obj1);
12070 if (arg2 == NULL) SWIG_fail;
12071 temp2 = true;
12072 }
12073 {
12074 PyThreadState* __tstate = wxPyBeginAllowThreads();
12075 (arg1)->SetMimeType((wxString const &)*arg2);
12076 wxPyEndAllowThreads(__tstate);
12077 if (PyErr_Occurred()) SWIG_fail;
12078 }
12079 resultobj = SWIG_Py_Void();
12080 {
12081 if (temp2)
12082 delete arg2;
12083 }
12084 return resultobj;
12085 fail:
12086 {
12087 if (temp2)
12088 delete arg2;
12089 }
12090 return NULL;
12091 }
12092
12093
12094 SWIGINTERN PyObject *ImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12095 PyObject *obj;
12096 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12097 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHandler, SWIG_NewClientData(obj));
12098 return SWIG_Py_Void();
12099 }
12100
12101 SWIGINTERN PyObject *_wrap_new_PyImageHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12102 PyObject *resultobj = 0;
12103 wxPyImageHandler *result = 0 ;
12104
12105 if (!SWIG_Python_UnpackTuple(args,"new_PyImageHandler",0,0,0)) SWIG_fail;
12106 {
12107 PyThreadState* __tstate = wxPyBeginAllowThreads();
12108 result = (wxPyImageHandler *)new wxPyImageHandler();
12109 wxPyEndAllowThreads(__tstate);
12110 if (PyErr_Occurred()) SWIG_fail;
12111 }
12112 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyImageHandler, SWIG_POINTER_NEW | 0 );
12113 return resultobj;
12114 fail:
12115 return NULL;
12116 }
12117
12118
12119 SWIGINTERN PyObject *_wrap_PyImageHandler__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12120 PyObject *resultobj = 0;
12121 wxPyImageHandler *arg1 = (wxPyImageHandler *) 0 ;
12122 PyObject *arg2 = (PyObject *) 0 ;
12123 void *argp1 = 0 ;
12124 int res1 = 0 ;
12125 PyObject * obj0 = 0 ;
12126 PyObject * obj1 = 0 ;
12127 char * kwnames[] = {
12128 (char *) "self",(char *) "self", NULL
12129 };
12130
12131 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyImageHandler__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
12132 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyImageHandler, 0 | 0 );
12133 if (!SWIG_IsOK(res1)) {
12134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyImageHandler__SetSelf" "', expected argument " "1"" of type '" "wxPyImageHandler *""'");
12135 }
12136 arg1 = reinterpret_cast< wxPyImageHandler * >(argp1);
12137 arg2 = obj1;
12138 {
12139 PyThreadState* __tstate = wxPyBeginAllowThreads();
12140 (arg1)->_SetSelf(arg2);
12141 wxPyEndAllowThreads(__tstate);
12142 if (PyErr_Occurred()) SWIG_fail;
12143 }
12144 resultobj = SWIG_Py_Void();
12145 return resultobj;
12146 fail:
12147 return NULL;
12148 }
12149
12150
12151 SWIGINTERN PyObject *PyImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12152 PyObject *obj;
12153 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12154 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyImageHandler, SWIG_NewClientData(obj));
12155 return SWIG_Py_Void();
12156 }
12157
12158 SWIGINTERN PyObject *PyImageHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12159 return SWIG_Python_InitShadowInstance(args);
12160 }
12161
12162 SWIGINTERN PyObject *_wrap_new_ImageHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12163 PyObject *resultobj = 0;
12164 wxImageHistogram *result = 0 ;
12165
12166 if (!SWIG_Python_UnpackTuple(args,"new_ImageHistogram",0,0,0)) SWIG_fail;
12167 {
12168 PyThreadState* __tstate = wxPyBeginAllowThreads();
12169 result = (wxImageHistogram *)new wxImageHistogram();
12170 wxPyEndAllowThreads(__tstate);
12171 if (PyErr_Occurred()) SWIG_fail;
12172 }
12173 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_NEW | 0 );
12174 return resultobj;
12175 fail:
12176 return NULL;
12177 }
12178
12179
12180 SWIGINTERN PyObject *_wrap_ImageHistogram_MakeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12181 PyObject *resultobj = 0;
12182 byte arg1 ;
12183 byte arg2 ;
12184 byte arg3 ;
12185 unsigned long result;
12186 unsigned char val1 ;
12187 int ecode1 = 0 ;
12188 unsigned char val2 ;
12189 int ecode2 = 0 ;
12190 unsigned char val3 ;
12191 int ecode3 = 0 ;
12192 PyObject * obj0 = 0 ;
12193 PyObject * obj1 = 0 ;
12194 PyObject * obj2 = 0 ;
12195 char * kwnames[] = {
12196 (char *) "r",(char *) "g",(char *) "b", NULL
12197 };
12198
12199 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12200 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12201 if (!SWIG_IsOK(ecode1)) {
12202 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ImageHistogram_MakeKey" "', expected argument " "1"" of type '" "byte""'");
12203 }
12204 arg1 = static_cast< byte >(val1);
12205 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12206 if (!SWIG_IsOK(ecode2)) {
12207 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_MakeKey" "', expected argument " "2"" of type '" "byte""'");
12208 }
12209 arg2 = static_cast< byte >(val2);
12210 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12211 if (!SWIG_IsOK(ecode3)) {
12212 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_MakeKey" "', expected argument " "3"" of type '" "byte""'");
12213 }
12214 arg3 = static_cast< byte >(val3);
12215 {
12216 PyThreadState* __tstate = wxPyBeginAllowThreads();
12217 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
12218 wxPyEndAllowThreads(__tstate);
12219 if (PyErr_Occurred()) SWIG_fail;
12220 }
12221 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12222 return resultobj;
12223 fail:
12224 return NULL;
12225 }
12226
12227
12228 SWIGINTERN PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12229 PyObject *resultobj = 0;
12230 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12231 byte *arg2 = (byte *) 0 ;
12232 byte *arg3 = (byte *) 0 ;
12233 byte *arg4 = (byte *) 0 ;
12234 byte arg5 = (byte) 1 ;
12235 byte arg6 = (byte) 0 ;
12236 byte arg7 = (byte) 0 ;
12237 bool result;
12238 void *argp1 = 0 ;
12239 int res1 = 0 ;
12240 byte temp2 ;
12241 int res2 = SWIG_TMPOBJ ;
12242 byte temp3 ;
12243 int res3 = SWIG_TMPOBJ ;
12244 byte temp4 ;
12245 int res4 = SWIG_TMPOBJ ;
12246 unsigned char val5 ;
12247 int ecode5 = 0 ;
12248 unsigned char val6 ;
12249 int ecode6 = 0 ;
12250 unsigned char val7 ;
12251 int ecode7 = 0 ;
12252 PyObject * obj0 = 0 ;
12253 PyObject * obj1 = 0 ;
12254 PyObject * obj2 = 0 ;
12255 PyObject * obj3 = 0 ;
12256 char * kwnames[] = {
12257 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
12258 };
12259
12260 arg2 = &temp2;
12261 arg3 = &temp3;
12262 arg4 = &temp4;
12263 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12264 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12265 if (!SWIG_IsOK(res1)) {
12266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImageHistogram const *""'");
12267 }
12268 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12269 if (obj1) {
12270 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
12271 if (!SWIG_IsOK(ecode5)) {
12272 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
12273 }
12274 arg5 = static_cast< byte >(val5);
12275 }
12276 if (obj2) {
12277 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
12278 if (!SWIG_IsOK(ecode6)) {
12279 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
12280 }
12281 arg6 = static_cast< byte >(val6);
12282 }
12283 if (obj3) {
12284 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
12285 if (!SWIG_IsOK(ecode7)) {
12286 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
12287 }
12288 arg7 = static_cast< byte >(val7);
12289 }
12290 {
12291 PyThreadState* __tstate = wxPyBeginAllowThreads();
12292 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
12293 wxPyEndAllowThreads(__tstate);
12294 if (PyErr_Occurred()) SWIG_fail;
12295 }
12296 {
12297 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12298 }
12299 if (SWIG_IsTmpObj(res2)) {
12300 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
12301 } else {
12302 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12303 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
12304 }
12305 if (SWIG_IsTmpObj(res3)) {
12306 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
12307 } else {
12308 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12309 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
12310 }
12311 if (SWIG_IsTmpObj(res4)) {
12312 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
12313 } else {
12314 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12315 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
12316 }
12317 return resultobj;
12318 fail:
12319 return NULL;
12320 }
12321
12322
12323 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12324 PyObject *resultobj = 0;
12325 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12326 unsigned long arg2 ;
12327 unsigned long result;
12328 void *argp1 = 0 ;
12329 int res1 = 0 ;
12330 unsigned long val2 ;
12331 int ecode2 = 0 ;
12332 PyObject * obj0 = 0 ;
12333 PyObject * obj1 = 0 ;
12334 char * kwnames[] = {
12335 (char *) "self",(char *) "key", NULL
12336 };
12337
12338 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) SWIG_fail;
12339 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12340 if (!SWIG_IsOK(res1)) {
12341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCount" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12342 }
12343 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12344 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
12345 if (!SWIG_IsOK(ecode2)) {
12346 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCount" "', expected argument " "2"" of type '" "unsigned long""'");
12347 }
12348 arg2 = static_cast< unsigned long >(val2);
12349 {
12350 PyThreadState* __tstate = wxPyBeginAllowThreads();
12351 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
12352 wxPyEndAllowThreads(__tstate);
12353 if (PyErr_Occurred()) SWIG_fail;
12354 }
12355 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12356 return resultobj;
12357 fail:
12358 return NULL;
12359 }
12360
12361
12362 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12363 PyObject *resultobj = 0;
12364 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12365 byte arg2 ;
12366 byte arg3 ;
12367 byte arg4 ;
12368 unsigned long result;
12369 void *argp1 = 0 ;
12370 int res1 = 0 ;
12371 unsigned char val2 ;
12372 int ecode2 = 0 ;
12373 unsigned char val3 ;
12374 int ecode3 = 0 ;
12375 unsigned char val4 ;
12376 int ecode4 = 0 ;
12377 PyObject * obj0 = 0 ;
12378 PyObject * obj1 = 0 ;
12379 PyObject * obj2 = 0 ;
12380 PyObject * obj3 = 0 ;
12381 char * kwnames[] = {
12382 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12383 };
12384
12385 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12386 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12387 if (!SWIG_IsOK(res1)) {
12388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12389 }
12390 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12391 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12392 if (!SWIG_IsOK(ecode2)) {
12393 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "2"" of type '" "byte""'");
12394 }
12395 arg2 = static_cast< byte >(val2);
12396 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12397 if (!SWIG_IsOK(ecode3)) {
12398 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "3"" of type '" "byte""'");
12399 }
12400 arg3 = static_cast< byte >(val3);
12401 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
12402 if (!SWIG_IsOK(ecode4)) {
12403 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "4"" of type '" "byte""'");
12404 }
12405 arg4 = static_cast< byte >(val4);
12406 {
12407 PyThreadState* __tstate = wxPyBeginAllowThreads();
12408 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
12409 wxPyEndAllowThreads(__tstate);
12410 if (PyErr_Occurred()) SWIG_fail;
12411 }
12412 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12413 return resultobj;
12414 fail:
12415 return NULL;
12416 }
12417
12418
12419 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12420 PyObject *resultobj = 0;
12421 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12422 wxColour *arg2 = 0 ;
12423 unsigned long result;
12424 void *argp1 = 0 ;
12425 int res1 = 0 ;
12426 wxColour temp2 ;
12427 PyObject * obj0 = 0 ;
12428 PyObject * obj1 = 0 ;
12429 char * kwnames[] = {
12430 (char *) "self",(char *) "colour", NULL
12431 };
12432
12433 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) SWIG_fail;
12434 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12435 if (!SWIG_IsOK(res1)) {
12436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountColour" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12437 }
12438 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12439 {
12440 arg2 = &temp2;
12441 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
12442 }
12443 {
12444 PyThreadState* __tstate = wxPyBeginAllowThreads();
12445 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
12446 wxPyEndAllowThreads(__tstate);
12447 if (PyErr_Occurred()) SWIG_fail;
12448 }
12449 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12450 return resultobj;
12451 fail:
12452 return NULL;
12453 }
12454
12455
12456 SWIGINTERN PyObject *ImageHistogram_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12457 PyObject *obj;
12458 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12459 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHistogram, SWIG_NewClientData(obj));
12460 return SWIG_Py_Void();
12461 }
12462
12463 SWIGINTERN PyObject *ImageHistogram_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12464 return SWIG_Python_InitShadowInstance(args);
12465 }
12466
12467 SWIGINTERN PyObject *_wrap_new_Image_RGBValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12468 PyObject *resultobj = 0;
12469 byte arg1 = (byte) 0 ;
12470 byte arg2 = (byte) 0 ;
12471 byte arg3 = (byte) 0 ;
12472 wxImage_RGBValue *result = 0 ;
12473 unsigned char val1 ;
12474 int ecode1 = 0 ;
12475 unsigned char val2 ;
12476 int ecode2 = 0 ;
12477 unsigned char val3 ;
12478 int ecode3 = 0 ;
12479 PyObject * obj0 = 0 ;
12480 PyObject * obj1 = 0 ;
12481 PyObject * obj2 = 0 ;
12482 char * kwnames[] = {
12483 (char *) "r",(char *) "g",(char *) "b", NULL
12484 };
12485
12486 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_RGBValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12487 if (obj0) {
12488 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12489 if (!SWIG_IsOK(ecode1)) {
12490 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_RGBValue" "', expected argument " "1"" of type '" "byte""'");
12491 }
12492 arg1 = static_cast< byte >(val1);
12493 }
12494 if (obj1) {
12495 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12496 if (!SWIG_IsOK(ecode2)) {
12497 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_RGBValue" "', expected argument " "2"" of type '" "byte""'");
12498 }
12499 arg2 = static_cast< byte >(val2);
12500 }
12501 if (obj2) {
12502 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12503 if (!SWIG_IsOK(ecode3)) {
12504 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_RGBValue" "', expected argument " "3"" of type '" "byte""'");
12505 }
12506 arg3 = static_cast< byte >(val3);
12507 }
12508 {
12509 PyThreadState* __tstate = wxPyBeginAllowThreads();
12510 result = (wxImage_RGBValue *)new wxImage_RGBValue(arg1,arg2,arg3);
12511 wxPyEndAllowThreads(__tstate);
12512 if (PyErr_Occurred()) SWIG_fail;
12513 }
12514 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_NEW | 0 );
12515 return resultobj;
12516 fail:
12517 return NULL;
12518 }
12519
12520
12521 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12522 PyObject *resultobj = 0;
12523 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12524 byte arg2 ;
12525 void *argp1 = 0 ;
12526 int res1 = 0 ;
12527 unsigned char val2 ;
12528 int ecode2 = 0 ;
12529 PyObject *swig_obj[2] ;
12530
12531 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_red_set",2,2,swig_obj)) SWIG_fail;
12532 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12533 if (!SWIG_IsOK(res1)) {
12534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12535 }
12536 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12537 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12538 if (!SWIG_IsOK(ecode2)) {
12539 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_red_set" "', expected argument " "2"" of type '" "byte""'");
12540 }
12541 arg2 = static_cast< byte >(val2);
12542 if (arg1) (arg1)->red = arg2;
12543
12544 resultobj = SWIG_Py_Void();
12545 return resultobj;
12546 fail:
12547 return NULL;
12548 }
12549
12550
12551 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12552 PyObject *resultobj = 0;
12553 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12554 byte result;
12555 void *argp1 = 0 ;
12556 int res1 = 0 ;
12557 PyObject *swig_obj[1] ;
12558
12559 if (!args) SWIG_fail;
12560 swig_obj[0] = args;
12561 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12562 if (!SWIG_IsOK(res1)) {
12563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12564 }
12565 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12566 result = (byte) ((arg1)->red);
12567 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12568 return resultobj;
12569 fail:
12570 return NULL;
12571 }
12572
12573
12574 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12575 PyObject *resultobj = 0;
12576 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12577 byte arg2 ;
12578 void *argp1 = 0 ;
12579 int res1 = 0 ;
12580 unsigned char val2 ;
12581 int ecode2 = 0 ;
12582 PyObject *swig_obj[2] ;
12583
12584 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_green_set",2,2,swig_obj)) SWIG_fail;
12585 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12586 if (!SWIG_IsOK(res1)) {
12587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12588 }
12589 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12590 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12591 if (!SWIG_IsOK(ecode2)) {
12592 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_green_set" "', expected argument " "2"" of type '" "byte""'");
12593 }
12594 arg2 = static_cast< byte >(val2);
12595 if (arg1) (arg1)->green = arg2;
12596
12597 resultobj = SWIG_Py_Void();
12598 return resultobj;
12599 fail:
12600 return NULL;
12601 }
12602
12603
12604 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12605 PyObject *resultobj = 0;
12606 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12607 byte result;
12608 void *argp1 = 0 ;
12609 int res1 = 0 ;
12610 PyObject *swig_obj[1] ;
12611
12612 if (!args) SWIG_fail;
12613 swig_obj[0] = args;
12614 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12615 if (!SWIG_IsOK(res1)) {
12616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12617 }
12618 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12619 result = (byte) ((arg1)->green);
12620 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12621 return resultobj;
12622 fail:
12623 return NULL;
12624 }
12625
12626
12627 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12628 PyObject *resultobj = 0;
12629 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12630 byte arg2 ;
12631 void *argp1 = 0 ;
12632 int res1 = 0 ;
12633 unsigned char val2 ;
12634 int ecode2 = 0 ;
12635 PyObject *swig_obj[2] ;
12636
12637 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_blue_set",2,2,swig_obj)) SWIG_fail;
12638 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12639 if (!SWIG_IsOK(res1)) {
12640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12641 }
12642 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12643 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12644 if (!SWIG_IsOK(ecode2)) {
12645 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_blue_set" "', expected argument " "2"" of type '" "byte""'");
12646 }
12647 arg2 = static_cast< byte >(val2);
12648 if (arg1) (arg1)->blue = arg2;
12649
12650 resultobj = SWIG_Py_Void();
12651 return resultobj;
12652 fail:
12653 return NULL;
12654 }
12655
12656
12657 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12658 PyObject *resultobj = 0;
12659 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12660 byte result;
12661 void *argp1 = 0 ;
12662 int res1 = 0 ;
12663 PyObject *swig_obj[1] ;
12664
12665 if (!args) SWIG_fail;
12666 swig_obj[0] = args;
12667 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12668 if (!SWIG_IsOK(res1)) {
12669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12670 }
12671 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12672 result = (byte) ((arg1)->blue);
12673 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12674 return resultobj;
12675 fail:
12676 return NULL;
12677 }
12678
12679
12680 SWIGINTERN PyObject *Image_RGBValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12681 PyObject *obj;
12682 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12683 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_RGBValue, SWIG_NewClientData(obj));
12684 return SWIG_Py_Void();
12685 }
12686
12687 SWIGINTERN PyObject *Image_RGBValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12688 return SWIG_Python_InitShadowInstance(args);
12689 }
12690
12691 SWIGINTERN PyObject *_wrap_new_Image_HSVValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12692 PyObject *resultobj = 0;
12693 double arg1 = (double) 0.0 ;
12694 double arg2 = (double) 0.0 ;
12695 double arg3 = (double) 0.0 ;
12696 wxImage_HSVValue *result = 0 ;
12697 double val1 ;
12698 int ecode1 = 0 ;
12699 double val2 ;
12700 int ecode2 = 0 ;
12701 double val3 ;
12702 int ecode3 = 0 ;
12703 PyObject * obj0 = 0 ;
12704 PyObject * obj1 = 0 ;
12705 PyObject * obj2 = 0 ;
12706 char * kwnames[] = {
12707 (char *) "h",(char *) "s",(char *) "v", NULL
12708 };
12709
12710 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_HSVValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12711 if (obj0) {
12712 ecode1 = SWIG_AsVal_double(obj0, &val1);
12713 if (!SWIG_IsOK(ecode1)) {
12714 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_HSVValue" "', expected argument " "1"" of type '" "double""'");
12715 }
12716 arg1 = static_cast< double >(val1);
12717 }
12718 if (obj1) {
12719 ecode2 = SWIG_AsVal_double(obj1, &val2);
12720 if (!SWIG_IsOK(ecode2)) {
12721 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_HSVValue" "', expected argument " "2"" of type '" "double""'");
12722 }
12723 arg2 = static_cast< double >(val2);
12724 }
12725 if (obj2) {
12726 ecode3 = SWIG_AsVal_double(obj2, &val3);
12727 if (!SWIG_IsOK(ecode3)) {
12728 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_HSVValue" "', expected argument " "3"" of type '" "double""'");
12729 }
12730 arg3 = static_cast< double >(val3);
12731 }
12732 {
12733 PyThreadState* __tstate = wxPyBeginAllowThreads();
12734 result = (wxImage_HSVValue *)new wxImage_HSVValue(arg1,arg2,arg3);
12735 wxPyEndAllowThreads(__tstate);
12736 if (PyErr_Occurred()) SWIG_fail;
12737 }
12738 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_NEW | 0 );
12739 return resultobj;
12740 fail:
12741 return NULL;
12742 }
12743
12744
12745 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12746 PyObject *resultobj = 0;
12747 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12748 double arg2 ;
12749 void *argp1 = 0 ;
12750 int res1 = 0 ;
12751 double val2 ;
12752 int ecode2 = 0 ;
12753 PyObject *swig_obj[2] ;
12754
12755 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_hue_set",2,2,swig_obj)) SWIG_fail;
12756 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12757 if (!SWIG_IsOK(res1)) {
12758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12759 }
12760 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12761 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12762 if (!SWIG_IsOK(ecode2)) {
12763 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_hue_set" "', expected argument " "2"" of type '" "double""'");
12764 }
12765 arg2 = static_cast< double >(val2);
12766 if (arg1) (arg1)->hue = arg2;
12767
12768 resultobj = SWIG_Py_Void();
12769 return resultobj;
12770 fail:
12771 return NULL;
12772 }
12773
12774
12775 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12776 PyObject *resultobj = 0;
12777 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12778 double result;
12779 void *argp1 = 0 ;
12780 int res1 = 0 ;
12781 PyObject *swig_obj[1] ;
12782
12783 if (!args) SWIG_fail;
12784 swig_obj[0] = args;
12785 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12786 if (!SWIG_IsOK(res1)) {
12787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12788 }
12789 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12790 result = (double) ((arg1)->hue);
12791 resultobj = SWIG_From_double(static_cast< double >(result));
12792 return resultobj;
12793 fail:
12794 return NULL;
12795 }
12796
12797
12798 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12799 PyObject *resultobj = 0;
12800 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12801 double arg2 ;
12802 void *argp1 = 0 ;
12803 int res1 = 0 ;
12804 double val2 ;
12805 int ecode2 = 0 ;
12806 PyObject *swig_obj[2] ;
12807
12808 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_saturation_set",2,2,swig_obj)) SWIG_fail;
12809 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12810 if (!SWIG_IsOK(res1)) {
12811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12812 }
12813 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12814 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12815 if (!SWIG_IsOK(ecode2)) {
12816 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "2"" of type '" "double""'");
12817 }
12818 arg2 = static_cast< double >(val2);
12819 if (arg1) (arg1)->saturation = arg2;
12820
12821 resultobj = SWIG_Py_Void();
12822 return resultobj;
12823 fail:
12824 return NULL;
12825 }
12826
12827
12828 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12829 PyObject *resultobj = 0;
12830 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12831 double result;
12832 void *argp1 = 0 ;
12833 int res1 = 0 ;
12834 PyObject *swig_obj[1] ;
12835
12836 if (!args) SWIG_fail;
12837 swig_obj[0] = args;
12838 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12839 if (!SWIG_IsOK(res1)) {
12840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12841 }
12842 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12843 result = (double) ((arg1)->saturation);
12844 resultobj = SWIG_From_double(static_cast< double >(result));
12845 return resultobj;
12846 fail:
12847 return NULL;
12848 }
12849
12850
12851 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12852 PyObject *resultobj = 0;
12853 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12854 double arg2 ;
12855 void *argp1 = 0 ;
12856 int res1 = 0 ;
12857 double val2 ;
12858 int ecode2 = 0 ;
12859 PyObject *swig_obj[2] ;
12860
12861 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_value_set",2,2,swig_obj)) SWIG_fail;
12862 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12863 if (!SWIG_IsOK(res1)) {
12864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12865 }
12866 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12867 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12868 if (!SWIG_IsOK(ecode2)) {
12869 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_value_set" "', expected argument " "2"" of type '" "double""'");
12870 }
12871 arg2 = static_cast< double >(val2);
12872 if (arg1) (arg1)->value = arg2;
12873
12874 resultobj = SWIG_Py_Void();
12875 return resultobj;
12876 fail:
12877 return NULL;
12878 }
12879
12880
12881 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12882 PyObject *resultobj = 0;
12883 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12884 double result;
12885 void *argp1 = 0 ;
12886 int res1 = 0 ;
12887 PyObject *swig_obj[1] ;
12888
12889 if (!args) SWIG_fail;
12890 swig_obj[0] = args;
12891 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12892 if (!SWIG_IsOK(res1)) {
12893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12894 }
12895 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12896 result = (double) ((arg1)->value);
12897 resultobj = SWIG_From_double(static_cast< double >(result));
12898 return resultobj;
12899 fail:
12900 return NULL;
12901 }
12902
12903
12904 SWIGINTERN PyObject *Image_HSVValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12905 PyObject *obj;
12906 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12907 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_HSVValue, SWIG_NewClientData(obj));
12908 return SWIG_Py_Void();
12909 }
12910
12911 SWIGINTERN PyObject *Image_HSVValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12912 return SWIG_Python_InitShadowInstance(args);
12913 }
12914
12915 SWIGINTERN PyObject *_wrap_new_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12916 PyObject *resultobj = 0;
12917 wxString *arg1 = 0 ;
12918 long arg2 = (long) wxBITMAP_TYPE_ANY ;
12919 int arg3 = (int) -1 ;
12920 wxImage *result = 0 ;
12921 bool temp1 = false ;
12922 long val2 ;
12923 int ecode2 = 0 ;
12924 int val3 ;
12925 int ecode3 = 0 ;
12926 PyObject * obj0 = 0 ;
12927 PyObject * obj1 = 0 ;
12928 PyObject * obj2 = 0 ;
12929 char * kwnames[] = {
12930 (char *) "name",(char *) "type",(char *) "index", NULL
12931 };
12932
12933 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12934 {
12935 arg1 = wxString_in_helper(obj0);
12936 if (arg1 == NULL) SWIG_fail;
12937 temp1 = true;
12938 }
12939 if (obj1) {
12940 ecode2 = SWIG_AsVal_long(obj1, &val2);
12941 if (!SWIG_IsOK(ecode2)) {
12942 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image" "', expected argument " "2"" of type '" "long""'");
12943 }
12944 arg2 = static_cast< long >(val2);
12945 }
12946 if (obj2) {
12947 ecode3 = SWIG_AsVal_int(obj2, &val3);
12948 if (!SWIG_IsOK(ecode3)) {
12949 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image" "', expected argument " "3"" of type '" "int""'");
12950 }
12951 arg3 = static_cast< int >(val3);
12952 }
12953 {
12954 PyThreadState* __tstate = wxPyBeginAllowThreads();
12955 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
12956 wxPyEndAllowThreads(__tstate);
12957 if (PyErr_Occurred()) SWIG_fail;
12958 }
12959 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_NEW | 0 );
12960 {
12961 if (temp1)
12962 delete arg1;
12963 }
12964 return resultobj;
12965 fail:
12966 {
12967 if (temp1)
12968 delete arg1;
12969 }
12970 return NULL;
12971 }
12972
12973
12974 SWIGINTERN PyObject *_wrap_delete_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12975 PyObject *resultobj = 0;
12976 wxImage *arg1 = (wxImage *) 0 ;
12977 void *argp1 = 0 ;
12978 int res1 = 0 ;
12979 PyObject *swig_obj[1] ;
12980
12981 if (!args) SWIG_fail;
12982 swig_obj[0] = args;
12983 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, SWIG_POINTER_DISOWN | 0 );
12984 if (!SWIG_IsOK(res1)) {
12985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Image" "', expected argument " "1"" of type '" "wxImage *""'");
12986 }
12987 arg1 = reinterpret_cast< wxImage * >(argp1);
12988 {
12989 PyThreadState* __tstate = wxPyBeginAllowThreads();
12990 delete arg1;
12991
12992 wxPyEndAllowThreads(__tstate);
12993 if (PyErr_Occurred()) SWIG_fail;
12994 }
12995 resultobj = SWIG_Py_Void();
12996 return resultobj;
12997 fail:
12998 return NULL;
12999 }
13000
13001
13002 SWIGINTERN PyObject *_wrap_new_ImageFromMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13003 PyObject *resultobj = 0;
13004 wxString *arg1 = 0 ;
13005 wxString *arg2 = 0 ;
13006 int arg3 = (int) -1 ;
13007 wxImage *result = 0 ;
13008 bool temp1 = false ;
13009 bool temp2 = false ;
13010 int val3 ;
13011 int ecode3 = 0 ;
13012 PyObject * obj0 = 0 ;
13013 PyObject * obj1 = 0 ;
13014 PyObject * obj2 = 0 ;
13015 char * kwnames[] = {
13016 (char *) "name",(char *) "mimetype",(char *) "index", NULL
13017 };
13018
13019 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13020 {
13021 arg1 = wxString_in_helper(obj0);
13022 if (arg1 == NULL) SWIG_fail;
13023 temp1 = true;
13024 }
13025 {
13026 arg2 = wxString_in_helper(obj1);
13027 if (arg2 == NULL) SWIG_fail;
13028 temp2 = true;
13029 }
13030 if (obj2) {
13031 ecode3 = SWIG_AsVal_int(obj2, &val3);
13032 if (!SWIG_IsOK(ecode3)) {
13033 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromMime" "', expected argument " "3"" of type '" "int""'");
13034 }
13035 arg3 = static_cast< int >(val3);
13036 }
13037 {
13038 PyThreadState* __tstate = wxPyBeginAllowThreads();
13039 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
13040 wxPyEndAllowThreads(__tstate);
13041 if (PyErr_Occurred()) SWIG_fail;
13042 }
13043 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13044 {
13045 if (temp1)
13046 delete arg1;
13047 }
13048 {
13049 if (temp2)
13050 delete arg2;
13051 }
13052 return resultobj;
13053 fail:
13054 {
13055 if (temp1)
13056 delete arg1;
13057 }
13058 {
13059 if (temp2)
13060 delete arg2;
13061 }
13062 return NULL;
13063 }
13064
13065
13066 SWIGINTERN PyObject *_wrap_new_ImageFromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13067 PyObject *resultobj = 0;
13068 wxInputStream *arg1 = 0 ;
13069 long arg2 = (long) wxBITMAP_TYPE_ANY ;
13070 int arg3 = (int) -1 ;
13071 wxImage *result = 0 ;
13072 wxPyInputStream *temp1 ;
13073 bool created1 ;
13074 long val2 ;
13075 int ecode2 = 0 ;
13076 int val3 ;
13077 int ecode3 = 0 ;
13078 PyObject * obj0 = 0 ;
13079 PyObject * obj1 = 0 ;
13080 PyObject * obj2 = 0 ;
13081 char * kwnames[] = {
13082 (char *) "stream",(char *) "type",(char *) "index", NULL
13083 };
13084
13085 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13086 {
13087 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13088 arg1 = temp1->m_wxis;
13089 created1 = false;
13090 } else {
13091 PyErr_Clear(); // clear the failure of the wxPyConvert above
13092 arg1 = wxPyCBInputStream_create(obj0, false);
13093 if (arg1 == NULL) {
13094 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13095 SWIG_fail;
13096 }
13097 created1 = true;
13098 }
13099 }
13100 if (obj1) {
13101 ecode2 = SWIG_AsVal_long(obj1, &val2);
13102 if (!SWIG_IsOK(ecode2)) {
13103 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromStream" "', expected argument " "2"" of type '" "long""'");
13104 }
13105 arg2 = static_cast< long >(val2);
13106 }
13107 if (obj2) {
13108 ecode3 = SWIG_AsVal_int(obj2, &val3);
13109 if (!SWIG_IsOK(ecode3)) {
13110 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStream" "', expected argument " "3"" of type '" "int""'");
13111 }
13112 arg3 = static_cast< int >(val3);
13113 }
13114 {
13115 PyThreadState* __tstate = wxPyBeginAllowThreads();
13116 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
13117 wxPyEndAllowThreads(__tstate);
13118 if (PyErr_Occurred()) SWIG_fail;
13119 }
13120 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13121 {
13122 if (created1) delete arg1;
13123 }
13124 return resultobj;
13125 fail:
13126 {
13127 if (created1) delete arg1;
13128 }
13129 return NULL;
13130 }
13131
13132
13133 SWIGINTERN PyObject *_wrap_new_ImageFromStreamMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13134 PyObject *resultobj = 0;
13135 wxInputStream *arg1 = 0 ;
13136 wxString *arg2 = 0 ;
13137 int arg3 = (int) -1 ;
13138 wxImage *result = 0 ;
13139 wxPyInputStream *temp1 ;
13140 bool created1 ;
13141 bool temp2 = false ;
13142 int val3 ;
13143 int ecode3 = 0 ;
13144 PyObject * obj0 = 0 ;
13145 PyObject * obj1 = 0 ;
13146 PyObject * obj2 = 0 ;
13147 char * kwnames[] = {
13148 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
13149 };
13150
13151 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13152 {
13153 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13154 arg1 = temp1->m_wxis;
13155 created1 = false;
13156 } else {
13157 PyErr_Clear(); // clear the failure of the wxPyConvert above
13158 arg1 = wxPyCBInputStream_create(obj0, false);
13159 if (arg1 == NULL) {
13160 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13161 SWIG_fail;
13162 }
13163 created1 = true;
13164 }
13165 }
13166 {
13167 arg2 = wxString_in_helper(obj1);
13168 if (arg2 == NULL) SWIG_fail;
13169 temp2 = true;
13170 }
13171 if (obj2) {
13172 ecode3 = SWIG_AsVal_int(obj2, &val3);
13173 if (!SWIG_IsOK(ecode3)) {
13174 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStreamMime" "', expected argument " "3"" of type '" "int""'");
13175 }
13176 arg3 = static_cast< int >(val3);
13177 }
13178 {
13179 PyThreadState* __tstate = wxPyBeginAllowThreads();
13180 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
13181 wxPyEndAllowThreads(__tstate);
13182 if (PyErr_Occurred()) SWIG_fail;
13183 }
13184 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13185 {
13186 if (created1) delete arg1;
13187 }
13188 {
13189 if (temp2)
13190 delete arg2;
13191 }
13192 return resultobj;
13193 fail:
13194 {
13195 if (created1) delete arg1;
13196 }
13197 {
13198 if (temp2)
13199 delete arg2;
13200 }
13201 return NULL;
13202 }
13203
13204
13205 SWIGINTERN PyObject *_wrap_new_EmptyImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13206 PyObject *resultobj = 0;
13207 int arg1 = (int) 0 ;
13208 int arg2 = (int) 0 ;
13209 bool arg3 = (bool) true ;
13210 wxImage *result = 0 ;
13211 int val1 ;
13212 int ecode1 = 0 ;
13213 int val2 ;
13214 int ecode2 = 0 ;
13215 bool val3 ;
13216 int ecode3 = 0 ;
13217 PyObject * obj0 = 0 ;
13218 PyObject * obj1 = 0 ;
13219 PyObject * obj2 = 0 ;
13220 char * kwnames[] = {
13221 (char *) "width",(char *) "height",(char *) "clear", NULL
13222 };
13223
13224 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13225 if (obj0) {
13226 ecode1 = SWIG_AsVal_int(obj0, &val1);
13227 if (!SWIG_IsOK(ecode1)) {
13228 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EmptyImage" "', expected argument " "1"" of type '" "int""'");
13229 }
13230 arg1 = static_cast< int >(val1);
13231 }
13232 if (obj1) {
13233 ecode2 = SWIG_AsVal_int(obj1, &val2);
13234 if (!SWIG_IsOK(ecode2)) {
13235 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EmptyImage" "', expected argument " "2"" of type '" "int""'");
13236 }
13237 arg2 = static_cast< int >(val2);
13238 }
13239 if (obj2) {
13240 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13241 if (!SWIG_IsOK(ecode3)) {
13242 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EmptyImage" "', expected argument " "3"" of type '" "bool""'");
13243 }
13244 arg3 = static_cast< bool >(val3);
13245 }
13246 {
13247 PyThreadState* __tstate = wxPyBeginAllowThreads();
13248 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
13249 wxPyEndAllowThreads(__tstate);
13250 if (PyErr_Occurred()) SWIG_fail;
13251 }
13252 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13253 return resultobj;
13254 fail:
13255 return NULL;
13256 }
13257
13258
13259 SWIGINTERN PyObject *_wrap_new_ImageFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13260 PyObject *resultobj = 0;
13261 wxBitmap *arg1 = 0 ;
13262 wxImage *result = 0 ;
13263 void *argp1 = 0 ;
13264 int res1 = 0 ;
13265 PyObject * obj0 = 0 ;
13266 char * kwnames[] = {
13267 (char *) "bitmap", NULL
13268 };
13269
13270 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) SWIG_fail;
13271 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
13272 if (!SWIG_IsOK(res1)) {
13273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13274 }
13275 if (!argp1) {
13276 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13277 }
13278 arg1 = reinterpret_cast< wxBitmap * >(argp1);
13279 {
13280 if (!wxPyCheckForApp()) SWIG_fail;
13281 PyThreadState* __tstate = wxPyBeginAllowThreads();
13282 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
13283 wxPyEndAllowThreads(__tstate);
13284 if (PyErr_Occurred()) SWIG_fail;
13285 }
13286 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13287 return resultobj;
13288 fail:
13289 return NULL;
13290 }
13291
13292
13293 SWIGINTERN PyObject *_wrap_new_ImageFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13294 PyObject *resultobj = 0;
13295 int arg1 ;
13296 int arg2 ;
13297 buffer arg3 ;
13298 int arg4 ;
13299 wxImage *result = 0 ;
13300 int val1 ;
13301 int ecode1 = 0 ;
13302 int val2 ;
13303 int ecode2 = 0 ;
13304 PyObject * obj0 = 0 ;
13305 PyObject * obj1 = 0 ;
13306 PyObject * obj2 = 0 ;
13307 char * kwnames[] = {
13308 (char *) "width",(char *) "height",(char *) "data", NULL
13309 };
13310
13311 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13312 ecode1 = SWIG_AsVal_int(obj0, &val1);
13313 if (!SWIG_IsOK(ecode1)) {
13314 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromData" "', expected argument " "1"" of type '" "int""'");
13315 }
13316 arg1 = static_cast< int >(val1);
13317 ecode2 = SWIG_AsVal_int(obj1, &val2);
13318 if (!SWIG_IsOK(ecode2)) {
13319 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromData" "', expected argument " "2"" of type '" "int""'");
13320 }
13321 arg2 = static_cast< int >(val2);
13322 {
13323 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
13324 }
13325 {
13326 PyThreadState* __tstate = wxPyBeginAllowThreads();
13327 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
13328 wxPyEndAllowThreads(__tstate);
13329 if (PyErr_Occurred()) SWIG_fail;
13330 }
13331 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13332 return resultobj;
13333 fail:
13334 return NULL;
13335 }
13336
13337
13338 SWIGINTERN PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13339 PyObject *resultobj = 0;
13340 int arg1 ;
13341 int arg2 ;
13342 buffer arg3 ;
13343 int arg4 ;
13344 buffer arg5 ;
13345 int arg6 ;
13346 wxImage *result = 0 ;
13347 int val1 ;
13348 int ecode1 = 0 ;
13349 int val2 ;
13350 int ecode2 = 0 ;
13351 PyObject * obj0 = 0 ;
13352 PyObject * obj1 = 0 ;
13353 PyObject * obj2 = 0 ;
13354 PyObject * obj3 = 0 ;
13355 char * kwnames[] = {
13356 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
13357 };
13358
13359 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13360 ecode1 = SWIG_AsVal_int(obj0, &val1);
13361 if (!SWIG_IsOK(ecode1)) {
13362 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "1"" of type '" "int""'");
13363 }
13364 arg1 = static_cast< int >(val1);
13365 ecode2 = SWIG_AsVal_int(obj1, &val2);
13366 if (!SWIG_IsOK(ecode2)) {
13367 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "2"" of type '" "int""'");
13368 }
13369 arg2 = static_cast< int >(val2);
13370 {
13371 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
13372 }
13373 {
13374 if (!PyArg_Parse(obj3, "t#", &arg5, &arg6)) SWIG_fail;
13375 }
13376 {
13377 PyThreadState* __tstate = wxPyBeginAllowThreads();
13378 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
13379 wxPyEndAllowThreads(__tstate);
13380 if (PyErr_Occurred()) SWIG_fail;
13381 }
13382 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13383 return resultobj;
13384 fail:
13385 return NULL;
13386 }
13387
13388
13389 SWIGINTERN PyObject *_wrap_Image_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13390 PyObject *resultobj = 0;
13391 wxImage *arg1 = (wxImage *) 0 ;
13392 int arg2 ;
13393 int arg3 ;
13394 bool arg4 = (bool) true ;
13395 void *argp1 = 0 ;
13396 int res1 = 0 ;
13397 int val2 ;
13398 int ecode2 = 0 ;
13399 int val3 ;
13400 int ecode3 = 0 ;
13401 bool val4 ;
13402 int ecode4 = 0 ;
13403 PyObject * obj0 = 0 ;
13404 PyObject * obj1 = 0 ;
13405 PyObject * obj2 = 0 ;
13406 PyObject * obj3 = 0 ;
13407 char * kwnames[] = {
13408 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
13409 };
13410
13411 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13412 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13413 if (!SWIG_IsOK(res1)) {
13414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Create" "', expected argument " "1"" of type '" "wxImage *""'");
13415 }
13416 arg1 = reinterpret_cast< wxImage * >(argp1);
13417 ecode2 = SWIG_AsVal_int(obj1, &val2);
13418 if (!SWIG_IsOK(ecode2)) {
13419 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Create" "', expected argument " "2"" of type '" "int""'");
13420 }
13421 arg2 = static_cast< int >(val2);
13422 ecode3 = SWIG_AsVal_int(obj2, &val3);
13423 if (!SWIG_IsOK(ecode3)) {
13424 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Create" "', expected argument " "3"" of type '" "int""'");
13425 }
13426 arg3 = static_cast< int >(val3);
13427 if (obj3) {
13428 ecode4 = SWIG_AsVal_bool(obj3, &val4);
13429 if (!SWIG_IsOK(ecode4)) {
13430 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Create" "', expected argument " "4"" of type '" "bool""'");
13431 }
13432 arg4 = static_cast< bool >(val4);
13433 }
13434 {
13435 PyThreadState* __tstate = wxPyBeginAllowThreads();
13436 (arg1)->Create(arg2,arg3,arg4);
13437 wxPyEndAllowThreads(__tstate);
13438 if (PyErr_Occurred()) SWIG_fail;
13439 }
13440 resultobj = SWIG_Py_Void();
13441 return resultobj;
13442 fail:
13443 return NULL;
13444 }
13445
13446
13447 SWIGINTERN PyObject *_wrap_Image_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13448 PyObject *resultobj = 0;
13449 wxImage *arg1 = (wxImage *) 0 ;
13450 void *argp1 = 0 ;
13451 int res1 = 0 ;
13452 PyObject *swig_obj[1] ;
13453
13454 if (!args) SWIG_fail;
13455 swig_obj[0] = args;
13456 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13457 if (!SWIG_IsOK(res1)) {
13458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Destroy" "', expected argument " "1"" of type '" "wxImage *""'");
13459 }
13460 arg1 = reinterpret_cast< wxImage * >(argp1);
13461 {
13462 PyThreadState* __tstate = wxPyBeginAllowThreads();
13463 (arg1)->Destroy();
13464 wxPyEndAllowThreads(__tstate);
13465 if (PyErr_Occurred()) SWIG_fail;
13466 }
13467 resultobj = SWIG_Py_Void();
13468 return resultobj;
13469 fail:
13470 return NULL;
13471 }
13472
13473
13474 SWIGINTERN PyObject *_wrap_Image_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13475 PyObject *resultobj = 0;
13476 wxImage *arg1 = (wxImage *) 0 ;
13477 int arg2 ;
13478 int arg3 ;
13479 SwigValueWrapper<wxImage > result;
13480 void *argp1 = 0 ;
13481 int res1 = 0 ;
13482 int val2 ;
13483 int ecode2 = 0 ;
13484 int val3 ;
13485 int ecode3 = 0 ;
13486 PyObject * obj0 = 0 ;
13487 PyObject * obj1 = 0 ;
13488 PyObject * obj2 = 0 ;
13489 char * kwnames[] = {
13490 (char *) "self",(char *) "width",(char *) "height", NULL
13491 };
13492
13493 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13494 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13495 if (!SWIG_IsOK(res1)) {
13496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Scale" "', expected argument " "1"" of type '" "wxImage *""'");
13497 }
13498 arg1 = reinterpret_cast< wxImage * >(argp1);
13499 ecode2 = SWIG_AsVal_int(obj1, &val2);
13500 if (!SWIG_IsOK(ecode2)) {
13501 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Scale" "', expected argument " "2"" of type '" "int""'");
13502 }
13503 arg2 = static_cast< int >(val2);
13504 ecode3 = SWIG_AsVal_int(obj2, &val3);
13505 if (!SWIG_IsOK(ecode3)) {
13506 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Scale" "', expected argument " "3"" of type '" "int""'");
13507 }
13508 arg3 = static_cast< int >(val3);
13509 {
13510 PyThreadState* __tstate = wxPyBeginAllowThreads();
13511 result = (arg1)->Scale(arg2,arg3);
13512 wxPyEndAllowThreads(__tstate);
13513 if (PyErr_Occurred()) SWIG_fail;
13514 }
13515 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13516 return resultobj;
13517 fail:
13518 return NULL;
13519 }
13520
13521
13522 SWIGINTERN PyObject *_wrap_Image_ShrinkBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13523 PyObject *resultobj = 0;
13524 wxImage *arg1 = (wxImage *) 0 ;
13525 int arg2 ;
13526 int arg3 ;
13527 SwigValueWrapper<wxImage > result;
13528 void *argp1 = 0 ;
13529 int res1 = 0 ;
13530 int val2 ;
13531 int ecode2 = 0 ;
13532 int val3 ;
13533 int ecode3 = 0 ;
13534 PyObject * obj0 = 0 ;
13535 PyObject * obj1 = 0 ;
13536 PyObject * obj2 = 0 ;
13537 char * kwnames[] = {
13538 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
13539 };
13540
13541 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13542 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13543 if (!SWIG_IsOK(res1)) {
13544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ShrinkBy" "', expected argument " "1"" of type '" "wxImage const *""'");
13545 }
13546 arg1 = reinterpret_cast< wxImage * >(argp1);
13547 ecode2 = SWIG_AsVal_int(obj1, &val2);
13548 if (!SWIG_IsOK(ecode2)) {
13549 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ShrinkBy" "', expected argument " "2"" of type '" "int""'");
13550 }
13551 arg2 = static_cast< int >(val2);
13552 ecode3 = SWIG_AsVal_int(obj2, &val3);
13553 if (!SWIG_IsOK(ecode3)) {
13554 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ShrinkBy" "', expected argument " "3"" of type '" "int""'");
13555 }
13556 arg3 = static_cast< int >(val3);
13557 {
13558 PyThreadState* __tstate = wxPyBeginAllowThreads();
13559 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
13560 wxPyEndAllowThreads(__tstate);
13561 if (PyErr_Occurred()) SWIG_fail;
13562 }
13563 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13564 return resultobj;
13565 fail:
13566 return NULL;
13567 }
13568
13569
13570 SWIGINTERN PyObject *_wrap_Image_Rescale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13571 PyObject *resultobj = 0;
13572 wxImage *arg1 = (wxImage *) 0 ;
13573 int arg2 ;
13574 int arg3 ;
13575 wxImage *result = 0 ;
13576 void *argp1 = 0 ;
13577 int res1 = 0 ;
13578 int val2 ;
13579 int ecode2 = 0 ;
13580 int val3 ;
13581 int ecode3 = 0 ;
13582 PyObject * obj0 = 0 ;
13583 PyObject * obj1 = 0 ;
13584 PyObject * obj2 = 0 ;
13585 char * kwnames[] = {
13586 (char *) "self",(char *) "width",(char *) "height", NULL
13587 };
13588
13589 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Rescale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13590 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13591 if (!SWIG_IsOK(res1)) {
13592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rescale" "', expected argument " "1"" of type '" "wxImage *""'");
13593 }
13594 arg1 = reinterpret_cast< wxImage * >(argp1);
13595 ecode2 = SWIG_AsVal_int(obj1, &val2);
13596 if (!SWIG_IsOK(ecode2)) {
13597 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rescale" "', expected argument " "2"" of type '" "int""'");
13598 }
13599 arg2 = static_cast< int >(val2);
13600 ecode3 = SWIG_AsVal_int(obj2, &val3);
13601 if (!SWIG_IsOK(ecode3)) {
13602 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Rescale" "', expected argument " "3"" of type '" "int""'");
13603 }
13604 arg3 = static_cast< int >(val3);
13605 {
13606 PyThreadState* __tstate = wxPyBeginAllowThreads();
13607 {
13608 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3);
13609 result = (wxImage *) &_result_ref;
13610 }
13611 wxPyEndAllowThreads(__tstate);
13612 if (PyErr_Occurred()) SWIG_fail;
13613 }
13614 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13615 return resultobj;
13616 fail:
13617 return NULL;
13618 }
13619
13620
13621 SWIGINTERN PyObject *_wrap_Image_Resize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13622 PyObject *resultobj = 0;
13623 wxImage *arg1 = (wxImage *) 0 ;
13624 wxSize *arg2 = 0 ;
13625 wxPoint *arg3 = 0 ;
13626 int arg4 = (int) -1 ;
13627 int arg5 = (int) -1 ;
13628 int arg6 = (int) -1 ;
13629 wxImage *result = 0 ;
13630 void *argp1 = 0 ;
13631 int res1 = 0 ;
13632 wxSize temp2 ;
13633 wxPoint temp3 ;
13634 int val4 ;
13635 int ecode4 = 0 ;
13636 int val5 ;
13637 int ecode5 = 0 ;
13638 int val6 ;
13639 int ecode6 = 0 ;
13640 PyObject * obj0 = 0 ;
13641 PyObject * obj1 = 0 ;
13642 PyObject * obj2 = 0 ;
13643 PyObject * obj3 = 0 ;
13644 PyObject * obj4 = 0 ;
13645 PyObject * obj5 = 0 ;
13646 char * kwnames[] = {
13647 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
13648 };
13649
13650 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13651 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13652 if (!SWIG_IsOK(res1)) {
13653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Resize" "', expected argument " "1"" of type '" "wxImage *""'");
13654 }
13655 arg1 = reinterpret_cast< wxImage * >(argp1);
13656 {
13657 arg2 = &temp2;
13658 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
13659 }
13660 {
13661 arg3 = &temp3;
13662 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13663 }
13664 if (obj3) {
13665 ecode4 = SWIG_AsVal_int(obj3, &val4);
13666 if (!SWIG_IsOK(ecode4)) {
13667 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Resize" "', expected argument " "4"" of type '" "int""'");
13668 }
13669 arg4 = static_cast< int >(val4);
13670 }
13671 if (obj4) {
13672 ecode5 = SWIG_AsVal_int(obj4, &val5);
13673 if (!SWIG_IsOK(ecode5)) {
13674 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Resize" "', expected argument " "5"" of type '" "int""'");
13675 }
13676 arg5 = static_cast< int >(val5);
13677 }
13678 if (obj5) {
13679 ecode6 = SWIG_AsVal_int(obj5, &val6);
13680 if (!SWIG_IsOK(ecode6)) {
13681 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Resize" "', expected argument " "6"" of type '" "int""'");
13682 }
13683 arg6 = static_cast< int >(val6);
13684 }
13685 {
13686 PyThreadState* __tstate = wxPyBeginAllowThreads();
13687 {
13688 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
13689 result = (wxImage *) &_result_ref;
13690 }
13691 wxPyEndAllowThreads(__tstate);
13692 if (PyErr_Occurred()) SWIG_fail;
13693 }
13694 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13695 return resultobj;
13696 fail:
13697 return NULL;
13698 }
13699
13700
13701 SWIGINTERN PyObject *_wrap_Image_SetRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13702 PyObject *resultobj = 0;
13703 wxImage *arg1 = (wxImage *) 0 ;
13704 int arg2 ;
13705 int arg3 ;
13706 byte arg4 ;
13707 byte arg5 ;
13708 byte arg6 ;
13709 void *argp1 = 0 ;
13710 int res1 = 0 ;
13711 int val2 ;
13712 int ecode2 = 0 ;
13713 int val3 ;
13714 int ecode3 = 0 ;
13715 unsigned char val4 ;
13716 int ecode4 = 0 ;
13717 unsigned char val5 ;
13718 int ecode5 = 0 ;
13719 unsigned char val6 ;
13720 int ecode6 = 0 ;
13721 PyObject * obj0 = 0 ;
13722 PyObject * obj1 = 0 ;
13723 PyObject * obj2 = 0 ;
13724 PyObject * obj3 = 0 ;
13725 PyObject * obj4 = 0 ;
13726 PyObject * obj5 = 0 ;
13727 char * kwnames[] = {
13728 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
13729 };
13730
13731 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13732 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13733 if (!SWIG_IsOK(res1)) {
13734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGB" "', expected argument " "1"" of type '" "wxImage *""'");
13735 }
13736 arg1 = reinterpret_cast< wxImage * >(argp1);
13737 ecode2 = SWIG_AsVal_int(obj1, &val2);
13738 if (!SWIG_IsOK(ecode2)) {
13739 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetRGB" "', expected argument " "2"" of type '" "int""'");
13740 }
13741 arg2 = static_cast< int >(val2);
13742 ecode3 = SWIG_AsVal_int(obj2, &val3);
13743 if (!SWIG_IsOK(ecode3)) {
13744 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGB" "', expected argument " "3"" of type '" "int""'");
13745 }
13746 arg3 = static_cast< int >(val3);
13747 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13748 if (!SWIG_IsOK(ecode4)) {
13749 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGB" "', expected argument " "4"" of type '" "byte""'");
13750 }
13751 arg4 = static_cast< byte >(val4);
13752 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
13753 if (!SWIG_IsOK(ecode5)) {
13754 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGB" "', expected argument " "5"" of type '" "byte""'");
13755 }
13756 arg5 = static_cast< byte >(val5);
13757 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
13758 if (!SWIG_IsOK(ecode6)) {
13759 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_SetRGB" "', expected argument " "6"" of type '" "byte""'");
13760 }
13761 arg6 = static_cast< byte >(val6);
13762 {
13763 PyThreadState* __tstate = wxPyBeginAllowThreads();
13764 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
13765 wxPyEndAllowThreads(__tstate);
13766 if (PyErr_Occurred()) SWIG_fail;
13767 }
13768 resultobj = SWIG_Py_Void();
13769 return resultobj;
13770 fail:
13771 return NULL;
13772 }
13773
13774
13775 SWIGINTERN PyObject *_wrap_Image_SetRGBRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13776 PyObject *resultobj = 0;
13777 wxImage *arg1 = (wxImage *) 0 ;
13778 wxRect *arg2 = 0 ;
13779 byte arg3 ;
13780 byte arg4 ;
13781 byte arg5 ;
13782 void *argp1 = 0 ;
13783 int res1 = 0 ;
13784 wxRect temp2 ;
13785 unsigned char val3 ;
13786 int ecode3 = 0 ;
13787 unsigned char val4 ;
13788 int ecode4 = 0 ;
13789 unsigned char val5 ;
13790 int ecode5 = 0 ;
13791 PyObject * obj0 = 0 ;
13792 PyObject * obj1 = 0 ;
13793 PyObject * obj2 = 0 ;
13794 PyObject * obj3 = 0 ;
13795 PyObject * obj4 = 0 ;
13796 char * kwnames[] = {
13797 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
13798 };
13799
13800 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
13801 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13802 if (!SWIG_IsOK(res1)) {
13803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGBRect" "', expected argument " "1"" of type '" "wxImage *""'");
13804 }
13805 arg1 = reinterpret_cast< wxImage * >(argp1);
13806 {
13807 arg2 = &temp2;
13808 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13809 }
13810 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
13811 if (!SWIG_IsOK(ecode3)) {
13812 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGBRect" "', expected argument " "3"" of type '" "byte""'");
13813 }
13814 arg3 = static_cast< byte >(val3);
13815 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13816 if (!SWIG_IsOK(ecode4)) {
13817 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGBRect" "', expected argument " "4"" of type '" "byte""'");
13818 }
13819 arg4 = static_cast< byte >(val4);
13820 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
13821 if (!SWIG_IsOK(ecode5)) {
13822 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGBRect" "', expected argument " "5"" of type '" "byte""'");
13823 }
13824 arg5 = static_cast< byte >(val5);
13825 {
13826 PyThreadState* __tstate = wxPyBeginAllowThreads();
13827 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
13828 wxPyEndAllowThreads(__tstate);
13829 if (PyErr_Occurred()) SWIG_fail;
13830 }
13831 resultobj = SWIG_Py_Void();
13832 return resultobj;
13833 fail:
13834 return NULL;
13835 }
13836
13837
13838 SWIGINTERN PyObject *_wrap_Image_GetRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13839 PyObject *resultobj = 0;
13840 wxImage *arg1 = (wxImage *) 0 ;
13841 int arg2 ;
13842 int arg3 ;
13843 byte result;
13844 void *argp1 = 0 ;
13845 int res1 = 0 ;
13846 int val2 ;
13847 int ecode2 = 0 ;
13848 int val3 ;
13849 int ecode3 = 0 ;
13850 PyObject * obj0 = 0 ;
13851 PyObject * obj1 = 0 ;
13852 PyObject * obj2 = 0 ;
13853 char * kwnames[] = {
13854 (char *) "self",(char *) "x",(char *) "y", NULL
13855 };
13856
13857 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13858 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13859 if (!SWIG_IsOK(res1)) {
13860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetRed" "', expected argument " "1"" of type '" "wxImage *""'");
13861 }
13862 arg1 = reinterpret_cast< wxImage * >(argp1);
13863 ecode2 = SWIG_AsVal_int(obj1, &val2);
13864 if (!SWIG_IsOK(ecode2)) {
13865 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetRed" "', expected argument " "2"" of type '" "int""'");
13866 }
13867 arg2 = static_cast< int >(val2);
13868 ecode3 = SWIG_AsVal_int(obj2, &val3);
13869 if (!SWIG_IsOK(ecode3)) {
13870 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetRed" "', expected argument " "3"" of type '" "int""'");
13871 }
13872 arg3 = static_cast< int >(val3);
13873 {
13874 PyThreadState* __tstate = wxPyBeginAllowThreads();
13875 result = (byte)(arg1)->GetRed(arg2,arg3);
13876 wxPyEndAllowThreads(__tstate);
13877 if (PyErr_Occurred()) SWIG_fail;
13878 }
13879 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13880 return resultobj;
13881 fail:
13882 return NULL;
13883 }
13884
13885
13886 SWIGINTERN PyObject *_wrap_Image_GetGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13887 PyObject *resultobj = 0;
13888 wxImage *arg1 = (wxImage *) 0 ;
13889 int arg2 ;
13890 int arg3 ;
13891 byte result;
13892 void *argp1 = 0 ;
13893 int res1 = 0 ;
13894 int val2 ;
13895 int ecode2 = 0 ;
13896 int val3 ;
13897 int ecode3 = 0 ;
13898 PyObject * obj0 = 0 ;
13899 PyObject * obj1 = 0 ;
13900 PyObject * obj2 = 0 ;
13901 char * kwnames[] = {
13902 (char *) "self",(char *) "x",(char *) "y", NULL
13903 };
13904
13905 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13906 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13907 if (!SWIG_IsOK(res1)) {
13908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetGreen" "', expected argument " "1"" of type '" "wxImage *""'");
13909 }
13910 arg1 = reinterpret_cast< wxImage * >(argp1);
13911 ecode2 = SWIG_AsVal_int(obj1, &val2);
13912 if (!SWIG_IsOK(ecode2)) {
13913 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetGreen" "', expected argument " "2"" of type '" "int""'");
13914 }
13915 arg2 = static_cast< int >(val2);
13916 ecode3 = SWIG_AsVal_int(obj2, &val3);
13917 if (!SWIG_IsOK(ecode3)) {
13918 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetGreen" "', expected argument " "3"" of type '" "int""'");
13919 }
13920 arg3 = static_cast< int >(val3);
13921 {
13922 PyThreadState* __tstate = wxPyBeginAllowThreads();
13923 result = (byte)(arg1)->GetGreen(arg2,arg3);
13924 wxPyEndAllowThreads(__tstate);
13925 if (PyErr_Occurred()) SWIG_fail;
13926 }
13927 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13928 return resultobj;
13929 fail:
13930 return NULL;
13931 }
13932
13933
13934 SWIGINTERN PyObject *_wrap_Image_GetBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13935 PyObject *resultobj = 0;
13936 wxImage *arg1 = (wxImage *) 0 ;
13937 int arg2 ;
13938 int arg3 ;
13939 byte result;
13940 void *argp1 = 0 ;
13941 int res1 = 0 ;
13942 int val2 ;
13943 int ecode2 = 0 ;
13944 int val3 ;
13945 int ecode3 = 0 ;
13946 PyObject * obj0 = 0 ;
13947 PyObject * obj1 = 0 ;
13948 PyObject * obj2 = 0 ;
13949 char * kwnames[] = {
13950 (char *) "self",(char *) "x",(char *) "y", NULL
13951 };
13952
13953 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13954 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13955 if (!SWIG_IsOK(res1)) {
13956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetBlue" "', expected argument " "1"" of type '" "wxImage *""'");
13957 }
13958 arg1 = reinterpret_cast< wxImage * >(argp1);
13959 ecode2 = SWIG_AsVal_int(obj1, &val2);
13960 if (!SWIG_IsOK(ecode2)) {
13961 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetBlue" "', expected argument " "2"" of type '" "int""'");
13962 }
13963 arg2 = static_cast< int >(val2);
13964 ecode3 = SWIG_AsVal_int(obj2, &val3);
13965 if (!SWIG_IsOK(ecode3)) {
13966 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetBlue" "', expected argument " "3"" of type '" "int""'");
13967 }
13968 arg3 = static_cast< int >(val3);
13969 {
13970 PyThreadState* __tstate = wxPyBeginAllowThreads();
13971 result = (byte)(arg1)->GetBlue(arg2,arg3);
13972 wxPyEndAllowThreads(__tstate);
13973 if (PyErr_Occurred()) SWIG_fail;
13974 }
13975 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13976 return resultobj;
13977 fail:
13978 return NULL;
13979 }
13980
13981
13982 SWIGINTERN PyObject *_wrap_Image_SetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13983 PyObject *resultobj = 0;
13984 wxImage *arg1 = (wxImage *) 0 ;
13985 int arg2 ;
13986 int arg3 ;
13987 byte arg4 ;
13988 void *argp1 = 0 ;
13989 int res1 = 0 ;
13990 int val2 ;
13991 int ecode2 = 0 ;
13992 int val3 ;
13993 int ecode3 = 0 ;
13994 unsigned char val4 ;
13995 int ecode4 = 0 ;
13996 PyObject * obj0 = 0 ;
13997 PyObject * obj1 = 0 ;
13998 PyObject * obj2 = 0 ;
13999 PyObject * obj3 = 0 ;
14000 char * kwnames[] = {
14001 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
14002 };
14003
14004 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14005 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14006 if (!SWIG_IsOK(res1)) {
14007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14008 }
14009 arg1 = reinterpret_cast< wxImage * >(argp1);
14010 ecode2 = SWIG_AsVal_int(obj1, &val2);
14011 if (!SWIG_IsOK(ecode2)) {
14012 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetAlpha" "', expected argument " "2"" of type '" "int""'");
14013 }
14014 arg2 = static_cast< int >(val2);
14015 ecode3 = SWIG_AsVal_int(obj2, &val3);
14016 if (!SWIG_IsOK(ecode3)) {
14017 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetAlpha" "', expected argument " "3"" of type '" "int""'");
14018 }
14019 arg3 = static_cast< int >(val3);
14020 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14021 if (!SWIG_IsOK(ecode4)) {
14022 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetAlpha" "', expected argument " "4"" of type '" "byte""'");
14023 }
14024 arg4 = static_cast< byte >(val4);
14025 {
14026 PyThreadState* __tstate = wxPyBeginAllowThreads();
14027 (arg1)->SetAlpha(arg2,arg3,arg4);
14028 wxPyEndAllowThreads(__tstate);
14029 if (PyErr_Occurred()) SWIG_fail;
14030 }
14031 resultobj = SWIG_Py_Void();
14032 return resultobj;
14033 fail:
14034 return NULL;
14035 }
14036
14037
14038 SWIGINTERN PyObject *_wrap_Image_GetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14039 PyObject *resultobj = 0;
14040 wxImage *arg1 = (wxImage *) 0 ;
14041 int arg2 ;
14042 int arg3 ;
14043 byte result;
14044 void *argp1 = 0 ;
14045 int res1 = 0 ;
14046 int val2 ;
14047 int ecode2 = 0 ;
14048 int val3 ;
14049 int ecode3 = 0 ;
14050 PyObject * obj0 = 0 ;
14051 PyObject * obj1 = 0 ;
14052 PyObject * obj2 = 0 ;
14053 char * kwnames[] = {
14054 (char *) "self",(char *) "x",(char *) "y", NULL
14055 };
14056
14057 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14058 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14059 if (!SWIG_IsOK(res1)) {
14060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14061 }
14062 arg1 = reinterpret_cast< wxImage * >(argp1);
14063 ecode2 = SWIG_AsVal_int(obj1, &val2);
14064 if (!SWIG_IsOK(ecode2)) {
14065 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetAlpha" "', expected argument " "2"" of type '" "int""'");
14066 }
14067 arg2 = static_cast< int >(val2);
14068 ecode3 = SWIG_AsVal_int(obj2, &val3);
14069 if (!SWIG_IsOK(ecode3)) {
14070 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetAlpha" "', expected argument " "3"" of type '" "int""'");
14071 }
14072 arg3 = static_cast< int >(val3);
14073 {
14074 PyThreadState* __tstate = wxPyBeginAllowThreads();
14075 result = (byte)(arg1)->GetAlpha(arg2,arg3);
14076 wxPyEndAllowThreads(__tstate);
14077 if (PyErr_Occurred()) SWIG_fail;
14078 }
14079 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14080 return resultobj;
14081 fail:
14082 return NULL;
14083 }
14084
14085
14086 SWIGINTERN PyObject *_wrap_Image_HasAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14087 PyObject *resultobj = 0;
14088 wxImage *arg1 = (wxImage *) 0 ;
14089 bool result;
14090 void *argp1 = 0 ;
14091 int res1 = 0 ;
14092 PyObject *swig_obj[1] ;
14093
14094 if (!args) SWIG_fail;
14095 swig_obj[0] = args;
14096 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14097 if (!SWIG_IsOK(res1)) {
14098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14099 }
14100 arg1 = reinterpret_cast< wxImage * >(argp1);
14101 {
14102 PyThreadState* __tstate = wxPyBeginAllowThreads();
14103 result = (bool)(arg1)->HasAlpha();
14104 wxPyEndAllowThreads(__tstate);
14105 if (PyErr_Occurred()) SWIG_fail;
14106 }
14107 {
14108 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14109 }
14110 return resultobj;
14111 fail:
14112 return NULL;
14113 }
14114
14115
14116 SWIGINTERN PyObject *_wrap_Image_InitAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14117 PyObject *resultobj = 0;
14118 wxImage *arg1 = (wxImage *) 0 ;
14119 void *argp1 = 0 ;
14120 int res1 = 0 ;
14121 PyObject *swig_obj[1] ;
14122
14123 if (!args) SWIG_fail;
14124 swig_obj[0] = args;
14125 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14126 if (!SWIG_IsOK(res1)) {
14127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InitAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14128 }
14129 arg1 = reinterpret_cast< wxImage * >(argp1);
14130 {
14131 PyThreadState* __tstate = wxPyBeginAllowThreads();
14132 (arg1)->InitAlpha();
14133 wxPyEndAllowThreads(__tstate);
14134 if (PyErr_Occurred()) SWIG_fail;
14135 }
14136 resultobj = SWIG_Py_Void();
14137 return resultobj;
14138 fail:
14139 return NULL;
14140 }
14141
14142
14143 SWIGINTERN PyObject *_wrap_Image_IsTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14144 PyObject *resultobj = 0;
14145 wxImage *arg1 = (wxImage *) 0 ;
14146 int arg2 ;
14147 int arg3 ;
14148 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14149 bool result;
14150 void *argp1 = 0 ;
14151 int res1 = 0 ;
14152 int val2 ;
14153 int ecode2 = 0 ;
14154 int val3 ;
14155 int ecode3 = 0 ;
14156 unsigned char val4 ;
14157 int ecode4 = 0 ;
14158 PyObject * obj0 = 0 ;
14159 PyObject * obj1 = 0 ;
14160 PyObject * obj2 = 0 ;
14161 PyObject * obj3 = 0 ;
14162 char * kwnames[] = {
14163 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
14164 };
14165
14166 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14167 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14168 if (!SWIG_IsOK(res1)) {
14169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsTransparent" "', expected argument " "1"" of type '" "wxImage const *""'");
14170 }
14171 arg1 = reinterpret_cast< wxImage * >(argp1);
14172 ecode2 = SWIG_AsVal_int(obj1, &val2);
14173 if (!SWIG_IsOK(ecode2)) {
14174 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_IsTransparent" "', expected argument " "2"" of type '" "int""'");
14175 }
14176 arg2 = static_cast< int >(val2);
14177 ecode3 = SWIG_AsVal_int(obj2, &val3);
14178 if (!SWIG_IsOK(ecode3)) {
14179 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_IsTransparent" "', expected argument " "3"" of type '" "int""'");
14180 }
14181 arg3 = static_cast< int >(val3);
14182 if (obj3) {
14183 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14184 if (!SWIG_IsOK(ecode4)) {
14185 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_IsTransparent" "', expected argument " "4"" of type '" "byte""'");
14186 }
14187 arg4 = static_cast< byte >(val4);
14188 }
14189 {
14190 PyThreadState* __tstate = wxPyBeginAllowThreads();
14191 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
14192 wxPyEndAllowThreads(__tstate);
14193 if (PyErr_Occurred()) SWIG_fail;
14194 }
14195 {
14196 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14197 }
14198 return resultobj;
14199 fail:
14200 return NULL;
14201 }
14202
14203
14204 SWIGINTERN PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14205 PyObject *resultobj = 0;
14206 wxImage *arg1 = (wxImage *) 0 ;
14207 byte *arg2 = (byte *) 0 ;
14208 byte *arg3 = (byte *) 0 ;
14209 byte *arg4 = (byte *) 0 ;
14210 byte arg5 = (byte) 0 ;
14211 byte arg6 = (byte) 0 ;
14212 byte arg7 = (byte) 0 ;
14213 bool result;
14214 void *argp1 = 0 ;
14215 int res1 = 0 ;
14216 byte temp2 ;
14217 int res2 = SWIG_TMPOBJ ;
14218 byte temp3 ;
14219 int res3 = SWIG_TMPOBJ ;
14220 byte temp4 ;
14221 int res4 = SWIG_TMPOBJ ;
14222 unsigned char val5 ;
14223 int ecode5 = 0 ;
14224 unsigned char val6 ;
14225 int ecode6 = 0 ;
14226 unsigned char val7 ;
14227 int ecode7 = 0 ;
14228 PyObject * obj0 = 0 ;
14229 PyObject * obj1 = 0 ;
14230 PyObject * obj2 = 0 ;
14231 PyObject * obj3 = 0 ;
14232 char * kwnames[] = {
14233 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
14234 };
14235
14236 arg2 = &temp2;
14237 arg3 = &temp3;
14238 arg4 = &temp4;
14239 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14240 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14241 if (!SWIG_IsOK(res1)) {
14242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImage const *""'");
14243 }
14244 arg1 = reinterpret_cast< wxImage * >(argp1);
14245 if (obj1) {
14246 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
14247 if (!SWIG_IsOK(ecode5)) {
14248 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
14249 }
14250 arg5 = static_cast< byte >(val5);
14251 }
14252 if (obj2) {
14253 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
14254 if (!SWIG_IsOK(ecode6)) {
14255 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
14256 }
14257 arg6 = static_cast< byte >(val6);
14258 }
14259 if (obj3) {
14260 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
14261 if (!SWIG_IsOK(ecode7)) {
14262 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
14263 }
14264 arg7 = static_cast< byte >(val7);
14265 }
14266 {
14267 PyThreadState* __tstate = wxPyBeginAllowThreads();
14268 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
14269 wxPyEndAllowThreads(__tstate);
14270 if (PyErr_Occurred()) SWIG_fail;
14271 }
14272 {
14273 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14274 }
14275 if (SWIG_IsTmpObj(res2)) {
14276 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
14277 } else {
14278 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14279 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
14280 }
14281 if (SWIG_IsTmpObj(res3)) {
14282 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
14283 } else {
14284 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14285 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
14286 }
14287 if (SWIG_IsTmpObj(res4)) {
14288 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
14289 } else {
14290 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14291 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
14292 }
14293 return resultobj;
14294 fail:
14295 return NULL;
14296 }
14297
14298
14299 SWIGINTERN PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14300 PyObject *resultobj = 0;
14301 wxImage *arg1 = (wxImage *) 0 ;
14302 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14303 bool result;
14304 void *argp1 = 0 ;
14305 int res1 = 0 ;
14306 unsigned char val2 ;
14307 int ecode2 = 0 ;
14308 PyObject * obj0 = 0 ;
14309 PyObject * obj1 = 0 ;
14310 char * kwnames[] = {
14311 (char *) "self",(char *) "threshold", NULL
14312 };
14313
14314 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) SWIG_fail;
14315 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14316 if (!SWIG_IsOK(res1)) {
14317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "1"" of type '" "wxImage *""'");
14318 }
14319 arg1 = reinterpret_cast< wxImage * >(argp1);
14320 if (obj1) {
14321 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14322 if (!SWIG_IsOK(ecode2)) {
14323 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "2"" of type '" "byte""'");
14324 }
14325 arg2 = static_cast< byte >(val2);
14326 }
14327 {
14328 PyThreadState* __tstate = wxPyBeginAllowThreads();
14329 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
14330 wxPyEndAllowThreads(__tstate);
14331 if (PyErr_Occurred()) SWIG_fail;
14332 }
14333 {
14334 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14335 }
14336 return resultobj;
14337 fail:
14338 return NULL;
14339 }
14340
14341
14342 SWIGINTERN PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14343 PyObject *resultobj = 0;
14344 wxImage *arg1 = (wxImage *) 0 ;
14345 byte arg2 ;
14346 byte arg3 ;
14347 byte arg4 ;
14348 bool result;
14349 void *argp1 = 0 ;
14350 int res1 = 0 ;
14351 unsigned char val2 ;
14352 int ecode2 = 0 ;
14353 unsigned char val3 ;
14354 int ecode3 = 0 ;
14355 unsigned char val4 ;
14356 int ecode4 = 0 ;
14357 PyObject * obj0 = 0 ;
14358 PyObject * obj1 = 0 ;
14359 PyObject * obj2 = 0 ;
14360 PyObject * obj3 = 0 ;
14361 char * kwnames[] = {
14362 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
14363 };
14364
14365 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14366 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14367 if (!SWIG_IsOK(res1)) {
14368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14369 }
14370 arg1 = reinterpret_cast< wxImage * >(argp1);
14371 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14372 if (!SWIG_IsOK(ecode2)) {
14373 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "2"" of type '" "byte""'");
14374 }
14375 arg2 = static_cast< byte >(val2);
14376 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14377 if (!SWIG_IsOK(ecode3)) {
14378 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "3"" of type '" "byte""'");
14379 }
14380 arg3 = static_cast< byte >(val3);
14381 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14382 if (!SWIG_IsOK(ecode4)) {
14383 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "4"" of type '" "byte""'");
14384 }
14385 arg4 = static_cast< byte >(val4);
14386 {
14387 PyThreadState* __tstate = wxPyBeginAllowThreads();
14388 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
14389 wxPyEndAllowThreads(__tstate);
14390 if (PyErr_Occurred()) SWIG_fail;
14391 }
14392 {
14393 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14394 }
14395 return resultobj;
14396 fail:
14397 return NULL;
14398 }
14399
14400
14401 SWIGINTERN PyObject *_wrap_Image_SetMaskFromImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14402 PyObject *resultobj = 0;
14403 wxImage *arg1 = (wxImage *) 0 ;
14404 wxImage *arg2 = 0 ;
14405 byte arg3 ;
14406 byte arg4 ;
14407 byte arg5 ;
14408 bool result;
14409 void *argp1 = 0 ;
14410 int res1 = 0 ;
14411 void *argp2 = 0 ;
14412 int res2 = 0 ;
14413 unsigned char val3 ;
14414 int ecode3 = 0 ;
14415 unsigned char val4 ;
14416 int ecode4 = 0 ;
14417 unsigned char val5 ;
14418 int ecode5 = 0 ;
14419 PyObject * obj0 = 0 ;
14420 PyObject * obj1 = 0 ;
14421 PyObject * obj2 = 0 ;
14422 PyObject * obj3 = 0 ;
14423 PyObject * obj4 = 0 ;
14424 char * kwnames[] = {
14425 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
14426 };
14427
14428 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
14429 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14430 if (!SWIG_IsOK(res1)) {
14431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskFromImage" "', expected argument " "1"" of type '" "wxImage *""'");
14432 }
14433 arg1 = reinterpret_cast< wxImage * >(argp1);
14434 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
14435 if (!SWIG_IsOK(res2)) {
14436 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14437 }
14438 if (!argp2) {
14439 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14440 }
14441 arg2 = reinterpret_cast< wxImage * >(argp2);
14442 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14443 if (!SWIG_IsOK(ecode3)) {
14444 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskFromImage" "', expected argument " "3"" of type '" "byte""'");
14445 }
14446 arg3 = static_cast< byte >(val3);
14447 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14448 if (!SWIG_IsOK(ecode4)) {
14449 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskFromImage" "', expected argument " "4"" of type '" "byte""'");
14450 }
14451 arg4 = static_cast< byte >(val4);
14452 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
14453 if (!SWIG_IsOK(ecode5)) {
14454 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetMaskFromImage" "', expected argument " "5"" of type '" "byte""'");
14455 }
14456 arg5 = static_cast< byte >(val5);
14457 {
14458 PyThreadState* __tstate = wxPyBeginAllowThreads();
14459 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
14460 wxPyEndAllowThreads(__tstate);
14461 if (PyErr_Occurred()) SWIG_fail;
14462 }
14463 {
14464 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14465 }
14466 return resultobj;
14467 fail:
14468 return NULL;
14469 }
14470
14471
14472 SWIGINTERN PyObject *_wrap_Image_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14473 PyObject *resultobj = 0;
14474 wxString *arg1 = 0 ;
14475 bool result;
14476 bool temp1 = false ;
14477 PyObject * obj0 = 0 ;
14478 char * kwnames[] = {
14479 (char *) "filename", NULL
14480 };
14481
14482 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) SWIG_fail;
14483 {
14484 arg1 = wxString_in_helper(obj0);
14485 if (arg1 == NULL) SWIG_fail;
14486 temp1 = true;
14487 }
14488 {
14489 PyThreadState* __tstate = wxPyBeginAllowThreads();
14490 result = (bool)wxImage::CanRead((wxString const &)*arg1);
14491 wxPyEndAllowThreads(__tstate);
14492 if (PyErr_Occurred()) SWIG_fail;
14493 }
14494 {
14495 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14496 }
14497 {
14498 if (temp1)
14499 delete arg1;
14500 }
14501 return resultobj;
14502 fail:
14503 {
14504 if (temp1)
14505 delete arg1;
14506 }
14507 return NULL;
14508 }
14509
14510
14511 SWIGINTERN PyObject *_wrap_Image_GetImageCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14512 PyObject *resultobj = 0;
14513 wxString *arg1 = 0 ;
14514 long arg2 = (long) wxBITMAP_TYPE_ANY ;
14515 int result;
14516 bool temp1 = false ;
14517 long val2 ;
14518 int ecode2 = 0 ;
14519 PyObject * obj0 = 0 ;
14520 PyObject * obj1 = 0 ;
14521 char * kwnames[] = {
14522 (char *) "filename",(char *) "type", NULL
14523 };
14524
14525 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) SWIG_fail;
14526 {
14527 arg1 = wxString_in_helper(obj0);
14528 if (arg1 == NULL) SWIG_fail;
14529 temp1 = true;
14530 }
14531 if (obj1) {
14532 ecode2 = SWIG_AsVal_long(obj1, &val2);
14533 if (!SWIG_IsOK(ecode2)) {
14534 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetImageCount" "', expected argument " "2"" of type '" "long""'");
14535 }
14536 arg2 = static_cast< long >(val2);
14537 }
14538 {
14539 PyThreadState* __tstate = wxPyBeginAllowThreads();
14540 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
14541 wxPyEndAllowThreads(__tstate);
14542 if (PyErr_Occurred()) SWIG_fail;
14543 }
14544 resultobj = SWIG_From_int(static_cast< int >(result));
14545 {
14546 if (temp1)
14547 delete arg1;
14548 }
14549 return resultobj;
14550 fail:
14551 {
14552 if (temp1)
14553 delete arg1;
14554 }
14555 return NULL;
14556 }
14557
14558
14559 SWIGINTERN PyObject *_wrap_Image_LoadFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14560 PyObject *resultobj = 0;
14561 wxImage *arg1 = (wxImage *) 0 ;
14562 wxString *arg2 = 0 ;
14563 long arg3 = (long) wxBITMAP_TYPE_ANY ;
14564 int arg4 = (int) -1 ;
14565 bool result;
14566 void *argp1 = 0 ;
14567 int res1 = 0 ;
14568 bool temp2 = false ;
14569 long val3 ;
14570 int ecode3 = 0 ;
14571 int val4 ;
14572 int ecode4 = 0 ;
14573 PyObject * obj0 = 0 ;
14574 PyObject * obj1 = 0 ;
14575 PyObject * obj2 = 0 ;
14576 PyObject * obj3 = 0 ;
14577 char * kwnames[] = {
14578 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
14579 };
14580
14581 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14582 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14583 if (!SWIG_IsOK(res1)) {
14584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadFile" "', expected argument " "1"" of type '" "wxImage *""'");
14585 }
14586 arg1 = reinterpret_cast< wxImage * >(argp1);
14587 {
14588 arg2 = wxString_in_helper(obj1);
14589 if (arg2 == NULL) SWIG_fail;
14590 temp2 = true;
14591 }
14592 if (obj2) {
14593 ecode3 = SWIG_AsVal_long(obj2, &val3);
14594 if (!SWIG_IsOK(ecode3)) {
14595 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadFile" "', expected argument " "3"" of type '" "long""'");
14596 }
14597 arg3 = static_cast< long >(val3);
14598 }
14599 if (obj3) {
14600 ecode4 = SWIG_AsVal_int(obj3, &val4);
14601 if (!SWIG_IsOK(ecode4)) {
14602 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadFile" "', expected argument " "4"" of type '" "int""'");
14603 }
14604 arg4 = static_cast< int >(val4);
14605 }
14606 {
14607 PyThreadState* __tstate = wxPyBeginAllowThreads();
14608 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
14609 wxPyEndAllowThreads(__tstate);
14610 if (PyErr_Occurred()) SWIG_fail;
14611 }
14612 {
14613 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14614 }
14615 {
14616 if (temp2)
14617 delete arg2;
14618 }
14619 return resultobj;
14620 fail:
14621 {
14622 if (temp2)
14623 delete arg2;
14624 }
14625 return NULL;
14626 }
14627
14628
14629 SWIGINTERN PyObject *_wrap_Image_LoadMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14630 PyObject *resultobj = 0;
14631 wxImage *arg1 = (wxImage *) 0 ;
14632 wxString *arg2 = 0 ;
14633 wxString *arg3 = 0 ;
14634 int arg4 = (int) -1 ;
14635 bool result;
14636 void *argp1 = 0 ;
14637 int res1 = 0 ;
14638 bool temp2 = false ;
14639 bool temp3 = false ;
14640 int val4 ;
14641 int ecode4 = 0 ;
14642 PyObject * obj0 = 0 ;
14643 PyObject * obj1 = 0 ;
14644 PyObject * obj2 = 0 ;
14645 PyObject * obj3 = 0 ;
14646 char * kwnames[] = {
14647 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
14648 };
14649
14650 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14651 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14652 if (!SWIG_IsOK(res1)) {
14653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14654 }
14655 arg1 = reinterpret_cast< wxImage * >(argp1);
14656 {
14657 arg2 = wxString_in_helper(obj1);
14658 if (arg2 == NULL) SWIG_fail;
14659 temp2 = true;
14660 }
14661 {
14662 arg3 = wxString_in_helper(obj2);
14663 if (arg3 == NULL) SWIG_fail;
14664 temp3 = true;
14665 }
14666 if (obj3) {
14667 ecode4 = SWIG_AsVal_int(obj3, &val4);
14668 if (!SWIG_IsOK(ecode4)) {
14669 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeFile" "', expected argument " "4"" of type '" "int""'");
14670 }
14671 arg4 = static_cast< int >(val4);
14672 }
14673 {
14674 PyThreadState* __tstate = wxPyBeginAllowThreads();
14675 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
14676 wxPyEndAllowThreads(__tstate);
14677 if (PyErr_Occurred()) SWIG_fail;
14678 }
14679 {
14680 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14681 }
14682 {
14683 if (temp2)
14684 delete arg2;
14685 }
14686 {
14687 if (temp3)
14688 delete arg3;
14689 }
14690 return resultobj;
14691 fail:
14692 {
14693 if (temp2)
14694 delete arg2;
14695 }
14696 {
14697 if (temp3)
14698 delete arg3;
14699 }
14700 return NULL;
14701 }
14702
14703
14704 SWIGINTERN PyObject *_wrap_Image_SaveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14705 PyObject *resultobj = 0;
14706 wxImage *arg1 = (wxImage *) 0 ;
14707 wxString *arg2 = 0 ;
14708 int arg3 ;
14709 bool result;
14710 void *argp1 = 0 ;
14711 int res1 = 0 ;
14712 bool temp2 = false ;
14713 int val3 ;
14714 int ecode3 = 0 ;
14715 PyObject * obj0 = 0 ;
14716 PyObject * obj1 = 0 ;
14717 PyObject * obj2 = 0 ;
14718 char * kwnames[] = {
14719 (char *) "self",(char *) "name",(char *) "type", NULL
14720 };
14721
14722 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14723 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14724 if (!SWIG_IsOK(res1)) {
14725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveFile" "', expected argument " "1"" of type '" "wxImage *""'");
14726 }
14727 arg1 = reinterpret_cast< wxImage * >(argp1);
14728 {
14729 arg2 = wxString_in_helper(obj1);
14730 if (arg2 == NULL) SWIG_fail;
14731 temp2 = true;
14732 }
14733 ecode3 = SWIG_AsVal_int(obj2, &val3);
14734 if (!SWIG_IsOK(ecode3)) {
14735 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SaveFile" "', expected argument " "3"" of type '" "int""'");
14736 }
14737 arg3 = static_cast< int >(val3);
14738 {
14739 PyThreadState* __tstate = wxPyBeginAllowThreads();
14740 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
14741 wxPyEndAllowThreads(__tstate);
14742 if (PyErr_Occurred()) SWIG_fail;
14743 }
14744 {
14745 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14746 }
14747 {
14748 if (temp2)
14749 delete arg2;
14750 }
14751 return resultobj;
14752 fail:
14753 {
14754 if (temp2)
14755 delete arg2;
14756 }
14757 return NULL;
14758 }
14759
14760
14761 SWIGINTERN PyObject *_wrap_Image_SaveMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14762 PyObject *resultobj = 0;
14763 wxImage *arg1 = (wxImage *) 0 ;
14764 wxString *arg2 = 0 ;
14765 wxString *arg3 = 0 ;
14766 bool result;
14767 void *argp1 = 0 ;
14768 int res1 = 0 ;
14769 bool temp2 = false ;
14770 bool temp3 = false ;
14771 PyObject * obj0 = 0 ;
14772 PyObject * obj1 = 0 ;
14773 PyObject * obj2 = 0 ;
14774 char * kwnames[] = {
14775 (char *) "self",(char *) "name",(char *) "mimetype", NULL
14776 };
14777
14778 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14779 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14780 if (!SWIG_IsOK(res1)) {
14781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14782 }
14783 arg1 = reinterpret_cast< wxImage * >(argp1);
14784 {
14785 arg2 = wxString_in_helper(obj1);
14786 if (arg2 == NULL) SWIG_fail;
14787 temp2 = true;
14788 }
14789 {
14790 arg3 = wxString_in_helper(obj2);
14791 if (arg3 == NULL) SWIG_fail;
14792 temp3 = true;
14793 }
14794 {
14795 PyThreadState* __tstate = wxPyBeginAllowThreads();
14796 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
14797 wxPyEndAllowThreads(__tstate);
14798 if (PyErr_Occurred()) SWIG_fail;
14799 }
14800 {
14801 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14802 }
14803 {
14804 if (temp2)
14805 delete arg2;
14806 }
14807 {
14808 if (temp3)
14809 delete arg3;
14810 }
14811 return resultobj;
14812 fail:
14813 {
14814 if (temp2)
14815 delete arg2;
14816 }
14817 {
14818 if (temp3)
14819 delete arg3;
14820 }
14821 return NULL;
14822 }
14823
14824
14825 SWIGINTERN PyObject *_wrap_Image_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14826 PyObject *resultobj = 0;
14827 wxInputStream *arg1 = 0 ;
14828 bool result;
14829 wxPyInputStream *temp1 ;
14830 bool created1 ;
14831 PyObject * obj0 = 0 ;
14832 char * kwnames[] = {
14833 (char *) "stream", NULL
14834 };
14835
14836 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) SWIG_fail;
14837 {
14838 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
14839 arg1 = temp1->m_wxis;
14840 created1 = false;
14841 } else {
14842 PyErr_Clear(); // clear the failure of the wxPyConvert above
14843 arg1 = wxPyCBInputStream_create(obj0, false);
14844 if (arg1 == NULL) {
14845 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14846 SWIG_fail;
14847 }
14848 created1 = true;
14849 }
14850 }
14851 {
14852 PyThreadState* __tstate = wxPyBeginAllowThreads();
14853 result = (bool)wxImage::CanRead(*arg1);
14854 wxPyEndAllowThreads(__tstate);
14855 if (PyErr_Occurred()) SWIG_fail;
14856 }
14857 {
14858 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14859 }
14860 {
14861 if (created1) delete arg1;
14862 }
14863 return resultobj;
14864 fail:
14865 {
14866 if (created1) delete arg1;
14867 }
14868 return NULL;
14869 }
14870
14871
14872 SWIGINTERN PyObject *_wrap_Image_LoadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14873 PyObject *resultobj = 0;
14874 wxImage *arg1 = (wxImage *) 0 ;
14875 wxInputStream *arg2 = 0 ;
14876 long arg3 = (long) wxBITMAP_TYPE_ANY ;
14877 int arg4 = (int) -1 ;
14878 bool result;
14879 void *argp1 = 0 ;
14880 int res1 = 0 ;
14881 wxPyInputStream *temp2 ;
14882 bool created2 ;
14883 long val3 ;
14884 int ecode3 = 0 ;
14885 int val4 ;
14886 int ecode4 = 0 ;
14887 PyObject * obj0 = 0 ;
14888 PyObject * obj1 = 0 ;
14889 PyObject * obj2 = 0 ;
14890 PyObject * obj3 = 0 ;
14891 char * kwnames[] = {
14892 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
14893 };
14894
14895 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14896 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14897 if (!SWIG_IsOK(res1)) {
14898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadStream" "', expected argument " "1"" of type '" "wxImage *""'");
14899 }
14900 arg1 = reinterpret_cast< wxImage * >(argp1);
14901 {
14902 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
14903 arg2 = temp2->m_wxis;
14904 created2 = false;
14905 } else {
14906 PyErr_Clear(); // clear the failure of the wxPyConvert above
14907 arg2 = wxPyCBInputStream_create(obj1, false);
14908 if (arg2 == NULL) {
14909 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14910 SWIG_fail;
14911 }
14912 created2 = true;
14913 }
14914 }
14915 if (obj2) {
14916 ecode3 = SWIG_AsVal_long(obj2, &val3);
14917 if (!SWIG_IsOK(ecode3)) {
14918 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadStream" "', expected argument " "3"" of type '" "long""'");
14919 }
14920 arg3 = static_cast< long >(val3);
14921 }
14922 if (obj3) {
14923 ecode4 = SWIG_AsVal_int(obj3, &val4);
14924 if (!SWIG_IsOK(ecode4)) {
14925 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadStream" "', expected argument " "4"" of type '" "int""'");
14926 }
14927 arg4 = static_cast< int >(val4);
14928 }
14929 {
14930 PyThreadState* __tstate = wxPyBeginAllowThreads();
14931 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
14932 wxPyEndAllowThreads(__tstate);
14933 if (PyErr_Occurred()) SWIG_fail;
14934 }
14935 {
14936 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14937 }
14938 {
14939 if (created2) delete arg2;
14940 }
14941 return resultobj;
14942 fail:
14943 {
14944 if (created2) delete arg2;
14945 }
14946 return NULL;
14947 }
14948
14949
14950 SWIGINTERN PyObject *_wrap_Image_LoadMimeStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14951 PyObject *resultobj = 0;
14952 wxImage *arg1 = (wxImage *) 0 ;
14953 wxInputStream *arg2 = 0 ;
14954 wxString *arg3 = 0 ;
14955 int arg4 = (int) -1 ;
14956 bool result;
14957 void *argp1 = 0 ;
14958 int res1 = 0 ;
14959 wxPyInputStream *temp2 ;
14960 bool created2 ;
14961 bool temp3 = false ;
14962 int val4 ;
14963 int ecode4 = 0 ;
14964 PyObject * obj0 = 0 ;
14965 PyObject * obj1 = 0 ;
14966 PyObject * obj2 = 0 ;
14967 PyObject * obj3 = 0 ;
14968 char * kwnames[] = {
14969 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
14970 };
14971
14972 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14973 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14974 if (!SWIG_IsOK(res1)) {
14975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeStream" "', expected argument " "1"" of type '" "wxImage *""'");
14976 }
14977 arg1 = reinterpret_cast< wxImage * >(argp1);
14978 {
14979 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
14980 arg2 = temp2->m_wxis;
14981 created2 = false;
14982 } else {
14983 PyErr_Clear(); // clear the failure of the wxPyConvert above
14984 arg2 = wxPyCBInputStream_create(obj1, false);
14985 if (arg2 == NULL) {
14986 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14987 SWIG_fail;
14988 }
14989 created2 = true;
14990 }
14991 }
14992 {
14993 arg3 = wxString_in_helper(obj2);
14994 if (arg3 == NULL) SWIG_fail;
14995 temp3 = true;
14996 }
14997 if (obj3) {
14998 ecode4 = SWIG_AsVal_int(obj3, &val4);
14999 if (!SWIG_IsOK(ecode4)) {
15000 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeStream" "', expected argument " "4"" of type '" "int""'");
15001 }
15002 arg4 = static_cast< int >(val4);
15003 }
15004 {
15005 PyThreadState* __tstate = wxPyBeginAllowThreads();
15006 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
15007 wxPyEndAllowThreads(__tstate);
15008 if (PyErr_Occurred()) SWIG_fail;
15009 }
15010 {
15011 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15012 }
15013 {
15014 if (created2) delete arg2;
15015 }
15016 {
15017 if (temp3)
15018 delete arg3;
15019 }
15020 return resultobj;
15021 fail:
15022 {
15023 if (created2) delete arg2;
15024 }
15025 {
15026 if (temp3)
15027 delete arg3;
15028 }
15029 return NULL;
15030 }
15031
15032
15033 SWIGINTERN PyObject *_wrap_Image_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15034 PyObject *resultobj = 0;
15035 wxImage *arg1 = (wxImage *) 0 ;
15036 bool result;
15037 void *argp1 = 0 ;
15038 int res1 = 0 ;
15039 PyObject *swig_obj[1] ;
15040
15041 if (!args) SWIG_fail;
15042 swig_obj[0] = args;
15043 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15044 if (!SWIG_IsOK(res1)) {
15045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Ok" "', expected argument " "1"" of type '" "wxImage *""'");
15046 }
15047 arg1 = reinterpret_cast< wxImage * >(argp1);
15048 {
15049 PyThreadState* __tstate = wxPyBeginAllowThreads();
15050 result = (bool)(arg1)->Ok();
15051 wxPyEndAllowThreads(__tstate);
15052 if (PyErr_Occurred()) SWIG_fail;
15053 }
15054 {
15055 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15056 }
15057 return resultobj;
15058 fail:
15059 return NULL;
15060 }
15061
15062
15063 SWIGINTERN PyObject *_wrap_Image_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15064 PyObject *resultobj = 0;
15065 wxImage *arg1 = (wxImage *) 0 ;
15066 int result;
15067 void *argp1 = 0 ;
15068 int res1 = 0 ;
15069 PyObject *swig_obj[1] ;
15070
15071 if (!args) SWIG_fail;
15072 swig_obj[0] = args;
15073 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15074 if (!SWIG_IsOK(res1)) {
15075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetWidth" "', expected argument " "1"" of type '" "wxImage *""'");
15076 }
15077 arg1 = reinterpret_cast< wxImage * >(argp1);
15078 {
15079 PyThreadState* __tstate = wxPyBeginAllowThreads();
15080 result = (int)(arg1)->GetWidth();
15081 wxPyEndAllowThreads(__tstate);
15082 if (PyErr_Occurred()) SWIG_fail;
15083 }
15084 resultobj = SWIG_From_int(static_cast< int >(result));
15085 return resultobj;
15086 fail:
15087 return NULL;
15088 }
15089
15090
15091 SWIGINTERN PyObject *_wrap_Image_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15092 PyObject *resultobj = 0;
15093 wxImage *arg1 = (wxImage *) 0 ;
15094 int result;
15095 void *argp1 = 0 ;
15096 int res1 = 0 ;
15097 PyObject *swig_obj[1] ;
15098
15099 if (!args) SWIG_fail;
15100 swig_obj[0] = args;
15101 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15102 if (!SWIG_IsOK(res1)) {
15103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetHeight" "', expected argument " "1"" of type '" "wxImage *""'");
15104 }
15105 arg1 = reinterpret_cast< wxImage * >(argp1);
15106 {
15107 PyThreadState* __tstate = wxPyBeginAllowThreads();
15108 result = (int)(arg1)->GetHeight();
15109 wxPyEndAllowThreads(__tstate);
15110 if (PyErr_Occurred()) SWIG_fail;
15111 }
15112 resultobj = SWIG_From_int(static_cast< int >(result));
15113 return resultobj;
15114 fail:
15115 return NULL;
15116 }
15117
15118
15119 SWIGINTERN PyObject *_wrap_Image_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15120 PyObject *resultobj = 0;
15121 wxImage *arg1 = (wxImage *) 0 ;
15122 wxSize result;
15123 void *argp1 = 0 ;
15124 int res1 = 0 ;
15125 PyObject *swig_obj[1] ;
15126
15127 if (!args) SWIG_fail;
15128 swig_obj[0] = args;
15129 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15130 if (!SWIG_IsOK(res1)) {
15131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSize" "', expected argument " "1"" of type '" "wxImage *""'");
15132 }
15133 arg1 = reinterpret_cast< wxImage * >(argp1);
15134 {
15135 PyThreadState* __tstate = wxPyBeginAllowThreads();
15136 result = wxImage_GetSize(arg1);
15137 wxPyEndAllowThreads(__tstate);
15138 if (PyErr_Occurred()) SWIG_fail;
15139 }
15140 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
15141 return resultobj;
15142 fail:
15143 return NULL;
15144 }
15145
15146
15147 SWIGINTERN PyObject *_wrap_Image_GetSubImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15148 PyObject *resultobj = 0;
15149 wxImage *arg1 = (wxImage *) 0 ;
15150 wxRect *arg2 = 0 ;
15151 SwigValueWrapper<wxImage > result;
15152 void *argp1 = 0 ;
15153 int res1 = 0 ;
15154 wxRect temp2 ;
15155 PyObject * obj0 = 0 ;
15156 PyObject * obj1 = 0 ;
15157 char * kwnames[] = {
15158 (char *) "self",(char *) "rect", NULL
15159 };
15160
15161 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) SWIG_fail;
15162 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15163 if (!SWIG_IsOK(res1)) {
15164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSubImage" "', expected argument " "1"" of type '" "wxImage *""'");
15165 }
15166 arg1 = reinterpret_cast< wxImage * >(argp1);
15167 {
15168 arg2 = &temp2;
15169 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
15170 }
15171 {
15172 PyThreadState* __tstate = wxPyBeginAllowThreads();
15173 result = (arg1)->GetSubImage((wxRect const &)*arg2);
15174 wxPyEndAllowThreads(__tstate);
15175 if (PyErr_Occurred()) SWIG_fail;
15176 }
15177 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15178 return resultobj;
15179 fail:
15180 return NULL;
15181 }
15182
15183
15184 SWIGINTERN PyObject *_wrap_Image_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15185 PyObject *resultobj = 0;
15186 wxImage *arg1 = (wxImage *) 0 ;
15187 wxSize *arg2 = 0 ;
15188 wxPoint *arg3 = 0 ;
15189 int arg4 = (int) -1 ;
15190 int arg5 = (int) -1 ;
15191 int arg6 = (int) -1 ;
15192 SwigValueWrapper<wxImage > result;
15193 void *argp1 = 0 ;
15194 int res1 = 0 ;
15195 wxSize temp2 ;
15196 wxPoint temp3 ;
15197 int val4 ;
15198 int ecode4 = 0 ;
15199 int val5 ;
15200 int ecode5 = 0 ;
15201 int val6 ;
15202 int ecode6 = 0 ;
15203 PyObject * obj0 = 0 ;
15204 PyObject * obj1 = 0 ;
15205 PyObject * obj2 = 0 ;
15206 PyObject * obj3 = 0 ;
15207 PyObject * obj4 = 0 ;
15208 PyObject * obj5 = 0 ;
15209 char * kwnames[] = {
15210 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
15211 };
15212
15213 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
15214 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15215 if (!SWIG_IsOK(res1)) {
15216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Size" "', expected argument " "1"" of type '" "wxImage const *""'");
15217 }
15218 arg1 = reinterpret_cast< wxImage * >(argp1);
15219 {
15220 arg2 = &temp2;
15221 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
15222 }
15223 {
15224 arg3 = &temp3;
15225 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
15226 }
15227 if (obj3) {
15228 ecode4 = SWIG_AsVal_int(obj3, &val4);
15229 if (!SWIG_IsOK(ecode4)) {
15230 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Size" "', expected argument " "4"" of type '" "int""'");
15231 }
15232 arg4 = static_cast< int >(val4);
15233 }
15234 if (obj4) {
15235 ecode5 = SWIG_AsVal_int(obj4, &val5);
15236 if (!SWIG_IsOK(ecode5)) {
15237 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Size" "', expected argument " "5"" of type '" "int""'");
15238 }
15239 arg5 = static_cast< int >(val5);
15240 }
15241 if (obj5) {
15242 ecode6 = SWIG_AsVal_int(obj5, &val6);
15243 if (!SWIG_IsOK(ecode6)) {
15244 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Size" "', expected argument " "6"" of type '" "int""'");
15245 }
15246 arg6 = static_cast< int >(val6);
15247 }
15248 {
15249 PyThreadState* __tstate = wxPyBeginAllowThreads();
15250 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
15251 wxPyEndAllowThreads(__tstate);
15252 if (PyErr_Occurred()) SWIG_fail;
15253 }
15254 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15255 return resultobj;
15256 fail:
15257 return NULL;
15258 }
15259
15260
15261 SWIGINTERN PyObject *_wrap_Image_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15262 PyObject *resultobj = 0;
15263 wxImage *arg1 = (wxImage *) 0 ;
15264 SwigValueWrapper<wxImage > result;
15265 void *argp1 = 0 ;
15266 int res1 = 0 ;
15267 PyObject *swig_obj[1] ;
15268
15269 if (!args) SWIG_fail;
15270 swig_obj[0] = args;
15271 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15272 if (!SWIG_IsOK(res1)) {
15273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Copy" "', expected argument " "1"" of type '" "wxImage *""'");
15274 }
15275 arg1 = reinterpret_cast< wxImage * >(argp1);
15276 {
15277 PyThreadState* __tstate = wxPyBeginAllowThreads();
15278 result = (arg1)->Copy();
15279 wxPyEndAllowThreads(__tstate);
15280 if (PyErr_Occurred()) SWIG_fail;
15281 }
15282 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15283 return resultobj;
15284 fail:
15285 return NULL;
15286 }
15287
15288
15289 SWIGINTERN PyObject *_wrap_Image_Paste(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15290 PyObject *resultobj = 0;
15291 wxImage *arg1 = (wxImage *) 0 ;
15292 wxImage *arg2 = 0 ;
15293 int arg3 ;
15294 int arg4 ;
15295 void *argp1 = 0 ;
15296 int res1 = 0 ;
15297 void *argp2 = 0 ;
15298 int res2 = 0 ;
15299 int val3 ;
15300 int ecode3 = 0 ;
15301 int val4 ;
15302 int ecode4 = 0 ;
15303 PyObject * obj0 = 0 ;
15304 PyObject * obj1 = 0 ;
15305 PyObject * obj2 = 0 ;
15306 PyObject * obj3 = 0 ;
15307 char * kwnames[] = {
15308 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
15309 };
15310
15311 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15312 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15313 if (!SWIG_IsOK(res1)) {
15314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Paste" "', expected argument " "1"" of type '" "wxImage *""'");
15315 }
15316 arg1 = reinterpret_cast< wxImage * >(argp1);
15317 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
15318 if (!SWIG_IsOK(res2)) {
15319 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15320 }
15321 if (!argp2) {
15322 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15323 }
15324 arg2 = reinterpret_cast< wxImage * >(argp2);
15325 ecode3 = SWIG_AsVal_int(obj2, &val3);
15326 if (!SWIG_IsOK(ecode3)) {
15327 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Paste" "', expected argument " "3"" of type '" "int""'");
15328 }
15329 arg3 = static_cast< int >(val3);
15330 ecode4 = SWIG_AsVal_int(obj3, &val4);
15331 if (!SWIG_IsOK(ecode4)) {
15332 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Paste" "', expected argument " "4"" of type '" "int""'");
15333 }
15334 arg4 = static_cast< int >(val4);
15335 {
15336 PyThreadState* __tstate = wxPyBeginAllowThreads();
15337 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
15338 wxPyEndAllowThreads(__tstate);
15339 if (PyErr_Occurred()) SWIG_fail;
15340 }
15341 resultobj = SWIG_Py_Void();
15342 return resultobj;
15343 fail:
15344 return NULL;
15345 }
15346
15347
15348 SWIGINTERN PyObject *_wrap_Image_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15349 PyObject *resultobj = 0;
15350 wxImage *arg1 = (wxImage *) 0 ;
15351 PyObject *result = 0 ;
15352 void *argp1 = 0 ;
15353 int res1 = 0 ;
15354 PyObject *swig_obj[1] ;
15355
15356 if (!args) SWIG_fail;
15357 swig_obj[0] = args;
15358 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15359 if (!SWIG_IsOK(res1)) {
15360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetData" "', expected argument " "1"" of type '" "wxImage *""'");
15361 }
15362 arg1 = reinterpret_cast< wxImage * >(argp1);
15363 {
15364 PyThreadState* __tstate = wxPyBeginAllowThreads();
15365 result = (PyObject *)wxImage_GetData(arg1);
15366 wxPyEndAllowThreads(__tstate);
15367 if (PyErr_Occurred()) SWIG_fail;
15368 }
15369 resultobj = result;
15370 return resultobj;
15371 fail:
15372 return NULL;
15373 }
15374
15375
15376 SWIGINTERN PyObject *_wrap_Image_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15377 PyObject *resultobj = 0;
15378 wxImage *arg1 = (wxImage *) 0 ;
15379 buffer arg2 ;
15380 int arg3 ;
15381 void *argp1 = 0 ;
15382 int res1 = 0 ;
15383 PyObject * obj0 = 0 ;
15384 PyObject * obj1 = 0 ;
15385 char * kwnames[] = {
15386 (char *) "self",(char *) "data", NULL
15387 };
15388
15389 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
15390 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15391 if (!SWIG_IsOK(res1)) {
15392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetData" "', expected argument " "1"" of type '" "wxImage *""'");
15393 }
15394 arg1 = reinterpret_cast< wxImage * >(argp1);
15395 {
15396 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15397 }
15398 {
15399 PyThreadState* __tstate = wxPyBeginAllowThreads();
15400 wxImage_SetData(arg1,arg2,arg3);
15401 wxPyEndAllowThreads(__tstate);
15402 if (PyErr_Occurred()) SWIG_fail;
15403 }
15404 resultobj = SWIG_Py_Void();
15405 return resultobj;
15406 fail:
15407 return NULL;
15408 }
15409
15410
15411 SWIGINTERN PyObject *_wrap_Image_GetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15412 PyObject *resultobj = 0;
15413 wxImage *arg1 = (wxImage *) 0 ;
15414 PyObject *result = 0 ;
15415 void *argp1 = 0 ;
15416 int res1 = 0 ;
15417 PyObject *swig_obj[1] ;
15418
15419 if (!args) SWIG_fail;
15420 swig_obj[0] = args;
15421 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15422 if (!SWIG_IsOK(res1)) {
15423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15424 }
15425 arg1 = reinterpret_cast< wxImage * >(argp1);
15426 {
15427 PyThreadState* __tstate = wxPyBeginAllowThreads();
15428 result = (PyObject *)wxImage_GetDataBuffer(arg1);
15429 wxPyEndAllowThreads(__tstate);
15430 if (PyErr_Occurred()) SWIG_fail;
15431 }
15432 resultobj = result;
15433 return resultobj;
15434 fail:
15435 return NULL;
15436 }
15437
15438
15439 SWIGINTERN PyObject *_wrap_Image_SetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15440 PyObject *resultobj = 0;
15441 wxImage *arg1 = (wxImage *) 0 ;
15442 buffer arg2 ;
15443 int arg3 ;
15444 void *argp1 = 0 ;
15445 int res1 = 0 ;
15446 PyObject * obj0 = 0 ;
15447 PyObject * obj1 = 0 ;
15448 char * kwnames[] = {
15449 (char *) "self",(char *) "data", NULL
15450 };
15451
15452 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
15453 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15454 if (!SWIG_IsOK(res1)) {
15455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15456 }
15457 arg1 = reinterpret_cast< wxImage * >(argp1);
15458 {
15459 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15460 }
15461 {
15462 PyThreadState* __tstate = wxPyBeginAllowThreads();
15463 wxImage_SetDataBuffer(arg1,arg2,arg3);
15464 wxPyEndAllowThreads(__tstate);
15465 if (PyErr_Occurred()) SWIG_fail;
15466 }
15467 resultobj = SWIG_Py_Void();
15468 return resultobj;
15469 fail:
15470 return NULL;
15471 }
15472
15473
15474 SWIGINTERN PyObject *_wrap_Image_GetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15475 PyObject *resultobj = 0;
15476 wxImage *arg1 = (wxImage *) 0 ;
15477 PyObject *result = 0 ;
15478 void *argp1 = 0 ;
15479 int res1 = 0 ;
15480 PyObject *swig_obj[1] ;
15481
15482 if (!args) SWIG_fail;
15483 swig_obj[0] = args;
15484 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15485 if (!SWIG_IsOK(res1)) {
15486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15487 }
15488 arg1 = reinterpret_cast< wxImage * >(argp1);
15489 {
15490 PyThreadState* __tstate = wxPyBeginAllowThreads();
15491 result = (PyObject *)wxImage_GetAlphaData(arg1);
15492 wxPyEndAllowThreads(__tstate);
15493 if (PyErr_Occurred()) SWIG_fail;
15494 }
15495 resultobj = result;
15496 return resultobj;
15497 fail:
15498 return NULL;
15499 }
15500
15501
15502 SWIGINTERN PyObject *_wrap_Image_SetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15503 PyObject *resultobj = 0;
15504 wxImage *arg1 = (wxImage *) 0 ;
15505 buffer arg2 ;
15506 int arg3 ;
15507 void *argp1 = 0 ;
15508 int res1 = 0 ;
15509 PyObject * obj0 = 0 ;
15510 PyObject * obj1 = 0 ;
15511 char * kwnames[] = {
15512 (char *) "self",(char *) "alpha", NULL
15513 };
15514
15515 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) SWIG_fail;
15516 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15517 if (!SWIG_IsOK(res1)) {
15518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15519 }
15520 arg1 = reinterpret_cast< wxImage * >(argp1);
15521 {
15522 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15523 }
15524 {
15525 PyThreadState* __tstate = wxPyBeginAllowThreads();
15526 wxImage_SetAlphaData(arg1,arg2,arg3);
15527 wxPyEndAllowThreads(__tstate);
15528 if (PyErr_Occurred()) SWIG_fail;
15529 }
15530 resultobj = SWIG_Py_Void();
15531 return resultobj;
15532 fail:
15533 return NULL;
15534 }
15535
15536
15537 SWIGINTERN PyObject *_wrap_Image_GetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15538 PyObject *resultobj = 0;
15539 wxImage *arg1 = (wxImage *) 0 ;
15540 PyObject *result = 0 ;
15541 void *argp1 = 0 ;
15542 int res1 = 0 ;
15543 PyObject *swig_obj[1] ;
15544
15545 if (!args) SWIG_fail;
15546 swig_obj[0] = args;
15547 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15548 if (!SWIG_IsOK(res1)) {
15549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15550 }
15551 arg1 = reinterpret_cast< wxImage * >(argp1);
15552 {
15553 PyThreadState* __tstate = wxPyBeginAllowThreads();
15554 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
15555 wxPyEndAllowThreads(__tstate);
15556 if (PyErr_Occurred()) SWIG_fail;
15557 }
15558 resultobj = result;
15559 return resultobj;
15560 fail:
15561 return NULL;
15562 }
15563
15564
15565 SWIGINTERN PyObject *_wrap_Image_SetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15566 PyObject *resultobj = 0;
15567 wxImage *arg1 = (wxImage *) 0 ;
15568 buffer arg2 ;
15569 int arg3 ;
15570 void *argp1 = 0 ;
15571 int res1 = 0 ;
15572 PyObject * obj0 = 0 ;
15573 PyObject * obj1 = 0 ;
15574 char * kwnames[] = {
15575 (char *) "self",(char *) "alpha", NULL
15576 };
15577
15578 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
15579 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15580 if (!SWIG_IsOK(res1)) {
15581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15582 }
15583 arg1 = reinterpret_cast< wxImage * >(argp1);
15584 {
15585 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15586 }
15587 {
15588 PyThreadState* __tstate = wxPyBeginAllowThreads();
15589 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
15590 wxPyEndAllowThreads(__tstate);
15591 if (PyErr_Occurred()) SWIG_fail;
15592 }
15593 resultobj = SWIG_Py_Void();
15594 return resultobj;
15595 fail:
15596 return NULL;
15597 }
15598
15599
15600 SWIGINTERN PyObject *_wrap_Image_SetMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15601 PyObject *resultobj = 0;
15602 wxImage *arg1 = (wxImage *) 0 ;
15603 byte arg2 ;
15604 byte arg3 ;
15605 byte arg4 ;
15606 void *argp1 = 0 ;
15607 int res1 = 0 ;
15608 unsigned char val2 ;
15609 int ecode2 = 0 ;
15610 unsigned char val3 ;
15611 int ecode3 = 0 ;
15612 unsigned char val4 ;
15613 int ecode4 = 0 ;
15614 PyObject * obj0 = 0 ;
15615 PyObject * obj1 = 0 ;
15616 PyObject * obj2 = 0 ;
15617 PyObject * obj3 = 0 ;
15618 char * kwnames[] = {
15619 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
15620 };
15621
15622 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15623 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15624 if (!SWIG_IsOK(res1)) {
15625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskColour" "', expected argument " "1"" of type '" "wxImage *""'");
15626 }
15627 arg1 = reinterpret_cast< wxImage * >(argp1);
15628 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15629 if (!SWIG_IsOK(ecode2)) {
15630 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMaskColour" "', expected argument " "2"" of type '" "byte""'");
15631 }
15632 arg2 = static_cast< byte >(val2);
15633 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15634 if (!SWIG_IsOK(ecode3)) {
15635 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskColour" "', expected argument " "3"" of type '" "byte""'");
15636 }
15637 arg3 = static_cast< byte >(val3);
15638 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
15639 if (!SWIG_IsOK(ecode4)) {
15640 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskColour" "', expected argument " "4"" of type '" "byte""'");
15641 }
15642 arg4 = static_cast< byte >(val4);
15643 {
15644 PyThreadState* __tstate = wxPyBeginAllowThreads();
15645 (arg1)->SetMaskColour(arg2,arg3,arg4);
15646 wxPyEndAllowThreads(__tstate);
15647 if (PyErr_Occurred()) SWIG_fail;
15648 }
15649 resultobj = SWIG_Py_Void();
15650 return resultobj;
15651 fail:
15652 return NULL;
15653 }
15654
15655
15656 SWIGINTERN PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15657 PyObject *resultobj = 0;
15658 wxImage *arg1 = (wxImage *) 0 ;
15659 byte *arg2 = (byte *) 0 ;
15660 byte *arg3 = (byte *) 0 ;
15661 byte *arg4 = (byte *) 0 ;
15662 void *argp1 = 0 ;
15663 int res1 = 0 ;
15664 byte temp2 ;
15665 int res2 = SWIG_TMPOBJ ;
15666 byte temp3 ;
15667 int res3 = SWIG_TMPOBJ ;
15668 byte temp4 ;
15669 int res4 = SWIG_TMPOBJ ;
15670 PyObject *swig_obj[1] ;
15671
15672 arg2 = &temp2;
15673 arg3 = &temp3;
15674 arg4 = &temp4;
15675 if (!args) SWIG_fail;
15676 swig_obj[0] = args;
15677 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15678 if (!SWIG_IsOK(res1)) {
15679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOrFindMaskColour" "', expected argument " "1"" of type '" "wxImage const *""'");
15680 }
15681 arg1 = reinterpret_cast< wxImage * >(argp1);
15682 {
15683 PyThreadState* __tstate = wxPyBeginAllowThreads();
15684 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
15685 wxPyEndAllowThreads(__tstate);
15686 if (PyErr_Occurred()) SWIG_fail;
15687 }
15688 resultobj = SWIG_Py_Void();
15689 if (SWIG_IsTmpObj(res2)) {
15690 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
15691 } else {
15692 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15693 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
15694 }
15695 if (SWIG_IsTmpObj(res3)) {
15696 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
15697 } else {
15698 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15699 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
15700 }
15701 if (SWIG_IsTmpObj(res4)) {
15702 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
15703 } else {
15704 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15705 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
15706 }
15707 return resultobj;
15708 fail:
15709 return NULL;
15710 }
15711
15712
15713 SWIGINTERN PyObject *_wrap_Image_GetMaskRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15714 PyObject *resultobj = 0;
15715 wxImage *arg1 = (wxImage *) 0 ;
15716 byte result;
15717 void *argp1 = 0 ;
15718 int res1 = 0 ;
15719 PyObject *swig_obj[1] ;
15720
15721 if (!args) SWIG_fail;
15722 swig_obj[0] = args;
15723 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15724 if (!SWIG_IsOK(res1)) {
15725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskRed" "', expected argument " "1"" of type '" "wxImage *""'");
15726 }
15727 arg1 = reinterpret_cast< wxImage * >(argp1);
15728 {
15729 PyThreadState* __tstate = wxPyBeginAllowThreads();
15730 result = (byte)(arg1)->GetMaskRed();
15731 wxPyEndAllowThreads(__tstate);
15732 if (PyErr_Occurred()) SWIG_fail;
15733 }
15734 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15735 return resultobj;
15736 fail:
15737 return NULL;
15738 }
15739
15740
15741 SWIGINTERN PyObject *_wrap_Image_GetMaskGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15742 PyObject *resultobj = 0;
15743 wxImage *arg1 = (wxImage *) 0 ;
15744 byte result;
15745 void *argp1 = 0 ;
15746 int res1 = 0 ;
15747 PyObject *swig_obj[1] ;
15748
15749 if (!args) SWIG_fail;
15750 swig_obj[0] = args;
15751 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15752 if (!SWIG_IsOK(res1)) {
15753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskGreen" "', expected argument " "1"" of type '" "wxImage *""'");
15754 }
15755 arg1 = reinterpret_cast< wxImage * >(argp1);
15756 {
15757 PyThreadState* __tstate = wxPyBeginAllowThreads();
15758 result = (byte)(arg1)->GetMaskGreen();
15759 wxPyEndAllowThreads(__tstate);
15760 if (PyErr_Occurred()) SWIG_fail;
15761 }
15762 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15763 return resultobj;
15764 fail:
15765 return NULL;
15766 }
15767
15768
15769 SWIGINTERN PyObject *_wrap_Image_GetMaskBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15770 PyObject *resultobj = 0;
15771 wxImage *arg1 = (wxImage *) 0 ;
15772 byte result;
15773 void *argp1 = 0 ;
15774 int res1 = 0 ;
15775 PyObject *swig_obj[1] ;
15776
15777 if (!args) SWIG_fail;
15778 swig_obj[0] = args;
15779 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15780 if (!SWIG_IsOK(res1)) {
15781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskBlue" "', expected argument " "1"" of type '" "wxImage *""'");
15782 }
15783 arg1 = reinterpret_cast< wxImage * >(argp1);
15784 {
15785 PyThreadState* __tstate = wxPyBeginAllowThreads();
15786 result = (byte)(arg1)->GetMaskBlue();
15787 wxPyEndAllowThreads(__tstate);
15788 if (PyErr_Occurred()) SWIG_fail;
15789 }
15790 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15791 return resultobj;
15792 fail:
15793 return NULL;
15794 }
15795
15796
15797 SWIGINTERN PyObject *_wrap_Image_SetMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15798 PyObject *resultobj = 0;
15799 wxImage *arg1 = (wxImage *) 0 ;
15800 bool arg2 = (bool) true ;
15801 void *argp1 = 0 ;
15802 int res1 = 0 ;
15803 bool val2 ;
15804 int ecode2 = 0 ;
15805 PyObject * obj0 = 0 ;
15806 PyObject * obj1 = 0 ;
15807 char * kwnames[] = {
15808 (char *) "self",(char *) "mask", NULL
15809 };
15810
15811 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) SWIG_fail;
15812 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15813 if (!SWIG_IsOK(res1)) {
15814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMask" "', expected argument " "1"" of type '" "wxImage *""'");
15815 }
15816 arg1 = reinterpret_cast< wxImage * >(argp1);
15817 if (obj1) {
15818 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15819 if (!SWIG_IsOK(ecode2)) {
15820 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMask" "', expected argument " "2"" of type '" "bool""'");
15821 }
15822 arg2 = static_cast< bool >(val2);
15823 }
15824 {
15825 PyThreadState* __tstate = wxPyBeginAllowThreads();
15826 (arg1)->SetMask(arg2);
15827 wxPyEndAllowThreads(__tstate);
15828 if (PyErr_Occurred()) SWIG_fail;
15829 }
15830 resultobj = SWIG_Py_Void();
15831 return resultobj;
15832 fail:
15833 return NULL;
15834 }
15835
15836
15837 SWIGINTERN PyObject *_wrap_Image_HasMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15838 PyObject *resultobj = 0;
15839 wxImage *arg1 = (wxImage *) 0 ;
15840 bool result;
15841 void *argp1 = 0 ;
15842 int res1 = 0 ;
15843 PyObject *swig_obj[1] ;
15844
15845 if (!args) SWIG_fail;
15846 swig_obj[0] = args;
15847 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15848 if (!SWIG_IsOK(res1)) {
15849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasMask" "', expected argument " "1"" of type '" "wxImage *""'");
15850 }
15851 arg1 = reinterpret_cast< wxImage * >(argp1);
15852 {
15853 PyThreadState* __tstate = wxPyBeginAllowThreads();
15854 result = (bool)(arg1)->HasMask();
15855 wxPyEndAllowThreads(__tstate);
15856 if (PyErr_Occurred()) SWIG_fail;
15857 }
15858 {
15859 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15860 }
15861 return resultobj;
15862 fail:
15863 return NULL;
15864 }
15865
15866
15867 SWIGINTERN PyObject *_wrap_Image_Rotate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15868 PyObject *resultobj = 0;
15869 wxImage *arg1 = (wxImage *) 0 ;
15870 double arg2 ;
15871 wxPoint *arg3 = 0 ;
15872 bool arg4 = (bool) true ;
15873 wxPoint *arg5 = (wxPoint *) NULL ;
15874 SwigValueWrapper<wxImage > result;
15875 void *argp1 = 0 ;
15876 int res1 = 0 ;
15877 double val2 ;
15878 int ecode2 = 0 ;
15879 wxPoint temp3 ;
15880 bool val4 ;
15881 int ecode4 = 0 ;
15882 void *argp5 = 0 ;
15883 int res5 = 0 ;
15884 PyObject * obj0 = 0 ;
15885 PyObject * obj1 = 0 ;
15886 PyObject * obj2 = 0 ;
15887 PyObject * obj3 = 0 ;
15888 PyObject * obj4 = 0 ;
15889 char * kwnames[] = {
15890 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
15891 };
15892
15893 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
15894 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15895 if (!SWIG_IsOK(res1)) {
15896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate" "', expected argument " "1"" of type '" "wxImage const *""'");
15897 }
15898 arg1 = reinterpret_cast< wxImage * >(argp1);
15899 ecode2 = SWIG_AsVal_double(obj1, &val2);
15900 if (!SWIG_IsOK(ecode2)) {
15901 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate" "', expected argument " "2"" of type '" "double""'");
15902 }
15903 arg2 = static_cast< double >(val2);
15904 {
15905 arg3 = &temp3;
15906 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
15907 }
15908 if (obj3) {
15909 ecode4 = SWIG_AsVal_bool(obj3, &val4);
15910 if (!SWIG_IsOK(ecode4)) {
15911 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rotate" "', expected argument " "4"" of type '" "bool""'");
15912 }
15913 arg4 = static_cast< bool >(val4);
15914 }
15915 if (obj4) {
15916 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxPoint, 0 | 0 );
15917 if (!SWIG_IsOK(res5)) {
15918 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Image_Rotate" "', expected argument " "5"" of type '" "wxPoint *""'");
15919 }
15920 arg5 = reinterpret_cast< wxPoint * >(argp5);
15921 }
15922 {
15923 PyThreadState* __tstate = wxPyBeginAllowThreads();
15924 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
15925 wxPyEndAllowThreads(__tstate);
15926 if (PyErr_Occurred()) SWIG_fail;
15927 }
15928 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15929 return resultobj;
15930 fail:
15931 return NULL;
15932 }
15933
15934
15935 SWIGINTERN PyObject *_wrap_Image_Rotate90(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15936 PyObject *resultobj = 0;
15937 wxImage *arg1 = (wxImage *) 0 ;
15938 bool arg2 = (bool) true ;
15939 SwigValueWrapper<wxImage > result;
15940 void *argp1 = 0 ;
15941 int res1 = 0 ;
15942 bool val2 ;
15943 int ecode2 = 0 ;
15944 PyObject * obj0 = 0 ;
15945 PyObject * obj1 = 0 ;
15946 char * kwnames[] = {
15947 (char *) "self",(char *) "clockwise", NULL
15948 };
15949
15950 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) SWIG_fail;
15951 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15952 if (!SWIG_IsOK(res1)) {
15953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate90" "', expected argument " "1"" of type '" "wxImage *""'");
15954 }
15955 arg1 = reinterpret_cast< wxImage * >(argp1);
15956 if (obj1) {
15957 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15958 if (!SWIG_IsOK(ecode2)) {
15959 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate90" "', expected argument " "2"" of type '" "bool""'");
15960 }
15961 arg2 = static_cast< bool >(val2);
15962 }
15963 {
15964 PyThreadState* __tstate = wxPyBeginAllowThreads();
15965 result = (arg1)->Rotate90(arg2);
15966 wxPyEndAllowThreads(__tstate);
15967 if (PyErr_Occurred()) SWIG_fail;
15968 }
15969 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15970 return resultobj;
15971 fail:
15972 return NULL;
15973 }
15974
15975
15976 SWIGINTERN PyObject *_wrap_Image_Mirror(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15977 PyObject *resultobj = 0;
15978 wxImage *arg1 = (wxImage *) 0 ;
15979 bool arg2 = (bool) true ;
15980 SwigValueWrapper<wxImage > result;
15981 void *argp1 = 0 ;
15982 int res1 = 0 ;
15983 bool val2 ;
15984 int ecode2 = 0 ;
15985 PyObject * obj0 = 0 ;
15986 PyObject * obj1 = 0 ;
15987 char * kwnames[] = {
15988 (char *) "self",(char *) "horizontally", NULL
15989 };
15990
15991 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) SWIG_fail;
15992 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15993 if (!SWIG_IsOK(res1)) {
15994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Mirror" "', expected argument " "1"" of type '" "wxImage *""'");
15995 }
15996 arg1 = reinterpret_cast< wxImage * >(argp1);
15997 if (obj1) {
15998 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15999 if (!SWIG_IsOK(ecode2)) {
16000 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Mirror" "', expected argument " "2"" of type '" "bool""'");
16001 }
16002 arg2 = static_cast< bool >(val2);
16003 }
16004 {
16005 PyThreadState* __tstate = wxPyBeginAllowThreads();
16006 result = (arg1)->Mirror(arg2);
16007 wxPyEndAllowThreads(__tstate);
16008 if (PyErr_Occurred()) SWIG_fail;
16009 }
16010 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16011 return resultobj;
16012 fail:
16013 return NULL;
16014 }
16015
16016
16017 SWIGINTERN PyObject *_wrap_Image_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16018 PyObject *resultobj = 0;
16019 wxImage *arg1 = (wxImage *) 0 ;
16020 byte arg2 ;
16021 byte arg3 ;
16022 byte arg4 ;
16023 byte arg5 ;
16024 byte arg6 ;
16025 byte arg7 ;
16026 void *argp1 = 0 ;
16027 int res1 = 0 ;
16028 unsigned char val2 ;
16029 int ecode2 = 0 ;
16030 unsigned char val3 ;
16031 int ecode3 = 0 ;
16032 unsigned char val4 ;
16033 int ecode4 = 0 ;
16034 unsigned char val5 ;
16035 int ecode5 = 0 ;
16036 unsigned char val6 ;
16037 int ecode6 = 0 ;
16038 unsigned char val7 ;
16039 int ecode7 = 0 ;
16040 PyObject * obj0 = 0 ;
16041 PyObject * obj1 = 0 ;
16042 PyObject * obj2 = 0 ;
16043 PyObject * obj3 = 0 ;
16044 PyObject * obj4 = 0 ;
16045 PyObject * obj5 = 0 ;
16046 PyObject * obj6 = 0 ;
16047 char * kwnames[] = {
16048 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
16049 };
16050
16051 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
16052 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16053 if (!SWIG_IsOK(res1)) {
16054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Replace" "', expected argument " "1"" of type '" "wxImage *""'");
16055 }
16056 arg1 = reinterpret_cast< wxImage * >(argp1);
16057 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16058 if (!SWIG_IsOK(ecode2)) {
16059 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Replace" "', expected argument " "2"" of type '" "byte""'");
16060 }
16061 arg2 = static_cast< byte >(val2);
16062 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16063 if (!SWIG_IsOK(ecode3)) {
16064 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Replace" "', expected argument " "3"" of type '" "byte""'");
16065 }
16066 arg3 = static_cast< byte >(val3);
16067 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16068 if (!SWIG_IsOK(ecode4)) {
16069 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Replace" "', expected argument " "4"" of type '" "byte""'");
16070 }
16071 arg4 = static_cast< byte >(val4);
16072 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
16073 if (!SWIG_IsOK(ecode5)) {
16074 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Replace" "', expected argument " "5"" of type '" "byte""'");
16075 }
16076 arg5 = static_cast< byte >(val5);
16077 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
16078 if (!SWIG_IsOK(ecode6)) {
16079 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Replace" "', expected argument " "6"" of type '" "byte""'");
16080 }
16081 arg6 = static_cast< byte >(val6);
16082 ecode7 = SWIG_AsVal_unsigned_SS_char(obj6, &val7);
16083 if (!SWIG_IsOK(ecode7)) {
16084 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_Replace" "', expected argument " "7"" of type '" "byte""'");
16085 }
16086 arg7 = static_cast< byte >(val7);
16087 {
16088 PyThreadState* __tstate = wxPyBeginAllowThreads();
16089 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
16090 wxPyEndAllowThreads(__tstate);
16091 if (PyErr_Occurred()) SWIG_fail;
16092 }
16093 resultobj = SWIG_Py_Void();
16094 return resultobj;
16095 fail:
16096 return NULL;
16097 }
16098
16099
16100 SWIGINTERN PyObject *_wrap_Image_ConvertToGreyscale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16101 PyObject *resultobj = 0;
16102 wxImage *arg1 = (wxImage *) 0 ;
16103 double arg2 = (double) 0.299 ;
16104 double arg3 = (double) 0.587 ;
16105 double arg4 = (double) 0.114 ;
16106 SwigValueWrapper<wxImage > result;
16107 void *argp1 = 0 ;
16108 int res1 = 0 ;
16109 double val2 ;
16110 int ecode2 = 0 ;
16111 double val3 ;
16112 int ecode3 = 0 ;
16113 double val4 ;
16114 int ecode4 = 0 ;
16115 PyObject * obj0 = 0 ;
16116 PyObject * obj1 = 0 ;
16117 PyObject * obj2 = 0 ;
16118 PyObject * obj3 = 0 ;
16119 char * kwnames[] = {
16120 (char *) "self",(char *) "lr",(char *) "lg",(char *) "lb", NULL
16121 };
16122
16123 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_ConvertToGreyscale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16124 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16125 if (!SWIG_IsOK(res1)) {
16126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToGreyscale" "', expected argument " "1"" of type '" "wxImage const *""'");
16127 }
16128 arg1 = reinterpret_cast< wxImage * >(argp1);
16129 if (obj1) {
16130 ecode2 = SWIG_AsVal_double(obj1, &val2);
16131 if (!SWIG_IsOK(ecode2)) {
16132 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToGreyscale" "', expected argument " "2"" of type '" "double""'");
16133 }
16134 arg2 = static_cast< double >(val2);
16135 }
16136 if (obj2) {
16137 ecode3 = SWIG_AsVal_double(obj2, &val3);
16138 if (!SWIG_IsOK(ecode3)) {
16139 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToGreyscale" "', expected argument " "3"" of type '" "double""'");
16140 }
16141 arg3 = static_cast< double >(val3);
16142 }
16143 if (obj3) {
16144 ecode4 = SWIG_AsVal_double(obj3, &val4);
16145 if (!SWIG_IsOK(ecode4)) {
16146 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToGreyscale" "', expected argument " "4"" of type '" "double""'");
16147 }
16148 arg4 = static_cast< double >(val4);
16149 }
16150 {
16151 PyThreadState* __tstate = wxPyBeginAllowThreads();
16152 result = ((wxImage const *)arg1)->ConvertToGreyscale(arg2,arg3,arg4);
16153 wxPyEndAllowThreads(__tstate);
16154 if (PyErr_Occurred()) SWIG_fail;
16155 }
16156 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16157 return resultobj;
16158 fail:
16159 return NULL;
16160 }
16161
16162
16163 SWIGINTERN PyObject *_wrap_Image_ConvertToMono(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16164 PyObject *resultobj = 0;
16165 wxImage *arg1 = (wxImage *) 0 ;
16166 byte arg2 ;
16167 byte arg3 ;
16168 byte arg4 ;
16169 SwigValueWrapper<wxImage > result;
16170 void *argp1 = 0 ;
16171 int res1 = 0 ;
16172 unsigned char val2 ;
16173 int ecode2 = 0 ;
16174 unsigned char val3 ;
16175 int ecode3 = 0 ;
16176 unsigned char val4 ;
16177 int ecode4 = 0 ;
16178 PyObject * obj0 = 0 ;
16179 PyObject * obj1 = 0 ;
16180 PyObject * obj2 = 0 ;
16181 PyObject * obj3 = 0 ;
16182 char * kwnames[] = {
16183 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
16184 };
16185
16186 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16187 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16188 if (!SWIG_IsOK(res1)) {
16189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMono" "', expected argument " "1"" of type '" "wxImage const *""'");
16190 }
16191 arg1 = reinterpret_cast< wxImage * >(argp1);
16192 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16193 if (!SWIG_IsOK(ecode2)) {
16194 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMono" "', expected argument " "2"" of type '" "byte""'");
16195 }
16196 arg2 = static_cast< byte >(val2);
16197 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16198 if (!SWIG_IsOK(ecode3)) {
16199 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMono" "', expected argument " "3"" of type '" "byte""'");
16200 }
16201 arg3 = static_cast< byte >(val3);
16202 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16203 if (!SWIG_IsOK(ecode4)) {
16204 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMono" "', expected argument " "4"" of type '" "byte""'");
16205 }
16206 arg4 = static_cast< byte >(val4);
16207 {
16208 PyThreadState* __tstate = wxPyBeginAllowThreads();
16209 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
16210 wxPyEndAllowThreads(__tstate);
16211 if (PyErr_Occurred()) SWIG_fail;
16212 }
16213 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16214 return resultobj;
16215 fail:
16216 return NULL;
16217 }
16218
16219
16220 SWIGINTERN PyObject *_wrap_Image_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16221 PyObject *resultobj = 0;
16222 wxImage *arg1 = (wxImage *) 0 ;
16223 wxString *arg2 = 0 ;
16224 wxString *arg3 = 0 ;
16225 void *argp1 = 0 ;
16226 int res1 = 0 ;
16227 bool temp2 = false ;
16228 bool temp3 = false ;
16229 PyObject * obj0 = 0 ;
16230 PyObject * obj1 = 0 ;
16231 PyObject * obj2 = 0 ;
16232 char * kwnames[] = {
16233 (char *) "self",(char *) "name",(char *) "value", NULL
16234 };
16235
16236 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16237 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16238 if (!SWIG_IsOK(res1)) {
16239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOption" "', expected argument " "1"" of type '" "wxImage *""'");
16240 }
16241 arg1 = reinterpret_cast< wxImage * >(argp1);
16242 {
16243 arg2 = wxString_in_helper(obj1);
16244 if (arg2 == NULL) SWIG_fail;
16245 temp2 = true;
16246 }
16247 {
16248 arg3 = wxString_in_helper(obj2);
16249 if (arg3 == NULL) SWIG_fail;
16250 temp3 = true;
16251 }
16252 {
16253 PyThreadState* __tstate = wxPyBeginAllowThreads();
16254 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
16255 wxPyEndAllowThreads(__tstate);
16256 if (PyErr_Occurred()) SWIG_fail;
16257 }
16258 resultobj = SWIG_Py_Void();
16259 {
16260 if (temp2)
16261 delete arg2;
16262 }
16263 {
16264 if (temp3)
16265 delete arg3;
16266 }
16267 return resultobj;
16268 fail:
16269 {
16270 if (temp2)
16271 delete arg2;
16272 }
16273 {
16274 if (temp3)
16275 delete arg3;
16276 }
16277 return NULL;
16278 }
16279
16280
16281 SWIGINTERN PyObject *_wrap_Image_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16282 PyObject *resultobj = 0;
16283 wxImage *arg1 = (wxImage *) 0 ;
16284 wxString *arg2 = 0 ;
16285 int arg3 ;
16286 void *argp1 = 0 ;
16287 int res1 = 0 ;
16288 bool temp2 = false ;
16289 int val3 ;
16290 int ecode3 = 0 ;
16291 PyObject * obj0 = 0 ;
16292 PyObject * obj1 = 0 ;
16293 PyObject * obj2 = 0 ;
16294 char * kwnames[] = {
16295 (char *) "self",(char *) "name",(char *) "value", NULL
16296 };
16297
16298 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16299 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16300 if (!SWIG_IsOK(res1)) {
16301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOptionInt" "', expected argument " "1"" of type '" "wxImage *""'");
16302 }
16303 arg1 = reinterpret_cast< wxImage * >(argp1);
16304 {
16305 arg2 = wxString_in_helper(obj1);
16306 if (arg2 == NULL) SWIG_fail;
16307 temp2 = true;
16308 }
16309 ecode3 = SWIG_AsVal_int(obj2, &val3);
16310 if (!SWIG_IsOK(ecode3)) {
16311 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetOptionInt" "', expected argument " "3"" of type '" "int""'");
16312 }
16313 arg3 = static_cast< int >(val3);
16314 {
16315 PyThreadState* __tstate = wxPyBeginAllowThreads();
16316 (arg1)->SetOption((wxString const &)*arg2,arg3);
16317 wxPyEndAllowThreads(__tstate);
16318 if (PyErr_Occurred()) SWIG_fail;
16319 }
16320 resultobj = SWIG_Py_Void();
16321 {
16322 if (temp2)
16323 delete arg2;
16324 }
16325 return resultobj;
16326 fail:
16327 {
16328 if (temp2)
16329 delete arg2;
16330 }
16331 return NULL;
16332 }
16333
16334
16335 SWIGINTERN PyObject *_wrap_Image_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16336 PyObject *resultobj = 0;
16337 wxImage *arg1 = (wxImage *) 0 ;
16338 wxString *arg2 = 0 ;
16339 wxString result;
16340 void *argp1 = 0 ;
16341 int res1 = 0 ;
16342 bool temp2 = false ;
16343 PyObject * obj0 = 0 ;
16344 PyObject * obj1 = 0 ;
16345 char * kwnames[] = {
16346 (char *) "self",(char *) "name", NULL
16347 };
16348
16349 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) SWIG_fail;
16350 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16351 if (!SWIG_IsOK(res1)) {
16352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16353 }
16354 arg1 = reinterpret_cast< wxImage * >(argp1);
16355 {
16356 arg2 = wxString_in_helper(obj1);
16357 if (arg2 == NULL) SWIG_fail;
16358 temp2 = true;
16359 }
16360 {
16361 PyThreadState* __tstate = wxPyBeginAllowThreads();
16362 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
16363 wxPyEndAllowThreads(__tstate);
16364 if (PyErr_Occurred()) SWIG_fail;
16365 }
16366 {
16367 #if wxUSE_UNICODE
16368 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16369 #else
16370 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16371 #endif
16372 }
16373 {
16374 if (temp2)
16375 delete arg2;
16376 }
16377 return resultobj;
16378 fail:
16379 {
16380 if (temp2)
16381 delete arg2;
16382 }
16383 return NULL;
16384 }
16385
16386
16387 SWIGINTERN PyObject *_wrap_Image_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16388 PyObject *resultobj = 0;
16389 wxImage *arg1 = (wxImage *) 0 ;
16390 wxString *arg2 = 0 ;
16391 int result;
16392 void *argp1 = 0 ;
16393 int res1 = 0 ;
16394 bool temp2 = false ;
16395 PyObject * obj0 = 0 ;
16396 PyObject * obj1 = 0 ;
16397 char * kwnames[] = {
16398 (char *) "self",(char *) "name", NULL
16399 };
16400
16401 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
16402 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16403 if (!SWIG_IsOK(res1)) {
16404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOptionInt" "', expected argument " "1"" of type '" "wxImage const *""'");
16405 }
16406 arg1 = reinterpret_cast< wxImage * >(argp1);
16407 {
16408 arg2 = wxString_in_helper(obj1);
16409 if (arg2 == NULL) SWIG_fail;
16410 temp2 = true;
16411 }
16412 {
16413 PyThreadState* __tstate = wxPyBeginAllowThreads();
16414 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
16415 wxPyEndAllowThreads(__tstate);
16416 if (PyErr_Occurred()) SWIG_fail;
16417 }
16418 resultobj = SWIG_From_int(static_cast< int >(result));
16419 {
16420 if (temp2)
16421 delete arg2;
16422 }
16423 return resultobj;
16424 fail:
16425 {
16426 if (temp2)
16427 delete arg2;
16428 }
16429 return NULL;
16430 }
16431
16432
16433 SWIGINTERN PyObject *_wrap_Image_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16434 PyObject *resultobj = 0;
16435 wxImage *arg1 = (wxImage *) 0 ;
16436 wxString *arg2 = 0 ;
16437 bool result;
16438 void *argp1 = 0 ;
16439 int res1 = 0 ;
16440 bool temp2 = false ;
16441 PyObject * obj0 = 0 ;
16442 PyObject * obj1 = 0 ;
16443 char * kwnames[] = {
16444 (char *) "self",(char *) "name", NULL
16445 };
16446
16447 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) SWIG_fail;
16448 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16449 if (!SWIG_IsOK(res1)) {
16450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16451 }
16452 arg1 = reinterpret_cast< wxImage * >(argp1);
16453 {
16454 arg2 = wxString_in_helper(obj1);
16455 if (arg2 == NULL) SWIG_fail;
16456 temp2 = true;
16457 }
16458 {
16459 PyThreadState* __tstate = wxPyBeginAllowThreads();
16460 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
16461 wxPyEndAllowThreads(__tstate);
16462 if (PyErr_Occurred()) SWIG_fail;
16463 }
16464 {
16465 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16466 }
16467 {
16468 if (temp2)
16469 delete arg2;
16470 }
16471 return resultobj;
16472 fail:
16473 {
16474 if (temp2)
16475 delete arg2;
16476 }
16477 return NULL;
16478 }
16479
16480
16481 SWIGINTERN PyObject *_wrap_Image_CountColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16482 PyObject *resultobj = 0;
16483 wxImage *arg1 = (wxImage *) 0 ;
16484 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
16485 unsigned long result;
16486 void *argp1 = 0 ;
16487 int res1 = 0 ;
16488 unsigned long val2 ;
16489 int ecode2 = 0 ;
16490 PyObject * obj0 = 0 ;
16491 PyObject * obj1 = 0 ;
16492 char * kwnames[] = {
16493 (char *) "self",(char *) "stopafter", NULL
16494 };
16495
16496 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) SWIG_fail;
16497 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16498 if (!SWIG_IsOK(res1)) {
16499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_CountColours" "', expected argument " "1"" of type '" "wxImage *""'");
16500 }
16501 arg1 = reinterpret_cast< wxImage * >(argp1);
16502 if (obj1) {
16503 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
16504 if (!SWIG_IsOK(ecode2)) {
16505 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_CountColours" "', expected argument " "2"" of type '" "unsigned long""'");
16506 }
16507 arg2 = static_cast< unsigned long >(val2);
16508 }
16509 {
16510 PyThreadState* __tstate = wxPyBeginAllowThreads();
16511 result = (unsigned long)(arg1)->CountColours(arg2);
16512 wxPyEndAllowThreads(__tstate);
16513 if (PyErr_Occurred()) SWIG_fail;
16514 }
16515 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16516 return resultobj;
16517 fail:
16518 return NULL;
16519 }
16520
16521
16522 SWIGINTERN PyObject *_wrap_Image_ComputeHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16523 PyObject *resultobj = 0;
16524 wxImage *arg1 = (wxImage *) 0 ;
16525 wxImageHistogram *arg2 = 0 ;
16526 unsigned long result;
16527 void *argp1 = 0 ;
16528 int res1 = 0 ;
16529 void *argp2 = 0 ;
16530 int res2 = 0 ;
16531 PyObject * obj0 = 0 ;
16532 PyObject * obj1 = 0 ;
16533 char * kwnames[] = {
16534 (char *) "self",(char *) "h", NULL
16535 };
16536
16537 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) SWIG_fail;
16538 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16539 if (!SWIG_IsOK(res1)) {
16540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ComputeHistogram" "', expected argument " "1"" of type '" "wxImage *""'");
16541 }
16542 arg1 = reinterpret_cast< wxImage * >(argp1);
16543 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImageHistogram, 0 );
16544 if (!SWIG_IsOK(res2)) {
16545 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16546 }
16547 if (!argp2) {
16548 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16549 }
16550 arg2 = reinterpret_cast< wxImageHistogram * >(argp2);
16551 {
16552 PyThreadState* __tstate = wxPyBeginAllowThreads();
16553 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
16554 wxPyEndAllowThreads(__tstate);
16555 if (PyErr_Occurred()) SWIG_fail;
16556 }
16557 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16558 return resultobj;
16559 fail:
16560 return NULL;
16561 }
16562
16563
16564 SWIGINTERN PyObject *_wrap_Image_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16565 PyObject *resultobj = 0;
16566 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16567 void *argp1 = 0 ;
16568 int res1 = 0 ;
16569 PyObject * obj0 = 0 ;
16570 char * kwnames[] = {
16571 (char *) "handler", NULL
16572 };
16573
16574 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) SWIG_fail;
16575 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16576 if (!SWIG_IsOK(res1)) {
16577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_AddHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16578 }
16579 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16580 {
16581 PyThreadState* __tstate = wxPyBeginAllowThreads();
16582 wxImage::AddHandler(arg1);
16583 wxPyEndAllowThreads(__tstate);
16584 if (PyErr_Occurred()) SWIG_fail;
16585 }
16586 resultobj = SWIG_Py_Void();
16587 return resultobj;
16588 fail:
16589 return NULL;
16590 }
16591
16592
16593 SWIGINTERN PyObject *_wrap_Image_InsertHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16594 PyObject *resultobj = 0;
16595 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16596 void *argp1 = 0 ;
16597 int res1 = 0 ;
16598 PyObject * obj0 = 0 ;
16599 char * kwnames[] = {
16600 (char *) "handler", NULL
16601 };
16602
16603 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) SWIG_fail;
16604 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16605 if (!SWIG_IsOK(res1)) {
16606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InsertHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16607 }
16608 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16609 {
16610 PyThreadState* __tstate = wxPyBeginAllowThreads();
16611 wxImage::InsertHandler(arg1);
16612 wxPyEndAllowThreads(__tstate);
16613 if (PyErr_Occurred()) SWIG_fail;
16614 }
16615 resultobj = SWIG_Py_Void();
16616 return resultobj;
16617 fail:
16618 return NULL;
16619 }
16620
16621
16622 SWIGINTERN PyObject *_wrap_Image_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16623 PyObject *resultobj = 0;
16624 wxString *arg1 = 0 ;
16625 bool result;
16626 bool temp1 = false ;
16627 PyObject * obj0 = 0 ;
16628 char * kwnames[] = {
16629 (char *) "name", NULL
16630 };
16631
16632 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) SWIG_fail;
16633 {
16634 arg1 = wxString_in_helper(obj0);
16635 if (arg1 == NULL) SWIG_fail;
16636 temp1 = true;
16637 }
16638 {
16639 PyThreadState* __tstate = wxPyBeginAllowThreads();
16640 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
16641 wxPyEndAllowThreads(__tstate);
16642 if (PyErr_Occurred()) SWIG_fail;
16643 }
16644 {
16645 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16646 }
16647 {
16648 if (temp1)
16649 delete arg1;
16650 }
16651 return resultobj;
16652 fail:
16653 {
16654 if (temp1)
16655 delete arg1;
16656 }
16657 return NULL;
16658 }
16659
16660
16661 SWIGINTERN PyObject *_wrap_Image_GetHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16662 PyObject *resultobj = 0;
16663 PyObject *result = 0 ;
16664
16665 if (!SWIG_Python_UnpackTuple(args,"Image_GetHandlers",0,0,0)) SWIG_fail;
16666 {
16667 PyThreadState* __tstate = wxPyBeginAllowThreads();
16668 result = (PyObject *)wxImage_GetHandlers();
16669 wxPyEndAllowThreads(__tstate);
16670 if (PyErr_Occurred()) SWIG_fail;
16671 }
16672 resultobj = result;
16673 return resultobj;
16674 fail:
16675 return NULL;
16676 }
16677
16678
16679 SWIGINTERN PyObject *_wrap_Image_GetImageExtWildcard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16680 PyObject *resultobj = 0;
16681 wxString result;
16682
16683 if (!SWIG_Python_UnpackTuple(args,"Image_GetImageExtWildcard",0,0,0)) SWIG_fail;
16684 {
16685 PyThreadState* __tstate = wxPyBeginAllowThreads();
16686 result = wxImage::GetImageExtWildcard();
16687 wxPyEndAllowThreads(__tstate);
16688 if (PyErr_Occurred()) SWIG_fail;
16689 }
16690 {
16691 #if wxUSE_UNICODE
16692 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16693 #else
16694 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16695 #endif
16696 }
16697 return resultobj;
16698 fail:
16699 return NULL;
16700 }
16701
16702
16703 SWIGINTERN PyObject *_wrap_Image_ConvertToBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16704 PyObject *resultobj = 0;
16705 wxImage *arg1 = (wxImage *) 0 ;
16706 int arg2 = (int) -1 ;
16707 wxBitmap result;
16708 void *argp1 = 0 ;
16709 int res1 = 0 ;
16710 int val2 ;
16711 int ecode2 = 0 ;
16712 PyObject * obj0 = 0 ;
16713 PyObject * obj1 = 0 ;
16714 char * kwnames[] = {
16715 (char *) "self",(char *) "depth", NULL
16716 };
16717
16718 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
16719 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16720 if (!SWIG_IsOK(res1)) {
16721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
16722 }
16723 arg1 = reinterpret_cast< wxImage * >(argp1);
16724 if (obj1) {
16725 ecode2 = SWIG_AsVal_int(obj1, &val2);
16726 if (!SWIG_IsOK(ecode2)) {
16727 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToBitmap" "', expected argument " "2"" of type '" "int""'");
16728 }
16729 arg2 = static_cast< int >(val2);
16730 }
16731 {
16732 if (!wxPyCheckForApp()) SWIG_fail;
16733 PyThreadState* __tstate = wxPyBeginAllowThreads();
16734 result = wxImage_ConvertToBitmap(arg1,arg2);
16735 wxPyEndAllowThreads(__tstate);
16736 if (PyErr_Occurred()) SWIG_fail;
16737 }
16738 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
16739 return resultobj;
16740 fail:
16741 return NULL;
16742 }
16743
16744
16745 SWIGINTERN PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16746 PyObject *resultobj = 0;
16747 wxImage *arg1 = (wxImage *) 0 ;
16748 byte arg2 ;
16749 byte arg3 ;
16750 byte arg4 ;
16751 wxBitmap result;
16752 void *argp1 = 0 ;
16753 int res1 = 0 ;
16754 unsigned char val2 ;
16755 int ecode2 = 0 ;
16756 unsigned char val3 ;
16757 int ecode3 = 0 ;
16758 unsigned char val4 ;
16759 int ecode4 = 0 ;
16760 PyObject * obj0 = 0 ;
16761 PyObject * obj1 = 0 ;
16762 PyObject * obj2 = 0 ;
16763 PyObject * obj3 = 0 ;
16764 char * kwnames[] = {
16765 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
16766 };
16767
16768 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16769 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16770 if (!SWIG_IsOK(res1)) {
16771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
16772 }
16773 arg1 = reinterpret_cast< wxImage * >(argp1);
16774 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16775 if (!SWIG_IsOK(ecode2)) {
16776 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "2"" of type '" "byte""'");
16777 }
16778 arg2 = static_cast< byte >(val2);
16779 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16780 if (!SWIG_IsOK(ecode3)) {
16781 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "3"" of type '" "byte""'");
16782 }
16783 arg3 = static_cast< byte >(val3);
16784 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16785 if (!SWIG_IsOK(ecode4)) {
16786 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "4"" of type '" "byte""'");
16787 }
16788 arg4 = static_cast< byte >(val4);
16789 {
16790 if (!wxPyCheckForApp()) SWIG_fail;
16791 PyThreadState* __tstate = wxPyBeginAllowThreads();
16792 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
16793 wxPyEndAllowThreads(__tstate);
16794 if (PyErr_Occurred()) SWIG_fail;
16795 }
16796 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
16797 return resultobj;
16798 fail:
16799 return NULL;
16800 }
16801
16802
16803 SWIGINTERN PyObject *_wrap_Image_RotateHue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16804 PyObject *resultobj = 0;
16805 wxImage *arg1 = (wxImage *) 0 ;
16806 double arg2 ;
16807 void *argp1 = 0 ;
16808 int res1 = 0 ;
16809 double val2 ;
16810 int ecode2 = 0 ;
16811 PyObject * obj0 = 0 ;
16812 PyObject * obj1 = 0 ;
16813 char * kwnames[] = {
16814 (char *) "self",(char *) "angle", NULL
16815 };
16816
16817 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RotateHue",kwnames,&obj0,&obj1)) SWIG_fail;
16818 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16819 if (!SWIG_IsOK(res1)) {
16820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RotateHue" "', expected argument " "1"" of type '" "wxImage *""'");
16821 }
16822 arg1 = reinterpret_cast< wxImage * >(argp1);
16823 ecode2 = SWIG_AsVal_double(obj1, &val2);
16824 if (!SWIG_IsOK(ecode2)) {
16825 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RotateHue" "', expected argument " "2"" of type '" "double""'");
16826 }
16827 arg2 = static_cast< double >(val2);
16828 {
16829 PyThreadState* __tstate = wxPyBeginAllowThreads();
16830 (arg1)->RotateHue(arg2);
16831 wxPyEndAllowThreads(__tstate);
16832 if (PyErr_Occurred()) SWIG_fail;
16833 }
16834 resultobj = SWIG_Py_Void();
16835 return resultobj;
16836 fail:
16837 return NULL;
16838 }
16839
16840
16841 SWIGINTERN PyObject *_wrap_Image_RGBtoHSV(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16842 PyObject *resultobj = 0;
16843 wxImage_RGBValue arg1 ;
16844 wxImage_HSVValue result;
16845 void *argp1 ;
16846 int res1 = 0 ;
16847 PyObject * obj0 = 0 ;
16848 char * kwnames[] = {
16849 (char *) "rgb", NULL
16850 };
16851
16852 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBtoHSV",kwnames,&obj0)) SWIG_fail;
16853 {
16854 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_RGBValue, 0 | 0);
16855 if (!SWIG_IsOK(res1)) {
16856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
16857 }
16858 if (!argp1) {
16859 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
16860 } else {
16861 wxImage_RGBValue * temp = reinterpret_cast< wxImage_RGBValue * >(argp1);
16862 arg1 = *temp;
16863 if (SWIG_IsNewObj(res1)) delete temp;
16864 }
16865 }
16866 {
16867 PyThreadState* __tstate = wxPyBeginAllowThreads();
16868 result = wxImage::RGBtoHSV(arg1);
16869 wxPyEndAllowThreads(__tstate);
16870 if (PyErr_Occurred()) SWIG_fail;
16871 }
16872 resultobj = SWIG_NewPointerObj((new wxImage_HSVValue(static_cast< const wxImage_HSVValue& >(result))), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_OWN | 0 );
16873 return resultobj;
16874 fail:
16875 return NULL;
16876 }
16877
16878
16879 SWIGINTERN PyObject *_wrap_Image_HSVtoRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16880 PyObject *resultobj = 0;
16881 wxImage_HSVValue arg1 ;
16882 wxImage_RGBValue result;
16883 void *argp1 ;
16884 int res1 = 0 ;
16885 PyObject * obj0 = 0 ;
16886 char * kwnames[] = {
16887 (char *) "hsv", NULL
16888 };
16889
16890 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVtoRGB",kwnames,&obj0)) SWIG_fail;
16891 {
16892 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_HSVValue, 0 | 0);
16893 if (!SWIG_IsOK(res1)) {
16894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
16895 }
16896 if (!argp1) {
16897 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
16898 } else {
16899 wxImage_HSVValue * temp = reinterpret_cast< wxImage_HSVValue * >(argp1);
16900 arg1 = *temp;
16901 if (SWIG_IsNewObj(res1)) delete temp;
16902 }
16903 }
16904 {
16905 PyThreadState* __tstate = wxPyBeginAllowThreads();
16906 result = wxImage::HSVtoRGB(arg1);
16907 wxPyEndAllowThreads(__tstate);
16908 if (PyErr_Occurred()) SWIG_fail;
16909 }
16910 resultobj = SWIG_NewPointerObj((new wxImage_RGBValue(static_cast< const wxImage_RGBValue& >(result))), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_OWN | 0 );
16911 return resultobj;
16912 fail:
16913 return NULL;
16914 }
16915
16916
16917 SWIGINTERN PyObject *Image_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16918 PyObject *obj;
16919 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16920 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage, SWIG_NewClientData(obj));
16921 return SWIG_Py_Void();
16922 }
16923
16924 SWIGINTERN PyObject *Image_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16925 return SWIG_Python_InitShadowInstance(args);
16926 }
16927
16928 SWIGINTERN int NullImage_set(PyObject *) {
16929 SWIG_Error(SWIG_AttributeError,"Variable NullImage is read-only.");
16930 return 1;
16931 }
16932
16933
16934 SWIGINTERN PyObject *NullImage_get(void) {
16935 PyObject *pyobj = 0;
16936
16937 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullImage), SWIGTYPE_p_wxImage, 0 );
16938 return pyobj;
16939 }
16940
16941
16942 SWIGINTERN int IMAGE_OPTION_FILENAME_set(PyObject *) {
16943 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
16944 return 1;
16945 }
16946
16947
16948 SWIGINTERN PyObject *IMAGE_OPTION_FILENAME_get(void) {
16949 PyObject *pyobj = 0;
16950
16951 {
16952 #if wxUSE_UNICODE
16953 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
16954 #else
16955 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
16956 #endif
16957 }
16958 return pyobj;
16959 }
16960
16961
16962 SWIGINTERN int IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
16963 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
16964 return 1;
16965 }
16966
16967
16968 SWIGINTERN PyObject *IMAGE_OPTION_BMP_FORMAT_get(void) {
16969 PyObject *pyobj = 0;
16970
16971 {
16972 #if wxUSE_UNICODE
16973 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
16974 #else
16975 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
16976 #endif
16977 }
16978 return pyobj;
16979 }
16980
16981
16982 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
16983 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
16984 return 1;
16985 }
16986
16987
16988 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
16989 PyObject *pyobj = 0;
16990
16991 {
16992 #if wxUSE_UNICODE
16993 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
16994 #else
16995 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
16996 #endif
16997 }
16998 return pyobj;
16999 }
17000
17001
17002 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
17003 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
17004 return 1;
17005 }
17006
17007
17008 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
17009 PyObject *pyobj = 0;
17010
17011 {
17012 #if wxUSE_UNICODE
17013 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
17014 #else
17015 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
17016 #endif
17017 }
17018 return pyobj;
17019 }
17020
17021
17022 SWIGINTERN int IMAGE_OPTION_RESOLUTION_set(PyObject *) {
17023 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
17024 return 1;
17025 }
17026
17027
17028 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTION_get(void) {
17029 PyObject *pyobj = 0;
17030
17031 {
17032 #if wxUSE_UNICODE
17033 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
17034 #else
17035 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
17036 #endif
17037 }
17038 return pyobj;
17039 }
17040
17041
17042 SWIGINTERN int IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
17043 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
17044 return 1;
17045 }
17046
17047
17048 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONX_get(void) {
17049 PyObject *pyobj = 0;
17050
17051 {
17052 #if wxUSE_UNICODE
17053 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
17054 #else
17055 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
17056 #endif
17057 }
17058 return pyobj;
17059 }
17060
17061
17062 SWIGINTERN int IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
17063 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
17064 return 1;
17065 }
17066
17067
17068 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONY_get(void) {
17069 PyObject *pyobj = 0;
17070
17071 {
17072 #if wxUSE_UNICODE
17073 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
17074 #else
17075 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
17076 #endif
17077 }
17078 return pyobj;
17079 }
17080
17081
17082 SWIGINTERN int IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
17083 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
17084 return 1;
17085 }
17086
17087
17088 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
17089 PyObject *pyobj = 0;
17090
17091 {
17092 #if wxUSE_UNICODE
17093 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17094 #else
17095 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17096 #endif
17097 }
17098 return pyobj;
17099 }
17100
17101
17102 SWIGINTERN int IMAGE_OPTION_QUALITY_set(PyObject *) {
17103 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
17104 return 1;
17105 }
17106
17107
17108 SWIGINTERN PyObject *IMAGE_OPTION_QUALITY_get(void) {
17109 PyObject *pyobj = 0;
17110
17111 {
17112 #if wxUSE_UNICODE
17113 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17114 #else
17115 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17116 #endif
17117 }
17118 return pyobj;
17119 }
17120
17121
17122 SWIGINTERN int IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
17123 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
17124 return 1;
17125 }
17126
17127
17128 SWIGINTERN PyObject *IMAGE_OPTION_BITSPERSAMPLE_get(void) {
17129 PyObject *pyobj = 0;
17130
17131 {
17132 #if wxUSE_UNICODE
17133 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17134 #else
17135 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17136 #endif
17137 }
17138 return pyobj;
17139 }
17140
17141
17142 SWIGINTERN int IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
17143 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
17144 return 1;
17145 }
17146
17147
17148 SWIGINTERN PyObject *IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
17149 PyObject *pyobj = 0;
17150
17151 {
17152 #if wxUSE_UNICODE
17153 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17154 #else
17155 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17156 #endif
17157 }
17158 return pyobj;
17159 }
17160
17161
17162 SWIGINTERN int IMAGE_OPTION_COMPRESSION_set(PyObject *) {
17163 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
17164 return 1;
17165 }
17166
17167
17168 SWIGINTERN PyObject *IMAGE_OPTION_COMPRESSION_get(void) {
17169 PyObject *pyobj = 0;
17170
17171 {
17172 #if wxUSE_UNICODE
17173 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17174 #else
17175 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17176 #endif
17177 }
17178 return pyobj;
17179 }
17180
17181
17182 SWIGINTERN int IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
17183 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
17184 return 1;
17185 }
17186
17187
17188 SWIGINTERN PyObject *IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
17189 PyObject *pyobj = 0;
17190
17191 {
17192 #if wxUSE_UNICODE
17193 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17194 #else
17195 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17196 #endif
17197 }
17198 return pyobj;
17199 }
17200
17201
17202 SWIGINTERN int IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
17203 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
17204 return 1;
17205 }
17206
17207
17208 SWIGINTERN PyObject *IMAGE_OPTION_PNG_FORMAT_get(void) {
17209 PyObject *pyobj = 0;
17210
17211 {
17212 #if wxUSE_UNICODE
17213 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17214 #else
17215 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17216 #endif
17217 }
17218 return pyobj;
17219 }
17220
17221
17222 SWIGINTERN int IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
17223 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
17224 return 1;
17225 }
17226
17227
17228 SWIGINTERN PyObject *IMAGE_OPTION_PNG_BITDEPTH_get(void) {
17229 PyObject *pyobj = 0;
17230
17231 {
17232 #if wxUSE_UNICODE
17233 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17234 #else
17235 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17236 #endif
17237 }
17238 return pyobj;
17239 }
17240
17241
17242 SWIGINTERN PyObject *_wrap_new_BMPHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17243 PyObject *resultobj = 0;
17244 wxBMPHandler *result = 0 ;
17245
17246 if (!SWIG_Python_UnpackTuple(args,"new_BMPHandler",0,0,0)) SWIG_fail;
17247 {
17248 PyThreadState* __tstate = wxPyBeginAllowThreads();
17249 result = (wxBMPHandler *)new wxBMPHandler();
17250 wxPyEndAllowThreads(__tstate);
17251 if (PyErr_Occurred()) SWIG_fail;
17252 }
17253 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBMPHandler, SWIG_POINTER_NEW | 0 );
17254 return resultobj;
17255 fail:
17256 return NULL;
17257 }
17258
17259
17260 SWIGINTERN PyObject *BMPHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17261 PyObject *obj;
17262 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17263 SWIG_TypeNewClientData(SWIGTYPE_p_wxBMPHandler, SWIG_NewClientData(obj));
17264 return SWIG_Py_Void();
17265 }
17266
17267 SWIGINTERN PyObject *BMPHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17268 return SWIG_Python_InitShadowInstance(args);
17269 }
17270
17271 SWIGINTERN PyObject *_wrap_new_ICOHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17272 PyObject *resultobj = 0;
17273 wxICOHandler *result = 0 ;
17274
17275 if (!SWIG_Python_UnpackTuple(args,"new_ICOHandler",0,0,0)) SWIG_fail;
17276 {
17277 PyThreadState* __tstate = wxPyBeginAllowThreads();
17278 result = (wxICOHandler *)new wxICOHandler();
17279 wxPyEndAllowThreads(__tstate);
17280 if (PyErr_Occurred()) SWIG_fail;
17281 }
17282 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxICOHandler, SWIG_POINTER_NEW | 0 );
17283 return resultobj;
17284 fail:
17285 return NULL;
17286 }
17287
17288
17289 SWIGINTERN PyObject *ICOHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17290 PyObject *obj;
17291 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17292 SWIG_TypeNewClientData(SWIGTYPE_p_wxICOHandler, SWIG_NewClientData(obj));
17293 return SWIG_Py_Void();
17294 }
17295
17296 SWIGINTERN PyObject *ICOHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17297 return SWIG_Python_InitShadowInstance(args);
17298 }
17299
17300 SWIGINTERN PyObject *_wrap_new_CURHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17301 PyObject *resultobj = 0;
17302 wxCURHandler *result = 0 ;
17303
17304 if (!SWIG_Python_UnpackTuple(args,"new_CURHandler",0,0,0)) SWIG_fail;
17305 {
17306 PyThreadState* __tstate = wxPyBeginAllowThreads();
17307 result = (wxCURHandler *)new wxCURHandler();
17308 wxPyEndAllowThreads(__tstate);
17309 if (PyErr_Occurred()) SWIG_fail;
17310 }
17311 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCURHandler, SWIG_POINTER_NEW | 0 );
17312 return resultobj;
17313 fail:
17314 return NULL;
17315 }
17316
17317
17318 SWIGINTERN PyObject *CURHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17319 PyObject *obj;
17320 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17321 SWIG_TypeNewClientData(SWIGTYPE_p_wxCURHandler, SWIG_NewClientData(obj));
17322 return SWIG_Py_Void();
17323 }
17324
17325 SWIGINTERN PyObject *CURHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17326 return SWIG_Python_InitShadowInstance(args);
17327 }
17328
17329 SWIGINTERN PyObject *_wrap_new_ANIHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17330 PyObject *resultobj = 0;
17331 wxANIHandler *result = 0 ;
17332
17333 if (!SWIG_Python_UnpackTuple(args,"new_ANIHandler",0,0,0)) SWIG_fail;
17334 {
17335 PyThreadState* __tstate = wxPyBeginAllowThreads();
17336 result = (wxANIHandler *)new wxANIHandler();
17337 wxPyEndAllowThreads(__tstate);
17338 if (PyErr_Occurred()) SWIG_fail;
17339 }
17340 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxANIHandler, SWIG_POINTER_NEW | 0 );
17341 return resultobj;
17342 fail:
17343 return NULL;
17344 }
17345
17346
17347 SWIGINTERN PyObject *ANIHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17348 PyObject *obj;
17349 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17350 SWIG_TypeNewClientData(SWIGTYPE_p_wxANIHandler, SWIG_NewClientData(obj));
17351 return SWIG_Py_Void();
17352 }
17353
17354 SWIGINTERN PyObject *ANIHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17355 return SWIG_Python_InitShadowInstance(args);
17356 }
17357
17358 SWIGINTERN PyObject *_wrap_new_PNGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17359 PyObject *resultobj = 0;
17360 wxPNGHandler *result = 0 ;
17361
17362 if (!SWIG_Python_UnpackTuple(args,"new_PNGHandler",0,0,0)) SWIG_fail;
17363 {
17364 PyThreadState* __tstate = wxPyBeginAllowThreads();
17365 result = (wxPNGHandler *)new wxPNGHandler();
17366 wxPyEndAllowThreads(__tstate);
17367 if (PyErr_Occurred()) SWIG_fail;
17368 }
17369 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNGHandler, SWIG_POINTER_NEW | 0 );
17370 return resultobj;
17371 fail:
17372 return NULL;
17373 }
17374
17375
17376 SWIGINTERN PyObject *PNGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17377 PyObject *obj;
17378 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17379 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNGHandler, SWIG_NewClientData(obj));
17380 return SWIG_Py_Void();
17381 }
17382
17383 SWIGINTERN PyObject *PNGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17384 return SWIG_Python_InitShadowInstance(args);
17385 }
17386
17387 SWIGINTERN PyObject *_wrap_new_GIFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17388 PyObject *resultobj = 0;
17389 wxGIFHandler *result = 0 ;
17390
17391 if (!SWIG_Python_UnpackTuple(args,"new_GIFHandler",0,0,0)) SWIG_fail;
17392 {
17393 PyThreadState* __tstate = wxPyBeginAllowThreads();
17394 result = (wxGIFHandler *)new wxGIFHandler();
17395 wxPyEndAllowThreads(__tstate);
17396 if (PyErr_Occurred()) SWIG_fail;
17397 }
17398 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGIFHandler, SWIG_POINTER_NEW | 0 );
17399 return resultobj;
17400 fail:
17401 return NULL;
17402 }
17403
17404
17405 SWIGINTERN PyObject *GIFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17406 PyObject *obj;
17407 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17408 SWIG_TypeNewClientData(SWIGTYPE_p_wxGIFHandler, SWIG_NewClientData(obj));
17409 return SWIG_Py_Void();
17410 }
17411
17412 SWIGINTERN PyObject *GIFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17413 return SWIG_Python_InitShadowInstance(args);
17414 }
17415
17416 SWIGINTERN PyObject *_wrap_new_PCXHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17417 PyObject *resultobj = 0;
17418 wxPCXHandler *result = 0 ;
17419
17420 if (!SWIG_Python_UnpackTuple(args,"new_PCXHandler",0,0,0)) SWIG_fail;
17421 {
17422 PyThreadState* __tstate = wxPyBeginAllowThreads();
17423 result = (wxPCXHandler *)new wxPCXHandler();
17424 wxPyEndAllowThreads(__tstate);
17425 if (PyErr_Occurred()) SWIG_fail;
17426 }
17427 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPCXHandler, SWIG_POINTER_NEW | 0 );
17428 return resultobj;
17429 fail:
17430 return NULL;
17431 }
17432
17433
17434 SWIGINTERN PyObject *PCXHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17435 PyObject *obj;
17436 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17437 SWIG_TypeNewClientData(SWIGTYPE_p_wxPCXHandler, SWIG_NewClientData(obj));
17438 return SWIG_Py_Void();
17439 }
17440
17441 SWIGINTERN PyObject *PCXHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17442 return SWIG_Python_InitShadowInstance(args);
17443 }
17444
17445 SWIGINTERN PyObject *_wrap_new_JPEGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17446 PyObject *resultobj = 0;
17447 wxJPEGHandler *result = 0 ;
17448
17449 if (!SWIG_Python_UnpackTuple(args,"new_JPEGHandler",0,0,0)) SWIG_fail;
17450 {
17451 PyThreadState* __tstate = wxPyBeginAllowThreads();
17452 result = (wxJPEGHandler *)new wxJPEGHandler();
17453 wxPyEndAllowThreads(__tstate);
17454 if (PyErr_Occurred()) SWIG_fail;
17455 }
17456 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJPEGHandler, SWIG_POINTER_NEW | 0 );
17457 return resultobj;
17458 fail:
17459 return NULL;
17460 }
17461
17462
17463 SWIGINTERN PyObject *JPEGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17464 PyObject *obj;
17465 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17466 SWIG_TypeNewClientData(SWIGTYPE_p_wxJPEGHandler, SWIG_NewClientData(obj));
17467 return SWIG_Py_Void();
17468 }
17469
17470 SWIGINTERN PyObject *JPEGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17471 return SWIG_Python_InitShadowInstance(args);
17472 }
17473
17474 SWIGINTERN PyObject *_wrap_new_PNMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17475 PyObject *resultobj = 0;
17476 wxPNMHandler *result = 0 ;
17477
17478 if (!SWIG_Python_UnpackTuple(args,"new_PNMHandler",0,0,0)) SWIG_fail;
17479 {
17480 PyThreadState* __tstate = wxPyBeginAllowThreads();
17481 result = (wxPNMHandler *)new wxPNMHandler();
17482 wxPyEndAllowThreads(__tstate);
17483 if (PyErr_Occurred()) SWIG_fail;
17484 }
17485 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNMHandler, SWIG_POINTER_NEW | 0 );
17486 return resultobj;
17487 fail:
17488 return NULL;
17489 }
17490
17491
17492 SWIGINTERN PyObject *PNMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17493 PyObject *obj;
17494 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17495 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNMHandler, SWIG_NewClientData(obj));
17496 return SWIG_Py_Void();
17497 }
17498
17499 SWIGINTERN PyObject *PNMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17500 return SWIG_Python_InitShadowInstance(args);
17501 }
17502
17503 SWIGINTERN PyObject *_wrap_new_XPMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17504 PyObject *resultobj = 0;
17505 wxXPMHandler *result = 0 ;
17506
17507 if (!SWIG_Python_UnpackTuple(args,"new_XPMHandler",0,0,0)) SWIG_fail;
17508 {
17509 PyThreadState* __tstate = wxPyBeginAllowThreads();
17510 result = (wxXPMHandler *)new wxXPMHandler();
17511 wxPyEndAllowThreads(__tstate);
17512 if (PyErr_Occurred()) SWIG_fail;
17513 }
17514 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXPMHandler, SWIG_POINTER_NEW | 0 );
17515 return resultobj;
17516 fail:
17517 return NULL;
17518 }
17519
17520
17521 SWIGINTERN PyObject *XPMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17522 PyObject *obj;
17523 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17524 SWIG_TypeNewClientData(SWIGTYPE_p_wxXPMHandler, SWIG_NewClientData(obj));
17525 return SWIG_Py_Void();
17526 }
17527
17528 SWIGINTERN PyObject *XPMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17529 return SWIG_Python_InitShadowInstance(args);
17530 }
17531
17532 SWIGINTERN PyObject *_wrap_new_TIFFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17533 PyObject *resultobj = 0;
17534 wxTIFFHandler *result = 0 ;
17535
17536 if (!SWIG_Python_UnpackTuple(args,"new_TIFFHandler",0,0,0)) SWIG_fail;
17537 {
17538 PyThreadState* __tstate = wxPyBeginAllowThreads();
17539 result = (wxTIFFHandler *)new wxTIFFHandler();
17540 wxPyEndAllowThreads(__tstate);
17541 if (PyErr_Occurred()) SWIG_fail;
17542 }
17543 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTIFFHandler, SWIG_POINTER_NEW | 0 );
17544 return resultobj;
17545 fail:
17546 return NULL;
17547 }
17548
17549
17550 SWIGINTERN PyObject *TIFFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17551 PyObject *obj;
17552 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17553 SWIG_TypeNewClientData(SWIGTYPE_p_wxTIFFHandler, SWIG_NewClientData(obj));
17554 return SWIG_Py_Void();
17555 }
17556
17557 SWIGINTERN PyObject *TIFFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17558 return SWIG_Python_InitShadowInstance(args);
17559 }
17560
17561 SWIGINTERN PyObject *_wrap_Quantize_Quantize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17562 PyObject *resultobj = 0;
17563 wxImage *arg1 = 0 ;
17564 wxImage *arg2 = 0 ;
17565 int arg3 = (int) 236 ;
17566 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
17567 bool result;
17568 void *argp1 = 0 ;
17569 int res1 = 0 ;
17570 void *argp2 = 0 ;
17571 int res2 = 0 ;
17572 int val3 ;
17573 int ecode3 = 0 ;
17574 int val4 ;
17575 int ecode4 = 0 ;
17576 PyObject * obj0 = 0 ;
17577 PyObject * obj1 = 0 ;
17578 PyObject * obj2 = 0 ;
17579 PyObject * obj3 = 0 ;
17580 char * kwnames[] = {
17581 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
17582 };
17583
17584 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17585 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage, 0 | 0);
17586 if (!SWIG_IsOK(res1)) {
17587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17588 }
17589 if (!argp1) {
17590 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17591 }
17592 arg1 = reinterpret_cast< wxImage * >(argp1);
17593 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
17594 if (!SWIG_IsOK(res2)) {
17595 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17596 }
17597 if (!argp2) {
17598 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17599 }
17600 arg2 = reinterpret_cast< wxImage * >(argp2);
17601 if (obj2) {
17602 ecode3 = SWIG_AsVal_int(obj2, &val3);
17603 if (!SWIG_IsOK(ecode3)) {
17604 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Quantize_Quantize" "', expected argument " "3"" of type '" "int""'");
17605 }
17606 arg3 = static_cast< int >(val3);
17607 }
17608 if (obj3) {
17609 ecode4 = SWIG_AsVal_int(obj3, &val4);
17610 if (!SWIG_IsOK(ecode4)) {
17611 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Quantize_Quantize" "', expected argument " "4"" of type '" "int""'");
17612 }
17613 arg4 = static_cast< int >(val4);
17614 }
17615 {
17616 PyThreadState* __tstate = wxPyBeginAllowThreads();
17617 result = (bool)wxQuantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
17618 wxPyEndAllowThreads(__tstate);
17619 if (PyErr_Occurred()) SWIG_fail;
17620 }
17621 {
17622 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17623 }
17624 return resultobj;
17625 fail:
17626 return NULL;
17627 }
17628
17629
17630 SWIGINTERN PyObject *Quantize_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17631 PyObject *obj;
17632 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17633 SWIG_TypeNewClientData(SWIGTYPE_p_wxQuantize, SWIG_NewClientData(obj));
17634 return SWIG_Py_Void();
17635 }
17636
17637 SWIGINTERN PyObject *_wrap_new_EvtHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17638 PyObject *resultobj = 0;
17639 wxEvtHandler *result = 0 ;
17640
17641 if (!SWIG_Python_UnpackTuple(args,"new_EvtHandler",0,0,0)) SWIG_fail;
17642 {
17643 PyThreadState* __tstate = wxPyBeginAllowThreads();
17644 result = (wxEvtHandler *)new wxEvtHandler();
17645 wxPyEndAllowThreads(__tstate);
17646 if (PyErr_Occurred()) SWIG_fail;
17647 }
17648 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_NEW | 0 );
17649 return resultobj;
17650 fail:
17651 return NULL;
17652 }
17653
17654
17655 SWIGINTERN PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17656 PyObject *resultobj = 0;
17657 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17658 wxEvtHandler *result = 0 ;
17659 void *argp1 = 0 ;
17660 int res1 = 0 ;
17661 PyObject *swig_obj[1] ;
17662
17663 if (!args) SWIG_fail;
17664 swig_obj[0] = args;
17665 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17666 if (!SWIG_IsOK(res1)) {
17667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17668 }
17669 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17670 {
17671 PyThreadState* __tstate = wxPyBeginAllowThreads();
17672 result = (wxEvtHandler *)(arg1)->GetNextHandler();
17673 wxPyEndAllowThreads(__tstate);
17674 if (PyErr_Occurred()) SWIG_fail;
17675 }
17676 {
17677 resultobj = wxPyMake_wxObject(result, 0);
17678 }
17679 return resultobj;
17680 fail:
17681 return NULL;
17682 }
17683
17684
17685 SWIGINTERN PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17686 PyObject *resultobj = 0;
17687 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17688 wxEvtHandler *result = 0 ;
17689 void *argp1 = 0 ;
17690 int res1 = 0 ;
17691 PyObject *swig_obj[1] ;
17692
17693 if (!args) SWIG_fail;
17694 swig_obj[0] = args;
17695 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17696 if (!SWIG_IsOK(res1)) {
17697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17698 }
17699 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17700 {
17701 PyThreadState* __tstate = wxPyBeginAllowThreads();
17702 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
17703 wxPyEndAllowThreads(__tstate);
17704 if (PyErr_Occurred()) SWIG_fail;
17705 }
17706 {
17707 resultobj = wxPyMake_wxObject(result, 0);
17708 }
17709 return resultobj;
17710 fail:
17711 return NULL;
17712 }
17713
17714
17715 SWIGINTERN PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17716 PyObject *resultobj = 0;
17717 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17718 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
17719 void *argp1 = 0 ;
17720 int res1 = 0 ;
17721 void *argp2 = 0 ;
17722 int res2 = 0 ;
17723 PyObject * obj0 = 0 ;
17724 PyObject * obj1 = 0 ;
17725 char * kwnames[] = {
17726 (char *) "self",(char *) "handler", NULL
17727 };
17728
17729 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) SWIG_fail;
17730 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17731 if (!SWIG_IsOK(res1)) {
17732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17733 }
17734 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17735 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17736 if (!SWIG_IsOK(res2)) {
17737 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
17738 }
17739 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
17740 {
17741 PyThreadState* __tstate = wxPyBeginAllowThreads();
17742 (arg1)->SetNextHandler(arg2);
17743 wxPyEndAllowThreads(__tstate);
17744 if (PyErr_Occurred()) SWIG_fail;
17745 }
17746 resultobj = SWIG_Py_Void();
17747 return resultobj;
17748 fail:
17749 return NULL;
17750 }
17751
17752
17753 SWIGINTERN PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17754 PyObject *resultobj = 0;
17755 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17756 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
17757 void *argp1 = 0 ;
17758 int res1 = 0 ;
17759 void *argp2 = 0 ;
17760 int res2 = 0 ;
17761 PyObject * obj0 = 0 ;
17762 PyObject * obj1 = 0 ;
17763 char * kwnames[] = {
17764 (char *) "self",(char *) "handler", NULL
17765 };
17766
17767 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) SWIG_fail;
17768 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17769 if (!SWIG_IsOK(res1)) {
17770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17771 }
17772 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17773 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17774 if (!SWIG_IsOK(res2)) {
17775 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
17776 }
17777 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
17778 {
17779 PyThreadState* __tstate = wxPyBeginAllowThreads();
17780 (arg1)->SetPreviousHandler(arg2);
17781 wxPyEndAllowThreads(__tstate);
17782 if (PyErr_Occurred()) SWIG_fail;
17783 }
17784 resultobj = SWIG_Py_Void();
17785 return resultobj;
17786 fail:
17787 return NULL;
17788 }
17789
17790
17791 SWIGINTERN PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17792 PyObject *resultobj = 0;
17793 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17794 bool result;
17795 void *argp1 = 0 ;
17796 int res1 = 0 ;
17797 PyObject *swig_obj[1] ;
17798
17799 if (!args) SWIG_fail;
17800 swig_obj[0] = args;
17801 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17802 if (!SWIG_IsOK(res1)) {
17803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17804 }
17805 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17806 {
17807 PyThreadState* __tstate = wxPyBeginAllowThreads();
17808 result = (bool)(arg1)->GetEvtHandlerEnabled();
17809 wxPyEndAllowThreads(__tstate);
17810 if (PyErr_Occurred()) SWIG_fail;
17811 }
17812 {
17813 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17814 }
17815 return resultobj;
17816 fail:
17817 return NULL;
17818 }
17819
17820
17821 SWIGINTERN PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17822 PyObject *resultobj = 0;
17823 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17824 bool arg2 ;
17825 void *argp1 = 0 ;
17826 int res1 = 0 ;
17827 bool val2 ;
17828 int ecode2 = 0 ;
17829 PyObject * obj0 = 0 ;
17830 PyObject * obj1 = 0 ;
17831 char * kwnames[] = {
17832 (char *) "self",(char *) "enabled", NULL
17833 };
17834
17835 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
17836 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17837 if (!SWIG_IsOK(res1)) {
17838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17839 }
17840 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17841 ecode2 = SWIG_AsVal_bool(obj1, &val2);
17842 if (!SWIG_IsOK(ecode2)) {
17843 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "2"" of type '" "bool""'");
17844 }
17845 arg2 = static_cast< bool >(val2);
17846 {
17847 PyThreadState* __tstate = wxPyBeginAllowThreads();
17848 (arg1)->SetEvtHandlerEnabled(arg2);
17849 wxPyEndAllowThreads(__tstate);
17850 if (PyErr_Occurred()) SWIG_fail;
17851 }
17852 resultobj = SWIG_Py_Void();
17853 return resultobj;
17854 fail:
17855 return NULL;
17856 }
17857
17858
17859 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17860 PyObject *resultobj = 0;
17861 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17862 wxEvent *arg2 = 0 ;
17863 bool result;
17864 void *argp1 = 0 ;
17865 int res1 = 0 ;
17866 void *argp2 = 0 ;
17867 int res2 = 0 ;
17868 PyObject * obj0 = 0 ;
17869 PyObject * obj1 = 0 ;
17870 char * kwnames[] = {
17871 (char *) "self",(char *) "event", NULL
17872 };
17873
17874 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) SWIG_fail;
17875 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17876 if (!SWIG_IsOK(res1)) {
17877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17878 }
17879 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17880 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
17881 if (!SWIG_IsOK(res2)) {
17882 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17883 }
17884 if (!argp2) {
17885 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17886 }
17887 arg2 = reinterpret_cast< wxEvent * >(argp2);
17888 {
17889 PyThreadState* __tstate = wxPyBeginAllowThreads();
17890 result = (bool)(arg1)->ProcessEvent(*arg2);
17891 wxPyEndAllowThreads(__tstate);
17892 if (PyErr_Occurred()) SWIG_fail;
17893 }
17894 {
17895 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17896 }
17897 return resultobj;
17898 fail:
17899 return NULL;
17900 }
17901
17902
17903 SWIGINTERN PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17904 PyObject *resultobj = 0;
17905 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17906 wxEvent *arg2 = 0 ;
17907 void *argp1 = 0 ;
17908 int res1 = 0 ;
17909 void *argp2 = 0 ;
17910 int res2 = 0 ;
17911 PyObject * obj0 = 0 ;
17912 PyObject * obj1 = 0 ;
17913 char * kwnames[] = {
17914 (char *) "self",(char *) "event", NULL
17915 };
17916
17917 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) SWIG_fail;
17918 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17919 if (!SWIG_IsOK(res1)) {
17920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17921 }
17922 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17923 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
17924 if (!SWIG_IsOK(res2)) {
17925 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17926 }
17927 if (!argp2) {
17928 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17929 }
17930 arg2 = reinterpret_cast< wxEvent * >(argp2);
17931 {
17932 PyThreadState* __tstate = wxPyBeginAllowThreads();
17933 (arg1)->AddPendingEvent(*arg2);
17934 wxPyEndAllowThreads(__tstate);
17935 if (PyErr_Occurred()) SWIG_fail;
17936 }
17937 resultobj = SWIG_Py_Void();
17938 return resultobj;
17939 fail:
17940 return NULL;
17941 }
17942
17943
17944 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17945 PyObject *resultobj = 0;
17946 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17947 void *argp1 = 0 ;
17948 int res1 = 0 ;
17949 PyObject *swig_obj[1] ;
17950
17951 if (!args) SWIG_fail;
17952 swig_obj[0] = args;
17953 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17954 if (!SWIG_IsOK(res1)) {
17955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17956 }
17957 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17958 {
17959 PyThreadState* __tstate = wxPyBeginAllowThreads();
17960 (arg1)->ProcessPendingEvents();
17961 wxPyEndAllowThreads(__tstate);
17962 if (PyErr_Occurred()) SWIG_fail;
17963 }
17964 resultobj = SWIG_Py_Void();
17965 return resultobj;
17966 fail:
17967 return NULL;
17968 }
17969
17970
17971 SWIGINTERN PyObject *_wrap_EvtHandler_Connect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17972 PyObject *resultobj = 0;
17973 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17974 int arg2 ;
17975 int arg3 ;
17976 int arg4 ;
17977 PyObject *arg5 = (PyObject *) 0 ;
17978 void *argp1 = 0 ;
17979 int res1 = 0 ;
17980 int val2 ;
17981 int ecode2 = 0 ;
17982 int val3 ;
17983 int ecode3 = 0 ;
17984 int val4 ;
17985 int ecode4 = 0 ;
17986 PyObject * obj0 = 0 ;
17987 PyObject * obj1 = 0 ;
17988 PyObject * obj2 = 0 ;
17989 PyObject * obj3 = 0 ;
17990 PyObject * obj4 = 0 ;
17991 char * kwnames[] = {
17992 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
17993 };
17994
17995 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
17996 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17997 if (!SWIG_IsOK(res1)) {
17998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Connect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17999 }
18000 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18001 ecode2 = SWIG_AsVal_int(obj1, &val2);
18002 if (!SWIG_IsOK(ecode2)) {
18003 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Connect" "', expected argument " "2"" of type '" "int""'");
18004 }
18005 arg2 = static_cast< int >(val2);
18006 ecode3 = SWIG_AsVal_int(obj2, &val3);
18007 if (!SWIG_IsOK(ecode3)) {
18008 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Connect" "', expected argument " "3"" of type '" "int""'");
18009 }
18010 arg3 = static_cast< int >(val3);
18011 ecode4 = SWIG_AsVal_int(obj3, &val4);
18012 if (!SWIG_IsOK(ecode4)) {
18013 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Connect" "', expected argument " "4"" of type '" "int""'");
18014 }
18015 arg4 = static_cast< int >(val4);
18016 arg5 = obj4;
18017 {
18018 PyThreadState* __tstate = wxPyBeginAllowThreads();
18019 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
18020 wxPyEndAllowThreads(__tstate);
18021 if (PyErr_Occurred()) SWIG_fail;
18022 }
18023 resultobj = SWIG_Py_Void();
18024 return resultobj;
18025 fail:
18026 return NULL;
18027 }
18028
18029
18030 SWIGINTERN PyObject *_wrap_EvtHandler_Disconnect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18031 PyObject *resultobj = 0;
18032 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18033 int arg2 ;
18034 int arg3 = (int) -1 ;
18035 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
18036 bool result;
18037 void *argp1 = 0 ;
18038 int res1 = 0 ;
18039 int val2 ;
18040 int ecode2 = 0 ;
18041 int val3 ;
18042 int ecode3 = 0 ;
18043 int val4 ;
18044 int ecode4 = 0 ;
18045 PyObject * obj0 = 0 ;
18046 PyObject * obj1 = 0 ;
18047 PyObject * obj2 = 0 ;
18048 PyObject * obj3 = 0 ;
18049 char * kwnames[] = {
18050 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
18051 };
18052
18053 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18054 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18055 if (!SWIG_IsOK(res1)) {
18056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Disconnect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18057 }
18058 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18059 ecode2 = SWIG_AsVal_int(obj1, &val2);
18060 if (!SWIG_IsOK(ecode2)) {
18061 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Disconnect" "', expected argument " "2"" of type '" "int""'");
18062 }
18063 arg2 = static_cast< int >(val2);
18064 if (obj2) {
18065 ecode3 = SWIG_AsVal_int(obj2, &val3);
18066 if (!SWIG_IsOK(ecode3)) {
18067 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Disconnect" "', expected argument " "3"" of type '" "int""'");
18068 }
18069 arg3 = static_cast< int >(val3);
18070 }
18071 if (obj3) {
18072 ecode4 = SWIG_AsVal_int(obj3, &val4);
18073 if (!SWIG_IsOK(ecode4)) {
18074 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Disconnect" "', expected argument " "4"" of type '" "wxEventType""'");
18075 }
18076 arg4 = static_cast< wxEventType >(val4);
18077 }
18078 {
18079 PyThreadState* __tstate = wxPyBeginAllowThreads();
18080 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
18081 wxPyEndAllowThreads(__tstate);
18082 if (PyErr_Occurred()) SWIG_fail;
18083 }
18084 {
18085 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18086 }
18087 return resultobj;
18088 fail:
18089 return NULL;
18090 }
18091
18092
18093 SWIGINTERN PyObject *_wrap_EvtHandler__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18094 PyObject *resultobj = 0;
18095 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18096 PyObject *arg2 = (PyObject *) 0 ;
18097 bool arg3 = (bool) true ;
18098 void *argp1 = 0 ;
18099 int res1 = 0 ;
18100 bool val3 ;
18101 int ecode3 = 0 ;
18102 PyObject * obj0 = 0 ;
18103 PyObject * obj1 = 0 ;
18104 PyObject * obj2 = 0 ;
18105 char * kwnames[] = {
18106 (char *) "self",(char *) "_self",(char *) "incref", NULL
18107 };
18108
18109 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18110 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18111 if (!SWIG_IsOK(res1)) {
18112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler__setOORInfo" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18113 }
18114 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18115 arg2 = obj1;
18116 if (obj2) {
18117 ecode3 = SWIG_AsVal_bool(obj2, &val3);
18118 if (!SWIG_IsOK(ecode3)) {
18119 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler__setOORInfo" "', expected argument " "3"" of type '" "bool""'");
18120 }
18121 arg3 = static_cast< bool >(val3);
18122 }
18123 {
18124 PyThreadState* __tstate = wxPyBeginAllowThreads();
18125 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
18126 wxPyEndAllowThreads(__tstate);
18127 if (PyErr_Occurred()) SWIG_fail;
18128 }
18129 resultobj = SWIG_Py_Void();
18130 return resultobj;
18131 fail:
18132 return NULL;
18133 }
18134
18135
18136 SWIGINTERN PyObject *EvtHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18137 PyObject *obj;
18138 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18139 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvtHandler, SWIG_NewClientData(obj));
18140 return SWIG_Py_Void();
18141 }
18142
18143 SWIGINTERN PyObject *EvtHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18144 return SWIG_Python_InitShadowInstance(args);
18145 }
18146
18147 SWIGINTERN PyObject *_wrap_NewEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18148 PyObject *resultobj = 0;
18149 wxEventType result;
18150
18151 if (!SWIG_Python_UnpackTuple(args,"NewEventType",0,0,0)) SWIG_fail;
18152 {
18153 PyThreadState* __tstate = wxPyBeginAllowThreads();
18154 result = (wxEventType)wxNewEventType();
18155 wxPyEndAllowThreads(__tstate);
18156 if (PyErr_Occurred()) SWIG_fail;
18157 }
18158 resultobj = SWIG_From_int(static_cast< int >(result));
18159 return resultobj;
18160 fail:
18161 return NULL;
18162 }
18163
18164
18165 SWIGINTERN PyObject *_wrap_delete_Event(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18166 PyObject *resultobj = 0;
18167 wxEvent *arg1 = (wxEvent *) 0 ;
18168 void *argp1 = 0 ;
18169 int res1 = 0 ;
18170 PyObject *swig_obj[1] ;
18171
18172 if (!args) SWIG_fail;
18173 swig_obj[0] = args;
18174 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, SWIG_POINTER_DISOWN | 0 );
18175 if (!SWIG_IsOK(res1)) {
18176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Event" "', expected argument " "1"" of type '" "wxEvent *""'");
18177 }
18178 arg1 = reinterpret_cast< wxEvent * >(argp1);
18179 {
18180 PyThreadState* __tstate = wxPyBeginAllowThreads();
18181 delete arg1;
18182
18183 wxPyEndAllowThreads(__tstate);
18184 if (PyErr_Occurred()) SWIG_fail;
18185 }
18186 resultobj = SWIG_Py_Void();
18187 return resultobj;
18188 fail:
18189 return NULL;
18190 }
18191
18192
18193 SWIGINTERN PyObject *_wrap_Event_SetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18194 PyObject *resultobj = 0;
18195 wxEvent *arg1 = (wxEvent *) 0 ;
18196 wxEventType arg2 ;
18197 void *argp1 = 0 ;
18198 int res1 = 0 ;
18199 int val2 ;
18200 int ecode2 = 0 ;
18201 PyObject * obj0 = 0 ;
18202 PyObject * obj1 = 0 ;
18203 char * kwnames[] = {
18204 (char *) "self",(char *) "typ", NULL
18205 };
18206
18207 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) SWIG_fail;
18208 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18209 if (!SWIG_IsOK(res1)) {
18210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventType" "', expected argument " "1"" of type '" "wxEvent *""'");
18211 }
18212 arg1 = reinterpret_cast< wxEvent * >(argp1);
18213 ecode2 = SWIG_AsVal_int(obj1, &val2);
18214 if (!SWIG_IsOK(ecode2)) {
18215 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetEventType" "', expected argument " "2"" of type '" "wxEventType""'");
18216 }
18217 arg2 = static_cast< wxEventType >(val2);
18218 {
18219 PyThreadState* __tstate = wxPyBeginAllowThreads();
18220 (arg1)->SetEventType(arg2);
18221 wxPyEndAllowThreads(__tstate);
18222 if (PyErr_Occurred()) SWIG_fail;
18223 }
18224 resultobj = SWIG_Py_Void();
18225 return resultobj;
18226 fail:
18227 return NULL;
18228 }
18229
18230
18231 SWIGINTERN PyObject *_wrap_Event_GetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18232 PyObject *resultobj = 0;
18233 wxEvent *arg1 = (wxEvent *) 0 ;
18234 wxEventType result;
18235 void *argp1 = 0 ;
18236 int res1 = 0 ;
18237 PyObject *swig_obj[1] ;
18238
18239 if (!args) SWIG_fail;
18240 swig_obj[0] = args;
18241 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18242 if (!SWIG_IsOK(res1)) {
18243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventType" "', expected argument " "1"" of type '" "wxEvent const *""'");
18244 }
18245 arg1 = reinterpret_cast< wxEvent * >(argp1);
18246 {
18247 PyThreadState* __tstate = wxPyBeginAllowThreads();
18248 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
18249 wxPyEndAllowThreads(__tstate);
18250 if (PyErr_Occurred()) SWIG_fail;
18251 }
18252 resultobj = SWIG_From_int(static_cast< int >(result));
18253 return resultobj;
18254 fail:
18255 return NULL;
18256 }
18257
18258
18259 SWIGINTERN PyObject *_wrap_Event_GetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18260 PyObject *resultobj = 0;
18261 wxEvent *arg1 = (wxEvent *) 0 ;
18262 wxObject *result = 0 ;
18263 void *argp1 = 0 ;
18264 int res1 = 0 ;
18265 PyObject *swig_obj[1] ;
18266
18267 if (!args) SWIG_fail;
18268 swig_obj[0] = args;
18269 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18270 if (!SWIG_IsOK(res1)) {
18271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventObject" "', expected argument " "1"" of type '" "wxEvent const *""'");
18272 }
18273 arg1 = reinterpret_cast< wxEvent * >(argp1);
18274 {
18275 PyThreadState* __tstate = wxPyBeginAllowThreads();
18276 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
18277 wxPyEndAllowThreads(__tstate);
18278 if (PyErr_Occurred()) SWIG_fail;
18279 }
18280 {
18281 resultobj = wxPyMake_wxObject(result, (bool)0);
18282 }
18283 return resultobj;
18284 fail:
18285 return NULL;
18286 }
18287
18288
18289 SWIGINTERN PyObject *_wrap_Event_SetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18290 PyObject *resultobj = 0;
18291 wxEvent *arg1 = (wxEvent *) 0 ;
18292 wxObject *arg2 = (wxObject *) 0 ;
18293 void *argp1 = 0 ;
18294 int res1 = 0 ;
18295 void *argp2 = 0 ;
18296 int res2 = 0 ;
18297 PyObject * obj0 = 0 ;
18298 PyObject * obj1 = 0 ;
18299 char * kwnames[] = {
18300 (char *) "self",(char *) "obj", NULL
18301 };
18302
18303 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) SWIG_fail;
18304 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18305 if (!SWIG_IsOK(res1)) {
18306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventObject" "', expected argument " "1"" of type '" "wxEvent *""'");
18307 }
18308 arg1 = reinterpret_cast< wxEvent * >(argp1);
18309 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxObject, 0 | 0 );
18310 if (!SWIG_IsOK(res2)) {
18311 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_SetEventObject" "', expected argument " "2"" of type '" "wxObject *""'");
18312 }
18313 arg2 = reinterpret_cast< wxObject * >(argp2);
18314 {
18315 PyThreadState* __tstate = wxPyBeginAllowThreads();
18316 (arg1)->SetEventObject(arg2);
18317 wxPyEndAllowThreads(__tstate);
18318 if (PyErr_Occurred()) SWIG_fail;
18319 }
18320 resultobj = SWIG_Py_Void();
18321 return resultobj;
18322 fail:
18323 return NULL;
18324 }
18325
18326
18327 SWIGINTERN PyObject *_wrap_Event_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18328 PyObject *resultobj = 0;
18329 wxEvent *arg1 = (wxEvent *) 0 ;
18330 long result;
18331 void *argp1 = 0 ;
18332 int res1 = 0 ;
18333 PyObject *swig_obj[1] ;
18334
18335 if (!args) SWIG_fail;
18336 swig_obj[0] = args;
18337 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18338 if (!SWIG_IsOK(res1)) {
18339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetTimestamp" "', expected argument " "1"" of type '" "wxEvent const *""'");
18340 }
18341 arg1 = reinterpret_cast< wxEvent * >(argp1);
18342 {
18343 PyThreadState* __tstate = wxPyBeginAllowThreads();
18344 result = (long)((wxEvent const *)arg1)->GetTimestamp();
18345 wxPyEndAllowThreads(__tstate);
18346 if (PyErr_Occurred()) SWIG_fail;
18347 }
18348 resultobj = SWIG_From_long(static_cast< long >(result));
18349 return resultobj;
18350 fail:
18351 return NULL;
18352 }
18353
18354
18355 SWIGINTERN PyObject *_wrap_Event_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18356 PyObject *resultobj = 0;
18357 wxEvent *arg1 = (wxEvent *) 0 ;
18358 long arg2 = (long) 0 ;
18359 void *argp1 = 0 ;
18360 int res1 = 0 ;
18361 long val2 ;
18362 int ecode2 = 0 ;
18363 PyObject * obj0 = 0 ;
18364 PyObject * obj1 = 0 ;
18365 char * kwnames[] = {
18366 (char *) "self",(char *) "ts", NULL
18367 };
18368
18369 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) SWIG_fail;
18370 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18371 if (!SWIG_IsOK(res1)) {
18372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetTimestamp" "', expected argument " "1"" of type '" "wxEvent *""'");
18373 }
18374 arg1 = reinterpret_cast< wxEvent * >(argp1);
18375 if (obj1) {
18376 ecode2 = SWIG_AsVal_long(obj1, &val2);
18377 if (!SWIG_IsOK(ecode2)) {
18378 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetTimestamp" "', expected argument " "2"" of type '" "long""'");
18379 }
18380 arg2 = static_cast< long >(val2);
18381 }
18382 {
18383 PyThreadState* __tstate = wxPyBeginAllowThreads();
18384 (arg1)->SetTimestamp(arg2);
18385 wxPyEndAllowThreads(__tstate);
18386 if (PyErr_Occurred()) SWIG_fail;
18387 }
18388 resultobj = SWIG_Py_Void();
18389 return resultobj;
18390 fail:
18391 return NULL;
18392 }
18393
18394
18395 SWIGINTERN PyObject *_wrap_Event_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18396 PyObject *resultobj = 0;
18397 wxEvent *arg1 = (wxEvent *) 0 ;
18398 int result;
18399 void *argp1 = 0 ;
18400 int res1 = 0 ;
18401 PyObject *swig_obj[1] ;
18402
18403 if (!args) SWIG_fail;
18404 swig_obj[0] = args;
18405 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18406 if (!SWIG_IsOK(res1)) {
18407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetId" "', expected argument " "1"" of type '" "wxEvent const *""'");
18408 }
18409 arg1 = reinterpret_cast< wxEvent * >(argp1);
18410 {
18411 PyThreadState* __tstate = wxPyBeginAllowThreads();
18412 result = (int)((wxEvent const *)arg1)->GetId();
18413 wxPyEndAllowThreads(__tstate);
18414 if (PyErr_Occurred()) SWIG_fail;
18415 }
18416 resultobj = SWIG_From_int(static_cast< int >(result));
18417 return resultobj;
18418 fail:
18419 return NULL;
18420 }
18421
18422
18423 SWIGINTERN PyObject *_wrap_Event_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18424 PyObject *resultobj = 0;
18425 wxEvent *arg1 = (wxEvent *) 0 ;
18426 int arg2 ;
18427 void *argp1 = 0 ;
18428 int res1 = 0 ;
18429 int val2 ;
18430 int ecode2 = 0 ;
18431 PyObject * obj0 = 0 ;
18432 PyObject * obj1 = 0 ;
18433 char * kwnames[] = {
18434 (char *) "self",(char *) "Id", NULL
18435 };
18436
18437 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
18438 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18439 if (!SWIG_IsOK(res1)) {
18440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetId" "', expected argument " "1"" of type '" "wxEvent *""'");
18441 }
18442 arg1 = reinterpret_cast< wxEvent * >(argp1);
18443 ecode2 = SWIG_AsVal_int(obj1, &val2);
18444 if (!SWIG_IsOK(ecode2)) {
18445 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetId" "', expected argument " "2"" of type '" "int""'");
18446 }
18447 arg2 = static_cast< int >(val2);
18448 {
18449 PyThreadState* __tstate = wxPyBeginAllowThreads();
18450 (arg1)->SetId(arg2);
18451 wxPyEndAllowThreads(__tstate);
18452 if (PyErr_Occurred()) SWIG_fail;
18453 }
18454 resultobj = SWIG_Py_Void();
18455 return resultobj;
18456 fail:
18457 return NULL;
18458 }
18459
18460
18461 SWIGINTERN PyObject *_wrap_Event_IsCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18462 PyObject *resultobj = 0;
18463 wxEvent *arg1 = (wxEvent *) 0 ;
18464 bool result;
18465 void *argp1 = 0 ;
18466 int res1 = 0 ;
18467 PyObject *swig_obj[1] ;
18468
18469 if (!args) SWIG_fail;
18470 swig_obj[0] = args;
18471 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18472 if (!SWIG_IsOK(res1)) {
18473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_IsCommandEvent" "', expected argument " "1"" of type '" "wxEvent const *""'");
18474 }
18475 arg1 = reinterpret_cast< wxEvent * >(argp1);
18476 {
18477 PyThreadState* __tstate = wxPyBeginAllowThreads();
18478 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
18479 wxPyEndAllowThreads(__tstate);
18480 if (PyErr_Occurred()) SWIG_fail;
18481 }
18482 {
18483 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18484 }
18485 return resultobj;
18486 fail:
18487 return NULL;
18488 }
18489
18490
18491 SWIGINTERN PyObject *_wrap_Event_Skip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18492 PyObject *resultobj = 0;
18493 wxEvent *arg1 = (wxEvent *) 0 ;
18494 bool arg2 = (bool) true ;
18495 void *argp1 = 0 ;
18496 int res1 = 0 ;
18497 bool val2 ;
18498 int ecode2 = 0 ;
18499 PyObject * obj0 = 0 ;
18500 PyObject * obj1 = 0 ;
18501 char * kwnames[] = {
18502 (char *) "self",(char *) "skip", NULL
18503 };
18504
18505 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) SWIG_fail;
18506 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18507 if (!SWIG_IsOK(res1)) {
18508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Skip" "', expected argument " "1"" of type '" "wxEvent *""'");
18509 }
18510 arg1 = reinterpret_cast< wxEvent * >(argp1);
18511 if (obj1) {
18512 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18513 if (!SWIG_IsOK(ecode2)) {
18514 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_Skip" "', expected argument " "2"" of type '" "bool""'");
18515 }
18516 arg2 = static_cast< bool >(val2);
18517 }
18518 {
18519 PyThreadState* __tstate = wxPyBeginAllowThreads();
18520 (arg1)->Skip(arg2);
18521 wxPyEndAllowThreads(__tstate);
18522 if (PyErr_Occurred()) SWIG_fail;
18523 }
18524 resultobj = SWIG_Py_Void();
18525 return resultobj;
18526 fail:
18527 return NULL;
18528 }
18529
18530
18531 SWIGINTERN PyObject *_wrap_Event_GetSkipped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18532 PyObject *resultobj = 0;
18533 wxEvent *arg1 = (wxEvent *) 0 ;
18534 bool result;
18535 void *argp1 = 0 ;
18536 int res1 = 0 ;
18537 PyObject *swig_obj[1] ;
18538
18539 if (!args) SWIG_fail;
18540 swig_obj[0] = args;
18541 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18542 if (!SWIG_IsOK(res1)) {
18543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetSkipped" "', expected argument " "1"" of type '" "wxEvent const *""'");
18544 }
18545 arg1 = reinterpret_cast< wxEvent * >(argp1);
18546 {
18547 PyThreadState* __tstate = wxPyBeginAllowThreads();
18548 result = (bool)((wxEvent const *)arg1)->GetSkipped();
18549 wxPyEndAllowThreads(__tstate);
18550 if (PyErr_Occurred()) SWIG_fail;
18551 }
18552 {
18553 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18554 }
18555 return resultobj;
18556 fail:
18557 return NULL;
18558 }
18559
18560
18561 SWIGINTERN PyObject *_wrap_Event_ShouldPropagate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18562 PyObject *resultobj = 0;
18563 wxEvent *arg1 = (wxEvent *) 0 ;
18564 bool result;
18565 void *argp1 = 0 ;
18566 int res1 = 0 ;
18567 PyObject *swig_obj[1] ;
18568
18569 if (!args) SWIG_fail;
18570 swig_obj[0] = args;
18571 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18572 if (!SWIG_IsOK(res1)) {
18573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ShouldPropagate" "', expected argument " "1"" of type '" "wxEvent const *""'");
18574 }
18575 arg1 = reinterpret_cast< wxEvent * >(argp1);
18576 {
18577 PyThreadState* __tstate = wxPyBeginAllowThreads();
18578 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
18579 wxPyEndAllowThreads(__tstate);
18580 if (PyErr_Occurred()) SWIG_fail;
18581 }
18582 {
18583 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18584 }
18585 return resultobj;
18586 fail:
18587 return NULL;
18588 }
18589
18590
18591 SWIGINTERN PyObject *_wrap_Event_StopPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18592 PyObject *resultobj = 0;
18593 wxEvent *arg1 = (wxEvent *) 0 ;
18594 int result;
18595 void *argp1 = 0 ;
18596 int res1 = 0 ;
18597 PyObject *swig_obj[1] ;
18598
18599 if (!args) SWIG_fail;
18600 swig_obj[0] = args;
18601 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18602 if (!SWIG_IsOK(res1)) {
18603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_StopPropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18604 }
18605 arg1 = reinterpret_cast< wxEvent * >(argp1);
18606 {
18607 PyThreadState* __tstate = wxPyBeginAllowThreads();
18608 result = (int)(arg1)->StopPropagation();
18609 wxPyEndAllowThreads(__tstate);
18610 if (PyErr_Occurred()) SWIG_fail;
18611 }
18612 resultobj = SWIG_From_int(static_cast< int >(result));
18613 return resultobj;
18614 fail:
18615 return NULL;
18616 }
18617
18618
18619 SWIGINTERN PyObject *_wrap_Event_ResumePropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18620 PyObject *resultobj = 0;
18621 wxEvent *arg1 = (wxEvent *) 0 ;
18622 int arg2 ;
18623 void *argp1 = 0 ;
18624 int res1 = 0 ;
18625 int val2 ;
18626 int ecode2 = 0 ;
18627 PyObject * obj0 = 0 ;
18628 PyObject * obj1 = 0 ;
18629 char * kwnames[] = {
18630 (char *) "self",(char *) "propagationLevel", NULL
18631 };
18632
18633 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) SWIG_fail;
18634 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18635 if (!SWIG_IsOK(res1)) {
18636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ResumePropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18637 }
18638 arg1 = reinterpret_cast< wxEvent * >(argp1);
18639 ecode2 = SWIG_AsVal_int(obj1, &val2);
18640 if (!SWIG_IsOK(ecode2)) {
18641 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_ResumePropagation" "', expected argument " "2"" of type '" "int""'");
18642 }
18643 arg2 = static_cast< int >(val2);
18644 {
18645 PyThreadState* __tstate = wxPyBeginAllowThreads();
18646 (arg1)->ResumePropagation(arg2);
18647 wxPyEndAllowThreads(__tstate);
18648 if (PyErr_Occurred()) SWIG_fail;
18649 }
18650 resultobj = SWIG_Py_Void();
18651 return resultobj;
18652 fail:
18653 return NULL;
18654 }
18655
18656
18657 SWIGINTERN PyObject *_wrap_Event_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18658 PyObject *resultobj = 0;
18659 wxEvent *arg1 = (wxEvent *) 0 ;
18660 wxEvent *result = 0 ;
18661 void *argp1 = 0 ;
18662 int res1 = 0 ;
18663 PyObject *swig_obj[1] ;
18664
18665 if (!args) SWIG_fail;
18666 swig_obj[0] = args;
18667 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18668 if (!SWIG_IsOK(res1)) {
18669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Clone" "', expected argument " "1"" of type '" "wxEvent *""'");
18670 }
18671 arg1 = reinterpret_cast< wxEvent * >(argp1);
18672 {
18673 PyThreadState* __tstate = wxPyBeginAllowThreads();
18674 result = (wxEvent *)(arg1)->Clone();
18675 wxPyEndAllowThreads(__tstate);
18676 if (PyErr_Occurred()) SWIG_fail;
18677 }
18678 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
18679 return resultobj;
18680 fail:
18681 return NULL;
18682 }
18683
18684
18685 SWIGINTERN PyObject *Event_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18686 PyObject *obj;
18687 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18688 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvent, SWIG_NewClientData(obj));
18689 return SWIG_Py_Void();
18690 }
18691
18692 SWIGINTERN PyObject *_wrap_new_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18693 PyObject *resultobj = 0;
18694 wxEvent *arg1 = 0 ;
18695 wxPropagationDisabler *result = 0 ;
18696 void *argp1 = 0 ;
18697 int res1 = 0 ;
18698 PyObject * obj0 = 0 ;
18699 char * kwnames[] = {
18700 (char *) "event", NULL
18701 };
18702
18703 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) SWIG_fail;
18704 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
18705 if (!SWIG_IsOK(res1)) {
18706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
18707 }
18708 if (!argp1) {
18709 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
18710 }
18711 arg1 = reinterpret_cast< wxEvent * >(argp1);
18712 {
18713 PyThreadState* __tstate = wxPyBeginAllowThreads();
18714 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
18715 wxPyEndAllowThreads(__tstate);
18716 if (PyErr_Occurred()) SWIG_fail;
18717 }
18718 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_NEW | 0 );
18719 return resultobj;
18720 fail:
18721 return NULL;
18722 }
18723
18724
18725 SWIGINTERN PyObject *_wrap_delete_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18726 PyObject *resultobj = 0;
18727 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
18728 void *argp1 = 0 ;
18729 int res1 = 0 ;
18730 PyObject *swig_obj[1] ;
18731
18732 if (!args) SWIG_fail;
18733 swig_obj[0] = args;
18734 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_DISOWN | 0 );
18735 if (!SWIG_IsOK(res1)) {
18736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagationDisabler" "', expected argument " "1"" of type '" "wxPropagationDisabler *""'");
18737 }
18738 arg1 = reinterpret_cast< wxPropagationDisabler * >(argp1);
18739 {
18740 PyThreadState* __tstate = wxPyBeginAllowThreads();
18741 delete arg1;
18742
18743 wxPyEndAllowThreads(__tstate);
18744 if (PyErr_Occurred()) SWIG_fail;
18745 }
18746 resultobj = SWIG_Py_Void();
18747 return resultobj;
18748 fail:
18749 return NULL;
18750 }
18751
18752
18753 SWIGINTERN PyObject *PropagationDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18754 PyObject *obj;
18755 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18756 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagationDisabler, SWIG_NewClientData(obj));
18757 return SWIG_Py_Void();
18758 }
18759
18760 SWIGINTERN PyObject *PropagationDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18761 return SWIG_Python_InitShadowInstance(args);
18762 }
18763
18764 SWIGINTERN PyObject *_wrap_new_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18765 PyObject *resultobj = 0;
18766 wxEvent *arg1 = 0 ;
18767 wxPropagateOnce *result = 0 ;
18768 void *argp1 = 0 ;
18769 int res1 = 0 ;
18770 PyObject * obj0 = 0 ;
18771 char * kwnames[] = {
18772 (char *) "event", NULL
18773 };
18774
18775 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) SWIG_fail;
18776 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
18777 if (!SWIG_IsOK(res1)) {
18778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
18779 }
18780 if (!argp1) {
18781 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
18782 }
18783 arg1 = reinterpret_cast< wxEvent * >(argp1);
18784 {
18785 PyThreadState* __tstate = wxPyBeginAllowThreads();
18786 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
18787 wxPyEndAllowThreads(__tstate);
18788 if (PyErr_Occurred()) SWIG_fail;
18789 }
18790 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_NEW | 0 );
18791 return resultobj;
18792 fail:
18793 return NULL;
18794 }
18795
18796
18797 SWIGINTERN PyObject *_wrap_delete_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18798 PyObject *resultobj = 0;
18799 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
18800 void *argp1 = 0 ;
18801 int res1 = 0 ;
18802 PyObject *swig_obj[1] ;
18803
18804 if (!args) SWIG_fail;
18805 swig_obj[0] = args;
18806 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_DISOWN | 0 );
18807 if (!SWIG_IsOK(res1)) {
18808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagateOnce" "', expected argument " "1"" of type '" "wxPropagateOnce *""'");
18809 }
18810 arg1 = reinterpret_cast< wxPropagateOnce * >(argp1);
18811 {
18812 PyThreadState* __tstate = wxPyBeginAllowThreads();
18813 delete arg1;
18814
18815 wxPyEndAllowThreads(__tstate);
18816 if (PyErr_Occurred()) SWIG_fail;
18817 }
18818 resultobj = SWIG_Py_Void();
18819 return resultobj;
18820 fail:
18821 return NULL;
18822 }
18823
18824
18825 SWIGINTERN PyObject *PropagateOnce_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18826 PyObject *obj;
18827 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18828 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagateOnce, SWIG_NewClientData(obj));
18829 return SWIG_Py_Void();
18830 }
18831
18832 SWIGINTERN PyObject *PropagateOnce_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18833 return SWIG_Python_InitShadowInstance(args);
18834 }
18835
18836 SWIGINTERN PyObject *_wrap_new_CommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18837 PyObject *resultobj = 0;
18838 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
18839 int arg2 = (int) 0 ;
18840 wxCommandEvent *result = 0 ;
18841 int val1 ;
18842 int ecode1 = 0 ;
18843 int val2 ;
18844 int ecode2 = 0 ;
18845 PyObject * obj0 = 0 ;
18846 PyObject * obj1 = 0 ;
18847 char * kwnames[] = {
18848 (char *) "commandType",(char *) "winid", NULL
18849 };
18850
18851 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
18852 if (obj0) {
18853 ecode1 = SWIG_AsVal_int(obj0, &val1);
18854 if (!SWIG_IsOK(ecode1)) {
18855 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
18856 }
18857 arg1 = static_cast< wxEventType >(val1);
18858 }
18859 if (obj1) {
18860 ecode2 = SWIG_AsVal_int(obj1, &val2);
18861 if (!SWIG_IsOK(ecode2)) {
18862 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CommandEvent" "', expected argument " "2"" of type '" "int""'");
18863 }
18864 arg2 = static_cast< int >(val2);
18865 }
18866 {
18867 PyThreadState* __tstate = wxPyBeginAllowThreads();
18868 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
18869 wxPyEndAllowThreads(__tstate);
18870 if (PyErr_Occurred()) SWIG_fail;
18871 }
18872 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_NEW | 0 );
18873 return resultobj;
18874 fail:
18875 return NULL;
18876 }
18877
18878
18879 SWIGINTERN PyObject *_wrap_CommandEvent_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18880 PyObject *resultobj = 0;
18881 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18882 int result;
18883 void *argp1 = 0 ;
18884 int res1 = 0 ;
18885 PyObject *swig_obj[1] ;
18886
18887 if (!args) SWIG_fail;
18888 swig_obj[0] = args;
18889 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18890 if (!SWIG_IsOK(res1)) {
18891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18892 }
18893 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18894 {
18895 PyThreadState* __tstate = wxPyBeginAllowThreads();
18896 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
18897 wxPyEndAllowThreads(__tstate);
18898 if (PyErr_Occurred()) SWIG_fail;
18899 }
18900 resultobj = SWIG_From_int(static_cast< int >(result));
18901 return resultobj;
18902 fail:
18903 return NULL;
18904 }
18905
18906
18907 SWIGINTERN PyObject *_wrap_CommandEvent_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18908 PyObject *resultobj = 0;
18909 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18910 wxString *arg2 = 0 ;
18911 void *argp1 = 0 ;
18912 int res1 = 0 ;
18913 bool temp2 = false ;
18914 PyObject * obj0 = 0 ;
18915 PyObject * obj1 = 0 ;
18916 char * kwnames[] = {
18917 (char *) "self",(char *) "s", NULL
18918 };
18919
18920 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) SWIG_fail;
18921 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18922 if (!SWIG_IsOK(res1)) {
18923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetString" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
18924 }
18925 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18926 {
18927 arg2 = wxString_in_helper(obj1);
18928 if (arg2 == NULL) SWIG_fail;
18929 temp2 = true;
18930 }
18931 {
18932 PyThreadState* __tstate = wxPyBeginAllowThreads();
18933 (arg1)->SetString((wxString const &)*arg2);
18934 wxPyEndAllowThreads(__tstate);
18935 if (PyErr_Occurred()) SWIG_fail;
18936 }
18937 resultobj = SWIG_Py_Void();
18938 {
18939 if (temp2)
18940 delete arg2;
18941 }
18942 return resultobj;
18943 fail:
18944 {
18945 if (temp2)
18946 delete arg2;
18947 }
18948 return NULL;
18949 }
18950
18951
18952 SWIGINTERN PyObject *_wrap_CommandEvent_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18953 PyObject *resultobj = 0;
18954 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18955 wxString result;
18956 void *argp1 = 0 ;
18957 int res1 = 0 ;
18958 PyObject *swig_obj[1] ;
18959
18960 if (!args) SWIG_fail;
18961 swig_obj[0] = args;
18962 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18963 if (!SWIG_IsOK(res1)) {
18964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetString" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18965 }
18966 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18967 {
18968 PyThreadState* __tstate = wxPyBeginAllowThreads();
18969 result = ((wxCommandEvent const *)arg1)->GetString();
18970 wxPyEndAllowThreads(__tstate);
18971 if (PyErr_Occurred()) SWIG_fail;
18972 }
18973 {
18974 #if wxUSE_UNICODE
18975 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18976 #else
18977 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18978 #endif
18979 }
18980 return resultobj;
18981 fail:
18982 return NULL;
18983 }
18984
18985
18986 SWIGINTERN PyObject *_wrap_CommandEvent_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18987 PyObject *resultobj = 0;
18988 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18989 bool result;
18990 void *argp1 = 0 ;
18991 int res1 = 0 ;
18992 PyObject *swig_obj[1] ;
18993
18994 if (!args) SWIG_fail;
18995 swig_obj[0] = args;
18996 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18997 if (!SWIG_IsOK(res1)) {
18998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsChecked" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18999 }
19000 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19001 {
19002 PyThreadState* __tstate = wxPyBeginAllowThreads();
19003 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
19004 wxPyEndAllowThreads(__tstate);
19005 if (PyErr_Occurred()) SWIG_fail;
19006 }
19007 {
19008 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19009 }
19010 return resultobj;
19011 fail:
19012 return NULL;
19013 }
19014
19015
19016 SWIGINTERN PyObject *_wrap_CommandEvent_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19017 PyObject *resultobj = 0;
19018 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19019 bool result;
19020 void *argp1 = 0 ;
19021 int res1 = 0 ;
19022 PyObject *swig_obj[1] ;
19023
19024 if (!args) SWIG_fail;
19025 swig_obj[0] = args;
19026 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19027 if (!SWIG_IsOK(res1)) {
19028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19029 }
19030 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19031 {
19032 PyThreadState* __tstate = wxPyBeginAllowThreads();
19033 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
19034 wxPyEndAllowThreads(__tstate);
19035 if (PyErr_Occurred()) SWIG_fail;
19036 }
19037 {
19038 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19039 }
19040 return resultobj;
19041 fail:
19042 return NULL;
19043 }
19044
19045
19046 SWIGINTERN PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19047 PyObject *resultobj = 0;
19048 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19049 long arg2 ;
19050 void *argp1 = 0 ;
19051 int res1 = 0 ;
19052 long val2 ;
19053 int ecode2 = 0 ;
19054 PyObject * obj0 = 0 ;
19055 PyObject * obj1 = 0 ;
19056 char * kwnames[] = {
19057 (char *) "self",(char *) "extraLong", NULL
19058 };
19059
19060 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) SWIG_fail;
19061 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19062 if (!SWIG_IsOK(res1)) {
19063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19064 }
19065 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19066 ecode2 = SWIG_AsVal_long(obj1, &val2);
19067 if (!SWIG_IsOK(ecode2)) {
19068 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "2"" of type '" "long""'");
19069 }
19070 arg2 = static_cast< long >(val2);
19071 {
19072 PyThreadState* __tstate = wxPyBeginAllowThreads();
19073 (arg1)->SetExtraLong(arg2);
19074 wxPyEndAllowThreads(__tstate);
19075 if (PyErr_Occurred()) SWIG_fail;
19076 }
19077 resultobj = SWIG_Py_Void();
19078 return resultobj;
19079 fail:
19080 return NULL;
19081 }
19082
19083
19084 SWIGINTERN PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19085 PyObject *resultobj = 0;
19086 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19087 long result;
19088 void *argp1 = 0 ;
19089 int res1 = 0 ;
19090 PyObject *swig_obj[1] ;
19091
19092 if (!args) SWIG_fail;
19093 swig_obj[0] = args;
19094 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19095 if (!SWIG_IsOK(res1)) {
19096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19097 }
19098 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19099 {
19100 PyThreadState* __tstate = wxPyBeginAllowThreads();
19101 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
19102 wxPyEndAllowThreads(__tstate);
19103 if (PyErr_Occurred()) SWIG_fail;
19104 }
19105 resultobj = SWIG_From_long(static_cast< long >(result));
19106 return resultobj;
19107 fail:
19108 return NULL;
19109 }
19110
19111
19112 SWIGINTERN PyObject *_wrap_CommandEvent_SetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19113 PyObject *resultobj = 0;
19114 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19115 int arg2 ;
19116 void *argp1 = 0 ;
19117 int res1 = 0 ;
19118 int val2 ;
19119 int ecode2 = 0 ;
19120 PyObject * obj0 = 0 ;
19121 PyObject * obj1 = 0 ;
19122 char * kwnames[] = {
19123 (char *) "self",(char *) "i", NULL
19124 };
19125
19126 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) SWIG_fail;
19127 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19128 if (!SWIG_IsOK(res1)) {
19129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetInt" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19130 }
19131 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19132 ecode2 = SWIG_AsVal_int(obj1, &val2);
19133 if (!SWIG_IsOK(ecode2)) {
19134 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetInt" "', expected argument " "2"" of type '" "int""'");
19135 }
19136 arg2 = static_cast< int >(val2);
19137 {
19138 PyThreadState* __tstate = wxPyBeginAllowThreads();
19139 (arg1)->SetInt(arg2);
19140 wxPyEndAllowThreads(__tstate);
19141 if (PyErr_Occurred()) SWIG_fail;
19142 }
19143 resultobj = SWIG_Py_Void();
19144 return resultobj;
19145 fail:
19146 return NULL;
19147 }
19148
19149
19150 SWIGINTERN PyObject *_wrap_CommandEvent_GetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19151 PyObject *resultobj = 0;
19152 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19153 int result;
19154 void *argp1 = 0 ;
19155 int res1 = 0 ;
19156 PyObject *swig_obj[1] ;
19157
19158 if (!args) SWIG_fail;
19159 swig_obj[0] = args;
19160 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19161 if (!SWIG_IsOK(res1)) {
19162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetInt" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19163 }
19164 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19165 {
19166 PyThreadState* __tstate = wxPyBeginAllowThreads();
19167 result = (int)((wxCommandEvent const *)arg1)->GetInt();
19168 wxPyEndAllowThreads(__tstate);
19169 if (PyErr_Occurred()) SWIG_fail;
19170 }
19171 resultobj = SWIG_From_int(static_cast< int >(result));
19172 return resultobj;
19173 fail:
19174 return NULL;
19175 }
19176
19177
19178 SWIGINTERN PyObject *_wrap_CommandEvent_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19179 PyObject *resultobj = 0;
19180 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19181 PyObject *result = 0 ;
19182 void *argp1 = 0 ;
19183 int res1 = 0 ;
19184 PyObject *swig_obj[1] ;
19185
19186 if (!args) SWIG_fail;
19187 swig_obj[0] = args;
19188 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19189 if (!SWIG_IsOK(res1)) {
19190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19191 }
19192 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19193 {
19194 PyThreadState* __tstate = wxPyBeginAllowThreads();
19195 result = (PyObject *)wxCommandEvent_GetClientData(arg1);
19196 wxPyEndAllowThreads(__tstate);
19197 if (PyErr_Occurred()) SWIG_fail;
19198 }
19199 resultobj = result;
19200 return resultobj;
19201 fail:
19202 return NULL;
19203 }
19204
19205
19206 SWIGINTERN PyObject *_wrap_CommandEvent_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19207 PyObject *resultobj = 0;
19208 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19209 PyObject *arg2 = (PyObject *) 0 ;
19210 void *argp1 = 0 ;
19211 int res1 = 0 ;
19212 PyObject * obj0 = 0 ;
19213 PyObject * obj1 = 0 ;
19214 char * kwnames[] = {
19215 (char *) "self",(char *) "clientData", NULL
19216 };
19217
19218 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
19219 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19220 if (!SWIG_IsOK(res1)) {
19221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19222 }
19223 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19224 arg2 = obj1;
19225 {
19226 PyThreadState* __tstate = wxPyBeginAllowThreads();
19227 wxCommandEvent_SetClientData(arg1,arg2);
19228 wxPyEndAllowThreads(__tstate);
19229 if (PyErr_Occurred()) SWIG_fail;
19230 }
19231 resultobj = SWIG_Py_Void();
19232 return resultobj;
19233 fail:
19234 return NULL;
19235 }
19236
19237
19238 SWIGINTERN PyObject *_wrap_CommandEvent_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19239 PyObject *resultobj = 0;
19240 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19241 wxEvent *result = 0 ;
19242 void *argp1 = 0 ;
19243 int res1 = 0 ;
19244 PyObject *swig_obj[1] ;
19245
19246 if (!args) SWIG_fail;
19247 swig_obj[0] = args;
19248 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19249 if (!SWIG_IsOK(res1)) {
19250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_Clone" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19251 }
19252 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19253 {
19254 PyThreadState* __tstate = wxPyBeginAllowThreads();
19255 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
19256 wxPyEndAllowThreads(__tstate);
19257 if (PyErr_Occurred()) SWIG_fail;
19258 }
19259 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
19260 return resultobj;
19261 fail:
19262 return NULL;
19263 }
19264
19265
19266 SWIGINTERN PyObject *CommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19267 PyObject *obj;
19268 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19269 SWIG_TypeNewClientData(SWIGTYPE_p_wxCommandEvent, SWIG_NewClientData(obj));
19270 return SWIG_Py_Void();
19271 }
19272
19273 SWIGINTERN PyObject *CommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19274 return SWIG_Python_InitShadowInstance(args);
19275 }
19276
19277 SWIGINTERN PyObject *_wrap_new_NotifyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19278 PyObject *resultobj = 0;
19279 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19280 int arg2 = (int) 0 ;
19281 wxNotifyEvent *result = 0 ;
19282 int val1 ;
19283 int ecode1 = 0 ;
19284 int val2 ;
19285 int ecode2 = 0 ;
19286 PyObject * obj0 = 0 ;
19287 PyObject * obj1 = 0 ;
19288 char * kwnames[] = {
19289 (char *) "commandType",(char *) "winid", NULL
19290 };
19291
19292 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
19293 if (obj0) {
19294 ecode1 = SWIG_AsVal_int(obj0, &val1);
19295 if (!SWIG_IsOK(ecode1)) {
19296 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NotifyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19297 }
19298 arg1 = static_cast< wxEventType >(val1);
19299 }
19300 if (obj1) {
19301 ecode2 = SWIG_AsVal_int(obj1, &val2);
19302 if (!SWIG_IsOK(ecode2)) {
19303 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NotifyEvent" "', expected argument " "2"" of type '" "int""'");
19304 }
19305 arg2 = static_cast< int >(val2);
19306 }
19307 {
19308 PyThreadState* __tstate = wxPyBeginAllowThreads();
19309 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
19310 wxPyEndAllowThreads(__tstate);
19311 if (PyErr_Occurred()) SWIG_fail;
19312 }
19313 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_NEW | 0 );
19314 return resultobj;
19315 fail:
19316 return NULL;
19317 }
19318
19319
19320 SWIGINTERN PyObject *_wrap_NotifyEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19321 PyObject *resultobj = 0;
19322 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19323 void *argp1 = 0 ;
19324 int res1 = 0 ;
19325 PyObject *swig_obj[1] ;
19326
19327 if (!args) SWIG_fail;
19328 swig_obj[0] = args;
19329 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19330 if (!SWIG_IsOK(res1)) {
19331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Veto" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19332 }
19333 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19334 {
19335 PyThreadState* __tstate = wxPyBeginAllowThreads();
19336 (arg1)->Veto();
19337 wxPyEndAllowThreads(__tstate);
19338 if (PyErr_Occurred()) SWIG_fail;
19339 }
19340 resultobj = SWIG_Py_Void();
19341 return resultobj;
19342 fail:
19343 return NULL;
19344 }
19345
19346
19347 SWIGINTERN PyObject *_wrap_NotifyEvent_Allow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19348 PyObject *resultobj = 0;
19349 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19350 void *argp1 = 0 ;
19351 int res1 = 0 ;
19352 PyObject *swig_obj[1] ;
19353
19354 if (!args) SWIG_fail;
19355 swig_obj[0] = args;
19356 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19357 if (!SWIG_IsOK(res1)) {
19358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Allow" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19359 }
19360 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19361 {
19362 PyThreadState* __tstate = wxPyBeginAllowThreads();
19363 (arg1)->Allow();
19364 wxPyEndAllowThreads(__tstate);
19365 if (PyErr_Occurred()) SWIG_fail;
19366 }
19367 resultobj = SWIG_Py_Void();
19368 return resultobj;
19369 fail:
19370 return NULL;
19371 }
19372
19373
19374 SWIGINTERN PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19375 PyObject *resultobj = 0;
19376 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19377 bool result;
19378 void *argp1 = 0 ;
19379 int res1 = 0 ;
19380 PyObject *swig_obj[1] ;
19381
19382 if (!args) SWIG_fail;
19383 swig_obj[0] = args;
19384 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19385 if (!SWIG_IsOK(res1)) {
19386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_IsAllowed" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19387 }
19388 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19389 {
19390 PyThreadState* __tstate = wxPyBeginAllowThreads();
19391 result = (bool)(arg1)->IsAllowed();
19392 wxPyEndAllowThreads(__tstate);
19393 if (PyErr_Occurred()) SWIG_fail;
19394 }
19395 {
19396 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19397 }
19398 return resultobj;
19399 fail:
19400 return NULL;
19401 }
19402
19403
19404 SWIGINTERN PyObject *NotifyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19405 PyObject *obj;
19406 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19407 SWIG_TypeNewClientData(SWIGTYPE_p_wxNotifyEvent, SWIG_NewClientData(obj));
19408 return SWIG_Py_Void();
19409 }
19410
19411 SWIGINTERN PyObject *NotifyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19412 return SWIG_Python_InitShadowInstance(args);
19413 }
19414
19415 SWIGINTERN PyObject *_wrap_new_ScrollEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19416 PyObject *resultobj = 0;
19417 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19418 int arg2 = (int) 0 ;
19419 int arg3 = (int) 0 ;
19420 int arg4 = (int) 0 ;
19421 wxScrollEvent *result = 0 ;
19422 int val1 ;
19423 int ecode1 = 0 ;
19424 int val2 ;
19425 int ecode2 = 0 ;
19426 int val3 ;
19427 int ecode3 = 0 ;
19428 int val4 ;
19429 int ecode4 = 0 ;
19430 PyObject * obj0 = 0 ;
19431 PyObject * obj1 = 0 ;
19432 PyObject * obj2 = 0 ;
19433 PyObject * obj3 = 0 ;
19434 char * kwnames[] = {
19435 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
19436 };
19437
19438 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19439 if (obj0) {
19440 ecode1 = SWIG_AsVal_int(obj0, &val1);
19441 if (!SWIG_IsOK(ecode1)) {
19442 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19443 }
19444 arg1 = static_cast< wxEventType >(val1);
19445 }
19446 if (obj1) {
19447 ecode2 = SWIG_AsVal_int(obj1, &val2);
19448 if (!SWIG_IsOK(ecode2)) {
19449 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollEvent" "', expected argument " "2"" of type '" "int""'");
19450 }
19451 arg2 = static_cast< int >(val2);
19452 }
19453 if (obj2) {
19454 ecode3 = SWIG_AsVal_int(obj2, &val3);
19455 if (!SWIG_IsOK(ecode3)) {
19456 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollEvent" "', expected argument " "3"" of type '" "int""'");
19457 }
19458 arg3 = static_cast< int >(val3);
19459 }
19460 if (obj3) {
19461 ecode4 = SWIG_AsVal_int(obj3, &val4);
19462 if (!SWIG_IsOK(ecode4)) {
19463 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ScrollEvent" "', expected argument " "4"" of type '" "int""'");
19464 }
19465 arg4 = static_cast< int >(val4);
19466 }
19467 {
19468 PyThreadState* __tstate = wxPyBeginAllowThreads();
19469 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
19470 wxPyEndAllowThreads(__tstate);
19471 if (PyErr_Occurred()) SWIG_fail;
19472 }
19473 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_NEW | 0 );
19474 return resultobj;
19475 fail:
19476 return NULL;
19477 }
19478
19479
19480 SWIGINTERN PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19481 PyObject *resultobj = 0;
19482 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19483 int result;
19484 void *argp1 = 0 ;
19485 int res1 = 0 ;
19486 PyObject *swig_obj[1] ;
19487
19488 if (!args) SWIG_fail;
19489 swig_obj[0] = args;
19490 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19491 if (!SWIG_IsOK(res1)) {
19492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19493 }
19494 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19495 {
19496 PyThreadState* __tstate = wxPyBeginAllowThreads();
19497 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
19498 wxPyEndAllowThreads(__tstate);
19499 if (PyErr_Occurred()) SWIG_fail;
19500 }
19501 resultobj = SWIG_From_int(static_cast< int >(result));
19502 return resultobj;
19503 fail:
19504 return NULL;
19505 }
19506
19507
19508 SWIGINTERN PyObject *_wrap_ScrollEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19509 PyObject *resultobj = 0;
19510 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19511 int result;
19512 void *argp1 = 0 ;
19513 int res1 = 0 ;
19514 PyObject *swig_obj[1] ;
19515
19516 if (!args) SWIG_fail;
19517 swig_obj[0] = args;
19518 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19519 if (!SWIG_IsOK(res1)) {
19520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19521 }
19522 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19523 {
19524 PyThreadState* __tstate = wxPyBeginAllowThreads();
19525 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
19526 wxPyEndAllowThreads(__tstate);
19527 if (PyErr_Occurred()) SWIG_fail;
19528 }
19529 resultobj = SWIG_From_int(static_cast< int >(result));
19530 return resultobj;
19531 fail:
19532 return NULL;
19533 }
19534
19535
19536 SWIGINTERN PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19537 PyObject *resultobj = 0;
19538 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19539 int arg2 ;
19540 void *argp1 = 0 ;
19541 int res1 = 0 ;
19542 int val2 ;
19543 int ecode2 = 0 ;
19544 PyObject * obj0 = 0 ;
19545 PyObject * obj1 = 0 ;
19546 char * kwnames[] = {
19547 (char *) "self",(char *) "orient", NULL
19548 };
19549
19550 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19551 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19552 if (!SWIG_IsOK(res1)) {
19553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19554 }
19555 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19556 ecode2 = SWIG_AsVal_int(obj1, &val2);
19557 if (!SWIG_IsOK(ecode2)) {
19558 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
19559 }
19560 arg2 = static_cast< int >(val2);
19561 {
19562 PyThreadState* __tstate = wxPyBeginAllowThreads();
19563 (arg1)->SetOrientation(arg2);
19564 wxPyEndAllowThreads(__tstate);
19565 if (PyErr_Occurred()) SWIG_fail;
19566 }
19567 resultobj = SWIG_Py_Void();
19568 return resultobj;
19569 fail:
19570 return NULL;
19571 }
19572
19573
19574 SWIGINTERN PyObject *_wrap_ScrollEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19575 PyObject *resultobj = 0;
19576 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19577 int arg2 ;
19578 void *argp1 = 0 ;
19579 int res1 = 0 ;
19580 int val2 ;
19581 int ecode2 = 0 ;
19582 PyObject * obj0 = 0 ;
19583 PyObject * obj1 = 0 ;
19584 char * kwnames[] = {
19585 (char *) "self",(char *) "pos", NULL
19586 };
19587
19588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
19589 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19590 if (!SWIG_IsOK(res1)) {
19591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19592 }
19593 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19594 ecode2 = SWIG_AsVal_int(obj1, &val2);
19595 if (!SWIG_IsOK(ecode2)) {
19596 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
19597 }
19598 arg2 = static_cast< int >(val2);
19599 {
19600 PyThreadState* __tstate = wxPyBeginAllowThreads();
19601 (arg1)->SetPosition(arg2);
19602 wxPyEndAllowThreads(__tstate);
19603 if (PyErr_Occurred()) SWIG_fail;
19604 }
19605 resultobj = SWIG_Py_Void();
19606 return resultobj;
19607 fail:
19608 return NULL;
19609 }
19610
19611
19612 SWIGINTERN PyObject *ScrollEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19613 PyObject *obj;
19614 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19615 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollEvent, SWIG_NewClientData(obj));
19616 return SWIG_Py_Void();
19617 }
19618
19619 SWIGINTERN PyObject *ScrollEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19620 return SWIG_Python_InitShadowInstance(args);
19621 }
19622
19623 SWIGINTERN PyObject *_wrap_new_ScrollWinEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19624 PyObject *resultobj = 0;
19625 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19626 int arg2 = (int) 0 ;
19627 int arg3 = (int) 0 ;
19628 wxScrollWinEvent *result = 0 ;
19629 int val1 ;
19630 int ecode1 = 0 ;
19631 int val2 ;
19632 int ecode2 = 0 ;
19633 int val3 ;
19634 int ecode3 = 0 ;
19635 PyObject * obj0 = 0 ;
19636 PyObject * obj1 = 0 ;
19637 PyObject * obj2 = 0 ;
19638 char * kwnames[] = {
19639 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
19640 };
19641
19642 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19643 if (obj0) {
19644 ecode1 = SWIG_AsVal_int(obj0, &val1);
19645 if (!SWIG_IsOK(ecode1)) {
19646 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollWinEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19647 }
19648 arg1 = static_cast< wxEventType >(val1);
19649 }
19650 if (obj1) {
19651 ecode2 = SWIG_AsVal_int(obj1, &val2);
19652 if (!SWIG_IsOK(ecode2)) {
19653 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollWinEvent" "', expected argument " "2"" of type '" "int""'");
19654 }
19655 arg2 = static_cast< int >(val2);
19656 }
19657 if (obj2) {
19658 ecode3 = SWIG_AsVal_int(obj2, &val3);
19659 if (!SWIG_IsOK(ecode3)) {
19660 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollWinEvent" "', expected argument " "3"" of type '" "int""'");
19661 }
19662 arg3 = static_cast< int >(val3);
19663 }
19664 {
19665 PyThreadState* __tstate = wxPyBeginAllowThreads();
19666 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
19667 wxPyEndAllowThreads(__tstate);
19668 if (PyErr_Occurred()) SWIG_fail;
19669 }
19670 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_NEW | 0 );
19671 return resultobj;
19672 fail:
19673 return NULL;
19674 }
19675
19676
19677 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19678 PyObject *resultobj = 0;
19679 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19680 int result;
19681 void *argp1 = 0 ;
19682 int res1 = 0 ;
19683 PyObject *swig_obj[1] ;
19684
19685 if (!args) SWIG_fail;
19686 swig_obj[0] = args;
19687 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19688 if (!SWIG_IsOK(res1)) {
19689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
19690 }
19691 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19692 {
19693 PyThreadState* __tstate = wxPyBeginAllowThreads();
19694 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
19695 wxPyEndAllowThreads(__tstate);
19696 if (PyErr_Occurred()) SWIG_fail;
19697 }
19698 resultobj = SWIG_From_int(static_cast< int >(result));
19699 return resultobj;
19700 fail:
19701 return NULL;
19702 }
19703
19704
19705 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19706 PyObject *resultobj = 0;
19707 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19708 int result;
19709 void *argp1 = 0 ;
19710 int res1 = 0 ;
19711 PyObject *swig_obj[1] ;
19712
19713 if (!args) SWIG_fail;
19714 swig_obj[0] = args;
19715 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19716 if (!SWIG_IsOK(res1)) {
19717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
19718 }
19719 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19720 {
19721 PyThreadState* __tstate = wxPyBeginAllowThreads();
19722 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
19723 wxPyEndAllowThreads(__tstate);
19724 if (PyErr_Occurred()) SWIG_fail;
19725 }
19726 resultobj = SWIG_From_int(static_cast< int >(result));
19727 return resultobj;
19728 fail:
19729 return NULL;
19730 }
19731
19732
19733 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19734 PyObject *resultobj = 0;
19735 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19736 int arg2 ;
19737 void *argp1 = 0 ;
19738 int res1 = 0 ;
19739 int val2 ;
19740 int ecode2 = 0 ;
19741 PyObject * obj0 = 0 ;
19742 PyObject * obj1 = 0 ;
19743 char * kwnames[] = {
19744 (char *) "self",(char *) "orient", NULL
19745 };
19746
19747 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19748 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19749 if (!SWIG_IsOK(res1)) {
19750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
19751 }
19752 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19753 ecode2 = SWIG_AsVal_int(obj1, &val2);
19754 if (!SWIG_IsOK(ecode2)) {
19755 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
19756 }
19757 arg2 = static_cast< int >(val2);
19758 {
19759 PyThreadState* __tstate = wxPyBeginAllowThreads();
19760 (arg1)->SetOrientation(arg2);
19761 wxPyEndAllowThreads(__tstate);
19762 if (PyErr_Occurred()) SWIG_fail;
19763 }
19764 resultobj = SWIG_Py_Void();
19765 return resultobj;
19766 fail:
19767 return NULL;
19768 }
19769
19770
19771 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19772 PyObject *resultobj = 0;
19773 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19774 int arg2 ;
19775 void *argp1 = 0 ;
19776 int res1 = 0 ;
19777 int val2 ;
19778 int ecode2 = 0 ;
19779 PyObject * obj0 = 0 ;
19780 PyObject * obj1 = 0 ;
19781 char * kwnames[] = {
19782 (char *) "self",(char *) "pos", NULL
19783 };
19784
19785 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
19786 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19787 if (!SWIG_IsOK(res1)) {
19788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
19789 }
19790 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19791 ecode2 = SWIG_AsVal_int(obj1, &val2);
19792 if (!SWIG_IsOK(ecode2)) {
19793 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
19794 }
19795 arg2 = static_cast< int >(val2);
19796 {
19797 PyThreadState* __tstate = wxPyBeginAllowThreads();
19798 (arg1)->SetPosition(arg2);
19799 wxPyEndAllowThreads(__tstate);
19800 if (PyErr_Occurred()) SWIG_fail;
19801 }
19802 resultobj = SWIG_Py_Void();
19803 return resultobj;
19804 fail:
19805 return NULL;
19806 }
19807
19808
19809 SWIGINTERN PyObject *ScrollWinEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19810 PyObject *obj;
19811 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19812 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollWinEvent, SWIG_NewClientData(obj));
19813 return SWIG_Py_Void();
19814 }
19815
19816 SWIGINTERN PyObject *ScrollWinEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19817 return SWIG_Python_InitShadowInstance(args);
19818 }
19819
19820 SWIGINTERN PyObject *_wrap_new_MouseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19821 PyObject *resultobj = 0;
19822 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19823 wxMouseEvent *result = 0 ;
19824 int val1 ;
19825 int ecode1 = 0 ;
19826 PyObject * obj0 = 0 ;
19827 char * kwnames[] = {
19828 (char *) "mouseType", NULL
19829 };
19830
19831 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) SWIG_fail;
19832 if (obj0) {
19833 ecode1 = SWIG_AsVal_int(obj0, &val1);
19834 if (!SWIG_IsOK(ecode1)) {
19835 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19836 }
19837 arg1 = static_cast< wxEventType >(val1);
19838 }
19839 {
19840 PyThreadState* __tstate = wxPyBeginAllowThreads();
19841 result = (wxMouseEvent *)new wxMouseEvent(arg1);
19842 wxPyEndAllowThreads(__tstate);
19843 if (PyErr_Occurred()) SWIG_fail;
19844 }
19845 {
19846 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
19847 }
19848 return resultobj;
19849 fail:
19850 return NULL;
19851 }
19852
19853
19854 SWIGINTERN PyObject *_wrap_MouseEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19855 PyObject *resultobj = 0;
19856 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19857 bool result;
19858 void *argp1 = 0 ;
19859 int res1 = 0 ;
19860 PyObject *swig_obj[1] ;
19861
19862 if (!args) SWIG_fail;
19863 swig_obj[0] = args;
19864 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19865 if (!SWIG_IsOK(res1)) {
19866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19867 }
19868 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19869 {
19870 PyThreadState* __tstate = wxPyBeginAllowThreads();
19871 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
19872 wxPyEndAllowThreads(__tstate);
19873 if (PyErr_Occurred()) SWIG_fail;
19874 }
19875 {
19876 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19877 }
19878 return resultobj;
19879 fail:
19880 return NULL;
19881 }
19882
19883
19884 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19885 PyObject *resultobj = 0;
19886 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19887 int arg2 = (int) wxMOUSE_BTN_ANY ;
19888 bool result;
19889 void *argp1 = 0 ;
19890 int res1 = 0 ;
19891 int val2 ;
19892 int ecode2 = 0 ;
19893 PyObject * obj0 = 0 ;
19894 PyObject * obj1 = 0 ;
19895 char * kwnames[] = {
19896 (char *) "self",(char *) "but", NULL
19897 };
19898
19899 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
19900 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19901 if (!SWIG_IsOK(res1)) {
19902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19903 }
19904 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19905 if (obj1) {
19906 ecode2 = SWIG_AsVal_int(obj1, &val2);
19907 if (!SWIG_IsOK(ecode2)) {
19908 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
19909 }
19910 arg2 = static_cast< int >(val2);
19911 }
19912 {
19913 PyThreadState* __tstate = wxPyBeginAllowThreads();
19914 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
19915 wxPyEndAllowThreads(__tstate);
19916 if (PyErr_Occurred()) SWIG_fail;
19917 }
19918 {
19919 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19920 }
19921 return resultobj;
19922 fail:
19923 return NULL;
19924 }
19925
19926
19927 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19928 PyObject *resultobj = 0;
19929 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19930 int arg2 = (int) wxMOUSE_BTN_ANY ;
19931 bool result;
19932 void *argp1 = 0 ;
19933 int res1 = 0 ;
19934 int val2 ;
19935 int ecode2 = 0 ;
19936 PyObject * obj0 = 0 ;
19937 PyObject * obj1 = 0 ;
19938 char * kwnames[] = {
19939 (char *) "self",(char *) "but", NULL
19940 };
19941
19942 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) SWIG_fail;
19943 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19944 if (!SWIG_IsOK(res1)) {
19945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19946 }
19947 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19948 if (obj1) {
19949 ecode2 = SWIG_AsVal_int(obj1, &val2);
19950 if (!SWIG_IsOK(ecode2)) {
19951 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "2"" of type '" "int""'");
19952 }
19953 arg2 = static_cast< int >(val2);
19954 }
19955 {
19956 PyThreadState* __tstate = wxPyBeginAllowThreads();
19957 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
19958 wxPyEndAllowThreads(__tstate);
19959 if (PyErr_Occurred()) SWIG_fail;
19960 }
19961 {
19962 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19963 }
19964 return resultobj;
19965 fail:
19966 return NULL;
19967 }
19968
19969
19970 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19971 PyObject *resultobj = 0;
19972 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19973 int arg2 = (int) wxMOUSE_BTN_ANY ;
19974 bool result;
19975 void *argp1 = 0 ;
19976 int res1 = 0 ;
19977 int val2 ;
19978 int ecode2 = 0 ;
19979 PyObject * obj0 = 0 ;
19980 PyObject * obj1 = 0 ;
19981 char * kwnames[] = {
19982 (char *) "self",(char *) "but", NULL
19983 };
19984
19985 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
19986 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19987 if (!SWIG_IsOK(res1)) {
19988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19989 }
19990 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19991 if (obj1) {
19992 ecode2 = SWIG_AsVal_int(obj1, &val2);
19993 if (!SWIG_IsOK(ecode2)) {
19994 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
19995 }
19996 arg2 = static_cast< int >(val2);
19997 }
19998 {
19999 PyThreadState* __tstate = wxPyBeginAllowThreads();
20000 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
20001 wxPyEndAllowThreads(__tstate);
20002 if (PyErr_Occurred()) SWIG_fail;
20003 }
20004 {
20005 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20006 }
20007 return resultobj;
20008 fail:
20009 return NULL;
20010 }
20011
20012
20013 SWIGINTERN PyObject *_wrap_MouseEvent_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20014 PyObject *resultobj = 0;
20015 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20016 int arg2 ;
20017 bool result;
20018 void *argp1 = 0 ;
20019 int res1 = 0 ;
20020 int val2 ;
20021 int ecode2 = 0 ;
20022 PyObject * obj0 = 0 ;
20023 PyObject * obj1 = 0 ;
20024 char * kwnames[] = {
20025 (char *) "self",(char *) "button", NULL
20026 };
20027
20028 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) SWIG_fail;
20029 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20030 if (!SWIG_IsOK(res1)) {
20031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Button" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20032 }
20033 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20034 ecode2 = SWIG_AsVal_int(obj1, &val2);
20035 if (!SWIG_IsOK(ecode2)) {
20036 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_Button" "', expected argument " "2"" of type '" "int""'");
20037 }
20038 arg2 = static_cast< int >(val2);
20039 {
20040 PyThreadState* __tstate = wxPyBeginAllowThreads();
20041 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
20042 wxPyEndAllowThreads(__tstate);
20043 if (PyErr_Occurred()) SWIG_fail;
20044 }
20045 {
20046 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20047 }
20048 return resultobj;
20049 fail:
20050 return NULL;
20051 }
20052
20053
20054 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20055 PyObject *resultobj = 0;
20056 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20057 int arg2 ;
20058 bool result;
20059 void *argp1 = 0 ;
20060 int res1 = 0 ;
20061 int val2 ;
20062 int ecode2 = 0 ;
20063 PyObject * obj0 = 0 ;
20064 PyObject * obj1 = 0 ;
20065 char * kwnames[] = {
20066 (char *) "self",(char *) "but", NULL
20067 };
20068
20069 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
20070 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20071 if (!SWIG_IsOK(res1)) {
20072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20073 }
20074 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20075 ecode2 = SWIG_AsVal_int(obj1, &val2);
20076 if (!SWIG_IsOK(ecode2)) {
20077 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
20078 }
20079 arg2 = static_cast< int >(val2);
20080 {
20081 PyThreadState* __tstate = wxPyBeginAllowThreads();
20082 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
20083 wxPyEndAllowThreads(__tstate);
20084 if (PyErr_Occurred()) SWIG_fail;
20085 }
20086 {
20087 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20088 }
20089 return resultobj;
20090 fail:
20091 return NULL;
20092 }
20093
20094
20095 SWIGINTERN PyObject *_wrap_MouseEvent_GetButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20096 PyObject *resultobj = 0;
20097 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20098 int result;
20099 void *argp1 = 0 ;
20100 int res1 = 0 ;
20101 PyObject *swig_obj[1] ;
20102
20103 if (!args) SWIG_fail;
20104 swig_obj[0] = args;
20105 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20106 if (!SWIG_IsOK(res1)) {
20107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20108 }
20109 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20110 {
20111 PyThreadState* __tstate = wxPyBeginAllowThreads();
20112 result = (int)((wxMouseEvent const *)arg1)->GetButton();
20113 wxPyEndAllowThreads(__tstate);
20114 if (PyErr_Occurred()) SWIG_fail;
20115 }
20116 resultobj = SWIG_From_int(static_cast< int >(result));
20117 return resultobj;
20118 fail:
20119 return NULL;
20120 }
20121
20122
20123 SWIGINTERN PyObject *_wrap_MouseEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20124 PyObject *resultobj = 0;
20125 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20126 bool result;
20127 void *argp1 = 0 ;
20128 int res1 = 0 ;
20129 PyObject *swig_obj[1] ;
20130
20131 if (!args) SWIG_fail;
20132 swig_obj[0] = args;
20133 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20134 if (!SWIG_IsOK(res1)) {
20135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ControlDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20136 }
20137 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20138 {
20139 PyThreadState* __tstate = wxPyBeginAllowThreads();
20140 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
20141 wxPyEndAllowThreads(__tstate);
20142 if (PyErr_Occurred()) SWIG_fail;
20143 }
20144 {
20145 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20146 }
20147 return resultobj;
20148 fail:
20149 return NULL;
20150 }
20151
20152
20153 SWIGINTERN PyObject *_wrap_MouseEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20154 PyObject *resultobj = 0;
20155 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20156 bool result;
20157 void *argp1 = 0 ;
20158 int res1 = 0 ;
20159 PyObject *swig_obj[1] ;
20160
20161 if (!args) SWIG_fail;
20162 swig_obj[0] = args;
20163 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20164 if (!SWIG_IsOK(res1)) {
20165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MetaDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20166 }
20167 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20168 {
20169 PyThreadState* __tstate = wxPyBeginAllowThreads();
20170 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
20171 wxPyEndAllowThreads(__tstate);
20172 if (PyErr_Occurred()) SWIG_fail;
20173 }
20174 {
20175 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20176 }
20177 return resultobj;
20178 fail:
20179 return NULL;
20180 }
20181
20182
20183 SWIGINTERN PyObject *_wrap_MouseEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20184 PyObject *resultobj = 0;
20185 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20186 bool result;
20187 void *argp1 = 0 ;
20188 int res1 = 0 ;
20189 PyObject *swig_obj[1] ;
20190
20191 if (!args) SWIG_fail;
20192 swig_obj[0] = args;
20193 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20194 if (!SWIG_IsOK(res1)) {
20195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_AltDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20196 }
20197 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20198 {
20199 PyThreadState* __tstate = wxPyBeginAllowThreads();
20200 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
20201 wxPyEndAllowThreads(__tstate);
20202 if (PyErr_Occurred()) SWIG_fail;
20203 }
20204 {
20205 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20206 }
20207 return resultobj;
20208 fail:
20209 return NULL;
20210 }
20211
20212
20213 SWIGINTERN PyObject *_wrap_MouseEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20214 PyObject *resultobj = 0;
20215 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20216 bool result;
20217 void *argp1 = 0 ;
20218 int res1 = 0 ;
20219 PyObject *swig_obj[1] ;
20220
20221 if (!args) SWIG_fail;
20222 swig_obj[0] = args;
20223 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20224 if (!SWIG_IsOK(res1)) {
20225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ShiftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20226 }
20227 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20228 {
20229 PyThreadState* __tstate = wxPyBeginAllowThreads();
20230 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
20231 wxPyEndAllowThreads(__tstate);
20232 if (PyErr_Occurred()) SWIG_fail;
20233 }
20234 {
20235 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20236 }
20237 return resultobj;
20238 fail:
20239 return NULL;
20240 }
20241
20242
20243 SWIGINTERN PyObject *_wrap_MouseEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20244 PyObject *resultobj = 0;
20245 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20246 bool result;
20247 void *argp1 = 0 ;
20248 int res1 = 0 ;
20249 PyObject *swig_obj[1] ;
20250
20251 if (!args) SWIG_fail;
20252 swig_obj[0] = args;
20253 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20254 if (!SWIG_IsOK(res1)) {
20255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_CmdDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20256 }
20257 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20258 {
20259 PyThreadState* __tstate = wxPyBeginAllowThreads();
20260 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
20261 wxPyEndAllowThreads(__tstate);
20262 if (PyErr_Occurred()) SWIG_fail;
20263 }
20264 {
20265 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20266 }
20267 return resultobj;
20268 fail:
20269 return NULL;
20270 }
20271
20272
20273 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20274 PyObject *resultobj = 0;
20275 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20276 bool result;
20277 void *argp1 = 0 ;
20278 int res1 = 0 ;
20279 PyObject *swig_obj[1] ;
20280
20281 if (!args) SWIG_fail;
20282 swig_obj[0] = args;
20283 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20284 if (!SWIG_IsOK(res1)) {
20285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20286 }
20287 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20288 {
20289 PyThreadState* __tstate = wxPyBeginAllowThreads();
20290 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
20291 wxPyEndAllowThreads(__tstate);
20292 if (PyErr_Occurred()) SWIG_fail;
20293 }
20294 {
20295 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20296 }
20297 return resultobj;
20298 fail:
20299 return NULL;
20300 }
20301
20302
20303 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20304 PyObject *resultobj = 0;
20305 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20306 bool result;
20307 void *argp1 = 0 ;
20308 int res1 = 0 ;
20309 PyObject *swig_obj[1] ;
20310
20311 if (!args) SWIG_fail;
20312 swig_obj[0] = args;
20313 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20314 if (!SWIG_IsOK(res1)) {
20315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20316 }
20317 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20318 {
20319 PyThreadState* __tstate = wxPyBeginAllowThreads();
20320 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
20321 wxPyEndAllowThreads(__tstate);
20322 if (PyErr_Occurred()) SWIG_fail;
20323 }
20324 {
20325 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20326 }
20327 return resultobj;
20328 fail:
20329 return NULL;
20330 }
20331
20332
20333 SWIGINTERN PyObject *_wrap_MouseEvent_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20334 PyObject *resultobj = 0;
20335 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20336 bool result;
20337 void *argp1 = 0 ;
20338 int res1 = 0 ;
20339 PyObject *swig_obj[1] ;
20340
20341 if (!args) SWIG_fail;
20342 swig_obj[0] = args;
20343 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20344 if (!SWIG_IsOK(res1)) {
20345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20346 }
20347 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20348 {
20349 PyThreadState* __tstate = wxPyBeginAllowThreads();
20350 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
20351 wxPyEndAllowThreads(__tstate);
20352 if (PyErr_Occurred()) SWIG_fail;
20353 }
20354 {
20355 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20356 }
20357 return resultobj;
20358 fail:
20359 return NULL;
20360 }
20361
20362
20363 SWIGINTERN PyObject *_wrap_MouseEvent_LeftUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20364 PyObject *resultobj = 0;
20365 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20366 bool result;
20367 void *argp1 = 0 ;
20368 int res1 = 0 ;
20369 PyObject *swig_obj[1] ;
20370
20371 if (!args) SWIG_fail;
20372 swig_obj[0] = args;
20373 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20374 if (!SWIG_IsOK(res1)) {
20375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20376 }
20377 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20378 {
20379 PyThreadState* __tstate = wxPyBeginAllowThreads();
20380 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
20381 wxPyEndAllowThreads(__tstate);
20382 if (PyErr_Occurred()) SWIG_fail;
20383 }
20384 {
20385 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20386 }
20387 return resultobj;
20388 fail:
20389 return NULL;
20390 }
20391
20392
20393 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20394 PyObject *resultobj = 0;
20395 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20396 bool result;
20397 void *argp1 = 0 ;
20398 int res1 = 0 ;
20399 PyObject *swig_obj[1] ;
20400
20401 if (!args) SWIG_fail;
20402 swig_obj[0] = args;
20403 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20404 if (!SWIG_IsOK(res1)) {
20405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20406 }
20407 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20408 {
20409 PyThreadState* __tstate = wxPyBeginAllowThreads();
20410 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
20411 wxPyEndAllowThreads(__tstate);
20412 if (PyErr_Occurred()) SWIG_fail;
20413 }
20414 {
20415 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20416 }
20417 return resultobj;
20418 fail:
20419 return NULL;
20420 }
20421
20422
20423 SWIGINTERN PyObject *_wrap_MouseEvent_RightUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20424 PyObject *resultobj = 0;
20425 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20426 bool result;
20427 void *argp1 = 0 ;
20428 int res1 = 0 ;
20429 PyObject *swig_obj[1] ;
20430
20431 if (!args) SWIG_fail;
20432 swig_obj[0] = args;
20433 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20434 if (!SWIG_IsOK(res1)) {
20435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20436 }
20437 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20438 {
20439 PyThreadState* __tstate = wxPyBeginAllowThreads();
20440 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
20441 wxPyEndAllowThreads(__tstate);
20442 if (PyErr_Occurred()) SWIG_fail;
20443 }
20444 {
20445 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20446 }
20447 return resultobj;
20448 fail:
20449 return NULL;
20450 }
20451
20452
20453 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20454 PyObject *resultobj = 0;
20455 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20456 bool result;
20457 void *argp1 = 0 ;
20458 int res1 = 0 ;
20459 PyObject *swig_obj[1] ;
20460
20461 if (!args) SWIG_fail;
20462 swig_obj[0] = args;
20463 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20464 if (!SWIG_IsOK(res1)) {
20465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20466 }
20467 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20468 {
20469 PyThreadState* __tstate = wxPyBeginAllowThreads();
20470 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
20471 wxPyEndAllowThreads(__tstate);
20472 if (PyErr_Occurred()) SWIG_fail;
20473 }
20474 {
20475 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20476 }
20477 return resultobj;
20478 fail:
20479 return NULL;
20480 }
20481
20482
20483 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20484 PyObject *resultobj = 0;
20485 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20486 bool result;
20487 void *argp1 = 0 ;
20488 int res1 = 0 ;
20489 PyObject *swig_obj[1] ;
20490
20491 if (!args) SWIG_fail;
20492 swig_obj[0] = args;
20493 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20494 if (!SWIG_IsOK(res1)) {
20495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20496 }
20497 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20498 {
20499 PyThreadState* __tstate = wxPyBeginAllowThreads();
20500 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
20501 wxPyEndAllowThreads(__tstate);
20502 if (PyErr_Occurred()) SWIG_fail;
20503 }
20504 {
20505 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20506 }
20507 return resultobj;
20508 fail:
20509 return NULL;
20510 }
20511
20512
20513 SWIGINTERN PyObject *_wrap_MouseEvent_RightDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20514 PyObject *resultobj = 0;
20515 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20516 bool result;
20517 void *argp1 = 0 ;
20518 int res1 = 0 ;
20519 PyObject *swig_obj[1] ;
20520
20521 if (!args) SWIG_fail;
20522 swig_obj[0] = args;
20523 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20524 if (!SWIG_IsOK(res1)) {
20525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20526 }
20527 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20528 {
20529 PyThreadState* __tstate = wxPyBeginAllowThreads();
20530 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
20531 wxPyEndAllowThreads(__tstate);
20532 if (PyErr_Occurred()) SWIG_fail;
20533 }
20534 {
20535 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20536 }
20537 return resultobj;
20538 fail:
20539 return NULL;
20540 }
20541
20542
20543 SWIGINTERN PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20544 PyObject *resultobj = 0;
20545 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20546 bool result;
20547 void *argp1 = 0 ;
20548 int res1 = 0 ;
20549 PyObject *swig_obj[1] ;
20550
20551 if (!args) SWIG_fail;
20552 swig_obj[0] = args;
20553 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20554 if (!SWIG_IsOK(res1)) {
20555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20556 }
20557 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20558 {
20559 PyThreadState* __tstate = wxPyBeginAllowThreads();
20560 result = (bool)(arg1)->LeftIsDown();
20561 wxPyEndAllowThreads(__tstate);
20562 if (PyErr_Occurred()) SWIG_fail;
20563 }
20564 {
20565 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20566 }
20567 return resultobj;
20568 fail:
20569 return NULL;
20570 }
20571
20572
20573 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20574 PyObject *resultobj = 0;
20575 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20576 bool result;
20577 void *argp1 = 0 ;
20578 int res1 = 0 ;
20579 PyObject *swig_obj[1] ;
20580
20581 if (!args) SWIG_fail;
20582 swig_obj[0] = args;
20583 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20584 if (!SWIG_IsOK(res1)) {
20585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20586 }
20587 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20588 {
20589 PyThreadState* __tstate = wxPyBeginAllowThreads();
20590 result = (bool)(arg1)->MiddleIsDown();
20591 wxPyEndAllowThreads(__tstate);
20592 if (PyErr_Occurred()) SWIG_fail;
20593 }
20594 {
20595 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20596 }
20597 return resultobj;
20598 fail:
20599 return NULL;
20600 }
20601
20602
20603 SWIGINTERN PyObject *_wrap_MouseEvent_RightIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20604 PyObject *resultobj = 0;
20605 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20606 bool result;
20607 void *argp1 = 0 ;
20608 int res1 = 0 ;
20609 PyObject *swig_obj[1] ;
20610
20611 if (!args) SWIG_fail;
20612 swig_obj[0] = args;
20613 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20614 if (!SWIG_IsOK(res1)) {
20615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20616 }
20617 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20618 {
20619 PyThreadState* __tstate = wxPyBeginAllowThreads();
20620 result = (bool)(arg1)->RightIsDown();
20621 wxPyEndAllowThreads(__tstate);
20622 if (PyErr_Occurred()) SWIG_fail;
20623 }
20624 {
20625 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20626 }
20627 return resultobj;
20628 fail:
20629 return NULL;
20630 }
20631
20632
20633 SWIGINTERN PyObject *_wrap_MouseEvent_Dragging(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20634 PyObject *resultobj = 0;
20635 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20636 bool result;
20637 void *argp1 = 0 ;
20638 int res1 = 0 ;
20639 PyObject *swig_obj[1] ;
20640
20641 if (!args) SWIG_fail;
20642 swig_obj[0] = args;
20643 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20644 if (!SWIG_IsOK(res1)) {
20645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Dragging" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20646 }
20647 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20648 {
20649 PyThreadState* __tstate = wxPyBeginAllowThreads();
20650 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
20651 wxPyEndAllowThreads(__tstate);
20652 if (PyErr_Occurred()) SWIG_fail;
20653 }
20654 {
20655 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20656 }
20657 return resultobj;
20658 fail:
20659 return NULL;
20660 }
20661
20662
20663 SWIGINTERN PyObject *_wrap_MouseEvent_Moving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20664 PyObject *resultobj = 0;
20665 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20666 bool result;
20667 void *argp1 = 0 ;
20668 int res1 = 0 ;
20669 PyObject *swig_obj[1] ;
20670
20671 if (!args) SWIG_fail;
20672 swig_obj[0] = args;
20673 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20674 if (!SWIG_IsOK(res1)) {
20675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Moving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20676 }
20677 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20678 {
20679 PyThreadState* __tstate = wxPyBeginAllowThreads();
20680 result = (bool)((wxMouseEvent const *)arg1)->Moving();
20681 wxPyEndAllowThreads(__tstate);
20682 if (PyErr_Occurred()) SWIG_fail;
20683 }
20684 {
20685 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20686 }
20687 return resultobj;
20688 fail:
20689 return NULL;
20690 }
20691
20692
20693 SWIGINTERN PyObject *_wrap_MouseEvent_Entering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20694 PyObject *resultobj = 0;
20695 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20696 bool result;
20697 void *argp1 = 0 ;
20698 int res1 = 0 ;
20699 PyObject *swig_obj[1] ;
20700
20701 if (!args) SWIG_fail;
20702 swig_obj[0] = args;
20703 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20704 if (!SWIG_IsOK(res1)) {
20705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Entering" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20706 }
20707 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20708 {
20709 PyThreadState* __tstate = wxPyBeginAllowThreads();
20710 result = (bool)((wxMouseEvent const *)arg1)->Entering();
20711 wxPyEndAllowThreads(__tstate);
20712 if (PyErr_Occurred()) SWIG_fail;
20713 }
20714 {
20715 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20716 }
20717 return resultobj;
20718 fail:
20719 return NULL;
20720 }
20721
20722
20723 SWIGINTERN PyObject *_wrap_MouseEvent_Leaving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20724 PyObject *resultobj = 0;
20725 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20726 bool result;
20727 void *argp1 = 0 ;
20728 int res1 = 0 ;
20729 PyObject *swig_obj[1] ;
20730
20731 if (!args) SWIG_fail;
20732 swig_obj[0] = args;
20733 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20734 if (!SWIG_IsOK(res1)) {
20735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Leaving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20736 }
20737 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20738 {
20739 PyThreadState* __tstate = wxPyBeginAllowThreads();
20740 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
20741 wxPyEndAllowThreads(__tstate);
20742 if (PyErr_Occurred()) SWIG_fail;
20743 }
20744 {
20745 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20746 }
20747 return resultobj;
20748 fail:
20749 return NULL;
20750 }
20751
20752
20753 SWIGINTERN PyObject *_wrap_MouseEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20754 PyObject *resultobj = 0;
20755 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20756 wxPoint result;
20757 void *argp1 = 0 ;
20758 int res1 = 0 ;
20759 PyObject *swig_obj[1] ;
20760
20761 if (!args) SWIG_fail;
20762 swig_obj[0] = args;
20763 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20764 if (!SWIG_IsOK(res1)) {
20765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPosition" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20766 }
20767 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20768 {
20769 PyThreadState* __tstate = wxPyBeginAllowThreads();
20770 result = (arg1)->GetPosition();
20771 wxPyEndAllowThreads(__tstate);
20772 if (PyErr_Occurred()) SWIG_fail;
20773 }
20774 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
20775 return resultobj;
20776 fail:
20777 return NULL;
20778 }
20779
20780
20781 SWIGINTERN PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20782 PyObject *resultobj = 0;
20783 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20784 long *arg2 = (long *) 0 ;
20785 long *arg3 = (long *) 0 ;
20786 void *argp1 = 0 ;
20787 int res1 = 0 ;
20788 long temp2 ;
20789 int res2 = SWIG_TMPOBJ ;
20790 long temp3 ;
20791 int res3 = SWIG_TMPOBJ ;
20792 PyObject *swig_obj[1] ;
20793
20794 arg2 = &temp2;
20795 arg3 = &temp3;
20796 if (!args) SWIG_fail;
20797 swig_obj[0] = args;
20798 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20799 if (!SWIG_IsOK(res1)) {
20800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20801 }
20802 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20803 {
20804 PyThreadState* __tstate = wxPyBeginAllowThreads();
20805 (arg1)->GetPosition(arg2,arg3);
20806 wxPyEndAllowThreads(__tstate);
20807 if (PyErr_Occurred()) SWIG_fail;
20808 }
20809 resultobj = SWIG_Py_Void();
20810 if (SWIG_IsTmpObj(res2)) {
20811 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
20812 } else {
20813 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20814 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
20815 }
20816 if (SWIG_IsTmpObj(res3)) {
20817 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
20818 } else {
20819 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20820 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
20821 }
20822 return resultobj;
20823 fail:
20824 return NULL;
20825 }
20826
20827
20828 SWIGINTERN PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20829 PyObject *resultobj = 0;
20830 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20831 wxDC *arg2 = 0 ;
20832 wxPoint result;
20833 void *argp1 = 0 ;
20834 int res1 = 0 ;
20835 void *argp2 = 0 ;
20836 int res2 = 0 ;
20837 PyObject * obj0 = 0 ;
20838 PyObject * obj1 = 0 ;
20839 char * kwnames[] = {
20840 (char *) "self",(char *) "dc", NULL
20841 };
20842
20843 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) SWIG_fail;
20844 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20845 if (!SWIG_IsOK(res1)) {
20846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20847 }
20848 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20849 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
20850 if (!SWIG_IsOK(res2)) {
20851 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
20852 }
20853 if (!argp2) {
20854 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
20855 }
20856 arg2 = reinterpret_cast< wxDC * >(argp2);
20857 {
20858 PyThreadState* __tstate = wxPyBeginAllowThreads();
20859 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
20860 wxPyEndAllowThreads(__tstate);
20861 if (PyErr_Occurred()) SWIG_fail;
20862 }
20863 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
20864 return resultobj;
20865 fail:
20866 return NULL;
20867 }
20868
20869
20870 SWIGINTERN PyObject *_wrap_MouseEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20871 PyObject *resultobj = 0;
20872 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20873 int result;
20874 void *argp1 = 0 ;
20875 int res1 = 0 ;
20876 PyObject *swig_obj[1] ;
20877
20878 if (!args) SWIG_fail;
20879 swig_obj[0] = args;
20880 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20881 if (!SWIG_IsOK(res1)) {
20882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetX" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20883 }
20884 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20885 {
20886 PyThreadState* __tstate = wxPyBeginAllowThreads();
20887 result = (int)((wxMouseEvent const *)arg1)->GetX();
20888 wxPyEndAllowThreads(__tstate);
20889 if (PyErr_Occurred()) SWIG_fail;
20890 }
20891 resultobj = SWIG_From_int(static_cast< int >(result));
20892 return resultobj;
20893 fail:
20894 return NULL;
20895 }
20896
20897
20898 SWIGINTERN PyObject *_wrap_MouseEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20899 PyObject *resultobj = 0;
20900 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20901 int result;
20902 void *argp1 = 0 ;
20903 int res1 = 0 ;
20904 PyObject *swig_obj[1] ;
20905
20906 if (!args) SWIG_fail;
20907 swig_obj[0] = args;
20908 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20909 if (!SWIG_IsOK(res1)) {
20910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetY" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20911 }
20912 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20913 {
20914 PyThreadState* __tstate = wxPyBeginAllowThreads();
20915 result = (int)((wxMouseEvent const *)arg1)->GetY();
20916 wxPyEndAllowThreads(__tstate);
20917 if (PyErr_Occurred()) SWIG_fail;
20918 }
20919 resultobj = SWIG_From_int(static_cast< int >(result));
20920 return resultobj;
20921 fail:
20922 return NULL;
20923 }
20924
20925
20926 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20927 PyObject *resultobj = 0;
20928 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20929 int result;
20930 void *argp1 = 0 ;
20931 int res1 = 0 ;
20932 PyObject *swig_obj[1] ;
20933
20934 if (!args) SWIG_fail;
20935 swig_obj[0] = args;
20936 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20937 if (!SWIG_IsOK(res1)) {
20938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelRotation" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20939 }
20940 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20941 {
20942 PyThreadState* __tstate = wxPyBeginAllowThreads();
20943 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
20944 wxPyEndAllowThreads(__tstate);
20945 if (PyErr_Occurred()) SWIG_fail;
20946 }
20947 resultobj = SWIG_From_int(static_cast< int >(result));
20948 return resultobj;
20949 fail:
20950 return NULL;
20951 }
20952
20953
20954 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20955 PyObject *resultobj = 0;
20956 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20957 int result;
20958 void *argp1 = 0 ;
20959 int res1 = 0 ;
20960 PyObject *swig_obj[1] ;
20961
20962 if (!args) SWIG_fail;
20963 swig_obj[0] = args;
20964 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20965 if (!SWIG_IsOK(res1)) {
20966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelDelta" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20967 }
20968 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20969 {
20970 PyThreadState* __tstate = wxPyBeginAllowThreads();
20971 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
20972 wxPyEndAllowThreads(__tstate);
20973 if (PyErr_Occurred()) SWIG_fail;
20974 }
20975 resultobj = SWIG_From_int(static_cast< int >(result));
20976 return resultobj;
20977 fail:
20978 return NULL;
20979 }
20980
20981
20982 SWIGINTERN PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20983 PyObject *resultobj = 0;
20984 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20985 int result;
20986 void *argp1 = 0 ;
20987 int res1 = 0 ;
20988 PyObject *swig_obj[1] ;
20989
20990 if (!args) SWIG_fail;
20991 swig_obj[0] = args;
20992 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20993 if (!SWIG_IsOK(res1)) {
20994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLinesPerAction" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20995 }
20996 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20997 {
20998 PyThreadState* __tstate = wxPyBeginAllowThreads();
20999 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
21000 wxPyEndAllowThreads(__tstate);
21001 if (PyErr_Occurred()) SWIG_fail;
21002 }
21003 resultobj = SWIG_From_int(static_cast< int >(result));
21004 return resultobj;
21005 fail:
21006 return NULL;
21007 }
21008
21009
21010 SWIGINTERN PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21011 PyObject *resultobj = 0;
21012 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21013 bool result;
21014 void *argp1 = 0 ;
21015 int res1 = 0 ;
21016 PyObject *swig_obj[1] ;
21017
21018 if (!args) SWIG_fail;
21019 swig_obj[0] = args;
21020 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21021 if (!SWIG_IsOK(res1)) {
21022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsPageScroll" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21023 }
21024 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21025 {
21026 PyThreadState* __tstate = wxPyBeginAllowThreads();
21027 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
21028 wxPyEndAllowThreads(__tstate);
21029 if (PyErr_Occurred()) SWIG_fail;
21030 }
21031 {
21032 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21033 }
21034 return resultobj;
21035 fail:
21036 return NULL;
21037 }
21038
21039
21040 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21041 PyObject *resultobj = 0;
21042 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21043 int arg2 ;
21044 void *argp1 = 0 ;
21045 int res1 = 0 ;
21046 int val2 ;
21047 int ecode2 = 0 ;
21048 PyObject *swig_obj[2] ;
21049
21050 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
21051 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21052 if (!SWIG_IsOK(res1)) {
21053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21054 }
21055 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21056 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21057 if (!SWIG_IsOK(ecode2)) {
21058 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
21059 }
21060 arg2 = static_cast< int >(val2);
21061 if (arg1) (arg1)->m_x = arg2;
21062
21063 resultobj = SWIG_Py_Void();
21064 return resultobj;
21065 fail:
21066 return NULL;
21067 }
21068
21069
21070 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21071 PyObject *resultobj = 0;
21072 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21073 int result;
21074 void *argp1 = 0 ;
21075 int res1 = 0 ;
21076 PyObject *swig_obj[1] ;
21077
21078 if (!args) SWIG_fail;
21079 swig_obj[0] = args;
21080 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21081 if (!SWIG_IsOK(res1)) {
21082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21083 }
21084 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21085 result = (int) ((arg1)->m_x);
21086 resultobj = SWIG_From_int(static_cast< int >(result));
21087 return resultobj;
21088 fail:
21089 return NULL;
21090 }
21091
21092
21093 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21094 PyObject *resultobj = 0;
21095 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21096 int arg2 ;
21097 void *argp1 = 0 ;
21098 int res1 = 0 ;
21099 int val2 ;
21100 int ecode2 = 0 ;
21101 PyObject *swig_obj[2] ;
21102
21103 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
21104 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21105 if (!SWIG_IsOK(res1)) {
21106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21107 }
21108 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21109 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21110 if (!SWIG_IsOK(ecode2)) {
21111 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
21112 }
21113 arg2 = static_cast< int >(val2);
21114 if (arg1) (arg1)->m_y = arg2;
21115
21116 resultobj = SWIG_Py_Void();
21117 return resultobj;
21118 fail:
21119 return NULL;
21120 }
21121
21122
21123 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21124 PyObject *resultobj = 0;
21125 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21126 int result;
21127 void *argp1 = 0 ;
21128 int res1 = 0 ;
21129 PyObject *swig_obj[1] ;
21130
21131 if (!args) SWIG_fail;
21132 swig_obj[0] = args;
21133 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21134 if (!SWIG_IsOK(res1)) {
21135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21136 }
21137 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21138 result = (int) ((arg1)->m_y);
21139 resultobj = SWIG_From_int(static_cast< int >(result));
21140 return resultobj;
21141 fail:
21142 return NULL;
21143 }
21144
21145
21146 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21147 PyObject *resultobj = 0;
21148 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21149 bool arg2 ;
21150 void *argp1 = 0 ;
21151 int res1 = 0 ;
21152 bool val2 ;
21153 int ecode2 = 0 ;
21154 PyObject *swig_obj[2] ;
21155
21156 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_leftDown_set",2,2,swig_obj)) SWIG_fail;
21157 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21158 if (!SWIG_IsOK(res1)) {
21159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21160 }
21161 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21162 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21163 if (!SWIG_IsOK(ecode2)) {
21164 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "2"" of type '" "bool""'");
21165 }
21166 arg2 = static_cast< bool >(val2);
21167 if (arg1) (arg1)->m_leftDown = arg2;
21168
21169 resultobj = SWIG_Py_Void();
21170 return resultobj;
21171 fail:
21172 return NULL;
21173 }
21174
21175
21176 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21177 PyObject *resultobj = 0;
21178 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21179 bool result;
21180 void *argp1 = 0 ;
21181 int res1 = 0 ;
21182 PyObject *swig_obj[1] ;
21183
21184 if (!args) SWIG_fail;
21185 swig_obj[0] = args;
21186 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21187 if (!SWIG_IsOK(res1)) {
21188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21189 }
21190 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21191 result = (bool) ((arg1)->m_leftDown);
21192 {
21193 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21194 }
21195 return resultobj;
21196 fail:
21197 return NULL;
21198 }
21199
21200
21201 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21202 PyObject *resultobj = 0;
21203 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21204 bool arg2 ;
21205 void *argp1 = 0 ;
21206 int res1 = 0 ;
21207 bool val2 ;
21208 int ecode2 = 0 ;
21209 PyObject *swig_obj[2] ;
21210
21211 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_middleDown_set",2,2,swig_obj)) SWIG_fail;
21212 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21213 if (!SWIG_IsOK(res1)) {
21214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21215 }
21216 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21217 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21218 if (!SWIG_IsOK(ecode2)) {
21219 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "2"" of type '" "bool""'");
21220 }
21221 arg2 = static_cast< bool >(val2);
21222 if (arg1) (arg1)->m_middleDown = arg2;
21223
21224 resultobj = SWIG_Py_Void();
21225 return resultobj;
21226 fail:
21227 return NULL;
21228 }
21229
21230
21231 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21232 PyObject *resultobj = 0;
21233 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21234 bool result;
21235 void *argp1 = 0 ;
21236 int res1 = 0 ;
21237 PyObject *swig_obj[1] ;
21238
21239 if (!args) SWIG_fail;
21240 swig_obj[0] = args;
21241 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21242 if (!SWIG_IsOK(res1)) {
21243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21244 }
21245 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21246 result = (bool) ((arg1)->m_middleDown);
21247 {
21248 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21249 }
21250 return resultobj;
21251 fail:
21252 return NULL;
21253 }
21254
21255
21256 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21257 PyObject *resultobj = 0;
21258 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21259 bool arg2 ;
21260 void *argp1 = 0 ;
21261 int res1 = 0 ;
21262 bool val2 ;
21263 int ecode2 = 0 ;
21264 PyObject *swig_obj[2] ;
21265
21266 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_rightDown_set",2,2,swig_obj)) SWIG_fail;
21267 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21268 if (!SWIG_IsOK(res1)) {
21269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21270 }
21271 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21272 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21273 if (!SWIG_IsOK(ecode2)) {
21274 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "2"" of type '" "bool""'");
21275 }
21276 arg2 = static_cast< bool >(val2);
21277 if (arg1) (arg1)->m_rightDown = arg2;
21278
21279 resultobj = SWIG_Py_Void();
21280 return resultobj;
21281 fail:
21282 return NULL;
21283 }
21284
21285
21286 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21287 PyObject *resultobj = 0;
21288 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21289 bool result;
21290 void *argp1 = 0 ;
21291 int res1 = 0 ;
21292 PyObject *swig_obj[1] ;
21293
21294 if (!args) SWIG_fail;
21295 swig_obj[0] = args;
21296 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21297 if (!SWIG_IsOK(res1)) {
21298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21299 }
21300 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21301 result = (bool) ((arg1)->m_rightDown);
21302 {
21303 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21304 }
21305 return resultobj;
21306 fail:
21307 return NULL;
21308 }
21309
21310
21311 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21312 PyObject *resultobj = 0;
21313 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21314 bool arg2 ;
21315 void *argp1 = 0 ;
21316 int res1 = 0 ;
21317 bool val2 ;
21318 int ecode2 = 0 ;
21319 PyObject *swig_obj[2] ;
21320
21321 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
21322 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21323 if (!SWIG_IsOK(res1)) {
21324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21325 }
21326 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21327 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21328 if (!SWIG_IsOK(ecode2)) {
21329 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
21330 }
21331 arg2 = static_cast< bool >(val2);
21332 if (arg1) (arg1)->m_controlDown = arg2;
21333
21334 resultobj = SWIG_Py_Void();
21335 return resultobj;
21336 fail:
21337 return NULL;
21338 }
21339
21340
21341 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21342 PyObject *resultobj = 0;
21343 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21344 bool result;
21345 void *argp1 = 0 ;
21346 int res1 = 0 ;
21347 PyObject *swig_obj[1] ;
21348
21349 if (!args) SWIG_fail;
21350 swig_obj[0] = args;
21351 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21352 if (!SWIG_IsOK(res1)) {
21353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21354 }
21355 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21356 result = (bool) ((arg1)->m_controlDown);
21357 {
21358 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21359 }
21360 return resultobj;
21361 fail:
21362 return NULL;
21363 }
21364
21365
21366 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21367 PyObject *resultobj = 0;
21368 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21369 bool arg2 ;
21370 void *argp1 = 0 ;
21371 int res1 = 0 ;
21372 bool val2 ;
21373 int ecode2 = 0 ;
21374 PyObject *swig_obj[2] ;
21375
21376 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
21377 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21378 if (!SWIG_IsOK(res1)) {
21379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21380 }
21381 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21382 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21383 if (!SWIG_IsOK(ecode2)) {
21384 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
21385 }
21386 arg2 = static_cast< bool >(val2);
21387 if (arg1) (arg1)->m_shiftDown = arg2;
21388
21389 resultobj = SWIG_Py_Void();
21390 return resultobj;
21391 fail:
21392 return NULL;
21393 }
21394
21395
21396 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21397 PyObject *resultobj = 0;
21398 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21399 bool result;
21400 void *argp1 = 0 ;
21401 int res1 = 0 ;
21402 PyObject *swig_obj[1] ;
21403
21404 if (!args) SWIG_fail;
21405 swig_obj[0] = args;
21406 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21407 if (!SWIG_IsOK(res1)) {
21408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21409 }
21410 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21411 result = (bool) ((arg1)->m_shiftDown);
21412 {
21413 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21414 }
21415 return resultobj;
21416 fail:
21417 return NULL;
21418 }
21419
21420
21421 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21422 PyObject *resultobj = 0;
21423 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21424 bool arg2 ;
21425 void *argp1 = 0 ;
21426 int res1 = 0 ;
21427 bool val2 ;
21428 int ecode2 = 0 ;
21429 PyObject *swig_obj[2] ;
21430
21431 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
21432 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21433 if (!SWIG_IsOK(res1)) {
21434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21435 }
21436 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21437 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21438 if (!SWIG_IsOK(ecode2)) {
21439 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
21440 }
21441 arg2 = static_cast< bool >(val2);
21442 if (arg1) (arg1)->m_altDown = arg2;
21443
21444 resultobj = SWIG_Py_Void();
21445 return resultobj;
21446 fail:
21447 return NULL;
21448 }
21449
21450
21451 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21452 PyObject *resultobj = 0;
21453 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21454 bool result;
21455 void *argp1 = 0 ;
21456 int res1 = 0 ;
21457 PyObject *swig_obj[1] ;
21458
21459 if (!args) SWIG_fail;
21460 swig_obj[0] = args;
21461 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21462 if (!SWIG_IsOK(res1)) {
21463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21464 }
21465 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21466 result = (bool) ((arg1)->m_altDown);
21467 {
21468 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21469 }
21470 return resultobj;
21471 fail:
21472 return NULL;
21473 }
21474
21475
21476 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21477 PyObject *resultobj = 0;
21478 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21479 bool arg2 ;
21480 void *argp1 = 0 ;
21481 int res1 = 0 ;
21482 bool val2 ;
21483 int ecode2 = 0 ;
21484 PyObject *swig_obj[2] ;
21485
21486 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
21487 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21488 if (!SWIG_IsOK(res1)) {
21489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21490 }
21491 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21492 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21493 if (!SWIG_IsOK(ecode2)) {
21494 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
21495 }
21496 arg2 = static_cast< bool >(val2);
21497 if (arg1) (arg1)->m_metaDown = arg2;
21498
21499 resultobj = SWIG_Py_Void();
21500 return resultobj;
21501 fail:
21502 return NULL;
21503 }
21504
21505
21506 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21507 PyObject *resultobj = 0;
21508 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21509 bool result;
21510 void *argp1 = 0 ;
21511 int res1 = 0 ;
21512 PyObject *swig_obj[1] ;
21513
21514 if (!args) SWIG_fail;
21515 swig_obj[0] = args;
21516 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21517 if (!SWIG_IsOK(res1)) {
21518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21519 }
21520 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21521 result = (bool) ((arg1)->m_metaDown);
21522 {
21523 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21524 }
21525 return resultobj;
21526 fail:
21527 return NULL;
21528 }
21529
21530
21531 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21532 PyObject *resultobj = 0;
21533 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21534 int arg2 ;
21535 void *argp1 = 0 ;
21536 int res1 = 0 ;
21537 int val2 ;
21538 int ecode2 = 0 ;
21539 PyObject *swig_obj[2] ;
21540
21541 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelRotation_set",2,2,swig_obj)) SWIG_fail;
21542 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21543 if (!SWIG_IsOK(res1)) {
21544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21545 }
21546 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21547 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21548 if (!SWIG_IsOK(ecode2)) {
21549 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "2"" of type '" "int""'");
21550 }
21551 arg2 = static_cast< int >(val2);
21552 if (arg1) (arg1)->m_wheelRotation = arg2;
21553
21554 resultobj = SWIG_Py_Void();
21555 return resultobj;
21556 fail:
21557 return NULL;
21558 }
21559
21560
21561 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21562 PyObject *resultobj = 0;
21563 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21564 int result;
21565 void *argp1 = 0 ;
21566 int res1 = 0 ;
21567 PyObject *swig_obj[1] ;
21568
21569 if (!args) SWIG_fail;
21570 swig_obj[0] = args;
21571 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21572 if (!SWIG_IsOK(res1)) {
21573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21574 }
21575 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21576 result = (int) ((arg1)->m_wheelRotation);
21577 resultobj = SWIG_From_int(static_cast< int >(result));
21578 return resultobj;
21579 fail:
21580 return NULL;
21581 }
21582
21583
21584 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21585 PyObject *resultobj = 0;
21586 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21587 int arg2 ;
21588 void *argp1 = 0 ;
21589 int res1 = 0 ;
21590 int val2 ;
21591 int ecode2 = 0 ;
21592 PyObject *swig_obj[2] ;
21593
21594 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelDelta_set",2,2,swig_obj)) SWIG_fail;
21595 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21596 if (!SWIG_IsOK(res1)) {
21597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21598 }
21599 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21600 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21601 if (!SWIG_IsOK(ecode2)) {
21602 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "2"" of type '" "int""'");
21603 }
21604 arg2 = static_cast< int >(val2);
21605 if (arg1) (arg1)->m_wheelDelta = arg2;
21606
21607 resultobj = SWIG_Py_Void();
21608 return resultobj;
21609 fail:
21610 return NULL;
21611 }
21612
21613
21614 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21615 PyObject *resultobj = 0;
21616 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21617 int result;
21618 void *argp1 = 0 ;
21619 int res1 = 0 ;
21620 PyObject *swig_obj[1] ;
21621
21622 if (!args) SWIG_fail;
21623 swig_obj[0] = args;
21624 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21625 if (!SWIG_IsOK(res1)) {
21626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21627 }
21628 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21629 result = (int) ((arg1)->m_wheelDelta);
21630 resultobj = SWIG_From_int(static_cast< int >(result));
21631 return resultobj;
21632 fail:
21633 return NULL;
21634 }
21635
21636
21637 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21638 PyObject *resultobj = 0;
21639 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21640 int arg2 ;
21641 void *argp1 = 0 ;
21642 int res1 = 0 ;
21643 int val2 ;
21644 int ecode2 = 0 ;
21645 PyObject *swig_obj[2] ;
21646
21647 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_linesPerAction_set",2,2,swig_obj)) SWIG_fail;
21648 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21649 if (!SWIG_IsOK(res1)) {
21650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21651 }
21652 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21653 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21654 if (!SWIG_IsOK(ecode2)) {
21655 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "2"" of type '" "int""'");
21656 }
21657 arg2 = static_cast< int >(val2);
21658 if (arg1) (arg1)->m_linesPerAction = arg2;
21659
21660 resultobj = SWIG_Py_Void();
21661 return resultobj;
21662 fail:
21663 return NULL;
21664 }
21665
21666
21667 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21668 PyObject *resultobj = 0;
21669 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21670 int result;
21671 void *argp1 = 0 ;
21672 int res1 = 0 ;
21673 PyObject *swig_obj[1] ;
21674
21675 if (!args) SWIG_fail;
21676 swig_obj[0] = args;
21677 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21678 if (!SWIG_IsOK(res1)) {
21679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21680 }
21681 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21682 result = (int) ((arg1)->m_linesPerAction);
21683 resultobj = SWIG_From_int(static_cast< int >(result));
21684 return resultobj;
21685 fail:
21686 return NULL;
21687 }
21688
21689
21690 SWIGINTERN PyObject *MouseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21691 PyObject *obj;
21692 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21693 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseEvent, SWIG_NewClientData(obj));
21694 return SWIG_Py_Void();
21695 }
21696
21697 SWIGINTERN PyObject *MouseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21698 return SWIG_Python_InitShadowInstance(args);
21699 }
21700
21701 SWIGINTERN PyObject *_wrap_new_SetCursorEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21702 PyObject *resultobj = 0;
21703 int arg1 = (int) 0 ;
21704 int arg2 = (int) 0 ;
21705 wxSetCursorEvent *result = 0 ;
21706 int val1 ;
21707 int ecode1 = 0 ;
21708 int val2 ;
21709 int ecode2 = 0 ;
21710 PyObject * obj0 = 0 ;
21711 PyObject * obj1 = 0 ;
21712 char * kwnames[] = {
21713 (char *) "x",(char *) "y", NULL
21714 };
21715
21716 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) SWIG_fail;
21717 if (obj0) {
21718 ecode1 = SWIG_AsVal_int(obj0, &val1);
21719 if (!SWIG_IsOK(ecode1)) {
21720 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SetCursorEvent" "', expected argument " "1"" of type '" "int""'");
21721 }
21722 arg1 = static_cast< int >(val1);
21723 }
21724 if (obj1) {
21725 ecode2 = SWIG_AsVal_int(obj1, &val2);
21726 if (!SWIG_IsOK(ecode2)) {
21727 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SetCursorEvent" "', expected argument " "2"" of type '" "int""'");
21728 }
21729 arg2 = static_cast< int >(val2);
21730 }
21731 {
21732 PyThreadState* __tstate = wxPyBeginAllowThreads();
21733 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
21734 wxPyEndAllowThreads(__tstate);
21735 if (PyErr_Occurred()) SWIG_fail;
21736 }
21737 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_NEW | 0 );
21738 return resultobj;
21739 fail:
21740 return NULL;
21741 }
21742
21743
21744 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21745 PyObject *resultobj = 0;
21746 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21747 int result;
21748 void *argp1 = 0 ;
21749 int res1 = 0 ;
21750 PyObject *swig_obj[1] ;
21751
21752 if (!args) SWIG_fail;
21753 swig_obj[0] = args;
21754 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21755 if (!SWIG_IsOK(res1)) {
21756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetX" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21757 }
21758 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21759 {
21760 PyThreadState* __tstate = wxPyBeginAllowThreads();
21761 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
21762 wxPyEndAllowThreads(__tstate);
21763 if (PyErr_Occurred()) SWIG_fail;
21764 }
21765 resultobj = SWIG_From_int(static_cast< int >(result));
21766 return resultobj;
21767 fail:
21768 return NULL;
21769 }
21770
21771
21772 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21773 PyObject *resultobj = 0;
21774 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21775 int result;
21776 void *argp1 = 0 ;
21777 int res1 = 0 ;
21778 PyObject *swig_obj[1] ;
21779
21780 if (!args) SWIG_fail;
21781 swig_obj[0] = args;
21782 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21783 if (!SWIG_IsOK(res1)) {
21784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetY" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21785 }
21786 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21787 {
21788 PyThreadState* __tstate = wxPyBeginAllowThreads();
21789 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
21790 wxPyEndAllowThreads(__tstate);
21791 if (PyErr_Occurred()) SWIG_fail;
21792 }
21793 resultobj = SWIG_From_int(static_cast< int >(result));
21794 return resultobj;
21795 fail:
21796 return NULL;
21797 }
21798
21799
21800 SWIGINTERN PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21801 PyObject *resultobj = 0;
21802 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21803 wxCursor *arg2 = 0 ;
21804 void *argp1 = 0 ;
21805 int res1 = 0 ;
21806 void *argp2 = 0 ;
21807 int res2 = 0 ;
21808 PyObject * obj0 = 0 ;
21809 PyObject * obj1 = 0 ;
21810 char * kwnames[] = {
21811 (char *) "self",(char *) "cursor", NULL
21812 };
21813
21814 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
21815 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21816 if (!SWIG_IsOK(res1)) {
21817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent *""'");
21818 }
21819 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21820 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
21821 if (!SWIG_IsOK(res2)) {
21822 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
21823 }
21824 if (!argp2) {
21825 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
21826 }
21827 arg2 = reinterpret_cast< wxCursor * >(argp2);
21828 {
21829 PyThreadState* __tstate = wxPyBeginAllowThreads();
21830 (arg1)->SetCursor((wxCursor const &)*arg2);
21831 wxPyEndAllowThreads(__tstate);
21832 if (PyErr_Occurred()) SWIG_fail;
21833 }
21834 resultobj = SWIG_Py_Void();
21835 return resultobj;
21836 fail:
21837 return NULL;
21838 }
21839
21840
21841 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21842 PyObject *resultobj = 0;
21843 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21844 wxCursor *result = 0 ;
21845 void *argp1 = 0 ;
21846 int res1 = 0 ;
21847 PyObject *swig_obj[1] ;
21848
21849 if (!args) SWIG_fail;
21850 swig_obj[0] = args;
21851 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21852 if (!SWIG_IsOK(res1)) {
21853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21854 }
21855 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21856 {
21857 PyThreadState* __tstate = wxPyBeginAllowThreads();
21858 {
21859 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
21860 result = (wxCursor *) &_result_ref;
21861 }
21862 wxPyEndAllowThreads(__tstate);
21863 if (PyErr_Occurred()) SWIG_fail;
21864 }
21865 {
21866 wxCursor* resultptr = new wxCursor(*result);
21867 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
21868 }
21869 return resultobj;
21870 fail:
21871 return NULL;
21872 }
21873
21874
21875 SWIGINTERN PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21876 PyObject *resultobj = 0;
21877 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21878 bool result;
21879 void *argp1 = 0 ;
21880 int res1 = 0 ;
21881 PyObject *swig_obj[1] ;
21882
21883 if (!args) SWIG_fail;
21884 swig_obj[0] = args;
21885 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21886 if (!SWIG_IsOK(res1)) {
21887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_HasCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21888 }
21889 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21890 {
21891 PyThreadState* __tstate = wxPyBeginAllowThreads();
21892 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
21893 wxPyEndAllowThreads(__tstate);
21894 if (PyErr_Occurred()) SWIG_fail;
21895 }
21896 {
21897 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21898 }
21899 return resultobj;
21900 fail:
21901 return NULL;
21902 }
21903
21904
21905 SWIGINTERN PyObject *SetCursorEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21906 PyObject *obj;
21907 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21908 SWIG_TypeNewClientData(SWIGTYPE_p_wxSetCursorEvent, SWIG_NewClientData(obj));
21909 return SWIG_Py_Void();
21910 }
21911
21912 SWIGINTERN PyObject *SetCursorEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21913 return SWIG_Python_InitShadowInstance(args);
21914 }
21915
21916 SWIGINTERN PyObject *_wrap_new_KeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21917 PyObject *resultobj = 0;
21918 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21919 wxKeyEvent *result = 0 ;
21920 int val1 ;
21921 int ecode1 = 0 ;
21922 PyObject * obj0 = 0 ;
21923 char * kwnames[] = {
21924 (char *) "eventType", NULL
21925 };
21926
21927 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) SWIG_fail;
21928 if (obj0) {
21929 ecode1 = SWIG_AsVal_int(obj0, &val1);
21930 if (!SWIG_IsOK(ecode1)) {
21931 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_KeyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
21932 }
21933 arg1 = static_cast< wxEventType >(val1);
21934 }
21935 {
21936 PyThreadState* __tstate = wxPyBeginAllowThreads();
21937 result = (wxKeyEvent *)new wxKeyEvent(arg1);
21938 wxPyEndAllowThreads(__tstate);
21939 if (PyErr_Occurred()) SWIG_fail;
21940 }
21941 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_NEW | 0 );
21942 return resultobj;
21943 fail:
21944 return NULL;
21945 }
21946
21947
21948 SWIGINTERN PyObject *_wrap_KeyEvent_GetModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21949 PyObject *resultobj = 0;
21950 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21951 int result;
21952 void *argp1 = 0 ;
21953 int res1 = 0 ;
21954 PyObject *swig_obj[1] ;
21955
21956 if (!args) SWIG_fail;
21957 swig_obj[0] = args;
21958 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21959 if (!SWIG_IsOK(res1)) {
21960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21961 }
21962 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21963 {
21964 PyThreadState* __tstate = wxPyBeginAllowThreads();
21965 result = (int)((wxKeyEvent const *)arg1)->GetModifiers();
21966 wxPyEndAllowThreads(__tstate);
21967 if (PyErr_Occurred()) SWIG_fail;
21968 }
21969 resultobj = SWIG_From_int(static_cast< int >(result));
21970 return resultobj;
21971 fail:
21972 return NULL;
21973 }
21974
21975
21976 SWIGINTERN PyObject *_wrap_KeyEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21977 PyObject *resultobj = 0;
21978 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21979 bool result;
21980 void *argp1 = 0 ;
21981 int res1 = 0 ;
21982 PyObject *swig_obj[1] ;
21983
21984 if (!args) SWIG_fail;
21985 swig_obj[0] = args;
21986 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21987 if (!SWIG_IsOK(res1)) {
21988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ControlDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21989 }
21990 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21991 {
21992 PyThreadState* __tstate = wxPyBeginAllowThreads();
21993 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
21994 wxPyEndAllowThreads(__tstate);
21995 if (PyErr_Occurred()) SWIG_fail;
21996 }
21997 {
21998 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21999 }
22000 return resultobj;
22001 fail:
22002 return NULL;
22003 }
22004
22005
22006 SWIGINTERN PyObject *_wrap_KeyEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22007 PyObject *resultobj = 0;
22008 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22009 bool result;
22010 void *argp1 = 0 ;
22011 int res1 = 0 ;
22012 PyObject *swig_obj[1] ;
22013
22014 if (!args) SWIG_fail;
22015 swig_obj[0] = args;
22016 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22017 if (!SWIG_IsOK(res1)) {
22018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_MetaDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22019 }
22020 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22021 {
22022 PyThreadState* __tstate = wxPyBeginAllowThreads();
22023 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
22024 wxPyEndAllowThreads(__tstate);
22025 if (PyErr_Occurred()) SWIG_fail;
22026 }
22027 {
22028 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22029 }
22030 return resultobj;
22031 fail:
22032 return NULL;
22033 }
22034
22035
22036 SWIGINTERN PyObject *_wrap_KeyEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22037 PyObject *resultobj = 0;
22038 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22039 bool result;
22040 void *argp1 = 0 ;
22041 int res1 = 0 ;
22042 PyObject *swig_obj[1] ;
22043
22044 if (!args) SWIG_fail;
22045 swig_obj[0] = args;
22046 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22047 if (!SWIG_IsOK(res1)) {
22048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_AltDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22049 }
22050 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22051 {
22052 PyThreadState* __tstate = wxPyBeginAllowThreads();
22053 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
22054 wxPyEndAllowThreads(__tstate);
22055 if (PyErr_Occurred()) SWIG_fail;
22056 }
22057 {
22058 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22059 }
22060 return resultobj;
22061 fail:
22062 return NULL;
22063 }
22064
22065
22066 SWIGINTERN PyObject *_wrap_KeyEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22067 PyObject *resultobj = 0;
22068 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22069 bool result;
22070 void *argp1 = 0 ;
22071 int res1 = 0 ;
22072 PyObject *swig_obj[1] ;
22073
22074 if (!args) SWIG_fail;
22075 swig_obj[0] = args;
22076 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22077 if (!SWIG_IsOK(res1)) {
22078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ShiftDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22079 }
22080 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22081 {
22082 PyThreadState* __tstate = wxPyBeginAllowThreads();
22083 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
22084 wxPyEndAllowThreads(__tstate);
22085 if (PyErr_Occurred()) SWIG_fail;
22086 }
22087 {
22088 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22089 }
22090 return resultobj;
22091 fail:
22092 return NULL;
22093 }
22094
22095
22096 SWIGINTERN PyObject *_wrap_KeyEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22097 PyObject *resultobj = 0;
22098 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22099 bool result;
22100 void *argp1 = 0 ;
22101 int res1 = 0 ;
22102 PyObject *swig_obj[1] ;
22103
22104 if (!args) SWIG_fail;
22105 swig_obj[0] = args;
22106 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22107 if (!SWIG_IsOK(res1)) {
22108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_CmdDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22109 }
22110 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22111 {
22112 PyThreadState* __tstate = wxPyBeginAllowThreads();
22113 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
22114 wxPyEndAllowThreads(__tstate);
22115 if (PyErr_Occurred()) SWIG_fail;
22116 }
22117 {
22118 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22119 }
22120 return resultobj;
22121 fail:
22122 return NULL;
22123 }
22124
22125
22126 SWIGINTERN PyObject *_wrap_KeyEvent_HasModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22127 PyObject *resultobj = 0;
22128 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22129 bool result;
22130 void *argp1 = 0 ;
22131 int res1 = 0 ;
22132 PyObject *swig_obj[1] ;
22133
22134 if (!args) SWIG_fail;
22135 swig_obj[0] = args;
22136 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22137 if (!SWIG_IsOK(res1)) {
22138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_HasModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22139 }
22140 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22141 {
22142 PyThreadState* __tstate = wxPyBeginAllowThreads();
22143 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
22144 wxPyEndAllowThreads(__tstate);
22145 if (PyErr_Occurred()) SWIG_fail;
22146 }
22147 {
22148 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22149 }
22150 return resultobj;
22151 fail:
22152 return NULL;
22153 }
22154
22155
22156 SWIGINTERN PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22157 PyObject *resultobj = 0;
22158 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22159 int result;
22160 void *argp1 = 0 ;
22161 int res1 = 0 ;
22162 PyObject *swig_obj[1] ;
22163
22164 if (!args) SWIG_fail;
22165 swig_obj[0] = args;
22166 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22167 if (!SWIG_IsOK(res1)) {
22168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22169 }
22170 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22171 {
22172 PyThreadState* __tstate = wxPyBeginAllowThreads();
22173 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
22174 wxPyEndAllowThreads(__tstate);
22175 if (PyErr_Occurred()) SWIG_fail;
22176 }
22177 resultobj = SWIG_From_int(static_cast< int >(result));
22178 return resultobj;
22179 fail:
22180 return NULL;
22181 }
22182
22183
22184 SWIGINTERN PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22185 PyObject *resultobj = 0;
22186 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22187 int result;
22188 void *argp1 = 0 ;
22189 int res1 = 0 ;
22190 PyObject *swig_obj[1] ;
22191
22192 if (!args) SWIG_fail;
22193 swig_obj[0] = args;
22194 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22195 if (!SWIG_IsOK(res1)) {
22196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22197 }
22198 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22199 {
22200 PyThreadState* __tstate = wxPyBeginAllowThreads();
22201 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
22202 wxPyEndAllowThreads(__tstate);
22203 if (PyErr_Occurred()) SWIG_fail;
22204 }
22205 resultobj = SWIG_From_int(static_cast< int >(result));
22206 return resultobj;
22207 fail:
22208 return NULL;
22209 }
22210
22211
22212 SWIGINTERN PyObject *_wrap_KeyEvent_SetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22213 PyObject *resultobj = 0;
22214 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22215 int arg2 ;
22216 void *argp1 = 0 ;
22217 int res1 = 0 ;
22218 int val2 ;
22219 int ecode2 = 0 ;
22220 PyObject * obj0 = 0 ;
22221 PyObject * obj1 = 0 ;
22222 char * kwnames[] = {
22223 (char *) "self",(char *) "uniChar", NULL
22224 };
22225
22226 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_SetUnicodeKey",kwnames,&obj0,&obj1)) SWIG_fail;
22227 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22228 if (!SWIG_IsOK(res1)) {
22229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22230 }
22231 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22232 ecode2 = SWIG_AsVal_int(obj1, &val2);
22233 if (!SWIG_IsOK(ecode2)) {
22234 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "2"" of type '" "int""'");
22235 }
22236 arg2 = static_cast< int >(val2);
22237 {
22238 PyThreadState* __tstate = wxPyBeginAllowThreads();
22239 wxKeyEvent_SetUnicodeKey(arg1,arg2);
22240 wxPyEndAllowThreads(__tstate);
22241 if (PyErr_Occurred()) SWIG_fail;
22242 }
22243 resultobj = SWIG_Py_Void();
22244 return resultobj;
22245 fail:
22246 return NULL;
22247 }
22248
22249
22250 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22251 PyObject *resultobj = 0;
22252 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22253 unsigned int result;
22254 void *argp1 = 0 ;
22255 int res1 = 0 ;
22256 PyObject *swig_obj[1] ;
22257
22258 if (!args) SWIG_fail;
22259 swig_obj[0] = args;
22260 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22261 if (!SWIG_IsOK(res1)) {
22262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22263 }
22264 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22265 {
22266 PyThreadState* __tstate = wxPyBeginAllowThreads();
22267 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
22268 wxPyEndAllowThreads(__tstate);
22269 if (PyErr_Occurred()) SWIG_fail;
22270 }
22271 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22272 return resultobj;
22273 fail:
22274 return NULL;
22275 }
22276
22277
22278 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22279 PyObject *resultobj = 0;
22280 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22281 unsigned int result;
22282 void *argp1 = 0 ;
22283 int res1 = 0 ;
22284 PyObject *swig_obj[1] ;
22285
22286 if (!args) SWIG_fail;
22287 swig_obj[0] = args;
22288 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22289 if (!SWIG_IsOK(res1)) {
22290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyFlags" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22291 }
22292 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22293 {
22294 PyThreadState* __tstate = wxPyBeginAllowThreads();
22295 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
22296 wxPyEndAllowThreads(__tstate);
22297 if (PyErr_Occurred()) SWIG_fail;
22298 }
22299 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22300 return resultobj;
22301 fail:
22302 return NULL;
22303 }
22304
22305
22306 SWIGINTERN PyObject *_wrap_KeyEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22307 PyObject *resultobj = 0;
22308 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22309 wxPoint result;
22310 void *argp1 = 0 ;
22311 int res1 = 0 ;
22312 PyObject *swig_obj[1] ;
22313
22314 if (!args) SWIG_fail;
22315 swig_obj[0] = args;
22316 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22317 if (!SWIG_IsOK(res1)) {
22318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPosition" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22319 }
22320 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22321 {
22322 PyThreadState* __tstate = wxPyBeginAllowThreads();
22323 result = (arg1)->GetPosition();
22324 wxPyEndAllowThreads(__tstate);
22325 if (PyErr_Occurred()) SWIG_fail;
22326 }
22327 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
22328 return resultobj;
22329 fail:
22330 return NULL;
22331 }
22332
22333
22334 SWIGINTERN PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22335 PyObject *resultobj = 0;
22336 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22337 long *arg2 = (long *) 0 ;
22338 long *arg3 = (long *) 0 ;
22339 void *argp1 = 0 ;
22340 int res1 = 0 ;
22341 long temp2 ;
22342 int res2 = SWIG_TMPOBJ ;
22343 long temp3 ;
22344 int res3 = SWIG_TMPOBJ ;
22345 PyObject *swig_obj[1] ;
22346
22347 arg2 = &temp2;
22348 arg3 = &temp3;
22349 if (!args) SWIG_fail;
22350 swig_obj[0] = args;
22351 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22352 if (!SWIG_IsOK(res1)) {
22353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22354 }
22355 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22356 {
22357 PyThreadState* __tstate = wxPyBeginAllowThreads();
22358 (arg1)->GetPosition(arg2,arg3);
22359 wxPyEndAllowThreads(__tstate);
22360 if (PyErr_Occurred()) SWIG_fail;
22361 }
22362 resultobj = SWIG_Py_Void();
22363 if (SWIG_IsTmpObj(res2)) {
22364 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
22365 } else {
22366 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22367 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
22368 }
22369 if (SWIG_IsTmpObj(res3)) {
22370 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
22371 } else {
22372 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22373 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
22374 }
22375 return resultobj;
22376 fail:
22377 return NULL;
22378 }
22379
22380
22381 SWIGINTERN PyObject *_wrap_KeyEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22382 PyObject *resultobj = 0;
22383 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22384 int result;
22385 void *argp1 = 0 ;
22386 int res1 = 0 ;
22387 PyObject *swig_obj[1] ;
22388
22389 if (!args) SWIG_fail;
22390 swig_obj[0] = args;
22391 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22392 if (!SWIG_IsOK(res1)) {
22393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetX" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22394 }
22395 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22396 {
22397 PyThreadState* __tstate = wxPyBeginAllowThreads();
22398 result = (int)((wxKeyEvent const *)arg1)->GetX();
22399 wxPyEndAllowThreads(__tstate);
22400 if (PyErr_Occurred()) SWIG_fail;
22401 }
22402 resultobj = SWIG_From_int(static_cast< int >(result));
22403 return resultobj;
22404 fail:
22405 return NULL;
22406 }
22407
22408
22409 SWIGINTERN PyObject *_wrap_KeyEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22410 PyObject *resultobj = 0;
22411 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22412 int result;
22413 void *argp1 = 0 ;
22414 int res1 = 0 ;
22415 PyObject *swig_obj[1] ;
22416
22417 if (!args) SWIG_fail;
22418 swig_obj[0] = args;
22419 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22420 if (!SWIG_IsOK(res1)) {
22421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetY" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22422 }
22423 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22424 {
22425 PyThreadState* __tstate = wxPyBeginAllowThreads();
22426 result = (int)((wxKeyEvent const *)arg1)->GetY();
22427 wxPyEndAllowThreads(__tstate);
22428 if (PyErr_Occurred()) SWIG_fail;
22429 }
22430 resultobj = SWIG_From_int(static_cast< int >(result));
22431 return resultobj;
22432 fail:
22433 return NULL;
22434 }
22435
22436
22437 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22438 PyObject *resultobj = 0;
22439 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22440 int arg2 ;
22441 void *argp1 = 0 ;
22442 int res1 = 0 ;
22443 int val2 ;
22444 int ecode2 = 0 ;
22445 PyObject *swig_obj[2] ;
22446
22447 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
22448 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22449 if (!SWIG_IsOK(res1)) {
22450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22451 }
22452 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22453 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22454 if (!SWIG_IsOK(ecode2)) {
22455 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
22456 }
22457 arg2 = static_cast< int >(val2);
22458 if (arg1) (arg1)->m_x = arg2;
22459
22460 resultobj = SWIG_Py_Void();
22461 return resultobj;
22462 fail:
22463 return NULL;
22464 }
22465
22466
22467 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22468 PyObject *resultobj = 0;
22469 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22470 int result;
22471 void *argp1 = 0 ;
22472 int res1 = 0 ;
22473 PyObject *swig_obj[1] ;
22474
22475 if (!args) SWIG_fail;
22476 swig_obj[0] = args;
22477 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22478 if (!SWIG_IsOK(res1)) {
22479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22480 }
22481 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22482 result = (int) ((arg1)->m_x);
22483 resultobj = SWIG_From_int(static_cast< int >(result));
22484 return resultobj;
22485 fail:
22486 return NULL;
22487 }
22488
22489
22490 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22491 PyObject *resultobj = 0;
22492 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22493 int arg2 ;
22494 void *argp1 = 0 ;
22495 int res1 = 0 ;
22496 int val2 ;
22497 int ecode2 = 0 ;
22498 PyObject *swig_obj[2] ;
22499
22500 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
22501 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22502 if (!SWIG_IsOK(res1)) {
22503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22504 }
22505 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22506 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22507 if (!SWIG_IsOK(ecode2)) {
22508 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
22509 }
22510 arg2 = static_cast< int >(val2);
22511 if (arg1) (arg1)->m_y = arg2;
22512
22513 resultobj = SWIG_Py_Void();
22514 return resultobj;
22515 fail:
22516 return NULL;
22517 }
22518
22519
22520 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22521 PyObject *resultobj = 0;
22522 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22523 int result;
22524 void *argp1 = 0 ;
22525 int res1 = 0 ;
22526 PyObject *swig_obj[1] ;
22527
22528 if (!args) SWIG_fail;
22529 swig_obj[0] = args;
22530 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22531 if (!SWIG_IsOK(res1)) {
22532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22533 }
22534 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22535 result = (int) ((arg1)->m_y);
22536 resultobj = SWIG_From_int(static_cast< int >(result));
22537 return resultobj;
22538 fail:
22539 return NULL;
22540 }
22541
22542
22543 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22544 PyObject *resultobj = 0;
22545 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22546 long arg2 ;
22547 void *argp1 = 0 ;
22548 int res1 = 0 ;
22549 long val2 ;
22550 int ecode2 = 0 ;
22551 PyObject *swig_obj[2] ;
22552
22553 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_keyCode_set",2,2,swig_obj)) SWIG_fail;
22554 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22555 if (!SWIG_IsOK(res1)) {
22556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22557 }
22558 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22559 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
22560 if (!SWIG_IsOK(ecode2)) {
22561 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "2"" of type '" "long""'");
22562 }
22563 arg2 = static_cast< long >(val2);
22564 if (arg1) (arg1)->m_keyCode = arg2;
22565
22566 resultobj = SWIG_Py_Void();
22567 return resultobj;
22568 fail:
22569 return NULL;
22570 }
22571
22572
22573 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22574 PyObject *resultobj = 0;
22575 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22576 long result;
22577 void *argp1 = 0 ;
22578 int res1 = 0 ;
22579 PyObject *swig_obj[1] ;
22580
22581 if (!args) SWIG_fail;
22582 swig_obj[0] = args;
22583 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22584 if (!SWIG_IsOK(res1)) {
22585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22586 }
22587 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22588 result = (long) ((arg1)->m_keyCode);
22589 resultobj = SWIG_From_long(static_cast< long >(result));
22590 return resultobj;
22591 fail:
22592 return NULL;
22593 }
22594
22595
22596 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22597 PyObject *resultobj = 0;
22598 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22599 bool arg2 ;
22600 void *argp1 = 0 ;
22601 int res1 = 0 ;
22602 bool val2 ;
22603 int ecode2 = 0 ;
22604 PyObject *swig_obj[2] ;
22605
22606 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
22607 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22608 if (!SWIG_IsOK(res1)) {
22609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22610 }
22611 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22612 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22613 if (!SWIG_IsOK(ecode2)) {
22614 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
22615 }
22616 arg2 = static_cast< bool >(val2);
22617 if (arg1) (arg1)->m_controlDown = arg2;
22618
22619 resultobj = SWIG_Py_Void();
22620 return resultobj;
22621 fail:
22622 return NULL;
22623 }
22624
22625
22626 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22627 PyObject *resultobj = 0;
22628 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22629 bool result;
22630 void *argp1 = 0 ;
22631 int res1 = 0 ;
22632 PyObject *swig_obj[1] ;
22633
22634 if (!args) SWIG_fail;
22635 swig_obj[0] = args;
22636 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22637 if (!SWIG_IsOK(res1)) {
22638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22639 }
22640 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22641 result = (bool) ((arg1)->m_controlDown);
22642 {
22643 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22644 }
22645 return resultobj;
22646 fail:
22647 return NULL;
22648 }
22649
22650
22651 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22652 PyObject *resultobj = 0;
22653 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22654 bool arg2 ;
22655 void *argp1 = 0 ;
22656 int res1 = 0 ;
22657 bool val2 ;
22658 int ecode2 = 0 ;
22659 PyObject *swig_obj[2] ;
22660
22661 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
22662 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22663 if (!SWIG_IsOK(res1)) {
22664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22665 }
22666 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22667 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22668 if (!SWIG_IsOK(ecode2)) {
22669 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
22670 }
22671 arg2 = static_cast< bool >(val2);
22672 if (arg1) (arg1)->m_shiftDown = arg2;
22673
22674 resultobj = SWIG_Py_Void();
22675 return resultobj;
22676 fail:
22677 return NULL;
22678 }
22679
22680
22681 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22682 PyObject *resultobj = 0;
22683 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22684 bool result;
22685 void *argp1 = 0 ;
22686 int res1 = 0 ;
22687 PyObject *swig_obj[1] ;
22688
22689 if (!args) SWIG_fail;
22690 swig_obj[0] = args;
22691 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22692 if (!SWIG_IsOK(res1)) {
22693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22694 }
22695 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22696 result = (bool) ((arg1)->m_shiftDown);
22697 {
22698 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22699 }
22700 return resultobj;
22701 fail:
22702 return NULL;
22703 }
22704
22705
22706 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22707 PyObject *resultobj = 0;
22708 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22709 bool arg2 ;
22710 void *argp1 = 0 ;
22711 int res1 = 0 ;
22712 bool val2 ;
22713 int ecode2 = 0 ;
22714 PyObject *swig_obj[2] ;
22715
22716 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
22717 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22718 if (!SWIG_IsOK(res1)) {
22719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22720 }
22721 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22722 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22723 if (!SWIG_IsOK(ecode2)) {
22724 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
22725 }
22726 arg2 = static_cast< bool >(val2);
22727 if (arg1) (arg1)->m_altDown = arg2;
22728
22729 resultobj = SWIG_Py_Void();
22730 return resultobj;
22731 fail:
22732 return NULL;
22733 }
22734
22735
22736 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22737 PyObject *resultobj = 0;
22738 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22739 bool result;
22740 void *argp1 = 0 ;
22741 int res1 = 0 ;
22742 PyObject *swig_obj[1] ;
22743
22744 if (!args) SWIG_fail;
22745 swig_obj[0] = args;
22746 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22747 if (!SWIG_IsOK(res1)) {
22748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22749 }
22750 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22751 result = (bool) ((arg1)->m_altDown);
22752 {
22753 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22754 }
22755 return resultobj;
22756 fail:
22757 return NULL;
22758 }
22759
22760
22761 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22762 PyObject *resultobj = 0;
22763 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22764 bool arg2 ;
22765 void *argp1 = 0 ;
22766 int res1 = 0 ;
22767 bool val2 ;
22768 int ecode2 = 0 ;
22769 PyObject *swig_obj[2] ;
22770
22771 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
22772 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22773 if (!SWIG_IsOK(res1)) {
22774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22775 }
22776 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22777 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22778 if (!SWIG_IsOK(ecode2)) {
22779 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
22780 }
22781 arg2 = static_cast< bool >(val2);
22782 if (arg1) (arg1)->m_metaDown = arg2;
22783
22784 resultobj = SWIG_Py_Void();
22785 return resultobj;
22786 fail:
22787 return NULL;
22788 }
22789
22790
22791 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22792 PyObject *resultobj = 0;
22793 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22794 bool result;
22795 void *argp1 = 0 ;
22796 int res1 = 0 ;
22797 PyObject *swig_obj[1] ;
22798
22799 if (!args) SWIG_fail;
22800 swig_obj[0] = args;
22801 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22802 if (!SWIG_IsOK(res1)) {
22803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22804 }
22805 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22806 result = (bool) ((arg1)->m_metaDown);
22807 {
22808 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22809 }
22810 return resultobj;
22811 fail:
22812 return NULL;
22813 }
22814
22815
22816 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22817 PyObject *resultobj = 0;
22818 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22819 bool arg2 ;
22820 void *argp1 = 0 ;
22821 int res1 = 0 ;
22822 bool val2 ;
22823 int ecode2 = 0 ;
22824 PyObject *swig_obj[2] ;
22825
22826 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_scanCode_set",2,2,swig_obj)) SWIG_fail;
22827 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22828 if (!SWIG_IsOK(res1)) {
22829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22830 }
22831 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22832 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22833 if (!SWIG_IsOK(ecode2)) {
22834 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "2"" of type '" "bool""'");
22835 }
22836 arg2 = static_cast< bool >(val2);
22837 if (arg1) (arg1)->m_scanCode = arg2;
22838
22839 resultobj = SWIG_Py_Void();
22840 return resultobj;
22841 fail:
22842 return NULL;
22843 }
22844
22845
22846 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22847 PyObject *resultobj = 0;
22848 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22849 bool result;
22850 void *argp1 = 0 ;
22851 int res1 = 0 ;
22852 PyObject *swig_obj[1] ;
22853
22854 if (!args) SWIG_fail;
22855 swig_obj[0] = args;
22856 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22857 if (!SWIG_IsOK(res1)) {
22858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22859 }
22860 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22861 result = (bool) ((arg1)->m_scanCode);
22862 {
22863 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22864 }
22865 return resultobj;
22866 fail:
22867 return NULL;
22868 }
22869
22870
22871 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22872 PyObject *resultobj = 0;
22873 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22874 unsigned int arg2 ;
22875 void *argp1 = 0 ;
22876 int res1 = 0 ;
22877 unsigned int val2 ;
22878 int ecode2 = 0 ;
22879 PyObject *swig_obj[2] ;
22880
22881 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawCode_set",2,2,swig_obj)) SWIG_fail;
22882 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22883 if (!SWIG_IsOK(res1)) {
22884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22885 }
22886 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22887 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
22888 if (!SWIG_IsOK(ecode2)) {
22889 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "2"" of type '" "unsigned int""'");
22890 }
22891 arg2 = static_cast< unsigned int >(val2);
22892 if (arg1) (arg1)->m_rawCode = arg2;
22893
22894 resultobj = SWIG_Py_Void();
22895 return resultobj;
22896 fail:
22897 return NULL;
22898 }
22899
22900
22901 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22902 PyObject *resultobj = 0;
22903 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22904 unsigned int result;
22905 void *argp1 = 0 ;
22906 int res1 = 0 ;
22907 PyObject *swig_obj[1] ;
22908
22909 if (!args) SWIG_fail;
22910 swig_obj[0] = args;
22911 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22912 if (!SWIG_IsOK(res1)) {
22913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22914 }
22915 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22916 result = (unsigned int) ((arg1)->m_rawCode);
22917 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22918 return resultobj;
22919 fail:
22920 return NULL;
22921 }
22922
22923
22924 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22925 PyObject *resultobj = 0;
22926 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22927 unsigned int arg2 ;
22928 void *argp1 = 0 ;
22929 int res1 = 0 ;
22930 unsigned int val2 ;
22931 int ecode2 = 0 ;
22932 PyObject *swig_obj[2] ;
22933
22934 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawFlags_set",2,2,swig_obj)) SWIG_fail;
22935 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22936 if (!SWIG_IsOK(res1)) {
22937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22938 }
22939 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22940 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
22941 if (!SWIG_IsOK(ecode2)) {
22942 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "2"" of type '" "unsigned int""'");
22943 }
22944 arg2 = static_cast< unsigned int >(val2);
22945 if (arg1) (arg1)->m_rawFlags = arg2;
22946
22947 resultobj = SWIG_Py_Void();
22948 return resultobj;
22949 fail:
22950 return NULL;
22951 }
22952
22953
22954 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22955 PyObject *resultobj = 0;
22956 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22957 unsigned int result;
22958 void *argp1 = 0 ;
22959 int res1 = 0 ;
22960 PyObject *swig_obj[1] ;
22961
22962 if (!args) SWIG_fail;
22963 swig_obj[0] = args;
22964 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22965 if (!SWIG_IsOK(res1)) {
22966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22967 }
22968 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22969 result = (unsigned int) ((arg1)->m_rawFlags);
22970 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22971 return resultobj;
22972 fail:
22973 return NULL;
22974 }
22975
22976
22977 SWIGINTERN PyObject *KeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22978 PyObject *obj;
22979 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22980 SWIG_TypeNewClientData(SWIGTYPE_p_wxKeyEvent, SWIG_NewClientData(obj));
22981 return SWIG_Py_Void();
22982 }
22983
22984 SWIGINTERN PyObject *KeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22985 return SWIG_Python_InitShadowInstance(args);
22986 }
22987
22988 SWIGINTERN PyObject *_wrap_new_SizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22989 PyObject *resultobj = 0;
22990 wxSize const &arg1_defvalue = wxDefaultSize ;
22991 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
22992 int arg2 = (int) 0 ;
22993 wxSizeEvent *result = 0 ;
22994 wxSize temp1 ;
22995 int val2 ;
22996 int ecode2 = 0 ;
22997 PyObject * obj0 = 0 ;
22998 PyObject * obj1 = 0 ;
22999 char * kwnames[] = {
23000 (char *) "sz",(char *) "winid", NULL
23001 };
23002
23003 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23004 if (obj0) {
23005 {
23006 arg1 = &temp1;
23007 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
23008 }
23009 }
23010 if (obj1) {
23011 ecode2 = SWIG_AsVal_int(obj1, &val2);
23012 if (!SWIG_IsOK(ecode2)) {
23013 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizeEvent" "', expected argument " "2"" of type '" "int""'");
23014 }
23015 arg2 = static_cast< int >(val2);
23016 }
23017 {
23018 PyThreadState* __tstate = wxPyBeginAllowThreads();
23019 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
23020 wxPyEndAllowThreads(__tstate);
23021 if (PyErr_Occurred()) SWIG_fail;
23022 }
23023 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_NEW | 0 );
23024 return resultobj;
23025 fail:
23026 return NULL;
23027 }
23028
23029
23030 SWIGINTERN PyObject *_wrap_SizeEvent_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23031 PyObject *resultobj = 0;
23032 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23033 wxSize result;
23034 void *argp1 = 0 ;
23035 int res1 = 0 ;
23036 PyObject *swig_obj[1] ;
23037
23038 if (!args) SWIG_fail;
23039 swig_obj[0] = args;
23040 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23041 if (!SWIG_IsOK(res1)) {
23042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetSize" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
23043 }
23044 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23045 {
23046 PyThreadState* __tstate = wxPyBeginAllowThreads();
23047 result = ((wxSizeEvent const *)arg1)->GetSize();
23048 wxPyEndAllowThreads(__tstate);
23049 if (PyErr_Occurred()) SWIG_fail;
23050 }
23051 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
23052 return resultobj;
23053 fail:
23054 return NULL;
23055 }
23056
23057
23058 SWIGINTERN PyObject *_wrap_SizeEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23059 PyObject *resultobj = 0;
23060 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23061 wxRect result;
23062 void *argp1 = 0 ;
23063 int res1 = 0 ;
23064 PyObject *swig_obj[1] ;
23065
23066 if (!args) SWIG_fail;
23067 swig_obj[0] = args;
23068 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23069 if (!SWIG_IsOK(res1)) {
23070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetRect" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
23071 }
23072 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23073 {
23074 PyThreadState* __tstate = wxPyBeginAllowThreads();
23075 result = ((wxSizeEvent const *)arg1)->GetRect();
23076 wxPyEndAllowThreads(__tstate);
23077 if (PyErr_Occurred()) SWIG_fail;
23078 }
23079 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
23080 return resultobj;
23081 fail:
23082 return NULL;
23083 }
23084
23085
23086 SWIGINTERN PyObject *_wrap_SizeEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23087 PyObject *resultobj = 0;
23088 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23089 wxRect arg2 ;
23090 void *argp1 = 0 ;
23091 int res1 = 0 ;
23092 void *argp2 ;
23093 int res2 = 0 ;
23094 PyObject * obj0 = 0 ;
23095 PyObject * obj1 = 0 ;
23096 char * kwnames[] = {
23097 (char *) "self",(char *) "rect", NULL
23098 };
23099
23100 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
23101 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23102 if (!SWIG_IsOK(res1)) {
23103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetRect" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23104 }
23105 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23106 {
23107 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRect, 0 | 0);
23108 if (!SWIG_IsOK(res2)) {
23109 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
23110 }
23111 if (!argp2) {
23112 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
23113 } else {
23114 wxRect * temp = reinterpret_cast< wxRect * >(argp2);
23115 arg2 = *temp;
23116 if (SWIG_IsNewObj(res2)) delete temp;
23117 }
23118 }
23119 {
23120 PyThreadState* __tstate = wxPyBeginAllowThreads();
23121 (arg1)->SetRect(arg2);
23122 wxPyEndAllowThreads(__tstate);
23123 if (PyErr_Occurred()) SWIG_fail;
23124 }
23125 resultobj = SWIG_Py_Void();
23126 return resultobj;
23127 fail:
23128 return NULL;
23129 }
23130
23131
23132 SWIGINTERN PyObject *_wrap_SizeEvent_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23133 PyObject *resultobj = 0;
23134 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23135 wxSize arg2 ;
23136 void *argp1 = 0 ;
23137 int res1 = 0 ;
23138 void *argp2 ;
23139 int res2 = 0 ;
23140 PyObject * obj0 = 0 ;
23141 PyObject * obj1 = 0 ;
23142 char * kwnames[] = {
23143 (char *) "self",(char *) "size", NULL
23144 };
23145
23146 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
23147 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23148 if (!SWIG_IsOK(res1)) {
23149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetSize" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23150 }
23151 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23152 {
23153 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxSize, 0 | 0);
23154 if (!SWIG_IsOK(res2)) {
23155 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23156 }
23157 if (!argp2) {
23158 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23159 } else {
23160 wxSize * temp = reinterpret_cast< wxSize * >(argp2);
23161 arg2 = *temp;
23162 if (SWIG_IsNewObj(res2)) delete temp;
23163 }
23164 }
23165 {
23166 PyThreadState* __tstate = wxPyBeginAllowThreads();
23167 wxSizeEvent_SetSize(arg1,arg2);
23168 wxPyEndAllowThreads(__tstate);
23169 if (PyErr_Occurred()) SWIG_fail;
23170 }
23171 resultobj = SWIG_Py_Void();
23172 return resultobj;
23173 fail:
23174 return NULL;
23175 }
23176
23177
23178 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23179 PyObject *resultobj = 0;
23180 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23181 wxSize *arg2 = (wxSize *) 0 ;
23182 void *argp1 = 0 ;
23183 int res1 = 0 ;
23184 void *argp2 = 0 ;
23185 int res2 = 0 ;
23186 PyObject *swig_obj[2] ;
23187
23188 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_size_set",2,2,swig_obj)) SWIG_fail;
23189 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23190 if (!SWIG_IsOK(res1)) {
23191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23192 }
23193 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23194 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSize, 0 | 0 );
23195 if (!SWIG_IsOK(res2)) {
23196 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_size_set" "', expected argument " "2"" of type '" "wxSize *""'");
23197 }
23198 arg2 = reinterpret_cast< wxSize * >(argp2);
23199 if (arg1) (arg1)->m_size = *arg2;
23200
23201 resultobj = SWIG_Py_Void();
23202 return resultobj;
23203 fail:
23204 return NULL;
23205 }
23206
23207
23208 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23209 PyObject *resultobj = 0;
23210 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23211 wxSize *result = 0 ;
23212 void *argp1 = 0 ;
23213 int res1 = 0 ;
23214 PyObject *swig_obj[1] ;
23215
23216 if (!args) SWIG_fail;
23217 swig_obj[0] = args;
23218 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23219 if (!SWIG_IsOK(res1)) {
23220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23221 }
23222 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23223 result = (wxSize *)& ((arg1)->m_size);
23224 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
23225 return resultobj;
23226 fail:
23227 return NULL;
23228 }
23229
23230
23231 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23232 PyObject *resultobj = 0;
23233 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23234 wxRect *arg2 = (wxRect *) 0 ;
23235 void *argp1 = 0 ;
23236 int res1 = 0 ;
23237 void *argp2 = 0 ;
23238 int res2 = 0 ;
23239 PyObject *swig_obj[2] ;
23240
23241 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_rect_set",2,2,swig_obj)) SWIG_fail;
23242 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23243 if (!SWIG_IsOK(res1)) {
23244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23245 }
23246 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23247 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
23248 if (!SWIG_IsOK(res2)) {
23249 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_rect_set" "', expected argument " "2"" of type '" "wxRect *""'");
23250 }
23251 arg2 = reinterpret_cast< wxRect * >(argp2);
23252 if (arg1) (arg1)->m_rect = *arg2;
23253
23254 resultobj = SWIG_Py_Void();
23255 return resultobj;
23256 fail:
23257 return NULL;
23258 }
23259
23260
23261 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23262 PyObject *resultobj = 0;
23263 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23264 wxRect *result = 0 ;
23265 void *argp1 = 0 ;
23266 int res1 = 0 ;
23267 PyObject *swig_obj[1] ;
23268
23269 if (!args) SWIG_fail;
23270 swig_obj[0] = args;
23271 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23272 if (!SWIG_IsOK(res1)) {
23273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23274 }
23275 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23276 result = (wxRect *)& ((arg1)->m_rect);
23277 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
23278 return resultobj;
23279 fail:
23280 return NULL;
23281 }
23282
23283
23284 SWIGINTERN PyObject *SizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23285 PyObject *obj;
23286 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23287 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizeEvent, SWIG_NewClientData(obj));
23288 return SWIG_Py_Void();
23289 }
23290
23291 SWIGINTERN PyObject *SizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23292 return SWIG_Python_InitShadowInstance(args);
23293 }
23294
23295 SWIGINTERN PyObject *_wrap_new_MoveEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23296 PyObject *resultobj = 0;
23297 wxPoint const &arg1_defvalue = wxDefaultPosition ;
23298 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
23299 int arg2 = (int) 0 ;
23300 wxMoveEvent *result = 0 ;
23301 wxPoint temp1 ;
23302 int val2 ;
23303 int ecode2 = 0 ;
23304 PyObject * obj0 = 0 ;
23305 PyObject * obj1 = 0 ;
23306 char * kwnames[] = {
23307 (char *) "pos",(char *) "winid", NULL
23308 };
23309
23310 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23311 if (obj0) {
23312 {
23313 arg1 = &temp1;
23314 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
23315 }
23316 }
23317 if (obj1) {
23318 ecode2 = SWIG_AsVal_int(obj1, &val2);
23319 if (!SWIG_IsOK(ecode2)) {
23320 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MoveEvent" "', expected argument " "2"" of type '" "int""'");
23321 }
23322 arg2 = static_cast< int >(val2);
23323 }
23324 {
23325 PyThreadState* __tstate = wxPyBeginAllowThreads();
23326 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
23327 wxPyEndAllowThreads(__tstate);
23328 if (PyErr_Occurred()) SWIG_fail;
23329 }
23330 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_NEW | 0 );
23331 return resultobj;
23332 fail:
23333 return NULL;
23334 }
23335
23336
23337 SWIGINTERN PyObject *_wrap_MoveEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23338 PyObject *resultobj = 0;
23339 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23340 wxPoint result;
23341 void *argp1 = 0 ;
23342 int res1 = 0 ;
23343 PyObject *swig_obj[1] ;
23344
23345 if (!args) SWIG_fail;
23346 swig_obj[0] = args;
23347 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23348 if (!SWIG_IsOK(res1)) {
23349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetPosition" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23350 }
23351 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23352 {
23353 PyThreadState* __tstate = wxPyBeginAllowThreads();
23354 result = ((wxMoveEvent const *)arg1)->GetPosition();
23355 wxPyEndAllowThreads(__tstate);
23356 if (PyErr_Occurred()) SWIG_fail;
23357 }
23358 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23359 return resultobj;
23360 fail:
23361 return NULL;
23362 }
23363
23364
23365 SWIGINTERN PyObject *_wrap_MoveEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23366 PyObject *resultobj = 0;
23367 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23368 wxRect result;
23369 void *argp1 = 0 ;
23370 int res1 = 0 ;
23371 PyObject *swig_obj[1] ;
23372
23373 if (!args) SWIG_fail;
23374 swig_obj[0] = args;
23375 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23376 if (!SWIG_IsOK(res1)) {
23377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetRect" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23378 }
23379 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23380 {
23381 PyThreadState* __tstate = wxPyBeginAllowThreads();
23382 result = ((wxMoveEvent const *)arg1)->GetRect();
23383 wxPyEndAllowThreads(__tstate);
23384 if (PyErr_Occurred()) SWIG_fail;
23385 }
23386 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
23387 return resultobj;
23388 fail:
23389 return NULL;
23390 }
23391
23392
23393 SWIGINTERN PyObject *_wrap_MoveEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23394 PyObject *resultobj = 0;
23395 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23396 wxRect *arg2 = 0 ;
23397 void *argp1 = 0 ;
23398 int res1 = 0 ;
23399 wxRect temp2 ;
23400 PyObject * obj0 = 0 ;
23401 PyObject * obj1 = 0 ;
23402 char * kwnames[] = {
23403 (char *) "self",(char *) "rect", NULL
23404 };
23405
23406 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
23407 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23408 if (!SWIG_IsOK(res1)) {
23409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetRect" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23410 }
23411 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23412 {
23413 arg2 = &temp2;
23414 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
23415 }
23416 {
23417 PyThreadState* __tstate = wxPyBeginAllowThreads();
23418 (arg1)->SetRect((wxRect const &)*arg2);
23419 wxPyEndAllowThreads(__tstate);
23420 if (PyErr_Occurred()) SWIG_fail;
23421 }
23422 resultobj = SWIG_Py_Void();
23423 return resultobj;
23424 fail:
23425 return NULL;
23426 }
23427
23428
23429 SWIGINTERN PyObject *_wrap_MoveEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23430 PyObject *resultobj = 0;
23431 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23432 wxPoint *arg2 = 0 ;
23433 void *argp1 = 0 ;
23434 int res1 = 0 ;
23435 wxPoint temp2 ;
23436 PyObject * obj0 = 0 ;
23437 PyObject * obj1 = 0 ;
23438 char * kwnames[] = {
23439 (char *) "self",(char *) "pos", NULL
23440 };
23441
23442 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",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_SetPosition" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23446 }
23447 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23448 {
23449 arg2 = &temp2;
23450 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
23451 }
23452 {
23453 PyThreadState* __tstate = wxPyBeginAllowThreads();
23454 (arg1)->SetPosition((wxPoint 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 *MoveEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23466 PyObject *obj;
23467 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23468 SWIG_TypeNewClientData(SWIGTYPE_p_wxMoveEvent, SWIG_NewClientData(obj));
23469 return SWIG_Py_Void();
23470 }
23471
23472 SWIGINTERN PyObject *MoveEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23473 return SWIG_Python_InitShadowInstance(args);
23474 }
23475
23476 SWIGINTERN PyObject *_wrap_new_PaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23477 PyObject *resultobj = 0;
23478 int arg1 = (int) 0 ;
23479 wxPaintEvent *result = 0 ;
23480 int val1 ;
23481 int ecode1 = 0 ;
23482 PyObject * obj0 = 0 ;
23483 char * kwnames[] = {
23484 (char *) "Id", NULL
23485 };
23486
23487 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) SWIG_fail;
23488 if (obj0) {
23489 ecode1 = SWIG_AsVal_int(obj0, &val1);
23490 if (!SWIG_IsOK(ecode1)) {
23491 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaintEvent" "', expected argument " "1"" of type '" "int""'");
23492 }
23493 arg1 = static_cast< int >(val1);
23494 }
23495 {
23496 PyThreadState* __tstate = wxPyBeginAllowThreads();
23497 result = (wxPaintEvent *)new wxPaintEvent(arg1);
23498 wxPyEndAllowThreads(__tstate);
23499 if (PyErr_Occurred()) SWIG_fail;
23500 }
23501 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_NEW | 0 );
23502 return resultobj;
23503 fail:
23504 return NULL;
23505 }
23506
23507
23508 SWIGINTERN PyObject *PaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23509 PyObject *obj;
23510 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23511 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaintEvent, SWIG_NewClientData(obj));
23512 return SWIG_Py_Void();
23513 }
23514
23515 SWIGINTERN PyObject *PaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23516 return SWIG_Python_InitShadowInstance(args);
23517 }
23518
23519 SWIGINTERN PyObject *_wrap_new_NcPaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23520 PyObject *resultobj = 0;
23521 int arg1 = (int) 0 ;
23522 wxNcPaintEvent *result = 0 ;
23523 int val1 ;
23524 int ecode1 = 0 ;
23525 PyObject * obj0 = 0 ;
23526 char * kwnames[] = {
23527 (char *) "winid", NULL
23528 };
23529
23530 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) SWIG_fail;
23531 if (obj0) {
23532 ecode1 = SWIG_AsVal_int(obj0, &val1);
23533 if (!SWIG_IsOK(ecode1)) {
23534 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NcPaintEvent" "', expected argument " "1"" of type '" "int""'");
23535 }
23536 arg1 = static_cast< int >(val1);
23537 }
23538 {
23539 PyThreadState* __tstate = wxPyBeginAllowThreads();
23540 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
23541 wxPyEndAllowThreads(__tstate);
23542 if (PyErr_Occurred()) SWIG_fail;
23543 }
23544 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNcPaintEvent, SWIG_POINTER_NEW | 0 );
23545 return resultobj;
23546 fail:
23547 return NULL;
23548 }
23549
23550
23551 SWIGINTERN PyObject *NcPaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23552 PyObject *obj;
23553 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23554 SWIG_TypeNewClientData(SWIGTYPE_p_wxNcPaintEvent, SWIG_NewClientData(obj));
23555 return SWIG_Py_Void();
23556 }
23557
23558 SWIGINTERN PyObject *NcPaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23559 return SWIG_Python_InitShadowInstance(args);
23560 }
23561
23562 SWIGINTERN PyObject *_wrap_new_EraseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23563 PyObject *resultobj = 0;
23564 int arg1 = (int) 0 ;
23565 wxDC *arg2 = (wxDC *) NULL ;
23566 wxEraseEvent *result = 0 ;
23567 int val1 ;
23568 int ecode1 = 0 ;
23569 void *argp2 = 0 ;
23570 int res2 = 0 ;
23571 PyObject * obj0 = 0 ;
23572 PyObject * obj1 = 0 ;
23573 char * kwnames[] = {
23574 (char *) "Id",(char *) "dc", NULL
23575 };
23576
23577 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23578 if (obj0) {
23579 ecode1 = SWIG_AsVal_int(obj0, &val1);
23580 if (!SWIG_IsOK(ecode1)) {
23581 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EraseEvent" "', expected argument " "1"" of type '" "int""'");
23582 }
23583 arg1 = static_cast< int >(val1);
23584 }
23585 if (obj1) {
23586 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDC, 0 | 0 );
23587 if (!SWIG_IsOK(res2)) {
23588 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EraseEvent" "', expected argument " "2"" of type '" "wxDC *""'");
23589 }
23590 arg2 = reinterpret_cast< wxDC * >(argp2);
23591 }
23592 {
23593 PyThreadState* __tstate = wxPyBeginAllowThreads();
23594 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
23595 wxPyEndAllowThreads(__tstate);
23596 if (PyErr_Occurred()) SWIG_fail;
23597 }
23598 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_NEW | 0 );
23599 return resultobj;
23600 fail:
23601 return NULL;
23602 }
23603
23604
23605 SWIGINTERN PyObject *_wrap_EraseEvent_GetDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23606 PyObject *resultobj = 0;
23607 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
23608 wxDC *result = 0 ;
23609 void *argp1 = 0 ;
23610 int res1 = 0 ;
23611 PyObject *swig_obj[1] ;
23612
23613 if (!args) SWIG_fail;
23614 swig_obj[0] = args;
23615 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEraseEvent, 0 | 0 );
23616 if (!SWIG_IsOK(res1)) {
23617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EraseEvent_GetDC" "', expected argument " "1"" of type '" "wxEraseEvent const *""'");
23618 }
23619 arg1 = reinterpret_cast< wxEraseEvent * >(argp1);
23620 {
23621 PyThreadState* __tstate = wxPyBeginAllowThreads();
23622 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
23623 wxPyEndAllowThreads(__tstate);
23624 if (PyErr_Occurred()) SWIG_fail;
23625 }
23626 {
23627 resultobj = wxPyMake_wxObject(result, (bool)0);
23628 }
23629 return resultobj;
23630 fail:
23631 return NULL;
23632 }
23633
23634
23635 SWIGINTERN PyObject *EraseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23636 PyObject *obj;
23637 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23638 SWIG_TypeNewClientData(SWIGTYPE_p_wxEraseEvent, SWIG_NewClientData(obj));
23639 return SWIG_Py_Void();
23640 }
23641
23642 SWIGINTERN PyObject *EraseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23643 return SWIG_Python_InitShadowInstance(args);
23644 }
23645
23646 SWIGINTERN PyObject *_wrap_new_FocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23647 PyObject *resultobj = 0;
23648 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23649 int arg2 = (int) 0 ;
23650 wxFocusEvent *result = 0 ;
23651 int val1 ;
23652 int ecode1 = 0 ;
23653 int val2 ;
23654 int ecode2 = 0 ;
23655 PyObject * obj0 = 0 ;
23656 PyObject * obj1 = 0 ;
23657 char * kwnames[] = {
23658 (char *) "type",(char *) "winid", NULL
23659 };
23660
23661 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23662 if (obj0) {
23663 ecode1 = SWIG_AsVal_int(obj0, &val1);
23664 if (!SWIG_IsOK(ecode1)) {
23665 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FocusEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23666 }
23667 arg1 = static_cast< wxEventType >(val1);
23668 }
23669 if (obj1) {
23670 ecode2 = SWIG_AsVal_int(obj1, &val2);
23671 if (!SWIG_IsOK(ecode2)) {
23672 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FocusEvent" "', expected argument " "2"" of type '" "int""'");
23673 }
23674 arg2 = static_cast< int >(val2);
23675 }
23676 {
23677 PyThreadState* __tstate = wxPyBeginAllowThreads();
23678 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
23679 wxPyEndAllowThreads(__tstate);
23680 if (PyErr_Occurred()) SWIG_fail;
23681 }
23682 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_NEW | 0 );
23683 return resultobj;
23684 fail:
23685 return NULL;
23686 }
23687
23688
23689 SWIGINTERN PyObject *_wrap_FocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23690 PyObject *resultobj = 0;
23691 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
23692 wxWindow *result = 0 ;
23693 void *argp1 = 0 ;
23694 int res1 = 0 ;
23695 PyObject *swig_obj[1] ;
23696
23697 if (!args) SWIG_fail;
23698 swig_obj[0] = args;
23699 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
23700 if (!SWIG_IsOK(res1)) {
23701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxFocusEvent const *""'");
23702 }
23703 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
23704 {
23705 PyThreadState* __tstate = wxPyBeginAllowThreads();
23706 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
23707 wxPyEndAllowThreads(__tstate);
23708 if (PyErr_Occurred()) SWIG_fail;
23709 }
23710 {
23711 resultobj = wxPyMake_wxObject(result, (bool)0);
23712 }
23713 return resultobj;
23714 fail:
23715 return NULL;
23716 }
23717
23718
23719 SWIGINTERN PyObject *_wrap_FocusEvent_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23720 PyObject *resultobj = 0;
23721 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
23722 wxWindow *arg2 = (wxWindow *) 0 ;
23723 void *argp1 = 0 ;
23724 int res1 = 0 ;
23725 void *argp2 = 0 ;
23726 int res2 = 0 ;
23727 PyObject * obj0 = 0 ;
23728 PyObject * obj1 = 0 ;
23729 char * kwnames[] = {
23730 (char *) "self",(char *) "win", NULL
23731 };
23732
23733 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
23734 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
23735 if (!SWIG_IsOK(res1)) {
23736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_SetWindow" "', expected argument " "1"" of type '" "wxFocusEvent *""'");
23737 }
23738 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
23739 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
23740 if (!SWIG_IsOK(res2)) {
23741 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FocusEvent_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
23742 }
23743 arg2 = reinterpret_cast< wxWindow * >(argp2);
23744 {
23745 PyThreadState* __tstate = wxPyBeginAllowThreads();
23746 (arg1)->SetWindow(arg2);
23747 wxPyEndAllowThreads(__tstate);
23748 if (PyErr_Occurred()) SWIG_fail;
23749 }
23750 resultobj = SWIG_Py_Void();
23751 return resultobj;
23752 fail:
23753 return NULL;
23754 }
23755
23756
23757 SWIGINTERN PyObject *FocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23758 PyObject *obj;
23759 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23760 SWIG_TypeNewClientData(SWIGTYPE_p_wxFocusEvent, SWIG_NewClientData(obj));
23761 return SWIG_Py_Void();
23762 }
23763
23764 SWIGINTERN PyObject *FocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23765 return SWIG_Python_InitShadowInstance(args);
23766 }
23767
23768 SWIGINTERN PyObject *_wrap_new_ChildFocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23769 PyObject *resultobj = 0;
23770 wxWindow *arg1 = (wxWindow *) NULL ;
23771 wxChildFocusEvent *result = 0 ;
23772 void *argp1 = 0 ;
23773 int res1 = 0 ;
23774 PyObject * obj0 = 0 ;
23775 char * kwnames[] = {
23776 (char *) "win", NULL
23777 };
23778
23779 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) SWIG_fail;
23780 if (obj0) {
23781 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
23782 if (!SWIG_IsOK(res1)) {
23783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ChildFocusEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
23784 }
23785 arg1 = reinterpret_cast< wxWindow * >(argp1);
23786 }
23787 {
23788 PyThreadState* __tstate = wxPyBeginAllowThreads();
23789 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
23790 wxPyEndAllowThreads(__tstate);
23791 if (PyErr_Occurred()) SWIG_fail;
23792 }
23793 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_NEW | 0 );
23794 return resultobj;
23795 fail:
23796 return NULL;
23797 }
23798
23799
23800 SWIGINTERN PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23801 PyObject *resultobj = 0;
23802 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
23803 wxWindow *result = 0 ;
23804 void *argp1 = 0 ;
23805 int res1 = 0 ;
23806 PyObject *swig_obj[1] ;
23807
23808 if (!args) SWIG_fail;
23809 swig_obj[0] = args;
23810 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxChildFocusEvent, 0 | 0 );
23811 if (!SWIG_IsOK(res1)) {
23812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChildFocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxChildFocusEvent const *""'");
23813 }
23814 arg1 = reinterpret_cast< wxChildFocusEvent * >(argp1);
23815 {
23816 PyThreadState* __tstate = wxPyBeginAllowThreads();
23817 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
23818 wxPyEndAllowThreads(__tstate);
23819 if (PyErr_Occurred()) SWIG_fail;
23820 }
23821 {
23822 resultobj = wxPyMake_wxObject(result, (bool)0);
23823 }
23824 return resultobj;
23825 fail:
23826 return NULL;
23827 }
23828
23829
23830 SWIGINTERN PyObject *ChildFocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23831 PyObject *obj;
23832 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23833 SWIG_TypeNewClientData(SWIGTYPE_p_wxChildFocusEvent, SWIG_NewClientData(obj));
23834 return SWIG_Py_Void();
23835 }
23836
23837 SWIGINTERN PyObject *ChildFocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23838 return SWIG_Python_InitShadowInstance(args);
23839 }
23840
23841 SWIGINTERN PyObject *_wrap_new_ActivateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23842 PyObject *resultobj = 0;
23843 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23844 bool arg2 = (bool) true ;
23845 int arg3 = (int) 0 ;
23846 wxActivateEvent *result = 0 ;
23847 int val1 ;
23848 int ecode1 = 0 ;
23849 bool val2 ;
23850 int ecode2 = 0 ;
23851 int val3 ;
23852 int ecode3 = 0 ;
23853 PyObject * obj0 = 0 ;
23854 PyObject * obj1 = 0 ;
23855 PyObject * obj2 = 0 ;
23856 char * kwnames[] = {
23857 (char *) "type",(char *) "active",(char *) "Id", NULL
23858 };
23859
23860 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23861 if (obj0) {
23862 ecode1 = SWIG_AsVal_int(obj0, &val1);
23863 if (!SWIG_IsOK(ecode1)) {
23864 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ActivateEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23865 }
23866 arg1 = static_cast< wxEventType >(val1);
23867 }
23868 if (obj1) {
23869 ecode2 = SWIG_AsVal_bool(obj1, &val2);
23870 if (!SWIG_IsOK(ecode2)) {
23871 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ActivateEvent" "', expected argument " "2"" of type '" "bool""'");
23872 }
23873 arg2 = static_cast< bool >(val2);
23874 }
23875 if (obj2) {
23876 ecode3 = SWIG_AsVal_int(obj2, &val3);
23877 if (!SWIG_IsOK(ecode3)) {
23878 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ActivateEvent" "', expected argument " "3"" of type '" "int""'");
23879 }
23880 arg3 = static_cast< int >(val3);
23881 }
23882 {
23883 PyThreadState* __tstate = wxPyBeginAllowThreads();
23884 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
23885 wxPyEndAllowThreads(__tstate);
23886 if (PyErr_Occurred()) SWIG_fail;
23887 }
23888 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_NEW | 0 );
23889 return resultobj;
23890 fail:
23891 return NULL;
23892 }
23893
23894
23895 SWIGINTERN PyObject *_wrap_ActivateEvent_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23896 PyObject *resultobj = 0;
23897 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
23898 bool result;
23899 void *argp1 = 0 ;
23900 int res1 = 0 ;
23901 PyObject *swig_obj[1] ;
23902
23903 if (!args) SWIG_fail;
23904 swig_obj[0] = args;
23905 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxActivateEvent, 0 | 0 );
23906 if (!SWIG_IsOK(res1)) {
23907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActivateEvent_GetActive" "', expected argument " "1"" of type '" "wxActivateEvent const *""'");
23908 }
23909 arg1 = reinterpret_cast< wxActivateEvent * >(argp1);
23910 {
23911 PyThreadState* __tstate = wxPyBeginAllowThreads();
23912 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
23913 wxPyEndAllowThreads(__tstate);
23914 if (PyErr_Occurred()) SWIG_fail;
23915 }
23916 {
23917 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23918 }
23919 return resultobj;
23920 fail:
23921 return NULL;
23922 }
23923
23924
23925 SWIGINTERN PyObject *ActivateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23926 PyObject *obj;
23927 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23928 SWIG_TypeNewClientData(SWIGTYPE_p_wxActivateEvent, SWIG_NewClientData(obj));
23929 return SWIG_Py_Void();
23930 }
23931
23932 SWIGINTERN PyObject *ActivateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23933 return SWIG_Python_InitShadowInstance(args);
23934 }
23935
23936 SWIGINTERN PyObject *_wrap_new_InitDialogEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23937 PyObject *resultobj = 0;
23938 int arg1 = (int) 0 ;
23939 wxInitDialogEvent *result = 0 ;
23940 int val1 ;
23941 int ecode1 = 0 ;
23942 PyObject * obj0 = 0 ;
23943 char * kwnames[] = {
23944 (char *) "Id", NULL
23945 };
23946
23947 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) SWIG_fail;
23948 if (obj0) {
23949 ecode1 = SWIG_AsVal_int(obj0, &val1);
23950 if (!SWIG_IsOK(ecode1)) {
23951 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InitDialogEvent" "', expected argument " "1"" of type '" "int""'");
23952 }
23953 arg1 = static_cast< int >(val1);
23954 }
23955 {
23956 PyThreadState* __tstate = wxPyBeginAllowThreads();
23957 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
23958 wxPyEndAllowThreads(__tstate);
23959 if (PyErr_Occurred()) SWIG_fail;
23960 }
23961 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInitDialogEvent, SWIG_POINTER_NEW | 0 );
23962 return resultobj;
23963 fail:
23964 return NULL;
23965 }
23966
23967
23968 SWIGINTERN PyObject *InitDialogEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23969 PyObject *obj;
23970 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23971 SWIG_TypeNewClientData(SWIGTYPE_p_wxInitDialogEvent, SWIG_NewClientData(obj));
23972 return SWIG_Py_Void();
23973 }
23974
23975 SWIGINTERN PyObject *InitDialogEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23976 return SWIG_Python_InitShadowInstance(args);
23977 }
23978
23979 SWIGINTERN PyObject *_wrap_new_MenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23980 PyObject *resultobj = 0;
23981 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23982 int arg2 = (int) 0 ;
23983 wxMenu *arg3 = (wxMenu *) NULL ;
23984 wxMenuEvent *result = 0 ;
23985 int val1 ;
23986 int ecode1 = 0 ;
23987 int val2 ;
23988 int ecode2 = 0 ;
23989 void *argp3 = 0 ;
23990 int res3 = 0 ;
23991 PyObject * obj0 = 0 ;
23992 PyObject * obj1 = 0 ;
23993 PyObject * obj2 = 0 ;
23994 char * kwnames[] = {
23995 (char *) "type",(char *) "winid",(char *) "menu", NULL
23996 };
23997
23998 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23999 if (obj0) {
24000 ecode1 = SWIG_AsVal_int(obj0, &val1);
24001 if (!SWIG_IsOK(ecode1)) {
24002 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24003 }
24004 arg1 = static_cast< wxEventType >(val1);
24005 }
24006 if (obj1) {
24007 ecode2 = SWIG_AsVal_int(obj1, &val2);
24008 if (!SWIG_IsOK(ecode2)) {
24009 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuEvent" "', expected argument " "2"" of type '" "int""'");
24010 }
24011 arg2 = static_cast< int >(val2);
24012 }
24013 if (obj2) {
24014 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
24015 if (!SWIG_IsOK(res3)) {
24016 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MenuEvent" "', expected argument " "3"" of type '" "wxMenu *""'");
24017 }
24018 arg3 = reinterpret_cast< wxMenu * >(argp3);
24019 }
24020 {
24021 PyThreadState* __tstate = wxPyBeginAllowThreads();
24022 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
24023 wxPyEndAllowThreads(__tstate);
24024 if (PyErr_Occurred()) SWIG_fail;
24025 }
24026 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_NEW | 0 );
24027 return resultobj;
24028 fail:
24029 return NULL;
24030 }
24031
24032
24033 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenuId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24034 PyObject *resultobj = 0;
24035 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24036 int result;
24037 void *argp1 = 0 ;
24038 int res1 = 0 ;
24039 PyObject *swig_obj[1] ;
24040
24041 if (!args) SWIG_fail;
24042 swig_obj[0] = args;
24043 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24044 if (!SWIG_IsOK(res1)) {
24045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenuId" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24046 }
24047 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24048 {
24049 PyThreadState* __tstate = wxPyBeginAllowThreads();
24050 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
24051 wxPyEndAllowThreads(__tstate);
24052 if (PyErr_Occurred()) SWIG_fail;
24053 }
24054 resultobj = SWIG_From_int(static_cast< int >(result));
24055 return resultobj;
24056 fail:
24057 return NULL;
24058 }
24059
24060
24061 SWIGINTERN PyObject *_wrap_MenuEvent_IsPopup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24062 PyObject *resultobj = 0;
24063 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24064 bool result;
24065 void *argp1 = 0 ;
24066 int res1 = 0 ;
24067 PyObject *swig_obj[1] ;
24068
24069 if (!args) SWIG_fail;
24070 swig_obj[0] = args;
24071 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24072 if (!SWIG_IsOK(res1)) {
24073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_IsPopup" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24074 }
24075 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24076 {
24077 PyThreadState* __tstate = wxPyBeginAllowThreads();
24078 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
24079 wxPyEndAllowThreads(__tstate);
24080 if (PyErr_Occurred()) SWIG_fail;
24081 }
24082 {
24083 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24084 }
24085 return resultobj;
24086 fail:
24087 return NULL;
24088 }
24089
24090
24091 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24092 PyObject *resultobj = 0;
24093 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24094 wxMenu *result = 0 ;
24095 void *argp1 = 0 ;
24096 int res1 = 0 ;
24097 PyObject *swig_obj[1] ;
24098
24099 if (!args) SWIG_fail;
24100 swig_obj[0] = args;
24101 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24102 if (!SWIG_IsOK(res1)) {
24103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenu" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24104 }
24105 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24106 {
24107 PyThreadState* __tstate = wxPyBeginAllowThreads();
24108 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
24109 wxPyEndAllowThreads(__tstate);
24110 if (PyErr_Occurred()) SWIG_fail;
24111 }
24112 {
24113 resultobj = wxPyMake_wxObject(result, (bool)0);
24114 }
24115 return resultobj;
24116 fail:
24117 return NULL;
24118 }
24119
24120
24121 SWIGINTERN PyObject *MenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24122 PyObject *obj;
24123 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24124 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuEvent, SWIG_NewClientData(obj));
24125 return SWIG_Py_Void();
24126 }
24127
24128 SWIGINTERN PyObject *MenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24129 return SWIG_Python_InitShadowInstance(args);
24130 }
24131
24132 SWIGINTERN PyObject *_wrap_new_CloseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24133 PyObject *resultobj = 0;
24134 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24135 int arg2 = (int) 0 ;
24136 wxCloseEvent *result = 0 ;
24137 int val1 ;
24138 int ecode1 = 0 ;
24139 int val2 ;
24140 int ecode2 = 0 ;
24141 PyObject * obj0 = 0 ;
24142 PyObject * obj1 = 0 ;
24143 char * kwnames[] = {
24144 (char *) "type",(char *) "winid", NULL
24145 };
24146
24147 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24148 if (obj0) {
24149 ecode1 = SWIG_AsVal_int(obj0, &val1);
24150 if (!SWIG_IsOK(ecode1)) {
24151 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CloseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24152 }
24153 arg1 = static_cast< wxEventType >(val1);
24154 }
24155 if (obj1) {
24156 ecode2 = SWIG_AsVal_int(obj1, &val2);
24157 if (!SWIG_IsOK(ecode2)) {
24158 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CloseEvent" "', expected argument " "2"" of type '" "int""'");
24159 }
24160 arg2 = static_cast< int >(val2);
24161 }
24162 {
24163 PyThreadState* __tstate = wxPyBeginAllowThreads();
24164 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
24165 wxPyEndAllowThreads(__tstate);
24166 if (PyErr_Occurred()) SWIG_fail;
24167 }
24168 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_NEW | 0 );
24169 return resultobj;
24170 fail:
24171 return NULL;
24172 }
24173
24174
24175 SWIGINTERN PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24176 PyObject *resultobj = 0;
24177 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24178 bool arg2 ;
24179 void *argp1 = 0 ;
24180 int res1 = 0 ;
24181 bool val2 ;
24182 int ecode2 = 0 ;
24183 PyObject * obj0 = 0 ;
24184 PyObject * obj1 = 0 ;
24185 char * kwnames[] = {
24186 (char *) "self",(char *) "logOff", NULL
24187 };
24188
24189 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) SWIG_fail;
24190 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24191 if (!SWIG_IsOK(res1)) {
24192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24193 }
24194 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24195 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24196 if (!SWIG_IsOK(ecode2)) {
24197 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "2"" of type '" "bool""'");
24198 }
24199 arg2 = static_cast< bool >(val2);
24200 {
24201 PyThreadState* __tstate = wxPyBeginAllowThreads();
24202 (arg1)->SetLoggingOff(arg2);
24203 wxPyEndAllowThreads(__tstate);
24204 if (PyErr_Occurred()) SWIG_fail;
24205 }
24206 resultobj = SWIG_Py_Void();
24207 return resultobj;
24208 fail:
24209 return NULL;
24210 }
24211
24212
24213 SWIGINTERN PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24214 PyObject *resultobj = 0;
24215 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24216 bool result;
24217 void *argp1 = 0 ;
24218 int res1 = 0 ;
24219 PyObject *swig_obj[1] ;
24220
24221 if (!args) SWIG_fail;
24222 swig_obj[0] = args;
24223 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24224 if (!SWIG_IsOK(res1)) {
24225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24226 }
24227 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24228 {
24229 PyThreadState* __tstate = wxPyBeginAllowThreads();
24230 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
24231 wxPyEndAllowThreads(__tstate);
24232 if (PyErr_Occurred()) SWIG_fail;
24233 }
24234 {
24235 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24236 }
24237 return resultobj;
24238 fail:
24239 return NULL;
24240 }
24241
24242
24243 SWIGINTERN PyObject *_wrap_CloseEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24244 PyObject *resultobj = 0;
24245 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24246 bool arg2 = (bool) true ;
24247 void *argp1 = 0 ;
24248 int res1 = 0 ;
24249 bool val2 ;
24250 int ecode2 = 0 ;
24251 PyObject * obj0 = 0 ;
24252 PyObject * obj1 = 0 ;
24253 char * kwnames[] = {
24254 (char *) "self",(char *) "veto", NULL
24255 };
24256
24257 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) SWIG_fail;
24258 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24259 if (!SWIG_IsOK(res1)) {
24260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_Veto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24261 }
24262 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24263 if (obj1) {
24264 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24265 if (!SWIG_IsOK(ecode2)) {
24266 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_Veto" "', expected argument " "2"" of type '" "bool""'");
24267 }
24268 arg2 = static_cast< bool >(val2);
24269 }
24270 {
24271 PyThreadState* __tstate = wxPyBeginAllowThreads();
24272 (arg1)->Veto(arg2);
24273 wxPyEndAllowThreads(__tstate);
24274 if (PyErr_Occurred()) SWIG_fail;
24275 }
24276 resultobj = SWIG_Py_Void();
24277 return resultobj;
24278 fail:
24279 return NULL;
24280 }
24281
24282
24283 SWIGINTERN PyObject *_wrap_CloseEvent_GetVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24284 PyObject *resultobj = 0;
24285 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24286 bool result;
24287 void *argp1 = 0 ;
24288 int res1 = 0 ;
24289 PyObject *swig_obj[1] ;
24290
24291 if (!args) SWIG_fail;
24292 swig_obj[0] = args;
24293 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24294 if (!SWIG_IsOK(res1)) {
24295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24296 }
24297 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24298 {
24299 PyThreadState* __tstate = wxPyBeginAllowThreads();
24300 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
24301 wxPyEndAllowThreads(__tstate);
24302 if (PyErr_Occurred()) SWIG_fail;
24303 }
24304 {
24305 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24306 }
24307 return resultobj;
24308 fail:
24309 return NULL;
24310 }
24311
24312
24313 SWIGINTERN PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24314 PyObject *resultobj = 0;
24315 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24316 bool arg2 ;
24317 void *argp1 = 0 ;
24318 int res1 = 0 ;
24319 bool val2 ;
24320 int ecode2 = 0 ;
24321 PyObject * obj0 = 0 ;
24322 PyObject * obj1 = 0 ;
24323 char * kwnames[] = {
24324 (char *) "self",(char *) "canVeto", NULL
24325 };
24326
24327 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) SWIG_fail;
24328 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24329 if (!SWIG_IsOK(res1)) {
24330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24331 }
24332 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24333 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24334 if (!SWIG_IsOK(ecode2)) {
24335 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "2"" of type '" "bool""'");
24336 }
24337 arg2 = static_cast< bool >(val2);
24338 {
24339 PyThreadState* __tstate = wxPyBeginAllowThreads();
24340 (arg1)->SetCanVeto(arg2);
24341 wxPyEndAllowThreads(__tstate);
24342 if (PyErr_Occurred()) SWIG_fail;
24343 }
24344 resultobj = SWIG_Py_Void();
24345 return resultobj;
24346 fail:
24347 return NULL;
24348 }
24349
24350
24351 SWIGINTERN PyObject *_wrap_CloseEvent_CanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24352 PyObject *resultobj = 0;
24353 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24354 bool result;
24355 void *argp1 = 0 ;
24356 int res1 = 0 ;
24357 PyObject *swig_obj[1] ;
24358
24359 if (!args) SWIG_fail;
24360 swig_obj[0] = args;
24361 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24362 if (!SWIG_IsOK(res1)) {
24363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_CanVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24364 }
24365 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24366 {
24367 PyThreadState* __tstate = wxPyBeginAllowThreads();
24368 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
24369 wxPyEndAllowThreads(__tstate);
24370 if (PyErr_Occurred()) SWIG_fail;
24371 }
24372 {
24373 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24374 }
24375 return resultobj;
24376 fail:
24377 return NULL;
24378 }
24379
24380
24381 SWIGINTERN PyObject *CloseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24382 PyObject *obj;
24383 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24384 SWIG_TypeNewClientData(SWIGTYPE_p_wxCloseEvent, SWIG_NewClientData(obj));
24385 return SWIG_Py_Void();
24386 }
24387
24388 SWIGINTERN PyObject *CloseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24389 return SWIG_Python_InitShadowInstance(args);
24390 }
24391
24392 SWIGINTERN PyObject *_wrap_new_ShowEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24393 PyObject *resultobj = 0;
24394 int arg1 = (int) 0 ;
24395 bool arg2 = (bool) false ;
24396 wxShowEvent *result = 0 ;
24397 int val1 ;
24398 int ecode1 = 0 ;
24399 bool val2 ;
24400 int ecode2 = 0 ;
24401 PyObject * obj0 = 0 ;
24402 PyObject * obj1 = 0 ;
24403 char * kwnames[] = {
24404 (char *) "winid",(char *) "show", NULL
24405 };
24406
24407 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24408 if (obj0) {
24409 ecode1 = SWIG_AsVal_int(obj0, &val1);
24410 if (!SWIG_IsOK(ecode1)) {
24411 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ShowEvent" "', expected argument " "1"" of type '" "int""'");
24412 }
24413 arg1 = static_cast< int >(val1);
24414 }
24415 if (obj1) {
24416 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24417 if (!SWIG_IsOK(ecode2)) {
24418 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ShowEvent" "', expected argument " "2"" of type '" "bool""'");
24419 }
24420 arg2 = static_cast< bool >(val2);
24421 }
24422 {
24423 PyThreadState* __tstate = wxPyBeginAllowThreads();
24424 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
24425 wxPyEndAllowThreads(__tstate);
24426 if (PyErr_Occurred()) SWIG_fail;
24427 }
24428 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxShowEvent, SWIG_POINTER_NEW | 0 );
24429 return resultobj;
24430 fail:
24431 return NULL;
24432 }
24433
24434
24435 SWIGINTERN PyObject *_wrap_ShowEvent_SetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24436 PyObject *resultobj = 0;
24437 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24438 bool arg2 ;
24439 void *argp1 = 0 ;
24440 int res1 = 0 ;
24441 bool val2 ;
24442 int ecode2 = 0 ;
24443 PyObject * obj0 = 0 ;
24444 PyObject * obj1 = 0 ;
24445 char * kwnames[] = {
24446 (char *) "self",(char *) "show", NULL
24447 };
24448
24449 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) SWIG_fail;
24450 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24451 if (!SWIG_IsOK(res1)) {
24452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_SetShow" "', expected argument " "1"" of type '" "wxShowEvent *""'");
24453 }
24454 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24455 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24456 if (!SWIG_IsOK(ecode2)) {
24457 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShowEvent_SetShow" "', expected argument " "2"" of type '" "bool""'");
24458 }
24459 arg2 = static_cast< bool >(val2);
24460 {
24461 PyThreadState* __tstate = wxPyBeginAllowThreads();
24462 (arg1)->SetShow(arg2);
24463 wxPyEndAllowThreads(__tstate);
24464 if (PyErr_Occurred()) SWIG_fail;
24465 }
24466 resultobj = SWIG_Py_Void();
24467 return resultobj;
24468 fail:
24469 return NULL;
24470 }
24471
24472
24473 SWIGINTERN PyObject *_wrap_ShowEvent_GetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24474 PyObject *resultobj = 0;
24475 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24476 bool result;
24477 void *argp1 = 0 ;
24478 int res1 = 0 ;
24479 PyObject *swig_obj[1] ;
24480
24481 if (!args) SWIG_fail;
24482 swig_obj[0] = args;
24483 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24484 if (!SWIG_IsOK(res1)) {
24485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_GetShow" "', expected argument " "1"" of type '" "wxShowEvent const *""'");
24486 }
24487 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24488 {
24489 PyThreadState* __tstate = wxPyBeginAllowThreads();
24490 result = (bool)((wxShowEvent const *)arg1)->GetShow();
24491 wxPyEndAllowThreads(__tstate);
24492 if (PyErr_Occurred()) SWIG_fail;
24493 }
24494 {
24495 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24496 }
24497 return resultobj;
24498 fail:
24499 return NULL;
24500 }
24501
24502
24503 SWIGINTERN PyObject *ShowEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24504 PyObject *obj;
24505 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24506 SWIG_TypeNewClientData(SWIGTYPE_p_wxShowEvent, SWIG_NewClientData(obj));
24507 return SWIG_Py_Void();
24508 }
24509
24510 SWIGINTERN PyObject *ShowEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24511 return SWIG_Python_InitShadowInstance(args);
24512 }
24513
24514 SWIGINTERN PyObject *_wrap_new_IconizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24515 PyObject *resultobj = 0;
24516 int arg1 = (int) 0 ;
24517 bool arg2 = (bool) true ;
24518 wxIconizeEvent *result = 0 ;
24519 int val1 ;
24520 int ecode1 = 0 ;
24521 bool val2 ;
24522 int ecode2 = 0 ;
24523 PyObject * obj0 = 0 ;
24524 PyObject * obj1 = 0 ;
24525 char * kwnames[] = {
24526 (char *) "id",(char *) "iconized", NULL
24527 };
24528
24529 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24530 if (obj0) {
24531 ecode1 = SWIG_AsVal_int(obj0, &val1);
24532 if (!SWIG_IsOK(ecode1)) {
24533 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IconizeEvent" "', expected argument " "1"" of type '" "int""'");
24534 }
24535 arg1 = static_cast< int >(val1);
24536 }
24537 if (obj1) {
24538 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24539 if (!SWIG_IsOK(ecode2)) {
24540 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IconizeEvent" "', expected argument " "2"" of type '" "bool""'");
24541 }
24542 arg2 = static_cast< bool >(val2);
24543 }
24544 {
24545 PyThreadState* __tstate = wxPyBeginAllowThreads();
24546 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
24547 wxPyEndAllowThreads(__tstate);
24548 if (PyErr_Occurred()) SWIG_fail;
24549 }
24550 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_NEW | 0 );
24551 return resultobj;
24552 fail:
24553 return NULL;
24554 }
24555
24556
24557 SWIGINTERN PyObject *_wrap_IconizeEvent_Iconized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24558 PyObject *resultobj = 0;
24559 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
24560 bool result;
24561 void *argp1 = 0 ;
24562 int res1 = 0 ;
24563 PyObject *swig_obj[1] ;
24564
24565 if (!args) SWIG_fail;
24566 swig_obj[0] = args;
24567 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconizeEvent, 0 | 0 );
24568 if (!SWIG_IsOK(res1)) {
24569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconizeEvent_Iconized" "', expected argument " "1"" of type '" "wxIconizeEvent *""'");
24570 }
24571 arg1 = reinterpret_cast< wxIconizeEvent * >(argp1);
24572 {
24573 PyThreadState* __tstate = wxPyBeginAllowThreads();
24574 result = (bool)(arg1)->Iconized();
24575 wxPyEndAllowThreads(__tstate);
24576 if (PyErr_Occurred()) SWIG_fail;
24577 }
24578 {
24579 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24580 }
24581 return resultobj;
24582 fail:
24583 return NULL;
24584 }
24585
24586
24587 SWIGINTERN PyObject *IconizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24588 PyObject *obj;
24589 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24590 SWIG_TypeNewClientData(SWIGTYPE_p_wxIconizeEvent, SWIG_NewClientData(obj));
24591 return SWIG_Py_Void();
24592 }
24593
24594 SWIGINTERN PyObject *IconizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24595 return SWIG_Python_InitShadowInstance(args);
24596 }
24597
24598 SWIGINTERN PyObject *_wrap_new_MaximizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24599 PyObject *resultobj = 0;
24600 int arg1 = (int) 0 ;
24601 wxMaximizeEvent *result = 0 ;
24602 int val1 ;
24603 int ecode1 = 0 ;
24604 PyObject * obj0 = 0 ;
24605 char * kwnames[] = {
24606 (char *) "id", NULL
24607 };
24608
24609 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) SWIG_fail;
24610 if (obj0) {
24611 ecode1 = SWIG_AsVal_int(obj0, &val1);
24612 if (!SWIG_IsOK(ecode1)) {
24613 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MaximizeEvent" "', expected argument " "1"" of type '" "int""'");
24614 }
24615 arg1 = static_cast< int >(val1);
24616 }
24617 {
24618 PyThreadState* __tstate = wxPyBeginAllowThreads();
24619 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
24620 wxPyEndAllowThreads(__tstate);
24621 if (PyErr_Occurred()) SWIG_fail;
24622 }
24623 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMaximizeEvent, SWIG_POINTER_NEW | 0 );
24624 return resultobj;
24625 fail:
24626 return NULL;
24627 }
24628
24629
24630 SWIGINTERN PyObject *MaximizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24631 PyObject *obj;
24632 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24633 SWIG_TypeNewClientData(SWIGTYPE_p_wxMaximizeEvent, SWIG_NewClientData(obj));
24634 return SWIG_Py_Void();
24635 }
24636
24637 SWIGINTERN PyObject *MaximizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24638 return SWIG_Python_InitShadowInstance(args);
24639 }
24640
24641 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24642 PyObject *resultobj = 0;
24643 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24644 wxPoint result;
24645 void *argp1 = 0 ;
24646 int res1 = 0 ;
24647 PyObject *swig_obj[1] ;
24648
24649 if (!args) SWIG_fail;
24650 swig_obj[0] = args;
24651 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24652 if (!SWIG_IsOK(res1)) {
24653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetPosition" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24654 }
24655 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24656 {
24657 PyThreadState* __tstate = wxPyBeginAllowThreads();
24658 result = (arg1)->GetPosition();
24659 wxPyEndAllowThreads(__tstate);
24660 if (PyErr_Occurred()) SWIG_fail;
24661 }
24662 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
24663 return resultobj;
24664 fail:
24665 return NULL;
24666 }
24667
24668
24669 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24670 PyObject *resultobj = 0;
24671 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24672 int result;
24673 void *argp1 = 0 ;
24674 int res1 = 0 ;
24675 PyObject *swig_obj[1] ;
24676
24677 if (!args) SWIG_fail;
24678 swig_obj[0] = args;
24679 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24680 if (!SWIG_IsOK(res1)) {
24681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetNumberOfFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24682 }
24683 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24684 {
24685 PyThreadState* __tstate = wxPyBeginAllowThreads();
24686 result = (int)(arg1)->GetNumberOfFiles();
24687 wxPyEndAllowThreads(__tstate);
24688 if (PyErr_Occurred()) SWIG_fail;
24689 }
24690 resultobj = SWIG_From_int(static_cast< int >(result));
24691 return resultobj;
24692 fail:
24693 return NULL;
24694 }
24695
24696
24697 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24698 PyObject *resultobj = 0;
24699 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24700 PyObject *result = 0 ;
24701 void *argp1 = 0 ;
24702 int res1 = 0 ;
24703 PyObject *swig_obj[1] ;
24704
24705 if (!args) SWIG_fail;
24706 swig_obj[0] = args;
24707 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24708 if (!SWIG_IsOK(res1)) {
24709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24710 }
24711 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24712 {
24713 PyThreadState* __tstate = wxPyBeginAllowThreads();
24714 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
24715 wxPyEndAllowThreads(__tstate);
24716 if (PyErr_Occurred()) SWIG_fail;
24717 }
24718 resultobj = result;
24719 return resultobj;
24720 fail:
24721 return NULL;
24722 }
24723
24724
24725 SWIGINTERN PyObject *DropFilesEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24726 PyObject *obj;
24727 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24728 SWIG_TypeNewClientData(SWIGTYPE_p_wxDropFilesEvent, SWIG_NewClientData(obj));
24729 return SWIG_Py_Void();
24730 }
24731
24732 SWIGINTERN PyObject *_wrap_new_UpdateUIEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24733 PyObject *resultobj = 0;
24734 int arg1 = (int) 0 ;
24735 wxUpdateUIEvent *result = 0 ;
24736 int val1 ;
24737 int ecode1 = 0 ;
24738 PyObject * obj0 = 0 ;
24739 char * kwnames[] = {
24740 (char *) "commandId", NULL
24741 };
24742
24743 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) SWIG_fail;
24744 if (obj0) {
24745 ecode1 = SWIG_AsVal_int(obj0, &val1);
24746 if (!SWIG_IsOK(ecode1)) {
24747 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UpdateUIEvent" "', expected argument " "1"" of type '" "int""'");
24748 }
24749 arg1 = static_cast< int >(val1);
24750 }
24751 {
24752 PyThreadState* __tstate = wxPyBeginAllowThreads();
24753 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
24754 wxPyEndAllowThreads(__tstate);
24755 if (PyErr_Occurred()) SWIG_fail;
24756 }
24757 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_NEW | 0 );
24758 return resultobj;
24759 fail:
24760 return NULL;
24761 }
24762
24763
24764 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24765 PyObject *resultobj = 0;
24766 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24767 bool result;
24768 void *argp1 = 0 ;
24769 int res1 = 0 ;
24770 PyObject *swig_obj[1] ;
24771
24772 if (!args) SWIG_fail;
24773 swig_obj[0] = args;
24774 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24775 if (!SWIG_IsOK(res1)) {
24776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24777 }
24778 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24779 {
24780 PyThreadState* __tstate = wxPyBeginAllowThreads();
24781 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
24782 wxPyEndAllowThreads(__tstate);
24783 if (PyErr_Occurred()) SWIG_fail;
24784 }
24785 {
24786 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24787 }
24788 return resultobj;
24789 fail:
24790 return NULL;
24791 }
24792
24793
24794 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24795 PyObject *resultobj = 0;
24796 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24797 bool result;
24798 void *argp1 = 0 ;
24799 int res1 = 0 ;
24800 PyObject *swig_obj[1] ;
24801
24802 if (!args) SWIG_fail;
24803 swig_obj[0] = args;
24804 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24805 if (!SWIG_IsOK(res1)) {
24806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24807 }
24808 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24809 {
24810 PyThreadState* __tstate = wxPyBeginAllowThreads();
24811 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
24812 wxPyEndAllowThreads(__tstate);
24813 if (PyErr_Occurred()) SWIG_fail;
24814 }
24815 {
24816 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24817 }
24818 return resultobj;
24819 fail:
24820 return NULL;
24821 }
24822
24823
24824 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24825 PyObject *resultobj = 0;
24826 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24827 bool result;
24828 void *argp1 = 0 ;
24829 int res1 = 0 ;
24830 PyObject *swig_obj[1] ;
24831
24832 if (!args) SWIG_fail;
24833 swig_obj[0] = args;
24834 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24835 if (!SWIG_IsOK(res1)) {
24836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24837 }
24838 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24839 {
24840 PyThreadState* __tstate = wxPyBeginAllowThreads();
24841 result = (bool)((wxUpdateUIEvent const *)arg1)->GetShown();
24842 wxPyEndAllowThreads(__tstate);
24843 if (PyErr_Occurred()) SWIG_fail;
24844 }
24845 {
24846 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24847 }
24848 return resultobj;
24849 fail:
24850 return NULL;
24851 }
24852
24853
24854 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24855 PyObject *resultobj = 0;
24856 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24857 wxString result;
24858 void *argp1 = 0 ;
24859 int res1 = 0 ;
24860 PyObject *swig_obj[1] ;
24861
24862 if (!args) SWIG_fail;
24863 swig_obj[0] = args;
24864 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24865 if (!SWIG_IsOK(res1)) {
24866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24867 }
24868 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24869 {
24870 PyThreadState* __tstate = wxPyBeginAllowThreads();
24871 result = ((wxUpdateUIEvent const *)arg1)->GetText();
24872 wxPyEndAllowThreads(__tstate);
24873 if (PyErr_Occurred()) SWIG_fail;
24874 }
24875 {
24876 #if wxUSE_UNICODE
24877 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24878 #else
24879 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24880 #endif
24881 }
24882 return resultobj;
24883 fail:
24884 return NULL;
24885 }
24886
24887
24888 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24889 PyObject *resultobj = 0;
24890 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24891 bool result;
24892 void *argp1 = 0 ;
24893 int res1 = 0 ;
24894 PyObject *swig_obj[1] ;
24895
24896 if (!args) SWIG_fail;
24897 swig_obj[0] = args;
24898 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24899 if (!SWIG_IsOK(res1)) {
24900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24901 }
24902 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24903 {
24904 PyThreadState* __tstate = wxPyBeginAllowThreads();
24905 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
24906 wxPyEndAllowThreads(__tstate);
24907 if (PyErr_Occurred()) SWIG_fail;
24908 }
24909 {
24910 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24911 }
24912 return resultobj;
24913 fail:
24914 return NULL;
24915 }
24916
24917
24918 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24919 PyObject *resultobj = 0;
24920 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24921 bool result;
24922 void *argp1 = 0 ;
24923 int res1 = 0 ;
24924 PyObject *swig_obj[1] ;
24925
24926 if (!args) SWIG_fail;
24927 swig_obj[0] = args;
24928 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24929 if (!SWIG_IsOK(res1)) {
24930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24931 }
24932 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24933 {
24934 PyThreadState* __tstate = wxPyBeginAllowThreads();
24935 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
24936 wxPyEndAllowThreads(__tstate);
24937 if (PyErr_Occurred()) SWIG_fail;
24938 }
24939 {
24940 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24941 }
24942 return resultobj;
24943 fail:
24944 return NULL;
24945 }
24946
24947
24948 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24949 PyObject *resultobj = 0;
24950 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24951 bool result;
24952 void *argp1 = 0 ;
24953 int res1 = 0 ;
24954 PyObject *swig_obj[1] ;
24955
24956 if (!args) SWIG_fail;
24957 swig_obj[0] = args;
24958 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24959 if (!SWIG_IsOK(res1)) {
24960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24961 }
24962 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24963 {
24964 PyThreadState* __tstate = wxPyBeginAllowThreads();
24965 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
24966 wxPyEndAllowThreads(__tstate);
24967 if (PyErr_Occurred()) SWIG_fail;
24968 }
24969 {
24970 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24971 }
24972 return resultobj;
24973 fail:
24974 return NULL;
24975 }
24976
24977
24978 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24979 PyObject *resultobj = 0;
24980 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24981 bool result;
24982 void *argp1 = 0 ;
24983 int res1 = 0 ;
24984 PyObject *swig_obj[1] ;
24985
24986 if (!args) SWIG_fail;
24987 swig_obj[0] = args;
24988 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24989 if (!SWIG_IsOK(res1)) {
24990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24991 }
24992 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24993 {
24994 PyThreadState* __tstate = wxPyBeginAllowThreads();
24995 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetShown();
24996 wxPyEndAllowThreads(__tstate);
24997 if (PyErr_Occurred()) SWIG_fail;
24998 }
24999 {
25000 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25001 }
25002 return resultobj;
25003 fail:
25004 return NULL;
25005 }
25006
25007
25008 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25009 PyObject *resultobj = 0;
25010 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25011 bool arg2 ;
25012 void *argp1 = 0 ;
25013 int res1 = 0 ;
25014 bool val2 ;
25015 int ecode2 = 0 ;
25016 PyObject * obj0 = 0 ;
25017 PyObject * obj1 = 0 ;
25018 char * kwnames[] = {
25019 (char *) "self",(char *) "check", NULL
25020 };
25021
25022 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) SWIG_fail;
25023 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25024 if (!SWIG_IsOK(res1)) {
25025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Check" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25026 }
25027 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25028 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25029 if (!SWIG_IsOK(ecode2)) {
25030 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Check" "', expected argument " "2"" of type '" "bool""'");
25031 }
25032 arg2 = static_cast< bool >(val2);
25033 {
25034 PyThreadState* __tstate = wxPyBeginAllowThreads();
25035 (arg1)->Check(arg2);
25036 wxPyEndAllowThreads(__tstate);
25037 if (PyErr_Occurred()) SWIG_fail;
25038 }
25039 resultobj = SWIG_Py_Void();
25040 return resultobj;
25041 fail:
25042 return NULL;
25043 }
25044
25045
25046 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25047 PyObject *resultobj = 0;
25048 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25049 bool arg2 ;
25050 void *argp1 = 0 ;
25051 int res1 = 0 ;
25052 bool val2 ;
25053 int ecode2 = 0 ;
25054 PyObject * obj0 = 0 ;
25055 PyObject * obj1 = 0 ;
25056 char * kwnames[] = {
25057 (char *) "self",(char *) "enable", NULL
25058 };
25059
25060 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
25061 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25062 if (!SWIG_IsOK(res1)) {
25063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Enable" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25064 }
25065 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25066 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25067 if (!SWIG_IsOK(ecode2)) {
25068 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Enable" "', expected argument " "2"" of type '" "bool""'");
25069 }
25070 arg2 = static_cast< bool >(val2);
25071 {
25072 PyThreadState* __tstate = wxPyBeginAllowThreads();
25073 (arg1)->Enable(arg2);
25074 wxPyEndAllowThreads(__tstate);
25075 if (PyErr_Occurred()) SWIG_fail;
25076 }
25077 resultobj = SWIG_Py_Void();
25078 return resultobj;
25079 fail:
25080 return NULL;
25081 }
25082
25083
25084 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25085 PyObject *resultobj = 0;
25086 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25087 bool arg2 ;
25088 void *argp1 = 0 ;
25089 int res1 = 0 ;
25090 bool val2 ;
25091 int ecode2 = 0 ;
25092 PyObject * obj0 = 0 ;
25093 PyObject * obj1 = 0 ;
25094 char * kwnames[] = {
25095 (char *) "self",(char *) "show", NULL
25096 };
25097
25098 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Show",kwnames,&obj0,&obj1)) SWIG_fail;
25099 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25100 if (!SWIG_IsOK(res1)) {
25101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Show" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25102 }
25103 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25104 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25105 if (!SWIG_IsOK(ecode2)) {
25106 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Show" "', expected argument " "2"" of type '" "bool""'");
25107 }
25108 arg2 = static_cast< bool >(val2);
25109 {
25110 PyThreadState* __tstate = wxPyBeginAllowThreads();
25111 (arg1)->Show(arg2);
25112 wxPyEndAllowThreads(__tstate);
25113 if (PyErr_Occurred()) SWIG_fail;
25114 }
25115 resultobj = SWIG_Py_Void();
25116 return resultobj;
25117 fail:
25118 return NULL;
25119 }
25120
25121
25122 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25123 PyObject *resultobj = 0;
25124 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25125 wxString *arg2 = 0 ;
25126 void *argp1 = 0 ;
25127 int res1 = 0 ;
25128 bool temp2 = false ;
25129 PyObject * obj0 = 0 ;
25130 PyObject * obj1 = 0 ;
25131 char * kwnames[] = {
25132 (char *) "self",(char *) "text", NULL
25133 };
25134
25135 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
25136 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25137 if (!SWIG_IsOK(res1)) {
25138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_SetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25139 }
25140 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25141 {
25142 arg2 = wxString_in_helper(obj1);
25143 if (arg2 == NULL) SWIG_fail;
25144 temp2 = true;
25145 }
25146 {
25147 PyThreadState* __tstate = wxPyBeginAllowThreads();
25148 (arg1)->SetText((wxString const &)*arg2);
25149 wxPyEndAllowThreads(__tstate);
25150 if (PyErr_Occurred()) SWIG_fail;
25151 }
25152 resultobj = SWIG_Py_Void();
25153 {
25154 if (temp2)
25155 delete arg2;
25156 }
25157 return resultobj;
25158 fail:
25159 {
25160 if (temp2)
25161 delete arg2;
25162 }
25163 return NULL;
25164 }
25165
25166
25167 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25168 PyObject *resultobj = 0;
25169 long arg1 ;
25170 long val1 ;
25171 int ecode1 = 0 ;
25172 PyObject * obj0 = 0 ;
25173 char * kwnames[] = {
25174 (char *) "updateInterval", NULL
25175 };
25176
25177 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) SWIG_fail;
25178 ecode1 = SWIG_AsVal_long(obj0, &val1);
25179 if (!SWIG_IsOK(ecode1)) {
25180 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetUpdateInterval" "', expected argument " "1"" of type '" "long""'");
25181 }
25182 arg1 = static_cast< long >(val1);
25183 {
25184 PyThreadState* __tstate = wxPyBeginAllowThreads();
25185 wxUpdateUIEvent::SetUpdateInterval(arg1);
25186 wxPyEndAllowThreads(__tstate);
25187 if (PyErr_Occurred()) SWIG_fail;
25188 }
25189 resultobj = SWIG_Py_Void();
25190 return resultobj;
25191 fail:
25192 return NULL;
25193 }
25194
25195
25196 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25197 PyObject *resultobj = 0;
25198 long result;
25199
25200 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetUpdateInterval",0,0,0)) SWIG_fail;
25201 {
25202 PyThreadState* __tstate = wxPyBeginAllowThreads();
25203 result = (long)wxUpdateUIEvent::GetUpdateInterval();
25204 wxPyEndAllowThreads(__tstate);
25205 if (PyErr_Occurred()) SWIG_fail;
25206 }
25207 resultobj = SWIG_From_long(static_cast< long >(result));
25208 return resultobj;
25209 fail:
25210 return NULL;
25211 }
25212
25213
25214 SWIGINTERN PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25215 PyObject *resultobj = 0;
25216 wxWindow *arg1 = (wxWindow *) 0 ;
25217 bool result;
25218 void *argp1 = 0 ;
25219 int res1 = 0 ;
25220 PyObject * obj0 = 0 ;
25221 char * kwnames[] = {
25222 (char *) "win", NULL
25223 };
25224
25225 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) SWIG_fail;
25226 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
25227 if (!SWIG_IsOK(res1)) {
25228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_CanUpdate" "', expected argument " "1"" of type '" "wxWindow *""'");
25229 }
25230 arg1 = reinterpret_cast< wxWindow * >(argp1);
25231 {
25232 PyThreadState* __tstate = wxPyBeginAllowThreads();
25233 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
25234 wxPyEndAllowThreads(__tstate);
25235 if (PyErr_Occurred()) SWIG_fail;
25236 }
25237 {
25238 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25239 }
25240 return resultobj;
25241 fail:
25242 return NULL;
25243 }
25244
25245
25246 SWIGINTERN PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25247 PyObject *resultobj = 0;
25248
25249 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_ResetUpdateTime",0,0,0)) SWIG_fail;
25250 {
25251 PyThreadState* __tstate = wxPyBeginAllowThreads();
25252 wxUpdateUIEvent::ResetUpdateTime();
25253 wxPyEndAllowThreads(__tstate);
25254 if (PyErr_Occurred()) SWIG_fail;
25255 }
25256 resultobj = SWIG_Py_Void();
25257 return resultobj;
25258 fail:
25259 return NULL;
25260 }
25261
25262
25263 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25264 PyObject *resultobj = 0;
25265 wxUpdateUIMode arg1 ;
25266 int val1 ;
25267 int ecode1 = 0 ;
25268 PyObject * obj0 = 0 ;
25269 char * kwnames[] = {
25270 (char *) "mode", NULL
25271 };
25272
25273 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) SWIG_fail;
25274 ecode1 = SWIG_AsVal_int(obj0, &val1);
25275 if (!SWIG_IsOK(ecode1)) {
25276 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetMode" "', expected argument " "1"" of type '" "wxUpdateUIMode""'");
25277 }
25278 arg1 = static_cast< wxUpdateUIMode >(val1);
25279 {
25280 PyThreadState* __tstate = wxPyBeginAllowThreads();
25281 wxUpdateUIEvent::SetMode(arg1);
25282 wxPyEndAllowThreads(__tstate);
25283 if (PyErr_Occurred()) SWIG_fail;
25284 }
25285 resultobj = SWIG_Py_Void();
25286 return resultobj;
25287 fail:
25288 return NULL;
25289 }
25290
25291
25292 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25293 PyObject *resultobj = 0;
25294 wxUpdateUIMode result;
25295
25296 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetMode",0,0,0)) SWIG_fail;
25297 {
25298 PyThreadState* __tstate = wxPyBeginAllowThreads();
25299 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
25300 wxPyEndAllowThreads(__tstate);
25301 if (PyErr_Occurred()) SWIG_fail;
25302 }
25303 resultobj = SWIG_From_int(static_cast< int >(result));
25304 return resultobj;
25305 fail:
25306 return NULL;
25307 }
25308
25309
25310 SWIGINTERN PyObject *UpdateUIEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25311 PyObject *obj;
25312 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25313 SWIG_TypeNewClientData(SWIGTYPE_p_wxUpdateUIEvent, SWIG_NewClientData(obj));
25314 return SWIG_Py_Void();
25315 }
25316
25317 SWIGINTERN PyObject *UpdateUIEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25318 return SWIG_Python_InitShadowInstance(args);
25319 }
25320
25321 SWIGINTERN PyObject *_wrap_new_SysColourChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25322 PyObject *resultobj = 0;
25323 wxSysColourChangedEvent *result = 0 ;
25324
25325 if (!SWIG_Python_UnpackTuple(args,"new_SysColourChangedEvent",0,0,0)) SWIG_fail;
25326 {
25327 PyThreadState* __tstate = wxPyBeginAllowThreads();
25328 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
25329 wxPyEndAllowThreads(__tstate);
25330 if (PyErr_Occurred()) SWIG_fail;
25331 }
25332 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSysColourChangedEvent, SWIG_POINTER_NEW | 0 );
25333 return resultobj;
25334 fail:
25335 return NULL;
25336 }
25337
25338
25339 SWIGINTERN PyObject *SysColourChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25340 PyObject *obj;
25341 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25342 SWIG_TypeNewClientData(SWIGTYPE_p_wxSysColourChangedEvent, SWIG_NewClientData(obj));
25343 return SWIG_Py_Void();
25344 }
25345
25346 SWIGINTERN PyObject *SysColourChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25347 return SWIG_Python_InitShadowInstance(args);
25348 }
25349
25350 SWIGINTERN PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25351 PyObject *resultobj = 0;
25352 int arg1 = (int) 0 ;
25353 wxWindow *arg2 = (wxWindow *) NULL ;
25354 wxMouseCaptureChangedEvent *result = 0 ;
25355 int val1 ;
25356 int ecode1 = 0 ;
25357 void *argp2 = 0 ;
25358 int res2 = 0 ;
25359 PyObject * obj0 = 0 ;
25360 PyObject * obj1 = 0 ;
25361 char * kwnames[] = {
25362 (char *) "winid",(char *) "gainedCapture", NULL
25363 };
25364
25365 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) SWIG_fail;
25366 if (obj0) {
25367 ecode1 = SWIG_AsVal_int(obj0, &val1);
25368 if (!SWIG_IsOK(ecode1)) {
25369 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "1"" of type '" "int""'");
25370 }
25371 arg1 = static_cast< int >(val1);
25372 }
25373 if (obj1) {
25374 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25375 if (!SWIG_IsOK(res2)) {
25376 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "2"" of type '" "wxWindow *""'");
25377 }
25378 arg2 = reinterpret_cast< wxWindow * >(argp2);
25379 }
25380 {
25381 PyThreadState* __tstate = wxPyBeginAllowThreads();
25382 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
25383 wxPyEndAllowThreads(__tstate);
25384 if (PyErr_Occurred()) SWIG_fail;
25385 }
25386 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_NEW | 0 );
25387 return resultobj;
25388 fail:
25389 return NULL;
25390 }
25391
25392
25393 SWIGINTERN PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25394 PyObject *resultobj = 0;
25395 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
25396 wxWindow *result = 0 ;
25397 void *argp1 = 0 ;
25398 int res1 = 0 ;
25399 PyObject *swig_obj[1] ;
25400
25401 if (!args) SWIG_fail;
25402 swig_obj[0] = args;
25403 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseCaptureChangedEvent, 0 | 0 );
25404 if (!SWIG_IsOK(res1)) {
25405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseCaptureChangedEvent_GetCapturedWindow" "', expected argument " "1"" of type '" "wxMouseCaptureChangedEvent const *""'");
25406 }
25407 arg1 = reinterpret_cast< wxMouseCaptureChangedEvent * >(argp1);
25408 {
25409 PyThreadState* __tstate = wxPyBeginAllowThreads();
25410 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
25411 wxPyEndAllowThreads(__tstate);
25412 if (PyErr_Occurred()) SWIG_fail;
25413 }
25414 {
25415 resultobj = wxPyMake_wxObject(result, (bool)0);
25416 }
25417 return resultobj;
25418 fail:
25419 return NULL;
25420 }
25421
25422
25423 SWIGINTERN PyObject *MouseCaptureChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25424 PyObject *obj;
25425 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25426 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_NewClientData(obj));
25427 return SWIG_Py_Void();
25428 }
25429
25430 SWIGINTERN PyObject *MouseCaptureChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25431 return SWIG_Python_InitShadowInstance(args);
25432 }
25433
25434 SWIGINTERN PyObject *_wrap_new_DisplayChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25435 PyObject *resultobj = 0;
25436 wxDisplayChangedEvent *result = 0 ;
25437
25438 if (!SWIG_Python_UnpackTuple(args,"new_DisplayChangedEvent",0,0,0)) SWIG_fail;
25439 {
25440 PyThreadState* __tstate = wxPyBeginAllowThreads();
25441 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
25442 wxPyEndAllowThreads(__tstate);
25443 if (PyErr_Occurred()) SWIG_fail;
25444 }
25445 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplayChangedEvent, SWIG_POINTER_NEW | 0 );
25446 return resultobj;
25447 fail:
25448 return NULL;
25449 }
25450
25451
25452 SWIGINTERN PyObject *DisplayChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25453 PyObject *obj;
25454 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25455 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplayChangedEvent, SWIG_NewClientData(obj));
25456 return SWIG_Py_Void();
25457 }
25458
25459 SWIGINTERN PyObject *DisplayChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25460 return SWIG_Python_InitShadowInstance(args);
25461 }
25462
25463 SWIGINTERN PyObject *_wrap_new_PaletteChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25464 PyObject *resultobj = 0;
25465 int arg1 = (int) 0 ;
25466 wxPaletteChangedEvent *result = 0 ;
25467 int val1 ;
25468 int ecode1 = 0 ;
25469 PyObject * obj0 = 0 ;
25470 char * kwnames[] = {
25471 (char *) "id", NULL
25472 };
25473
25474 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) SWIG_fail;
25475 if (obj0) {
25476 ecode1 = SWIG_AsVal_int(obj0, &val1);
25477 if (!SWIG_IsOK(ecode1)) {
25478 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaletteChangedEvent" "', expected argument " "1"" of type '" "int""'");
25479 }
25480 arg1 = static_cast< int >(val1);
25481 }
25482 {
25483 PyThreadState* __tstate = wxPyBeginAllowThreads();
25484 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
25485 wxPyEndAllowThreads(__tstate);
25486 if (PyErr_Occurred()) SWIG_fail;
25487 }
25488 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_NEW | 0 );
25489 return resultobj;
25490 fail:
25491 return NULL;
25492 }
25493
25494
25495 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25496 PyObject *resultobj = 0;
25497 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25498 wxWindow *arg2 = (wxWindow *) 0 ;
25499 void *argp1 = 0 ;
25500 int res1 = 0 ;
25501 void *argp2 = 0 ;
25502 int res2 = 0 ;
25503 PyObject * obj0 = 0 ;
25504 PyObject * obj1 = 0 ;
25505 char * kwnames[] = {
25506 (char *) "self",(char *) "win", NULL
25507 };
25508
25509 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) SWIG_fail;
25510 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25511 if (!SWIG_IsOK(res1)) {
25512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25513 }
25514 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25515 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25516 if (!SWIG_IsOK(res2)) {
25517 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
25518 }
25519 arg2 = reinterpret_cast< wxWindow * >(argp2);
25520 {
25521 PyThreadState* __tstate = wxPyBeginAllowThreads();
25522 (arg1)->SetChangedWindow(arg2);
25523 wxPyEndAllowThreads(__tstate);
25524 if (PyErr_Occurred()) SWIG_fail;
25525 }
25526 resultobj = SWIG_Py_Void();
25527 return resultobj;
25528 fail:
25529 return NULL;
25530 }
25531
25532
25533 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25534 PyObject *resultobj = 0;
25535 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25536 wxWindow *result = 0 ;
25537 void *argp1 = 0 ;
25538 int res1 = 0 ;
25539 PyObject *swig_obj[1] ;
25540
25541 if (!args) SWIG_fail;
25542 swig_obj[0] = args;
25543 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25544 if (!SWIG_IsOK(res1)) {
25545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_GetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25546 }
25547 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25548 {
25549 PyThreadState* __tstate = wxPyBeginAllowThreads();
25550 result = (wxWindow *)(arg1)->GetChangedWindow();
25551 wxPyEndAllowThreads(__tstate);
25552 if (PyErr_Occurred()) SWIG_fail;
25553 }
25554 {
25555 resultobj = wxPyMake_wxObject(result, (bool)0);
25556 }
25557 return resultobj;
25558 fail:
25559 return NULL;
25560 }
25561
25562
25563 SWIGINTERN PyObject *PaletteChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25564 PyObject *obj;
25565 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25566 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaletteChangedEvent, SWIG_NewClientData(obj));
25567 return SWIG_Py_Void();
25568 }
25569
25570 SWIGINTERN PyObject *PaletteChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25571 return SWIG_Python_InitShadowInstance(args);
25572 }
25573
25574 SWIGINTERN PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25575 PyObject *resultobj = 0;
25576 int arg1 = (int) 0 ;
25577 wxQueryNewPaletteEvent *result = 0 ;
25578 int val1 ;
25579 int ecode1 = 0 ;
25580 PyObject * obj0 = 0 ;
25581 char * kwnames[] = {
25582 (char *) "winid", NULL
25583 };
25584
25585 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) SWIG_fail;
25586 if (obj0) {
25587 ecode1 = SWIG_AsVal_int(obj0, &val1);
25588 if (!SWIG_IsOK(ecode1)) {
25589 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_QueryNewPaletteEvent" "', expected argument " "1"" of type '" "int""'");
25590 }
25591 arg1 = static_cast< int >(val1);
25592 }
25593 {
25594 PyThreadState* __tstate = wxPyBeginAllowThreads();
25595 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
25596 wxPyEndAllowThreads(__tstate);
25597 if (PyErr_Occurred()) SWIG_fail;
25598 }
25599 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_NEW | 0 );
25600 return resultobj;
25601 fail:
25602 return NULL;
25603 }
25604
25605
25606 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25607 PyObject *resultobj = 0;
25608 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
25609 bool arg2 ;
25610 void *argp1 = 0 ;
25611 int res1 = 0 ;
25612 bool val2 ;
25613 int ecode2 = 0 ;
25614 PyObject * obj0 = 0 ;
25615 PyObject * obj1 = 0 ;
25616 char * kwnames[] = {
25617 (char *) "self",(char *) "realized", NULL
25618 };
25619
25620 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) SWIG_fail;
25621 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
25622 if (!SWIG_IsOK(res1)) {
25623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent *""'");
25624 }
25625 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
25626 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25627 if (!SWIG_IsOK(ecode2)) {
25628 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "2"" of type '" "bool""'");
25629 }
25630 arg2 = static_cast< bool >(val2);
25631 {
25632 PyThreadState* __tstate = wxPyBeginAllowThreads();
25633 (arg1)->SetPaletteRealized(arg2);
25634 wxPyEndAllowThreads(__tstate);
25635 if (PyErr_Occurred()) SWIG_fail;
25636 }
25637 resultobj = SWIG_Py_Void();
25638 return resultobj;
25639 fail:
25640 return NULL;
25641 }
25642
25643
25644 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25645 PyObject *resultobj = 0;
25646 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
25647 bool result;
25648 void *argp1 = 0 ;
25649 int res1 = 0 ;
25650 PyObject *swig_obj[1] ;
25651
25652 if (!args) SWIG_fail;
25653 swig_obj[0] = args;
25654 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
25655 if (!SWIG_IsOK(res1)) {
25656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_GetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent const *""'");
25657 }
25658 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
25659 {
25660 PyThreadState* __tstate = wxPyBeginAllowThreads();
25661 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
25662 wxPyEndAllowThreads(__tstate);
25663 if (PyErr_Occurred()) SWIG_fail;
25664 }
25665 {
25666 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25667 }
25668 return resultobj;
25669 fail:
25670 return NULL;
25671 }
25672
25673
25674 SWIGINTERN PyObject *QueryNewPaletteEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25675 PyObject *obj;
25676 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25677 SWIG_TypeNewClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_NewClientData(obj));
25678 return SWIG_Py_Void();
25679 }
25680
25681 SWIGINTERN PyObject *QueryNewPaletteEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25682 return SWIG_Python_InitShadowInstance(args);
25683 }
25684
25685 SWIGINTERN PyObject *_wrap_new_NavigationKeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25686 PyObject *resultobj = 0;
25687 wxNavigationKeyEvent *result = 0 ;
25688
25689 if (!SWIG_Python_UnpackTuple(args,"new_NavigationKeyEvent",0,0,0)) SWIG_fail;
25690 {
25691 PyThreadState* __tstate = wxPyBeginAllowThreads();
25692 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
25693 wxPyEndAllowThreads(__tstate);
25694 if (PyErr_Occurred()) SWIG_fail;
25695 }
25696 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_NEW | 0 );
25697 return resultobj;
25698 fail:
25699 return NULL;
25700 }
25701
25702
25703 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25704 PyObject *resultobj = 0;
25705 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25706 bool result;
25707 void *argp1 = 0 ;
25708 int res1 = 0 ;
25709 PyObject *swig_obj[1] ;
25710
25711 if (!args) SWIG_fail;
25712 swig_obj[0] = args;
25713 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25714 if (!SWIG_IsOK(res1)) {
25715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25716 }
25717 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25718 {
25719 PyThreadState* __tstate = wxPyBeginAllowThreads();
25720 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
25721 wxPyEndAllowThreads(__tstate);
25722 if (PyErr_Occurred()) SWIG_fail;
25723 }
25724 {
25725 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25726 }
25727 return resultobj;
25728 fail:
25729 return NULL;
25730 }
25731
25732
25733 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25734 PyObject *resultobj = 0;
25735 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25736 bool arg2 ;
25737 void *argp1 = 0 ;
25738 int res1 = 0 ;
25739 bool val2 ;
25740 int ecode2 = 0 ;
25741 PyObject * obj0 = 0 ;
25742 PyObject * obj1 = 0 ;
25743 char * kwnames[] = {
25744 (char *) "self",(char *) "forward", NULL
25745 };
25746
25747 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) SWIG_fail;
25748 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25749 if (!SWIG_IsOK(res1)) {
25750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25751 }
25752 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25753 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25754 if (!SWIG_IsOK(ecode2)) {
25755 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "2"" of type '" "bool""'");
25756 }
25757 arg2 = static_cast< bool >(val2);
25758 {
25759 PyThreadState* __tstate = wxPyBeginAllowThreads();
25760 (arg1)->SetDirection(arg2);
25761 wxPyEndAllowThreads(__tstate);
25762 if (PyErr_Occurred()) SWIG_fail;
25763 }
25764 resultobj = SWIG_Py_Void();
25765 return resultobj;
25766 fail:
25767 return NULL;
25768 }
25769
25770
25771 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25772 PyObject *resultobj = 0;
25773 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25774 bool result;
25775 void *argp1 = 0 ;
25776 int res1 = 0 ;
25777 PyObject *swig_obj[1] ;
25778
25779 if (!args) SWIG_fail;
25780 swig_obj[0] = args;
25781 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25782 if (!SWIG_IsOK(res1)) {
25783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25784 }
25785 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25786 {
25787 PyThreadState* __tstate = wxPyBeginAllowThreads();
25788 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
25789 wxPyEndAllowThreads(__tstate);
25790 if (PyErr_Occurred()) SWIG_fail;
25791 }
25792 {
25793 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25794 }
25795 return resultobj;
25796 fail:
25797 return NULL;
25798 }
25799
25800
25801 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25802 PyObject *resultobj = 0;
25803 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25804 bool arg2 ;
25805 void *argp1 = 0 ;
25806 int res1 = 0 ;
25807 bool val2 ;
25808 int ecode2 = 0 ;
25809 PyObject * obj0 = 0 ;
25810 PyObject * obj1 = 0 ;
25811 char * kwnames[] = {
25812 (char *) "self",(char *) "ischange", NULL
25813 };
25814
25815 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) SWIG_fail;
25816 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25817 if (!SWIG_IsOK(res1)) {
25818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25819 }
25820 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25821 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25822 if (!SWIG_IsOK(ecode2)) {
25823 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "2"" of type '" "bool""'");
25824 }
25825 arg2 = static_cast< bool >(val2);
25826 {
25827 PyThreadState* __tstate = wxPyBeginAllowThreads();
25828 (arg1)->SetWindowChange(arg2);
25829 wxPyEndAllowThreads(__tstate);
25830 if (PyErr_Occurred()) SWIG_fail;
25831 }
25832 resultobj = SWIG_Py_Void();
25833 return resultobj;
25834 fail:
25835 return NULL;
25836 }
25837
25838
25839 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25840 PyObject *resultobj = 0;
25841 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25842 bool result;
25843 void *argp1 = 0 ;
25844 int res1 = 0 ;
25845 PyObject *swig_obj[1] ;
25846
25847 if (!args) SWIG_fail;
25848 swig_obj[0] = args;
25849 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25850 if (!SWIG_IsOK(res1)) {
25851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25852 }
25853 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25854 {
25855 PyThreadState* __tstate = wxPyBeginAllowThreads();
25856 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
25857 wxPyEndAllowThreads(__tstate);
25858 if (PyErr_Occurred()) SWIG_fail;
25859 }
25860 {
25861 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25862 }
25863 return resultobj;
25864 fail:
25865 return NULL;
25866 }
25867
25868
25869 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25870 PyObject *resultobj = 0;
25871 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25872 bool arg2 ;
25873 void *argp1 = 0 ;
25874 int res1 = 0 ;
25875 bool val2 ;
25876 int ecode2 = 0 ;
25877 PyObject * obj0 = 0 ;
25878 PyObject * obj1 = 0 ;
25879 char * kwnames[] = {
25880 (char *) "self",(char *) "bIs", NULL
25881 };
25882
25883 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) SWIG_fail;
25884 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25885 if (!SWIG_IsOK(res1)) {
25886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25887 }
25888 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25889 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25890 if (!SWIG_IsOK(ecode2)) {
25891 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "2"" of type '" "bool""'");
25892 }
25893 arg2 = static_cast< bool >(val2);
25894 {
25895 PyThreadState* __tstate = wxPyBeginAllowThreads();
25896 (arg1)->SetFromTab(arg2);
25897 wxPyEndAllowThreads(__tstate);
25898 if (PyErr_Occurred()) SWIG_fail;
25899 }
25900 resultobj = SWIG_Py_Void();
25901 return resultobj;
25902 fail:
25903 return NULL;
25904 }
25905
25906
25907 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25908 PyObject *resultobj = 0;
25909 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25910 long arg2 ;
25911 void *argp1 = 0 ;
25912 int res1 = 0 ;
25913 long val2 ;
25914 int ecode2 = 0 ;
25915 PyObject * obj0 = 0 ;
25916 PyObject * obj1 = 0 ;
25917 char * kwnames[] = {
25918 (char *) "self",(char *) "flags", NULL
25919 };
25920
25921 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) SWIG_fail;
25922 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25923 if (!SWIG_IsOK(res1)) {
25924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25925 }
25926 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25927 ecode2 = SWIG_AsVal_long(obj1, &val2);
25928 if (!SWIG_IsOK(ecode2)) {
25929 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "2"" of type '" "long""'");
25930 }
25931 arg2 = static_cast< long >(val2);
25932 {
25933 PyThreadState* __tstate = wxPyBeginAllowThreads();
25934 (arg1)->SetFlags(arg2);
25935 wxPyEndAllowThreads(__tstate);
25936 if (PyErr_Occurred()) SWIG_fail;
25937 }
25938 resultobj = SWIG_Py_Void();
25939 return resultobj;
25940 fail:
25941 return NULL;
25942 }
25943
25944
25945 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25946 PyObject *resultobj = 0;
25947 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25948 wxWindow *result = 0 ;
25949 void *argp1 = 0 ;
25950 int res1 = 0 ;
25951 PyObject *swig_obj[1] ;
25952
25953 if (!args) SWIG_fail;
25954 swig_obj[0] = args;
25955 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25956 if (!SWIG_IsOK(res1)) {
25957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25958 }
25959 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25960 {
25961 PyThreadState* __tstate = wxPyBeginAllowThreads();
25962 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
25963 wxPyEndAllowThreads(__tstate);
25964 if (PyErr_Occurred()) SWIG_fail;
25965 }
25966 {
25967 resultobj = wxPyMake_wxObject(result, (bool)0);
25968 }
25969 return resultobj;
25970 fail:
25971 return NULL;
25972 }
25973
25974
25975 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25976 PyObject *resultobj = 0;
25977 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25978 wxWindow *arg2 = (wxWindow *) 0 ;
25979 void *argp1 = 0 ;
25980 int res1 = 0 ;
25981 void *argp2 = 0 ;
25982 int res2 = 0 ;
25983 PyObject * obj0 = 0 ;
25984 PyObject * obj1 = 0 ;
25985 char * kwnames[] = {
25986 (char *) "self",(char *) "win", NULL
25987 };
25988
25989 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) SWIG_fail;
25990 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25991 if (!SWIG_IsOK(res1)) {
25992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25993 }
25994 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25995 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25996 if (!SWIG_IsOK(res2)) {
25997 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "2"" of type '" "wxWindow *""'");
25998 }
25999 arg2 = reinterpret_cast< wxWindow * >(argp2);
26000 {
26001 PyThreadState* __tstate = wxPyBeginAllowThreads();
26002 (arg1)->SetCurrentFocus(arg2);
26003 wxPyEndAllowThreads(__tstate);
26004 if (PyErr_Occurred()) SWIG_fail;
26005 }
26006 resultobj = SWIG_Py_Void();
26007 return resultobj;
26008 fail:
26009 return NULL;
26010 }
26011
26012
26013 SWIGINTERN PyObject *NavigationKeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26014 PyObject *obj;
26015 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26016 SWIG_TypeNewClientData(SWIGTYPE_p_wxNavigationKeyEvent, SWIG_NewClientData(obj));
26017 return SWIG_Py_Void();
26018 }
26019
26020 SWIGINTERN PyObject *NavigationKeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26021 return SWIG_Python_InitShadowInstance(args);
26022 }
26023
26024 SWIGINTERN PyObject *_wrap_new_WindowCreateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26025 PyObject *resultobj = 0;
26026 wxWindow *arg1 = (wxWindow *) NULL ;
26027 wxWindowCreateEvent *result = 0 ;
26028 void *argp1 = 0 ;
26029 int res1 = 0 ;
26030 PyObject * obj0 = 0 ;
26031 char * kwnames[] = {
26032 (char *) "win", NULL
26033 };
26034
26035 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) SWIG_fail;
26036 if (obj0) {
26037 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26038 if (!SWIG_IsOK(res1)) {
26039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowCreateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26040 }
26041 arg1 = reinterpret_cast< wxWindow * >(argp1);
26042 }
26043 {
26044 PyThreadState* __tstate = wxPyBeginAllowThreads();
26045 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
26046 wxPyEndAllowThreads(__tstate);
26047 if (PyErr_Occurred()) SWIG_fail;
26048 }
26049 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_NEW | 0 );
26050 return resultobj;
26051 fail:
26052 return NULL;
26053 }
26054
26055
26056 SWIGINTERN PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26057 PyObject *resultobj = 0;
26058 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
26059 wxWindow *result = 0 ;
26060 void *argp1 = 0 ;
26061 int res1 = 0 ;
26062 PyObject *swig_obj[1] ;
26063
26064 if (!args) SWIG_fail;
26065 swig_obj[0] = args;
26066 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowCreateEvent, 0 | 0 );
26067 if (!SWIG_IsOK(res1)) {
26068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowCreateEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowCreateEvent const *""'");
26069 }
26070 arg1 = reinterpret_cast< wxWindowCreateEvent * >(argp1);
26071 {
26072 PyThreadState* __tstate = wxPyBeginAllowThreads();
26073 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
26074 wxPyEndAllowThreads(__tstate);
26075 if (PyErr_Occurred()) SWIG_fail;
26076 }
26077 {
26078 resultobj = wxPyMake_wxObject(result, (bool)0);
26079 }
26080 return resultobj;
26081 fail:
26082 return NULL;
26083 }
26084
26085
26086 SWIGINTERN PyObject *WindowCreateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26087 PyObject *obj;
26088 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26089 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowCreateEvent, SWIG_NewClientData(obj));
26090 return SWIG_Py_Void();
26091 }
26092
26093 SWIGINTERN PyObject *WindowCreateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26094 return SWIG_Python_InitShadowInstance(args);
26095 }
26096
26097 SWIGINTERN PyObject *_wrap_new_WindowDestroyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26098 PyObject *resultobj = 0;
26099 wxWindow *arg1 = (wxWindow *) NULL ;
26100 wxWindowDestroyEvent *result = 0 ;
26101 void *argp1 = 0 ;
26102 int res1 = 0 ;
26103 PyObject * obj0 = 0 ;
26104 char * kwnames[] = {
26105 (char *) "win", NULL
26106 };
26107
26108 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) SWIG_fail;
26109 if (obj0) {
26110 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26111 if (!SWIG_IsOK(res1)) {
26112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDestroyEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26113 }
26114 arg1 = reinterpret_cast< wxWindow * >(argp1);
26115 }
26116 {
26117 PyThreadState* __tstate = wxPyBeginAllowThreads();
26118 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
26119 wxPyEndAllowThreads(__tstate);
26120 if (PyErr_Occurred()) SWIG_fail;
26121 }
26122 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_NEW | 0 );
26123 return resultobj;
26124 fail:
26125 return NULL;
26126 }
26127
26128
26129 SWIGINTERN PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26130 PyObject *resultobj = 0;
26131 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
26132 wxWindow *result = 0 ;
26133 void *argp1 = 0 ;
26134 int res1 = 0 ;
26135 PyObject *swig_obj[1] ;
26136
26137 if (!args) SWIG_fail;
26138 swig_obj[0] = args;
26139 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDestroyEvent, 0 | 0 );
26140 if (!SWIG_IsOK(res1)) {
26141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowDestroyEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowDestroyEvent const *""'");
26142 }
26143 arg1 = reinterpret_cast< wxWindowDestroyEvent * >(argp1);
26144 {
26145 PyThreadState* __tstate = wxPyBeginAllowThreads();
26146 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
26147 wxPyEndAllowThreads(__tstate);
26148 if (PyErr_Occurred()) SWIG_fail;
26149 }
26150 {
26151 resultobj = wxPyMake_wxObject(result, (bool)0);
26152 }
26153 return resultobj;
26154 fail:
26155 return NULL;
26156 }
26157
26158
26159 SWIGINTERN PyObject *WindowDestroyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26160 PyObject *obj;
26161 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26162 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDestroyEvent, SWIG_NewClientData(obj));
26163 return SWIG_Py_Void();
26164 }
26165
26166 SWIGINTERN PyObject *WindowDestroyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26167 return SWIG_Python_InitShadowInstance(args);
26168 }
26169
26170 SWIGINTERN PyObject *_wrap_new_ContextMenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26171 PyObject *resultobj = 0;
26172 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26173 int arg2 = (int) 0 ;
26174 wxPoint const &arg3_defvalue = wxDefaultPosition ;
26175 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
26176 wxContextMenuEvent *result = 0 ;
26177 int val1 ;
26178 int ecode1 = 0 ;
26179 int val2 ;
26180 int ecode2 = 0 ;
26181 wxPoint temp3 ;
26182 PyObject * obj0 = 0 ;
26183 PyObject * obj1 = 0 ;
26184 PyObject * obj2 = 0 ;
26185 char * kwnames[] = {
26186 (char *) "type",(char *) "winid",(char *) "pt", NULL
26187 };
26188
26189 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26190 if (obj0) {
26191 ecode1 = SWIG_AsVal_int(obj0, &val1);
26192 if (!SWIG_IsOK(ecode1)) {
26193 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ContextMenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26194 }
26195 arg1 = static_cast< wxEventType >(val1);
26196 }
26197 if (obj1) {
26198 ecode2 = SWIG_AsVal_int(obj1, &val2);
26199 if (!SWIG_IsOK(ecode2)) {
26200 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ContextMenuEvent" "', expected argument " "2"" of type '" "int""'");
26201 }
26202 arg2 = static_cast< int >(val2);
26203 }
26204 if (obj2) {
26205 {
26206 arg3 = &temp3;
26207 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
26208 }
26209 }
26210 {
26211 PyThreadState* __tstate = wxPyBeginAllowThreads();
26212 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
26213 wxPyEndAllowThreads(__tstate);
26214 if (PyErr_Occurred()) SWIG_fail;
26215 }
26216 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_NEW | 0 );
26217 return resultobj;
26218 fail:
26219 return NULL;
26220 }
26221
26222
26223 SWIGINTERN PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26224 PyObject *resultobj = 0;
26225 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26226 wxPoint *result = 0 ;
26227 void *argp1 = 0 ;
26228 int res1 = 0 ;
26229 PyObject *swig_obj[1] ;
26230
26231 if (!args) SWIG_fail;
26232 swig_obj[0] = args;
26233 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26234 if (!SWIG_IsOK(res1)) {
26235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_GetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent const *""'");
26236 }
26237 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26238 {
26239 PyThreadState* __tstate = wxPyBeginAllowThreads();
26240 {
26241 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
26242 result = (wxPoint *) &_result_ref;
26243 }
26244 wxPyEndAllowThreads(__tstate);
26245 if (PyErr_Occurred()) SWIG_fail;
26246 }
26247 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, 0 | 0 );
26248 return resultobj;
26249 fail:
26250 return NULL;
26251 }
26252
26253
26254 SWIGINTERN PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26255 PyObject *resultobj = 0;
26256 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26257 wxPoint *arg2 = 0 ;
26258 void *argp1 = 0 ;
26259 int res1 = 0 ;
26260 wxPoint temp2 ;
26261 PyObject * obj0 = 0 ;
26262 PyObject * obj1 = 0 ;
26263 char * kwnames[] = {
26264 (char *) "self",(char *) "pos", NULL
26265 };
26266
26267 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
26268 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26269 if (!SWIG_IsOK(res1)) {
26270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_SetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent *""'");
26271 }
26272 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26273 {
26274 arg2 = &temp2;
26275 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
26276 }
26277 {
26278 PyThreadState* __tstate = wxPyBeginAllowThreads();
26279 (arg1)->SetPosition((wxPoint const &)*arg2);
26280 wxPyEndAllowThreads(__tstate);
26281 if (PyErr_Occurred()) SWIG_fail;
26282 }
26283 resultobj = SWIG_Py_Void();
26284 return resultobj;
26285 fail:
26286 return NULL;
26287 }
26288
26289
26290 SWIGINTERN PyObject *ContextMenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26291 PyObject *obj;
26292 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26293 SWIG_TypeNewClientData(SWIGTYPE_p_wxContextMenuEvent, SWIG_NewClientData(obj));
26294 return SWIG_Py_Void();
26295 }
26296
26297 SWIGINTERN PyObject *ContextMenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26298 return SWIG_Python_InitShadowInstance(args);
26299 }
26300
26301 SWIGINTERN PyObject *_wrap_new_IdleEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26302 PyObject *resultobj = 0;
26303 wxIdleEvent *result = 0 ;
26304
26305 if (!SWIG_Python_UnpackTuple(args,"new_IdleEvent",0,0,0)) SWIG_fail;
26306 {
26307 PyThreadState* __tstate = wxPyBeginAllowThreads();
26308 result = (wxIdleEvent *)new wxIdleEvent();
26309 wxPyEndAllowThreads(__tstate);
26310 if (PyErr_Occurred()) SWIG_fail;
26311 }
26312 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_NEW | 0 );
26313 return resultobj;
26314 fail:
26315 return NULL;
26316 }
26317
26318
26319 SWIGINTERN PyObject *_wrap_IdleEvent_RequestMore(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26320 PyObject *resultobj = 0;
26321 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26322 bool arg2 = (bool) true ;
26323 void *argp1 = 0 ;
26324 int res1 = 0 ;
26325 bool val2 ;
26326 int ecode2 = 0 ;
26327 PyObject * obj0 = 0 ;
26328 PyObject * obj1 = 0 ;
26329 char * kwnames[] = {
26330 (char *) "self",(char *) "needMore", NULL
26331 };
26332
26333 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) SWIG_fail;
26334 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26335 if (!SWIG_IsOK(res1)) {
26336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_RequestMore" "', expected argument " "1"" of type '" "wxIdleEvent *""'");
26337 }
26338 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26339 if (obj1) {
26340 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26341 if (!SWIG_IsOK(ecode2)) {
26342 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IdleEvent_RequestMore" "', expected argument " "2"" of type '" "bool""'");
26343 }
26344 arg2 = static_cast< bool >(val2);
26345 }
26346 {
26347 PyThreadState* __tstate = wxPyBeginAllowThreads();
26348 (arg1)->RequestMore(arg2);
26349 wxPyEndAllowThreads(__tstate);
26350 if (PyErr_Occurred()) SWIG_fail;
26351 }
26352 resultobj = SWIG_Py_Void();
26353 return resultobj;
26354 fail:
26355 return NULL;
26356 }
26357
26358
26359 SWIGINTERN PyObject *_wrap_IdleEvent_MoreRequested(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26360 PyObject *resultobj = 0;
26361 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26362 bool result;
26363 void *argp1 = 0 ;
26364 int res1 = 0 ;
26365 PyObject *swig_obj[1] ;
26366
26367 if (!args) SWIG_fail;
26368 swig_obj[0] = args;
26369 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26370 if (!SWIG_IsOK(res1)) {
26371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_MoreRequested" "', expected argument " "1"" of type '" "wxIdleEvent const *""'");
26372 }
26373 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26374 {
26375 PyThreadState* __tstate = wxPyBeginAllowThreads();
26376 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
26377 wxPyEndAllowThreads(__tstate);
26378 if (PyErr_Occurred()) SWIG_fail;
26379 }
26380 {
26381 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26382 }
26383 return resultobj;
26384 fail:
26385 return NULL;
26386 }
26387
26388
26389 SWIGINTERN PyObject *_wrap_IdleEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26390 PyObject *resultobj = 0;
26391 wxIdleMode arg1 ;
26392 int val1 ;
26393 int ecode1 = 0 ;
26394 PyObject * obj0 = 0 ;
26395 char * kwnames[] = {
26396 (char *) "mode", NULL
26397 };
26398
26399 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) SWIG_fail;
26400 ecode1 = SWIG_AsVal_int(obj0, &val1);
26401 if (!SWIG_IsOK(ecode1)) {
26402 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IdleEvent_SetMode" "', expected argument " "1"" of type '" "wxIdleMode""'");
26403 }
26404 arg1 = static_cast< wxIdleMode >(val1);
26405 {
26406 PyThreadState* __tstate = wxPyBeginAllowThreads();
26407 wxIdleEvent::SetMode(arg1);
26408 wxPyEndAllowThreads(__tstate);
26409 if (PyErr_Occurred()) SWIG_fail;
26410 }
26411 resultobj = SWIG_Py_Void();
26412 return resultobj;
26413 fail:
26414 return NULL;
26415 }
26416
26417
26418 SWIGINTERN PyObject *_wrap_IdleEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26419 PyObject *resultobj = 0;
26420 wxIdleMode result;
26421
26422 if (!SWIG_Python_UnpackTuple(args,"IdleEvent_GetMode",0,0,0)) SWIG_fail;
26423 {
26424 PyThreadState* __tstate = wxPyBeginAllowThreads();
26425 result = (wxIdleMode)wxIdleEvent::GetMode();
26426 wxPyEndAllowThreads(__tstate);
26427 if (PyErr_Occurred()) SWIG_fail;
26428 }
26429 resultobj = SWIG_From_int(static_cast< int >(result));
26430 return resultobj;
26431 fail:
26432 return NULL;
26433 }
26434
26435
26436 SWIGINTERN PyObject *_wrap_IdleEvent_CanSend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26437 PyObject *resultobj = 0;
26438 wxWindow *arg1 = (wxWindow *) 0 ;
26439 bool result;
26440 void *argp1 = 0 ;
26441 int res1 = 0 ;
26442 PyObject * obj0 = 0 ;
26443 char * kwnames[] = {
26444 (char *) "win", NULL
26445 };
26446
26447 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) SWIG_fail;
26448 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26449 if (!SWIG_IsOK(res1)) {
26450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_CanSend" "', expected argument " "1"" of type '" "wxWindow *""'");
26451 }
26452 arg1 = reinterpret_cast< wxWindow * >(argp1);
26453 {
26454 PyThreadState* __tstate = wxPyBeginAllowThreads();
26455 result = (bool)wxIdleEvent::CanSend(arg1);
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 *IdleEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26469 PyObject *obj;
26470 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26471 SWIG_TypeNewClientData(SWIGTYPE_p_wxIdleEvent, SWIG_NewClientData(obj));
26472 return SWIG_Py_Void();
26473 }
26474
26475 SWIGINTERN PyObject *IdleEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26476 return SWIG_Python_InitShadowInstance(args);
26477 }
26478
26479 SWIGINTERN PyObject *_wrap_new_ClipboardTextEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26480 PyObject *resultobj = 0;
26481 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26482 int arg2 = (int) 0 ;
26483 wxClipboardTextEvent *result = 0 ;
26484 int val1 ;
26485 int ecode1 = 0 ;
26486 int val2 ;
26487 int ecode2 = 0 ;
26488 PyObject * obj0 = 0 ;
26489 PyObject * obj1 = 0 ;
26490 char * kwnames[] = {
26491 (char *) "type",(char *) "winid", NULL
26492 };
26493
26494 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ClipboardTextEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26495 if (obj0) {
26496 ecode1 = SWIG_AsVal_int(obj0, &val1);
26497 if (!SWIG_IsOK(ecode1)) {
26498 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ClipboardTextEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26499 }
26500 arg1 = static_cast< wxEventType >(val1);
26501 }
26502 if (obj1) {
26503 ecode2 = SWIG_AsVal_int(obj1, &val2);
26504 if (!SWIG_IsOK(ecode2)) {
26505 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ClipboardTextEvent" "', expected argument " "2"" of type '" "int""'");
26506 }
26507 arg2 = static_cast< int >(val2);
26508 }
26509 {
26510 PyThreadState* __tstate = wxPyBeginAllowThreads();
26511 result = (wxClipboardTextEvent *)new wxClipboardTextEvent(arg1,arg2);
26512 wxPyEndAllowThreads(__tstate);
26513 if (PyErr_Occurred()) SWIG_fail;
26514 }
26515 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardTextEvent, SWIG_POINTER_NEW | 0 );
26516 return resultobj;
26517 fail:
26518 return NULL;
26519 }
26520
26521
26522 SWIGINTERN PyObject *ClipboardTextEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26523 PyObject *obj;
26524 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26525 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardTextEvent, SWIG_NewClientData(obj));
26526 return SWIG_Py_Void();
26527 }
26528
26529 SWIGINTERN PyObject *ClipboardTextEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26530 return SWIG_Python_InitShadowInstance(args);
26531 }
26532
26533 SWIGINTERN PyObject *_wrap_new_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26534 PyObject *resultobj = 0;
26535 int arg1 = (int) 0 ;
26536 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
26537 wxPyEvent *result = 0 ;
26538 int val1 ;
26539 int ecode1 = 0 ;
26540 int val2 ;
26541 int ecode2 = 0 ;
26542 PyObject * obj0 = 0 ;
26543 PyObject * obj1 = 0 ;
26544 char * kwnames[] = {
26545 (char *) "winid",(char *) "eventType", NULL
26546 };
26547
26548 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26549 if (obj0) {
26550 ecode1 = SWIG_AsVal_int(obj0, &val1);
26551 if (!SWIG_IsOK(ecode1)) {
26552 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyEvent" "', expected argument " "1"" of type '" "int""'");
26553 }
26554 arg1 = static_cast< int >(val1);
26555 }
26556 if (obj1) {
26557 ecode2 = SWIG_AsVal_int(obj1, &val2);
26558 if (!SWIG_IsOK(ecode2)) {
26559 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyEvent" "', expected argument " "2"" of type '" "wxEventType""'");
26560 }
26561 arg2 = static_cast< wxEventType >(val2);
26562 }
26563 {
26564 PyThreadState* __tstate = wxPyBeginAllowThreads();
26565 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
26566 wxPyEndAllowThreads(__tstate);
26567 if (PyErr_Occurred()) SWIG_fail;
26568 }
26569 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyEvent, SWIG_POINTER_NEW | 0 );
26570 return resultobj;
26571 fail:
26572 return NULL;
26573 }
26574
26575
26576 SWIGINTERN PyObject *_wrap_delete_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26577 PyObject *resultobj = 0;
26578 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26579 void *argp1 = 0 ;
26580 int res1 = 0 ;
26581 PyObject *swig_obj[1] ;
26582
26583 if (!args) SWIG_fail;
26584 swig_obj[0] = args;
26585 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, SWIG_POINTER_DISOWN | 0 );
26586 if (!SWIG_IsOK(res1)) {
26587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyEvent" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26588 }
26589 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26590 {
26591 PyThreadState* __tstate = wxPyBeginAllowThreads();
26592 delete arg1;
26593
26594 wxPyEndAllowThreads(__tstate);
26595 if (PyErr_Occurred()) SWIG_fail;
26596 }
26597 resultobj = SWIG_Py_Void();
26598 return resultobj;
26599 fail:
26600 return NULL;
26601 }
26602
26603
26604 SWIGINTERN PyObject *_wrap_PyEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26605 PyObject *resultobj = 0;
26606 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26607 PyObject *arg2 = (PyObject *) 0 ;
26608 void *argp1 = 0 ;
26609 int res1 = 0 ;
26610 PyObject * obj0 = 0 ;
26611 PyObject * obj1 = 0 ;
26612 char * kwnames[] = {
26613 (char *) "self",(char *) "self", NULL
26614 };
26615
26616 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
26617 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
26618 if (!SWIG_IsOK(res1)) {
26619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26620 }
26621 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26622 arg2 = obj1;
26623 {
26624 PyThreadState* __tstate = wxPyBeginAllowThreads();
26625 (arg1)->SetSelf(arg2);
26626 wxPyEndAllowThreads(__tstate);
26627 if (PyErr_Occurred()) SWIG_fail;
26628 }
26629 resultobj = SWIG_Py_Void();
26630 return resultobj;
26631 fail:
26632 return NULL;
26633 }
26634
26635
26636 SWIGINTERN PyObject *_wrap_PyEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26637 PyObject *resultobj = 0;
26638 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26639 PyObject *result = 0 ;
26640 void *argp1 = 0 ;
26641 int res1 = 0 ;
26642 PyObject *swig_obj[1] ;
26643
26644 if (!args) SWIG_fail;
26645 swig_obj[0] = args;
26646 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
26647 if (!SWIG_IsOK(res1)) {
26648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26649 }
26650 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26651 {
26652 PyThreadState* __tstate = wxPyBeginAllowThreads();
26653 result = (PyObject *)(arg1)->GetSelf();
26654 wxPyEndAllowThreads(__tstate);
26655 if (PyErr_Occurred()) SWIG_fail;
26656 }
26657 resultobj = result;
26658 return resultobj;
26659 fail:
26660 return NULL;
26661 }
26662
26663
26664 SWIGINTERN PyObject *PyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26665 PyObject *obj;
26666 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26667 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyEvent, SWIG_NewClientData(obj));
26668 return SWIG_Py_Void();
26669 }
26670
26671 SWIGINTERN PyObject *PyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26672 return SWIG_Python_InitShadowInstance(args);
26673 }
26674
26675 SWIGINTERN PyObject *_wrap_new_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26676 PyObject *resultobj = 0;
26677 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26678 int arg2 = (int) 0 ;
26679 wxPyCommandEvent *result = 0 ;
26680 int val1 ;
26681 int ecode1 = 0 ;
26682 int val2 ;
26683 int ecode2 = 0 ;
26684 PyObject * obj0 = 0 ;
26685 PyObject * obj1 = 0 ;
26686 char * kwnames[] = {
26687 (char *) "eventType",(char *) "id", NULL
26688 };
26689
26690 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26691 if (obj0) {
26692 ecode1 = SWIG_AsVal_int(obj0, &val1);
26693 if (!SWIG_IsOK(ecode1)) {
26694 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyCommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26695 }
26696 arg1 = static_cast< wxEventType >(val1);
26697 }
26698 if (obj1) {
26699 ecode2 = SWIG_AsVal_int(obj1, &val2);
26700 if (!SWIG_IsOK(ecode2)) {
26701 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyCommandEvent" "', expected argument " "2"" of type '" "int""'");
26702 }
26703 arg2 = static_cast< int >(val2);
26704 }
26705 {
26706 PyThreadState* __tstate = wxPyBeginAllowThreads();
26707 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
26708 wxPyEndAllowThreads(__tstate);
26709 if (PyErr_Occurred()) SWIG_fail;
26710 }
26711 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_NEW | 0 );
26712 return resultobj;
26713 fail:
26714 return NULL;
26715 }
26716
26717
26718 SWIGINTERN PyObject *_wrap_delete_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26719 PyObject *resultobj = 0;
26720 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26721 void *argp1 = 0 ;
26722 int res1 = 0 ;
26723 PyObject *swig_obj[1] ;
26724
26725 if (!args) SWIG_fail;
26726 swig_obj[0] = args;
26727 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_DISOWN | 0 );
26728 if (!SWIG_IsOK(res1)) {
26729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyCommandEvent" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26730 }
26731 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26732 {
26733 PyThreadState* __tstate = wxPyBeginAllowThreads();
26734 delete arg1;
26735
26736 wxPyEndAllowThreads(__tstate);
26737 if (PyErr_Occurred()) SWIG_fail;
26738 }
26739 resultobj = SWIG_Py_Void();
26740 return resultobj;
26741 fail:
26742 return NULL;
26743 }
26744
26745
26746 SWIGINTERN PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26747 PyObject *resultobj = 0;
26748 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26749 PyObject *arg2 = (PyObject *) 0 ;
26750 void *argp1 = 0 ;
26751 int res1 = 0 ;
26752 PyObject * obj0 = 0 ;
26753 PyObject * obj1 = 0 ;
26754 char * kwnames[] = {
26755 (char *) "self",(char *) "self", NULL
26756 };
26757
26758 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
26759 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
26760 if (!SWIG_IsOK(res1)) {
26761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26762 }
26763 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26764 arg2 = obj1;
26765 {
26766 PyThreadState* __tstate = wxPyBeginAllowThreads();
26767 (arg1)->SetSelf(arg2);
26768 wxPyEndAllowThreads(__tstate);
26769 if (PyErr_Occurred()) SWIG_fail;
26770 }
26771 resultobj = SWIG_Py_Void();
26772 return resultobj;
26773 fail:
26774 return NULL;
26775 }
26776
26777
26778 SWIGINTERN PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26779 PyObject *resultobj = 0;
26780 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26781 PyObject *result = 0 ;
26782 void *argp1 = 0 ;
26783 int res1 = 0 ;
26784 PyObject *swig_obj[1] ;
26785
26786 if (!args) SWIG_fail;
26787 swig_obj[0] = args;
26788 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
26789 if (!SWIG_IsOK(res1)) {
26790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26791 }
26792 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26793 {
26794 PyThreadState* __tstate = wxPyBeginAllowThreads();
26795 result = (PyObject *)(arg1)->GetSelf();
26796 wxPyEndAllowThreads(__tstate);
26797 if (PyErr_Occurred()) SWIG_fail;
26798 }
26799 resultobj = result;
26800 return resultobj;
26801 fail:
26802 return NULL;
26803 }
26804
26805
26806 SWIGINTERN PyObject *PyCommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26807 PyObject *obj;
26808 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26809 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyCommandEvent, SWIG_NewClientData(obj));
26810 return SWIG_Py_Void();
26811 }
26812
26813 SWIGINTERN PyObject *PyCommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26814 return SWIG_Python_InitShadowInstance(args);
26815 }
26816
26817 SWIGINTERN PyObject *_wrap_new_DateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26818 PyObject *resultobj = 0;
26819 wxWindow *arg1 = (wxWindow *) 0 ;
26820 wxDateTime *arg2 = 0 ;
26821 wxEventType arg3 ;
26822 wxDateEvent *result = 0 ;
26823 void *argp1 = 0 ;
26824 int res1 = 0 ;
26825 void *argp2 = 0 ;
26826 int res2 = 0 ;
26827 int val3 ;
26828 int ecode3 = 0 ;
26829 PyObject * obj0 = 0 ;
26830 PyObject * obj1 = 0 ;
26831 PyObject * obj2 = 0 ;
26832 char * kwnames[] = {
26833 (char *) "win",(char *) "dt",(char *) "type", NULL
26834 };
26835
26836 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26837 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26838 if (!SWIG_IsOK(res1)) {
26839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26840 }
26841 arg1 = reinterpret_cast< wxWindow * >(argp1);
26842 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26843 if (!SWIG_IsOK(res2)) {
26844 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26845 }
26846 if (!argp2) {
26847 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26848 }
26849 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26850 ecode3 = SWIG_AsVal_int(obj2, &val3);
26851 if (!SWIG_IsOK(ecode3)) {
26852 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateEvent" "', expected argument " "3"" of type '" "wxEventType""'");
26853 }
26854 arg3 = static_cast< wxEventType >(val3);
26855 {
26856 PyThreadState* __tstate = wxPyBeginAllowThreads();
26857 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
26858 wxPyEndAllowThreads(__tstate);
26859 if (PyErr_Occurred()) SWIG_fail;
26860 }
26861 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateEvent, SWIG_POINTER_NEW | 0 );
26862 return resultobj;
26863 fail:
26864 return NULL;
26865 }
26866
26867
26868 SWIGINTERN PyObject *_wrap_DateEvent_GetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26869 PyObject *resultobj = 0;
26870 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
26871 wxDateTime *result = 0 ;
26872 void *argp1 = 0 ;
26873 int res1 = 0 ;
26874 PyObject *swig_obj[1] ;
26875
26876 if (!args) SWIG_fail;
26877 swig_obj[0] = args;
26878 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
26879 if (!SWIG_IsOK(res1)) {
26880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_GetDate" "', expected argument " "1"" of type '" "wxDateEvent const *""'");
26881 }
26882 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
26883 {
26884 PyThreadState* __tstate = wxPyBeginAllowThreads();
26885 {
26886 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
26887 result = (wxDateTime *) &_result_ref;
26888 }
26889 wxPyEndAllowThreads(__tstate);
26890 if (PyErr_Occurred()) SWIG_fail;
26891 }
26892 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26893 return resultobj;
26894 fail:
26895 return NULL;
26896 }
26897
26898
26899 SWIGINTERN PyObject *_wrap_DateEvent_SetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26900 PyObject *resultobj = 0;
26901 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
26902 wxDateTime *arg2 = 0 ;
26903 void *argp1 = 0 ;
26904 int res1 = 0 ;
26905 void *argp2 = 0 ;
26906 int res2 = 0 ;
26907 PyObject * obj0 = 0 ;
26908 PyObject * obj1 = 0 ;
26909 char * kwnames[] = {
26910 (char *) "self",(char *) "date", NULL
26911 };
26912
26913 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) SWIG_fail;
26914 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
26915 if (!SWIG_IsOK(res1)) {
26916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_SetDate" "', expected argument " "1"" of type '" "wxDateEvent *""'");
26917 }
26918 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
26919 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26920 if (!SWIG_IsOK(res2)) {
26921 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26922 }
26923 if (!argp2) {
26924 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26925 }
26926 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26927 {
26928 PyThreadState* __tstate = wxPyBeginAllowThreads();
26929 (arg1)->SetDate((wxDateTime const &)*arg2);
26930 wxPyEndAllowThreads(__tstate);
26931 if (PyErr_Occurred()) SWIG_fail;
26932 }
26933 resultobj = SWIG_Py_Void();
26934 return resultobj;
26935 fail:
26936 return NULL;
26937 }
26938
26939
26940 SWIGINTERN PyObject *DateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26941 PyObject *obj;
26942 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26943 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateEvent, SWIG_NewClientData(obj));
26944 return SWIG_Py_Void();
26945 }
26946
26947 SWIGINTERN PyObject *DateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26948 return SWIG_Python_InitShadowInstance(args);
26949 }
26950
26951 SWIGINTERN PyObject *_wrap_new_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26952 PyObject *resultobj = 0;
26953 wxPyApp *result = 0 ;
26954
26955 if (!SWIG_Python_UnpackTuple(args,"new_PyApp",0,0,0)) SWIG_fail;
26956 {
26957 PyThreadState* __tstate = wxPyBeginAllowThreads();
26958 result = (wxPyApp *)new_wxPyApp();
26959 wxPyEndAllowThreads(__tstate);
26960 if (PyErr_Occurred()) SWIG_fail;
26961 }
26962 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyApp, SWIG_POINTER_NEW | 0 );
26963 return resultobj;
26964 fail:
26965 return NULL;
26966 }
26967
26968
26969 SWIGINTERN PyObject *_wrap_delete_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26970 PyObject *resultobj = 0;
26971 wxPyApp *arg1 = (wxPyApp *) 0 ;
26972 void *argp1 = 0 ;
26973 int res1 = 0 ;
26974 PyObject *swig_obj[1] ;
26975
26976 if (!args) SWIG_fail;
26977 swig_obj[0] = args;
26978 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, SWIG_POINTER_DISOWN | 0 );
26979 if (!SWIG_IsOK(res1)) {
26980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
26981 }
26982 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26983 {
26984 PyThreadState* __tstate = wxPyBeginAllowThreads();
26985 delete arg1;
26986
26987 wxPyEndAllowThreads(__tstate);
26988 if (PyErr_Occurred()) SWIG_fail;
26989 }
26990 resultobj = SWIG_Py_Void();
26991 return resultobj;
26992 fail:
26993 return NULL;
26994 }
26995
26996
26997 SWIGINTERN PyObject *_wrap_PyApp__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26998 PyObject *resultobj = 0;
26999 wxPyApp *arg1 = (wxPyApp *) 0 ;
27000 PyObject *arg2 = (PyObject *) 0 ;
27001 PyObject *arg3 = (PyObject *) 0 ;
27002 bool arg4 ;
27003 void *argp1 = 0 ;
27004 int res1 = 0 ;
27005 bool val4 ;
27006 int ecode4 = 0 ;
27007 PyObject * obj0 = 0 ;
27008 PyObject * obj1 = 0 ;
27009 PyObject * obj2 = 0 ;
27010 PyObject * obj3 = 0 ;
27011 char * kwnames[] = {
27012 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
27013 };
27014
27015 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
27016 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27017 if (!SWIG_IsOK(res1)) {
27018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyApp *""'");
27019 }
27020 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27021 arg2 = obj1;
27022 arg3 = obj2;
27023 ecode4 = SWIG_AsVal_bool(obj3, &val4);
27024 if (!SWIG_IsOK(ecode4)) {
27025 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyApp__setCallbackInfo" "', expected argument " "4"" of type '" "bool""'");
27026 }
27027 arg4 = static_cast< bool >(val4);
27028 {
27029 PyThreadState* __tstate = wxPyBeginAllowThreads();
27030 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
27031 wxPyEndAllowThreads(__tstate);
27032 if (PyErr_Occurred()) SWIG_fail;
27033 }
27034 resultobj = SWIG_Py_Void();
27035 return resultobj;
27036 fail:
27037 return NULL;
27038 }
27039
27040
27041 SWIGINTERN PyObject *_wrap_PyApp_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27042 PyObject *resultobj = 0;
27043 wxPyApp *arg1 = (wxPyApp *) 0 ;
27044 wxString result;
27045 void *argp1 = 0 ;
27046 int res1 = 0 ;
27047 PyObject *swig_obj[1] ;
27048
27049 if (!args) SWIG_fail;
27050 swig_obj[0] = args;
27051 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27052 if (!SWIG_IsOK(res1)) {
27053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAppName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27054 }
27055 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27056 {
27057 PyThreadState* __tstate = wxPyBeginAllowThreads();
27058 result = ((wxPyApp const *)arg1)->GetAppName();
27059 wxPyEndAllowThreads(__tstate);
27060 if (PyErr_Occurred()) SWIG_fail;
27061 }
27062 {
27063 #if wxUSE_UNICODE
27064 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27065 #else
27066 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27067 #endif
27068 }
27069 return resultobj;
27070 fail:
27071 return NULL;
27072 }
27073
27074
27075 SWIGINTERN PyObject *_wrap_PyApp_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27076 PyObject *resultobj = 0;
27077 wxPyApp *arg1 = (wxPyApp *) 0 ;
27078 wxString *arg2 = 0 ;
27079 void *argp1 = 0 ;
27080 int res1 = 0 ;
27081 bool temp2 = false ;
27082 PyObject * obj0 = 0 ;
27083 PyObject * obj1 = 0 ;
27084 char * kwnames[] = {
27085 (char *) "self",(char *) "name", NULL
27086 };
27087
27088 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
27089 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27090 if (!SWIG_IsOK(res1)) {
27091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAppName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27092 }
27093 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27094 {
27095 arg2 = wxString_in_helper(obj1);
27096 if (arg2 == NULL) SWIG_fail;
27097 temp2 = true;
27098 }
27099 {
27100 PyThreadState* __tstate = wxPyBeginAllowThreads();
27101 (arg1)->SetAppName((wxString const &)*arg2);
27102 wxPyEndAllowThreads(__tstate);
27103 if (PyErr_Occurred()) SWIG_fail;
27104 }
27105 resultobj = SWIG_Py_Void();
27106 {
27107 if (temp2)
27108 delete arg2;
27109 }
27110 return resultobj;
27111 fail:
27112 {
27113 if (temp2)
27114 delete arg2;
27115 }
27116 return NULL;
27117 }
27118
27119
27120 SWIGINTERN PyObject *_wrap_PyApp_GetClassName(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_GetClassName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27133 }
27134 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27135 {
27136 PyThreadState* __tstate = wxPyBeginAllowThreads();
27137 result = ((wxPyApp const *)arg1)->GetClassName();
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_SetClassName(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_SetClassName",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_SetClassName" "', 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)->SetClassName((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_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27200 PyObject *resultobj = 0;
27201 wxPyApp *arg1 = (wxPyApp *) 0 ;
27202 wxString *result = 0 ;
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_GetVendorName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27212 }
27213 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27214 {
27215 PyThreadState* __tstate = wxPyBeginAllowThreads();
27216 {
27217 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
27218 result = (wxString *) &_result_ref;
27219 }
27220 wxPyEndAllowThreads(__tstate);
27221 if (PyErr_Occurred()) SWIG_fail;
27222 }
27223 {
27224 #if wxUSE_UNICODE
27225 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
27226 #else
27227 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
27228 #endif
27229 }
27230 return resultobj;
27231 fail:
27232 return NULL;
27233 }
27234
27235
27236 SWIGINTERN PyObject *_wrap_PyApp_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27237 PyObject *resultobj = 0;
27238 wxPyApp *arg1 = (wxPyApp *) 0 ;
27239 wxString *arg2 = 0 ;
27240 void *argp1 = 0 ;
27241 int res1 = 0 ;
27242 bool temp2 = false ;
27243 PyObject * obj0 = 0 ;
27244 PyObject * obj1 = 0 ;
27245 char * kwnames[] = {
27246 (char *) "self",(char *) "name", NULL
27247 };
27248
27249 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
27250 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27251 if (!SWIG_IsOK(res1)) {
27252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetVendorName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27253 }
27254 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27255 {
27256 arg2 = wxString_in_helper(obj1);
27257 if (arg2 == NULL) SWIG_fail;
27258 temp2 = true;
27259 }
27260 {
27261 PyThreadState* __tstate = wxPyBeginAllowThreads();
27262 (arg1)->SetVendorName((wxString const &)*arg2);
27263 wxPyEndAllowThreads(__tstate);
27264 if (PyErr_Occurred()) SWIG_fail;
27265 }
27266 resultobj = SWIG_Py_Void();
27267 {
27268 if (temp2)
27269 delete arg2;
27270 }
27271 return resultobj;
27272 fail:
27273 {
27274 if (temp2)
27275 delete arg2;
27276 }
27277 return NULL;
27278 }
27279
27280
27281 SWIGINTERN PyObject *_wrap_PyApp_GetTraits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27282 PyObject *resultobj = 0;
27283 wxPyApp *arg1 = (wxPyApp *) 0 ;
27284 wxAppTraits *result = 0 ;
27285 void *argp1 = 0 ;
27286 int res1 = 0 ;
27287 PyObject *swig_obj[1] ;
27288
27289 if (!args) SWIG_fail;
27290 swig_obj[0] = args;
27291 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27292 if (!SWIG_IsOK(res1)) {
27293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTraits" "', expected argument " "1"" of type '" "wxPyApp *""'");
27294 }
27295 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27296 {
27297 PyThreadState* __tstate = wxPyBeginAllowThreads();
27298 result = (wxAppTraits *)(arg1)->GetTraits();
27299 wxPyEndAllowThreads(__tstate);
27300 if (PyErr_Occurred()) SWIG_fail;
27301 }
27302 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAppTraits, 0 | 0 );
27303 return resultobj;
27304 fail:
27305 return NULL;
27306 }
27307
27308
27309 SWIGINTERN PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27310 PyObject *resultobj = 0;
27311 wxPyApp *arg1 = (wxPyApp *) 0 ;
27312 void *argp1 = 0 ;
27313 int res1 = 0 ;
27314 PyObject *swig_obj[1] ;
27315
27316 if (!args) SWIG_fail;
27317 swig_obj[0] = args;
27318 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27319 if (!SWIG_IsOK(res1)) {
27320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27321 }
27322 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27323 {
27324 PyThreadState* __tstate = wxPyBeginAllowThreads();
27325 (arg1)->ProcessPendingEvents();
27326 wxPyEndAllowThreads(__tstate);
27327 if (PyErr_Occurred()) SWIG_fail;
27328 }
27329 resultobj = SWIG_Py_Void();
27330 return resultobj;
27331 fail:
27332 return NULL;
27333 }
27334
27335
27336 SWIGINTERN PyObject *_wrap_PyApp_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27337 PyObject *resultobj = 0;
27338 wxPyApp *arg1 = (wxPyApp *) 0 ;
27339 bool arg2 = (bool) false ;
27340 bool result;
27341 void *argp1 = 0 ;
27342 int res1 = 0 ;
27343 bool val2 ;
27344 int ecode2 = 0 ;
27345 PyObject * obj0 = 0 ;
27346 PyObject * obj1 = 0 ;
27347 char * kwnames[] = {
27348 (char *) "self",(char *) "onlyIfNeeded", NULL
27349 };
27350
27351 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) SWIG_fail;
27352 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27353 if (!SWIG_IsOK(res1)) {
27354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Yield" "', expected argument " "1"" of type '" "wxPyApp *""'");
27355 }
27356 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27357 if (obj1) {
27358 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27359 if (!SWIG_IsOK(ecode2)) {
27360 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_Yield" "', expected argument " "2"" of type '" "bool""'");
27361 }
27362 arg2 = static_cast< bool >(val2);
27363 }
27364 {
27365 PyThreadState* __tstate = wxPyBeginAllowThreads();
27366 result = (bool)(arg1)->Yield(arg2);
27367 wxPyEndAllowThreads(__tstate);
27368 if (PyErr_Occurred()) SWIG_fail;
27369 }
27370 {
27371 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27372 }
27373 return resultobj;
27374 fail:
27375 return NULL;
27376 }
27377
27378
27379 SWIGINTERN PyObject *_wrap_PyApp_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27380 PyObject *resultobj = 0;
27381 wxPyApp *arg1 = (wxPyApp *) 0 ;
27382 void *argp1 = 0 ;
27383 int res1 = 0 ;
27384 PyObject *swig_obj[1] ;
27385
27386 if (!args) SWIG_fail;
27387 swig_obj[0] = args;
27388 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27389 if (!SWIG_IsOK(res1)) {
27390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_WakeUpIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27391 }
27392 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27393 {
27394 PyThreadState* __tstate = wxPyBeginAllowThreads();
27395 (arg1)->WakeUpIdle();
27396 wxPyEndAllowThreads(__tstate);
27397 if (PyErr_Occurred()) SWIG_fail;
27398 }
27399 resultobj = SWIG_Py_Void();
27400 return resultobj;
27401 fail:
27402 return NULL;
27403 }
27404
27405
27406 SWIGINTERN PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27407 PyObject *resultobj = 0;
27408 bool result;
27409
27410 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsMainLoopRunning",0,0,0)) SWIG_fail;
27411 {
27412 PyThreadState* __tstate = wxPyBeginAllowThreads();
27413 result = (bool)wxPyApp::IsMainLoopRunning();
27414 wxPyEndAllowThreads(__tstate);
27415 if (PyErr_Occurred()) SWIG_fail;
27416 }
27417 {
27418 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27419 }
27420 return resultobj;
27421 fail:
27422 return NULL;
27423 }
27424
27425
27426 SWIGINTERN PyObject *_wrap_PyApp_MainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27427 PyObject *resultobj = 0;
27428 wxPyApp *arg1 = (wxPyApp *) 0 ;
27429 int result;
27430 void *argp1 = 0 ;
27431 int res1 = 0 ;
27432 PyObject *swig_obj[1] ;
27433
27434 if (!args) SWIG_fail;
27435 swig_obj[0] = args;
27436 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27437 if (!SWIG_IsOK(res1)) {
27438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_MainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27439 }
27440 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27441 {
27442 PyThreadState* __tstate = wxPyBeginAllowThreads();
27443 result = (int)(arg1)->MainLoop();
27444 wxPyEndAllowThreads(__tstate);
27445 if (PyErr_Occurred()) SWIG_fail;
27446 }
27447 resultobj = SWIG_From_int(static_cast< int >(result));
27448 return resultobj;
27449 fail:
27450 return NULL;
27451 }
27452
27453
27454 SWIGINTERN PyObject *_wrap_PyApp_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27455 PyObject *resultobj = 0;
27456 wxPyApp *arg1 = (wxPyApp *) 0 ;
27457 void *argp1 = 0 ;
27458 int res1 = 0 ;
27459 PyObject *swig_obj[1] ;
27460
27461 if (!args) SWIG_fail;
27462 swig_obj[0] = args;
27463 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27464 if (!SWIG_IsOK(res1)) {
27465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Exit" "', expected argument " "1"" of type '" "wxPyApp *""'");
27466 }
27467 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27468 {
27469 PyThreadState* __tstate = wxPyBeginAllowThreads();
27470 (arg1)->Exit();
27471 wxPyEndAllowThreads(__tstate);
27472 if (PyErr_Occurred()) SWIG_fail;
27473 }
27474 resultobj = SWIG_Py_Void();
27475 return resultobj;
27476 fail:
27477 return NULL;
27478 }
27479
27480
27481 SWIGINTERN PyObject *_wrap_PyApp_ExitMainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27482 PyObject *resultobj = 0;
27483 wxPyApp *arg1 = (wxPyApp *) 0 ;
27484 void *argp1 = 0 ;
27485 int res1 = 0 ;
27486 PyObject *swig_obj[1] ;
27487
27488 if (!args) SWIG_fail;
27489 swig_obj[0] = args;
27490 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27491 if (!SWIG_IsOK(res1)) {
27492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ExitMainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27493 }
27494 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27495 {
27496 PyThreadState* __tstate = wxPyBeginAllowThreads();
27497 (arg1)->ExitMainLoop();
27498 wxPyEndAllowThreads(__tstate);
27499 if (PyErr_Occurred()) SWIG_fail;
27500 }
27501 resultobj = SWIG_Py_Void();
27502 return resultobj;
27503 fail:
27504 return NULL;
27505 }
27506
27507
27508 SWIGINTERN PyObject *_wrap_PyApp_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27509 PyObject *resultobj = 0;
27510 wxPyApp *arg1 = (wxPyApp *) 0 ;
27511 bool result;
27512 void *argp1 = 0 ;
27513 int res1 = 0 ;
27514 PyObject *swig_obj[1] ;
27515
27516 if (!args) SWIG_fail;
27517 swig_obj[0] = args;
27518 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27519 if (!SWIG_IsOK(res1)) {
27520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Pending" "', expected argument " "1"" of type '" "wxPyApp *""'");
27521 }
27522 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27523 {
27524 PyThreadState* __tstate = wxPyBeginAllowThreads();
27525 result = (bool)(arg1)->Pending();
27526 wxPyEndAllowThreads(__tstate);
27527 if (PyErr_Occurred()) SWIG_fail;
27528 }
27529 {
27530 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27531 }
27532 return resultobj;
27533 fail:
27534 return NULL;
27535 }
27536
27537
27538 SWIGINTERN PyObject *_wrap_PyApp_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27539 PyObject *resultobj = 0;
27540 wxPyApp *arg1 = (wxPyApp *) 0 ;
27541 bool result;
27542 void *argp1 = 0 ;
27543 int res1 = 0 ;
27544 PyObject *swig_obj[1] ;
27545
27546 if (!args) SWIG_fail;
27547 swig_obj[0] = args;
27548 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27549 if (!SWIG_IsOK(res1)) {
27550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Dispatch" "', expected argument " "1"" of type '" "wxPyApp *""'");
27551 }
27552 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27553 {
27554 PyThreadState* __tstate = wxPyBeginAllowThreads();
27555 result = (bool)(arg1)->Dispatch();
27556 wxPyEndAllowThreads(__tstate);
27557 if (PyErr_Occurred()) SWIG_fail;
27558 }
27559 {
27560 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27561 }
27562 return resultobj;
27563 fail:
27564 return NULL;
27565 }
27566
27567
27568 SWIGINTERN PyObject *_wrap_PyApp_ProcessIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27569 PyObject *resultobj = 0;
27570 wxPyApp *arg1 = (wxPyApp *) 0 ;
27571 bool result;
27572 void *argp1 = 0 ;
27573 int res1 = 0 ;
27574 PyObject *swig_obj[1] ;
27575
27576 if (!args) SWIG_fail;
27577 swig_obj[0] = args;
27578 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27579 if (!SWIG_IsOK(res1)) {
27580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27581 }
27582 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27583 {
27584 PyThreadState* __tstate = wxPyBeginAllowThreads();
27585 result = (bool)(arg1)->ProcessIdle();
27586 wxPyEndAllowThreads(__tstate);
27587 if (PyErr_Occurred()) SWIG_fail;
27588 }
27589 {
27590 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27591 }
27592 return resultobj;
27593 fail:
27594 return NULL;
27595 }
27596
27597
27598 SWIGINTERN PyObject *_wrap_PyApp_SendIdleEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27599 PyObject *resultobj = 0;
27600 wxPyApp *arg1 = (wxPyApp *) 0 ;
27601 wxWindow *arg2 = (wxWindow *) 0 ;
27602 wxIdleEvent *arg3 = 0 ;
27603 bool result;
27604 void *argp1 = 0 ;
27605 int res1 = 0 ;
27606 void *argp2 = 0 ;
27607 int res2 = 0 ;
27608 void *argp3 = 0 ;
27609 int res3 = 0 ;
27610 PyObject * obj0 = 0 ;
27611 PyObject * obj1 = 0 ;
27612 PyObject * obj2 = 0 ;
27613 char * kwnames[] = {
27614 (char *) "self",(char *) "win",(char *) "event", NULL
27615 };
27616
27617 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27618 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27619 if (!SWIG_IsOK(res1)) {
27620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SendIdleEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27621 }
27622 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27623 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27624 if (!SWIG_IsOK(res2)) {
27625 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SendIdleEvents" "', expected argument " "2"" of type '" "wxWindow *""'");
27626 }
27627 arg2 = reinterpret_cast< wxWindow * >(argp2);
27628 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIdleEvent, 0 );
27629 if (!SWIG_IsOK(res3)) {
27630 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27631 }
27632 if (!argp3) {
27633 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27634 }
27635 arg3 = reinterpret_cast< wxIdleEvent * >(argp3);
27636 {
27637 PyThreadState* __tstate = wxPyBeginAllowThreads();
27638 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
27639 wxPyEndAllowThreads(__tstate);
27640 if (PyErr_Occurred()) SWIG_fail;
27641 }
27642 {
27643 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27644 }
27645 return resultobj;
27646 fail:
27647 return NULL;
27648 }
27649
27650
27651 SWIGINTERN PyObject *_wrap_PyApp_IsActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27652 PyObject *resultobj = 0;
27653 wxPyApp *arg1 = (wxPyApp *) 0 ;
27654 bool result;
27655 void *argp1 = 0 ;
27656 int res1 = 0 ;
27657 PyObject *swig_obj[1] ;
27658
27659 if (!args) SWIG_fail;
27660 swig_obj[0] = args;
27661 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27662 if (!SWIG_IsOK(res1)) {
27663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_IsActive" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27664 }
27665 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27666 {
27667 PyThreadState* __tstate = wxPyBeginAllowThreads();
27668 result = (bool)((wxPyApp const *)arg1)->IsActive();
27669 wxPyEndAllowThreads(__tstate);
27670 if (PyErr_Occurred()) SWIG_fail;
27671 }
27672 {
27673 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27674 }
27675 return resultobj;
27676 fail:
27677 return NULL;
27678 }
27679
27680
27681 SWIGINTERN PyObject *_wrap_PyApp_SetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27682 PyObject *resultobj = 0;
27683 wxPyApp *arg1 = (wxPyApp *) 0 ;
27684 wxWindow *arg2 = (wxWindow *) 0 ;
27685 void *argp1 = 0 ;
27686 int res1 = 0 ;
27687 void *argp2 = 0 ;
27688 int res2 = 0 ;
27689 PyObject * obj0 = 0 ;
27690 PyObject * obj1 = 0 ;
27691 char * kwnames[] = {
27692 (char *) "self",(char *) "win", NULL
27693 };
27694
27695 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) SWIG_fail;
27696 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27697 if (!SWIG_IsOK(res1)) {
27698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetTopWindow" "', expected argument " "1"" of type '" "wxPyApp *""'");
27699 }
27700 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27701 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27702 if (!SWIG_IsOK(res2)) {
27703 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SetTopWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
27704 }
27705 arg2 = reinterpret_cast< wxWindow * >(argp2);
27706 {
27707 PyThreadState* __tstate = wxPyBeginAllowThreads();
27708 (arg1)->SetTopWindow(arg2);
27709 wxPyEndAllowThreads(__tstate);
27710 if (PyErr_Occurred()) SWIG_fail;
27711 }
27712 resultobj = SWIG_Py_Void();
27713 return resultobj;
27714 fail:
27715 return NULL;
27716 }
27717
27718
27719 SWIGINTERN PyObject *_wrap_PyApp_GetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27720 PyObject *resultobj = 0;
27721 wxPyApp *arg1 = (wxPyApp *) 0 ;
27722 wxWindow *result = 0 ;
27723 void *argp1 = 0 ;
27724 int res1 = 0 ;
27725 PyObject *swig_obj[1] ;
27726
27727 if (!args) SWIG_fail;
27728 swig_obj[0] = args;
27729 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27730 if (!SWIG_IsOK(res1)) {
27731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTopWindow" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27732 }
27733 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27734 {
27735 PyThreadState* __tstate = wxPyBeginAllowThreads();
27736 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
27737 wxPyEndAllowThreads(__tstate);
27738 if (PyErr_Occurred()) SWIG_fail;
27739 }
27740 {
27741 resultobj = wxPyMake_wxObject(result, (bool)0);
27742 }
27743 return resultobj;
27744 fail:
27745 return NULL;
27746 }
27747
27748
27749 SWIGINTERN PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27750 PyObject *resultobj = 0;
27751 wxPyApp *arg1 = (wxPyApp *) 0 ;
27752 bool arg2 ;
27753 void *argp1 = 0 ;
27754 int res1 = 0 ;
27755 bool val2 ;
27756 int ecode2 = 0 ;
27757 PyObject * obj0 = 0 ;
27758 PyObject * obj1 = 0 ;
27759 char * kwnames[] = {
27760 (char *) "self",(char *) "flag", NULL
27761 };
27762
27763 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) SWIG_fail;
27764 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27765 if (!SWIG_IsOK(res1)) {
27766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp *""'");
27767 }
27768 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27769 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27770 if (!SWIG_IsOK(ecode2)) {
27771 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "2"" of type '" "bool""'");
27772 }
27773 arg2 = static_cast< bool >(val2);
27774 {
27775 PyThreadState* __tstate = wxPyBeginAllowThreads();
27776 (arg1)->SetExitOnFrameDelete(arg2);
27777 wxPyEndAllowThreads(__tstate);
27778 if (PyErr_Occurred()) SWIG_fail;
27779 }
27780 resultobj = SWIG_Py_Void();
27781 return resultobj;
27782 fail:
27783 return NULL;
27784 }
27785
27786
27787 SWIGINTERN PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27788 PyObject *resultobj = 0;
27789 wxPyApp *arg1 = (wxPyApp *) 0 ;
27790 bool result;
27791 void *argp1 = 0 ;
27792 int res1 = 0 ;
27793 PyObject *swig_obj[1] ;
27794
27795 if (!args) SWIG_fail;
27796 swig_obj[0] = args;
27797 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27798 if (!SWIG_IsOK(res1)) {
27799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27800 }
27801 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27802 {
27803 PyThreadState* __tstate = wxPyBeginAllowThreads();
27804 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
27805 wxPyEndAllowThreads(__tstate);
27806 if (PyErr_Occurred()) SWIG_fail;
27807 }
27808 {
27809 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27810 }
27811 return resultobj;
27812 fail:
27813 return NULL;
27814 }
27815
27816
27817 SWIGINTERN PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27818 PyObject *resultobj = 0;
27819 wxPyApp *arg1 = (wxPyApp *) 0 ;
27820 bool arg2 ;
27821 void *argp1 = 0 ;
27822 int res1 = 0 ;
27823 bool val2 ;
27824 int ecode2 = 0 ;
27825 PyObject * obj0 = 0 ;
27826 PyObject * obj1 = 0 ;
27827 char * kwnames[] = {
27828 (char *) "self",(char *) "flag", NULL
27829 };
27830
27831 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) SWIG_fail;
27832 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27833 if (!SWIG_IsOK(res1)) {
27834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp *""'");
27835 }
27836 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27837 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27838 if (!SWIG_IsOK(ecode2)) {
27839 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "2"" of type '" "bool""'");
27840 }
27841 arg2 = static_cast< bool >(val2);
27842 {
27843 PyThreadState* __tstate = wxPyBeginAllowThreads();
27844 (arg1)->SetUseBestVisual(arg2);
27845 wxPyEndAllowThreads(__tstate);
27846 if (PyErr_Occurred()) SWIG_fail;
27847 }
27848 resultobj = SWIG_Py_Void();
27849 return resultobj;
27850 fail:
27851 return NULL;
27852 }
27853
27854
27855 SWIGINTERN PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27856 PyObject *resultobj = 0;
27857 wxPyApp *arg1 = (wxPyApp *) 0 ;
27858 bool result;
27859 void *argp1 = 0 ;
27860 int res1 = 0 ;
27861 PyObject *swig_obj[1] ;
27862
27863 if (!args) SWIG_fail;
27864 swig_obj[0] = args;
27865 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27866 if (!SWIG_IsOK(res1)) {
27867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27868 }
27869 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27870 {
27871 PyThreadState* __tstate = wxPyBeginAllowThreads();
27872 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
27873 wxPyEndAllowThreads(__tstate);
27874 if (PyErr_Occurred()) SWIG_fail;
27875 }
27876 {
27877 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27878 }
27879 return resultobj;
27880 fail:
27881 return NULL;
27882 }
27883
27884
27885 SWIGINTERN PyObject *_wrap_PyApp_SetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27886 PyObject *resultobj = 0;
27887 wxPyApp *arg1 = (wxPyApp *) 0 ;
27888 int arg2 ;
27889 void *argp1 = 0 ;
27890 int res1 = 0 ;
27891 int val2 ;
27892 int ecode2 = 0 ;
27893 PyObject * obj0 = 0 ;
27894 PyObject * obj1 = 0 ;
27895 char * kwnames[] = {
27896 (char *) "self",(char *) "mode", NULL
27897 };
27898
27899 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) SWIG_fail;
27900 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27901 if (!SWIG_IsOK(res1)) {
27902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetPrintMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
27903 }
27904 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27905 ecode2 = SWIG_AsVal_int(obj1, &val2);
27906 if (!SWIG_IsOK(ecode2)) {
27907 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetPrintMode" "', expected argument " "2"" of type '" "int""'");
27908 }
27909 arg2 = static_cast< int >(val2);
27910 {
27911 PyThreadState* __tstate = wxPyBeginAllowThreads();
27912 (arg1)->SetPrintMode(arg2);
27913 wxPyEndAllowThreads(__tstate);
27914 if (PyErr_Occurred()) SWIG_fail;
27915 }
27916 resultobj = SWIG_Py_Void();
27917 return resultobj;
27918 fail:
27919 return NULL;
27920 }
27921
27922
27923 SWIGINTERN PyObject *_wrap_PyApp_GetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27924 PyObject *resultobj = 0;
27925 wxPyApp *arg1 = (wxPyApp *) 0 ;
27926 int result;
27927 void *argp1 = 0 ;
27928 int res1 = 0 ;
27929 PyObject *swig_obj[1] ;
27930
27931 if (!args) SWIG_fail;
27932 swig_obj[0] = args;
27933 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27934 if (!SWIG_IsOK(res1)) {
27935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetPrintMode" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27936 }
27937 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27938 {
27939 PyThreadState* __tstate = wxPyBeginAllowThreads();
27940 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
27941 wxPyEndAllowThreads(__tstate);
27942 if (PyErr_Occurred()) SWIG_fail;
27943 }
27944 resultobj = SWIG_From_int(static_cast< int >(result));
27945 return resultobj;
27946 fail:
27947 return NULL;
27948 }
27949
27950
27951 SWIGINTERN PyObject *_wrap_PyApp_SetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27952 PyObject *resultobj = 0;
27953 wxPyApp *arg1 = (wxPyApp *) 0 ;
27954 int arg2 ;
27955 void *argp1 = 0 ;
27956 int res1 = 0 ;
27957 int val2 ;
27958 int ecode2 = 0 ;
27959 PyObject * obj0 = 0 ;
27960 PyObject * obj1 = 0 ;
27961 char * kwnames[] = {
27962 (char *) "self",(char *) "mode", NULL
27963 };
27964
27965 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) SWIG_fail;
27966 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27967 if (!SWIG_IsOK(res1)) {
27968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
27969 }
27970 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27971 ecode2 = SWIG_AsVal_int(obj1, &val2);
27972 if (!SWIG_IsOK(ecode2)) {
27973 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetAssertMode" "', expected argument " "2"" of type '" "int""'");
27974 }
27975 arg2 = static_cast< int >(val2);
27976 {
27977 PyThreadState* __tstate = wxPyBeginAllowThreads();
27978 (arg1)->SetAssertMode(arg2);
27979 wxPyEndAllowThreads(__tstate);
27980 if (PyErr_Occurred()) SWIG_fail;
27981 }
27982 resultobj = SWIG_Py_Void();
27983 return resultobj;
27984 fail:
27985 return NULL;
27986 }
27987
27988
27989 SWIGINTERN PyObject *_wrap_PyApp_GetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27990 PyObject *resultobj = 0;
27991 wxPyApp *arg1 = (wxPyApp *) 0 ;
27992 int result;
27993 void *argp1 = 0 ;
27994 int res1 = 0 ;
27995 PyObject *swig_obj[1] ;
27996
27997 if (!args) SWIG_fail;
27998 swig_obj[0] = args;
27999 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28000 if (!SWIG_IsOK(res1)) {
28001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
28002 }
28003 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28004 {
28005 PyThreadState* __tstate = wxPyBeginAllowThreads();
28006 result = (int)(arg1)->GetAssertMode();
28007 wxPyEndAllowThreads(__tstate);
28008 if (PyErr_Occurred()) SWIG_fail;
28009 }
28010 resultobj = SWIG_From_int(static_cast< int >(result));
28011 return resultobj;
28012 fail:
28013 return NULL;
28014 }
28015
28016
28017 SWIGINTERN PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28018 PyObject *resultobj = 0;
28019 bool result;
28020
28021 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacSupportPCMenuShortcuts",0,0,0)) SWIG_fail;
28022 {
28023 PyThreadState* __tstate = wxPyBeginAllowThreads();
28024 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
28025 wxPyEndAllowThreads(__tstate);
28026 if (PyErr_Occurred()) SWIG_fail;
28027 }
28028 {
28029 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28030 }
28031 return resultobj;
28032 fail:
28033 return NULL;
28034 }
28035
28036
28037 SWIGINTERN PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28038 PyObject *resultobj = 0;
28039 long result;
28040
28041 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacAboutMenuItemId",0,0,0)) SWIG_fail;
28042 {
28043 PyThreadState* __tstate = wxPyBeginAllowThreads();
28044 result = (long)wxPyApp::GetMacAboutMenuItemId();
28045 wxPyEndAllowThreads(__tstate);
28046 if (PyErr_Occurred()) SWIG_fail;
28047 }
28048 resultobj = SWIG_From_long(static_cast< long >(result));
28049 return resultobj;
28050 fail:
28051 return NULL;
28052 }
28053
28054
28055 SWIGINTERN PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28056 PyObject *resultobj = 0;
28057 long result;
28058
28059 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacPreferencesMenuItemId",0,0,0)) SWIG_fail;
28060 {
28061 PyThreadState* __tstate = wxPyBeginAllowThreads();
28062 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
28063 wxPyEndAllowThreads(__tstate);
28064 if (PyErr_Occurred()) SWIG_fail;
28065 }
28066 resultobj = SWIG_From_long(static_cast< long >(result));
28067 return resultobj;
28068 fail:
28069 return NULL;
28070 }
28071
28072
28073 SWIGINTERN PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28074 PyObject *resultobj = 0;
28075 long result;
28076
28077 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacExitMenuItemId",0,0,0)) SWIG_fail;
28078 {
28079 PyThreadState* __tstate = wxPyBeginAllowThreads();
28080 result = (long)wxPyApp::GetMacExitMenuItemId();
28081 wxPyEndAllowThreads(__tstate);
28082 if (PyErr_Occurred()) SWIG_fail;
28083 }
28084 resultobj = SWIG_From_long(static_cast< long >(result));
28085 return resultobj;
28086 fail:
28087 return NULL;
28088 }
28089
28090
28091 SWIGINTERN PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28092 PyObject *resultobj = 0;
28093 wxString result;
28094
28095 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacHelpMenuTitleName",0,0,0)) SWIG_fail;
28096 {
28097 PyThreadState* __tstate = wxPyBeginAllowThreads();
28098 result = wxPyApp::GetMacHelpMenuTitleName();
28099 wxPyEndAllowThreads(__tstate);
28100 if (PyErr_Occurred()) SWIG_fail;
28101 }
28102 {
28103 #if wxUSE_UNICODE
28104 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28105 #else
28106 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28107 #endif
28108 }
28109 return resultobj;
28110 fail:
28111 return NULL;
28112 }
28113
28114
28115 SWIGINTERN PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28116 PyObject *resultobj = 0;
28117 bool arg1 ;
28118 bool val1 ;
28119 int ecode1 = 0 ;
28120 PyObject * obj0 = 0 ;
28121 char * kwnames[] = {
28122 (char *) "val", NULL
28123 };
28124
28125 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) SWIG_fail;
28126 ecode1 = SWIG_AsVal_bool(obj0, &val1);
28127 if (!SWIG_IsOK(ecode1)) {
28128 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacSupportPCMenuShortcuts" "', expected argument " "1"" of type '" "bool""'");
28129 }
28130 arg1 = static_cast< bool >(val1);
28131 {
28132 PyThreadState* __tstate = wxPyBeginAllowThreads();
28133 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
28134 wxPyEndAllowThreads(__tstate);
28135 if (PyErr_Occurred()) SWIG_fail;
28136 }
28137 resultobj = SWIG_Py_Void();
28138 return resultobj;
28139 fail:
28140 return NULL;
28141 }
28142
28143
28144 SWIGINTERN PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28145 PyObject *resultobj = 0;
28146 long arg1 ;
28147 long val1 ;
28148 int ecode1 = 0 ;
28149 PyObject * obj0 = 0 ;
28150 char * kwnames[] = {
28151 (char *) "val", NULL
28152 };
28153
28154 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) SWIG_fail;
28155 ecode1 = SWIG_AsVal_long(obj0, &val1);
28156 if (!SWIG_IsOK(ecode1)) {
28157 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacAboutMenuItemId" "', expected argument " "1"" of type '" "long""'");
28158 }
28159 arg1 = static_cast< long >(val1);
28160 {
28161 PyThreadState* __tstate = wxPyBeginAllowThreads();
28162 wxPyApp::SetMacAboutMenuItemId(arg1);
28163 wxPyEndAllowThreads(__tstate);
28164 if (PyErr_Occurred()) SWIG_fail;
28165 }
28166 resultobj = SWIG_Py_Void();
28167 return resultobj;
28168 fail:
28169 return NULL;
28170 }
28171
28172
28173 SWIGINTERN PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28174 PyObject *resultobj = 0;
28175 long arg1 ;
28176 long val1 ;
28177 int ecode1 = 0 ;
28178 PyObject * obj0 = 0 ;
28179 char * kwnames[] = {
28180 (char *) "val", NULL
28181 };
28182
28183 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) SWIG_fail;
28184 ecode1 = SWIG_AsVal_long(obj0, &val1);
28185 if (!SWIG_IsOK(ecode1)) {
28186 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacPreferencesMenuItemId" "', expected argument " "1"" of type '" "long""'");
28187 }
28188 arg1 = static_cast< long >(val1);
28189 {
28190 PyThreadState* __tstate = wxPyBeginAllowThreads();
28191 wxPyApp::SetMacPreferencesMenuItemId(arg1);
28192 wxPyEndAllowThreads(__tstate);
28193 if (PyErr_Occurred()) SWIG_fail;
28194 }
28195 resultobj = SWIG_Py_Void();
28196 return resultobj;
28197 fail:
28198 return NULL;
28199 }
28200
28201
28202 SWIGINTERN PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28203 PyObject *resultobj = 0;
28204 long arg1 ;
28205 long val1 ;
28206 int ecode1 = 0 ;
28207 PyObject * obj0 = 0 ;
28208 char * kwnames[] = {
28209 (char *) "val", NULL
28210 };
28211
28212 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) SWIG_fail;
28213 ecode1 = SWIG_AsVal_long(obj0, &val1);
28214 if (!SWIG_IsOK(ecode1)) {
28215 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacExitMenuItemId" "', expected argument " "1"" of type '" "long""'");
28216 }
28217 arg1 = static_cast< long >(val1);
28218 {
28219 PyThreadState* __tstate = wxPyBeginAllowThreads();
28220 wxPyApp::SetMacExitMenuItemId(arg1);
28221 wxPyEndAllowThreads(__tstate);
28222 if (PyErr_Occurred()) SWIG_fail;
28223 }
28224 resultobj = SWIG_Py_Void();
28225 return resultobj;
28226 fail:
28227 return NULL;
28228 }
28229
28230
28231 SWIGINTERN PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28232 PyObject *resultobj = 0;
28233 wxString *arg1 = 0 ;
28234 bool temp1 = false ;
28235 PyObject * obj0 = 0 ;
28236 char * kwnames[] = {
28237 (char *) "val", NULL
28238 };
28239
28240 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) SWIG_fail;
28241 {
28242 arg1 = wxString_in_helper(obj0);
28243 if (arg1 == NULL) SWIG_fail;
28244 temp1 = true;
28245 }
28246 {
28247 PyThreadState* __tstate = wxPyBeginAllowThreads();
28248 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
28249 wxPyEndAllowThreads(__tstate);
28250 if (PyErr_Occurred()) SWIG_fail;
28251 }
28252 resultobj = SWIG_Py_Void();
28253 {
28254 if (temp1)
28255 delete arg1;
28256 }
28257 return resultobj;
28258 fail:
28259 {
28260 if (temp1)
28261 delete arg1;
28262 }
28263 return NULL;
28264 }
28265
28266
28267 SWIGINTERN PyObject *_wrap_PyApp__BootstrapApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28268 PyObject *resultobj = 0;
28269 wxPyApp *arg1 = (wxPyApp *) 0 ;
28270 void *argp1 = 0 ;
28271 int res1 = 0 ;
28272 PyObject *swig_obj[1] ;
28273
28274 if (!args) SWIG_fail;
28275 swig_obj[0] = args;
28276 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28277 if (!SWIG_IsOK(res1)) {
28278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__BootstrapApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
28279 }
28280 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28281 {
28282 PyThreadState* __tstate = wxPyBeginAllowThreads();
28283 (arg1)->_BootstrapApp();
28284 wxPyEndAllowThreads(__tstate);
28285 if (PyErr_Occurred()) SWIG_fail;
28286 }
28287 resultobj = SWIG_Py_Void();
28288 return resultobj;
28289 fail:
28290 return NULL;
28291 }
28292
28293
28294 SWIGINTERN PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28295 PyObject *resultobj = 0;
28296 int result;
28297
28298 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetComCtl32Version",0,0,0)) SWIG_fail;
28299 {
28300 PyThreadState* __tstate = wxPyBeginAllowThreads();
28301 result = (int)wxPyApp_GetComCtl32Version();
28302 wxPyEndAllowThreads(__tstate);
28303 if (PyErr_Occurred()) SWIG_fail;
28304 }
28305 resultobj = SWIG_From_int(static_cast< int >(result));
28306 return resultobj;
28307 fail:
28308 return NULL;
28309 }
28310
28311
28312 SWIGINTERN PyObject *PyApp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28313 PyObject *obj;
28314 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28315 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyApp, SWIG_NewClientData(obj));
28316 return SWIG_Py_Void();
28317 }
28318
28319 SWIGINTERN PyObject *PyApp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28320 return SWIG_Python_InitShadowInstance(args);
28321 }
28322
28323 SWIGINTERN PyObject *_wrap_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28324 PyObject *resultobj = 0;
28325
28326 if (!SWIG_Python_UnpackTuple(args,"Exit",0,0,0)) SWIG_fail;
28327 {
28328 PyThreadState* __tstate = wxPyBeginAllowThreads();
28329 wxExit();
28330 wxPyEndAllowThreads(__tstate);
28331 if (PyErr_Occurred()) SWIG_fail;
28332 }
28333 resultobj = SWIG_Py_Void();
28334 return resultobj;
28335 fail:
28336 return NULL;
28337 }
28338
28339
28340 SWIGINTERN PyObject *_wrap_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28341 PyObject *resultobj = 0;
28342 bool result;
28343
28344 if (!SWIG_Python_UnpackTuple(args,"Yield",0,0,0)) SWIG_fail;
28345 {
28346 PyThreadState* __tstate = wxPyBeginAllowThreads();
28347 result = (bool)wxYield();
28348 wxPyEndAllowThreads(__tstate);
28349 if (PyErr_Occurred()) SWIG_fail;
28350 }
28351 {
28352 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28353 }
28354 return resultobj;
28355 fail:
28356 return NULL;
28357 }
28358
28359
28360 SWIGINTERN PyObject *_wrap_YieldIfNeeded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28361 PyObject *resultobj = 0;
28362 bool result;
28363
28364 if (!SWIG_Python_UnpackTuple(args,"YieldIfNeeded",0,0,0)) SWIG_fail;
28365 {
28366 PyThreadState* __tstate = wxPyBeginAllowThreads();
28367 result = (bool)wxYieldIfNeeded();
28368 wxPyEndAllowThreads(__tstate);
28369 if (PyErr_Occurred()) SWIG_fail;
28370 }
28371 {
28372 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28373 }
28374 return resultobj;
28375 fail:
28376 return NULL;
28377 }
28378
28379
28380 SWIGINTERN PyObject *_wrap_SafeYield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28381 PyObject *resultobj = 0;
28382 wxWindow *arg1 = (wxWindow *) NULL ;
28383 bool arg2 = (bool) false ;
28384 bool result;
28385 void *argp1 = 0 ;
28386 int res1 = 0 ;
28387 bool val2 ;
28388 int ecode2 = 0 ;
28389 PyObject * obj0 = 0 ;
28390 PyObject * obj1 = 0 ;
28391 char * kwnames[] = {
28392 (char *) "win",(char *) "onlyIfNeeded", NULL
28393 };
28394
28395 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) SWIG_fail;
28396 if (obj0) {
28397 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
28398 if (!SWIG_IsOK(res1)) {
28399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SafeYield" "', expected argument " "1"" of type '" "wxWindow *""'");
28400 }
28401 arg1 = reinterpret_cast< wxWindow * >(argp1);
28402 }
28403 if (obj1) {
28404 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28405 if (!SWIG_IsOK(ecode2)) {
28406 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SafeYield" "', expected argument " "2"" of type '" "bool""'");
28407 }
28408 arg2 = static_cast< bool >(val2);
28409 }
28410 {
28411 PyThreadState* __tstate = wxPyBeginAllowThreads();
28412 result = (bool)wxSafeYield(arg1,arg2);
28413 wxPyEndAllowThreads(__tstate);
28414 if (PyErr_Occurred()) SWIG_fail;
28415 }
28416 {
28417 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28418 }
28419 return resultobj;
28420 fail:
28421 return NULL;
28422 }
28423
28424
28425 SWIGINTERN PyObject *_wrap_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28426 PyObject *resultobj = 0;
28427
28428 if (!SWIG_Python_UnpackTuple(args,"WakeUpIdle",0,0,0)) SWIG_fail;
28429 {
28430 PyThreadState* __tstate = wxPyBeginAllowThreads();
28431 wxWakeUpIdle();
28432 wxPyEndAllowThreads(__tstate);
28433 if (PyErr_Occurred()) SWIG_fail;
28434 }
28435 resultobj = SWIG_Py_Void();
28436 return resultobj;
28437 fail:
28438 return NULL;
28439 }
28440
28441
28442 SWIGINTERN PyObject *_wrap_PostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28443 PyObject *resultobj = 0;
28444 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
28445 wxEvent *arg2 = 0 ;
28446 void *argp1 = 0 ;
28447 int res1 = 0 ;
28448 void *argp2 = 0 ;
28449 int res2 = 0 ;
28450 PyObject * obj0 = 0 ;
28451 PyObject * obj1 = 0 ;
28452 char * kwnames[] = {
28453 (char *) "dest",(char *) "event", NULL
28454 };
28455
28456 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) SWIG_fail;
28457 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
28458 if (!SWIG_IsOK(res1)) {
28459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
28460 }
28461 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
28462 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
28463 if (!SWIG_IsOK(res2)) {
28464 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28465 }
28466 if (!argp2) {
28467 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28468 }
28469 arg2 = reinterpret_cast< wxEvent * >(argp2);
28470 {
28471 PyThreadState* __tstate = wxPyBeginAllowThreads();
28472 wxPostEvent(arg1,*arg2);
28473 wxPyEndAllowThreads(__tstate);
28474 if (PyErr_Occurred()) SWIG_fail;
28475 }
28476 resultobj = SWIG_Py_Void();
28477 return resultobj;
28478 fail:
28479 return NULL;
28480 }
28481
28482
28483 SWIGINTERN PyObject *_wrap_App_CleanUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28484 PyObject *resultobj = 0;
28485
28486 if (!SWIG_Python_UnpackTuple(args,"App_CleanUp",0,0,0)) SWIG_fail;
28487 {
28488 PyThreadState* __tstate = wxPyBeginAllowThreads();
28489 wxApp_CleanUp();
28490 wxPyEndAllowThreads(__tstate);
28491 if (PyErr_Occurred()) SWIG_fail;
28492 }
28493 resultobj = SWIG_Py_Void();
28494 return resultobj;
28495 fail:
28496 return NULL;
28497 }
28498
28499
28500 SWIGINTERN PyObject *_wrap_GetApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28501 PyObject *resultobj = 0;
28502 wxPyApp *result = 0 ;
28503
28504 if (!SWIG_Python_UnpackTuple(args,"GetApp",0,0,0)) SWIG_fail;
28505 {
28506 PyThreadState* __tstate = wxPyBeginAllowThreads();
28507 result = (wxPyApp *)wxPyGetApp();
28508 wxPyEndAllowThreads(__tstate);
28509 if (PyErr_Occurred()) SWIG_fail;
28510 }
28511 {
28512 resultobj = wxPyMake_wxObject(result, 0);
28513 }
28514 return resultobj;
28515 fail:
28516 return NULL;
28517 }
28518
28519
28520 SWIGINTERN PyObject *_wrap_SetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28521 PyObject *resultobj = 0;
28522 char *arg1 = (char *) 0 ;
28523 int res1 ;
28524 char *buf1 = 0 ;
28525 int alloc1 = 0 ;
28526 PyObject * obj0 = 0 ;
28527 char * kwnames[] = {
28528 (char *) "encoding", NULL
28529 };
28530
28531 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) SWIG_fail;
28532 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
28533 if (!SWIG_IsOK(res1)) {
28534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetDefaultPyEncoding" "', expected argument " "1"" of type '" "char const *""'");
28535 }
28536 arg1 = buf1;
28537 {
28538 PyThreadState* __tstate = wxPyBeginAllowThreads();
28539 wxSetDefaultPyEncoding((char const *)arg1);
28540 wxPyEndAllowThreads(__tstate);
28541 if (PyErr_Occurred()) SWIG_fail;
28542 }
28543 resultobj = SWIG_Py_Void();
28544 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28545 return resultobj;
28546 fail:
28547 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28548 return NULL;
28549 }
28550
28551
28552 SWIGINTERN PyObject *_wrap_GetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28553 PyObject *resultobj = 0;
28554 char *result = 0 ;
28555
28556 if (!SWIG_Python_UnpackTuple(args,"GetDefaultPyEncoding",0,0,0)) SWIG_fail;
28557 {
28558 PyThreadState* __tstate = wxPyBeginAllowThreads();
28559 result = (char *)wxGetDefaultPyEncoding();
28560 wxPyEndAllowThreads(__tstate);
28561 if (PyErr_Occurred()) SWIG_fail;
28562 }
28563 resultobj = SWIG_FromCharPtr(result);
28564 return resultobj;
28565 fail:
28566 return NULL;
28567 }
28568
28569
28570 SWIGINTERN PyObject *_wrap_new_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28571 PyObject *resultobj = 0;
28572 wxEventLoop *result = 0 ;
28573
28574 if (!SWIG_Python_UnpackTuple(args,"new_EventLoop",0,0,0)) SWIG_fail;
28575 {
28576 PyThreadState* __tstate = wxPyBeginAllowThreads();
28577 result = (wxEventLoop *)new wxEventLoop();
28578 wxPyEndAllowThreads(__tstate);
28579 if (PyErr_Occurred()) SWIG_fail;
28580 }
28581 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, SWIG_POINTER_NEW | 0 );
28582 return resultobj;
28583 fail:
28584 return NULL;
28585 }
28586
28587
28588 SWIGINTERN PyObject *_wrap_delete_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28589 PyObject *resultobj = 0;
28590 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28591 void *argp1 = 0 ;
28592 int res1 = 0 ;
28593 PyObject *swig_obj[1] ;
28594
28595 if (!args) SWIG_fail;
28596 swig_obj[0] = args;
28597 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, SWIG_POINTER_DISOWN | 0 );
28598 if (!SWIG_IsOK(res1)) {
28599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoop" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28600 }
28601 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28602 {
28603 PyThreadState* __tstate = wxPyBeginAllowThreads();
28604 delete arg1;
28605
28606 wxPyEndAllowThreads(__tstate);
28607 if (PyErr_Occurred()) SWIG_fail;
28608 }
28609 resultobj = SWIG_Py_Void();
28610 return resultobj;
28611 fail:
28612 return NULL;
28613 }
28614
28615
28616 SWIGINTERN PyObject *_wrap_EventLoop_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28617 PyObject *resultobj = 0;
28618 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28619 int result;
28620 void *argp1 = 0 ;
28621 int res1 = 0 ;
28622 PyObject *swig_obj[1] ;
28623
28624 if (!args) SWIG_fail;
28625 swig_obj[0] = args;
28626 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28627 if (!SWIG_IsOK(res1)) {
28628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Run" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28629 }
28630 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28631 {
28632 PyThreadState* __tstate = wxPyBeginAllowThreads();
28633 result = (int)(arg1)->Run();
28634 wxPyEndAllowThreads(__tstate);
28635 if (PyErr_Occurred()) SWIG_fail;
28636 }
28637 resultobj = SWIG_From_int(static_cast< int >(result));
28638 return resultobj;
28639 fail:
28640 return NULL;
28641 }
28642
28643
28644 SWIGINTERN PyObject *_wrap_EventLoop_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28645 PyObject *resultobj = 0;
28646 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28647 int arg2 = (int) 0 ;
28648 void *argp1 = 0 ;
28649 int res1 = 0 ;
28650 int val2 ;
28651 int ecode2 = 0 ;
28652 PyObject * obj0 = 0 ;
28653 PyObject * obj1 = 0 ;
28654 char * kwnames[] = {
28655 (char *) "self",(char *) "rc", NULL
28656 };
28657
28658 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) SWIG_fail;
28659 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28660 if (!SWIG_IsOK(res1)) {
28661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Exit" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28662 }
28663 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28664 if (obj1) {
28665 ecode2 = SWIG_AsVal_int(obj1, &val2);
28666 if (!SWIG_IsOK(ecode2)) {
28667 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventLoop_Exit" "', expected argument " "2"" of type '" "int""'");
28668 }
28669 arg2 = static_cast< int >(val2);
28670 }
28671 {
28672 PyThreadState* __tstate = wxPyBeginAllowThreads();
28673 (arg1)->Exit(arg2);
28674 wxPyEndAllowThreads(__tstate);
28675 if (PyErr_Occurred()) SWIG_fail;
28676 }
28677 resultobj = SWIG_Py_Void();
28678 return resultobj;
28679 fail:
28680 return NULL;
28681 }
28682
28683
28684 SWIGINTERN PyObject *_wrap_EventLoop_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28685 PyObject *resultobj = 0;
28686 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28687 bool result;
28688 void *argp1 = 0 ;
28689 int res1 = 0 ;
28690 PyObject *swig_obj[1] ;
28691
28692 if (!args) SWIG_fail;
28693 swig_obj[0] = args;
28694 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28695 if (!SWIG_IsOK(res1)) {
28696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Pending" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
28697 }
28698 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28699 {
28700 PyThreadState* __tstate = wxPyBeginAllowThreads();
28701 result = (bool)((wxEventLoop const *)arg1)->Pending();
28702 wxPyEndAllowThreads(__tstate);
28703 if (PyErr_Occurred()) SWIG_fail;
28704 }
28705 {
28706 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28707 }
28708 return resultobj;
28709 fail:
28710 return NULL;
28711 }
28712
28713
28714 SWIGINTERN PyObject *_wrap_EventLoop_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28715 PyObject *resultobj = 0;
28716 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28717 bool result;
28718 void *argp1 = 0 ;
28719 int res1 = 0 ;
28720 PyObject *swig_obj[1] ;
28721
28722 if (!args) SWIG_fail;
28723 swig_obj[0] = args;
28724 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28725 if (!SWIG_IsOK(res1)) {
28726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Dispatch" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28727 }
28728 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28729 {
28730 PyThreadState* __tstate = wxPyBeginAllowThreads();
28731 result = (bool)(arg1)->Dispatch();
28732 wxPyEndAllowThreads(__tstate);
28733 if (PyErr_Occurred()) SWIG_fail;
28734 }
28735 {
28736 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28737 }
28738 return resultobj;
28739 fail:
28740 return NULL;
28741 }
28742
28743
28744 SWIGINTERN PyObject *_wrap_EventLoop_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28745 PyObject *resultobj = 0;
28746 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28747 bool result;
28748 void *argp1 = 0 ;
28749 int res1 = 0 ;
28750 PyObject *swig_obj[1] ;
28751
28752 if (!args) SWIG_fail;
28753 swig_obj[0] = args;
28754 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28755 if (!SWIG_IsOK(res1)) {
28756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_IsRunning" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
28757 }
28758 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28759 {
28760 PyThreadState* __tstate = wxPyBeginAllowThreads();
28761 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
28762 wxPyEndAllowThreads(__tstate);
28763 if (PyErr_Occurred()) SWIG_fail;
28764 }
28765 {
28766 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28767 }
28768 return resultobj;
28769 fail:
28770 return NULL;
28771 }
28772
28773
28774 SWIGINTERN PyObject *_wrap_EventLoop_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28775 PyObject *resultobj = 0;
28776 wxEventLoop *result = 0 ;
28777
28778 if (!SWIG_Python_UnpackTuple(args,"EventLoop_GetActive",0,0,0)) SWIG_fail;
28779 {
28780 PyThreadState* __tstate = wxPyBeginAllowThreads();
28781 result = (wxEventLoop *)wxEventLoop::GetActive();
28782 wxPyEndAllowThreads(__tstate);
28783 if (PyErr_Occurred()) SWIG_fail;
28784 }
28785 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, 0 | 0 );
28786 return resultobj;
28787 fail:
28788 return NULL;
28789 }
28790
28791
28792 SWIGINTERN PyObject *_wrap_EventLoop_SetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28793 PyObject *resultobj = 0;
28794 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28795 void *argp1 = 0 ;
28796 int res1 = 0 ;
28797 PyObject * obj0 = 0 ;
28798 char * kwnames[] = {
28799 (char *) "loop", NULL
28800 };
28801
28802 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) SWIG_fail;
28803 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28804 if (!SWIG_IsOK(res1)) {
28805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_SetActive" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28806 }
28807 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28808 {
28809 PyThreadState* __tstate = wxPyBeginAllowThreads();
28810 wxEventLoop::SetActive(arg1);
28811 wxPyEndAllowThreads(__tstate);
28812 if (PyErr_Occurred()) SWIG_fail;
28813 }
28814 resultobj = SWIG_Py_Void();
28815 return resultobj;
28816 fail:
28817 return NULL;
28818 }
28819
28820
28821 SWIGINTERN PyObject *EventLoop_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28822 PyObject *obj;
28823 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28824 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoop, SWIG_NewClientData(obj));
28825 return SWIG_Py_Void();
28826 }
28827
28828 SWIGINTERN PyObject *EventLoop_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28829 return SWIG_Python_InitShadowInstance(args);
28830 }
28831
28832 SWIGINTERN PyObject *_wrap_new_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28833 PyObject *resultobj = 0;
28834 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28835 wxEventLoopActivator *result = 0 ;
28836 void *argp1 = 0 ;
28837 int res1 = 0 ;
28838 PyObject * obj0 = 0 ;
28839 char * kwnames[] = {
28840 (char *) "evtLoop", NULL
28841 };
28842
28843 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_EventLoopActivator",kwnames,&obj0)) SWIG_fail;
28844 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28845 if (!SWIG_IsOK(res1)) {
28846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28847 }
28848 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28849 {
28850 PyThreadState* __tstate = wxPyBeginAllowThreads();
28851 result = (wxEventLoopActivator *)new wxEventLoopActivator(arg1);
28852 wxPyEndAllowThreads(__tstate);
28853 if (PyErr_Occurred()) SWIG_fail;
28854 }
28855 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_NEW | 0 );
28856 return resultobj;
28857 fail:
28858 return NULL;
28859 }
28860
28861
28862 SWIGINTERN PyObject *_wrap_delete_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28863 PyObject *resultobj = 0;
28864 wxEventLoopActivator *arg1 = (wxEventLoopActivator *) 0 ;
28865 void *argp1 = 0 ;
28866 int res1 = 0 ;
28867 PyObject *swig_obj[1] ;
28868
28869 if (!args) SWIG_fail;
28870 swig_obj[0] = args;
28871 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_DISOWN | 0 );
28872 if (!SWIG_IsOK(res1)) {
28873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoopActivator *""'");
28874 }
28875 arg1 = reinterpret_cast< wxEventLoopActivator * >(argp1);
28876 {
28877 PyThreadState* __tstate = wxPyBeginAllowThreads();
28878 delete arg1;
28879
28880 wxPyEndAllowThreads(__tstate);
28881 if (PyErr_Occurred()) SWIG_fail;
28882 }
28883 resultobj = SWIG_Py_Void();
28884 return resultobj;
28885 fail:
28886 return NULL;
28887 }
28888
28889
28890 SWIGINTERN PyObject *EventLoopActivator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28891 PyObject *obj;
28892 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28893 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoopActivator, SWIG_NewClientData(obj));
28894 return SWIG_Py_Void();
28895 }
28896
28897 SWIGINTERN PyObject *EventLoopActivator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28898 return SWIG_Python_InitShadowInstance(args);
28899 }
28900
28901 SWIGINTERN PyObject *_wrap_new_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28902 PyObject *resultobj = 0;
28903 int arg1 = (int) 0 ;
28904 int arg2 = (int) 0 ;
28905 int arg3 = (int) 0 ;
28906 wxAcceleratorEntry *result = 0 ;
28907 int val1 ;
28908 int ecode1 = 0 ;
28909 int val2 ;
28910 int ecode2 = 0 ;
28911 int val3 ;
28912 int ecode3 = 0 ;
28913 PyObject * obj0 = 0 ;
28914 PyObject * obj1 = 0 ;
28915 PyObject * obj2 = 0 ;
28916 char * kwnames[] = {
28917 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
28918 };
28919
28920 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
28921 if (obj0) {
28922 ecode1 = SWIG_AsVal_int(obj0, &val1);
28923 if (!SWIG_IsOK(ecode1)) {
28924 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AcceleratorEntry" "', expected argument " "1"" of type '" "int""'");
28925 }
28926 arg1 = static_cast< int >(val1);
28927 }
28928 if (obj1) {
28929 ecode2 = SWIG_AsVal_int(obj1, &val2);
28930 if (!SWIG_IsOK(ecode2)) {
28931 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AcceleratorEntry" "', expected argument " "2"" of type '" "int""'");
28932 }
28933 arg2 = static_cast< int >(val2);
28934 }
28935 if (obj2) {
28936 ecode3 = SWIG_AsVal_int(obj2, &val3);
28937 if (!SWIG_IsOK(ecode3)) {
28938 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AcceleratorEntry" "', expected argument " "3"" of type '" "int""'");
28939 }
28940 arg3 = static_cast< int >(val3);
28941 }
28942 {
28943 PyThreadState* __tstate = wxPyBeginAllowThreads();
28944 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
28945 wxPyEndAllowThreads(__tstate);
28946 if (PyErr_Occurred()) SWIG_fail;
28947 }
28948 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_NEW | 0 );
28949 return resultobj;
28950 fail:
28951 return NULL;
28952 }
28953
28954
28955 SWIGINTERN PyObject *_wrap_delete_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28956 PyObject *resultobj = 0;
28957 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28958 void *argp1 = 0 ;
28959 int res1 = 0 ;
28960 PyObject *swig_obj[1] ;
28961
28962 if (!args) SWIG_fail;
28963 swig_obj[0] = args;
28964 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_DISOWN | 0 );
28965 if (!SWIG_IsOK(res1)) {
28966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorEntry" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28967 }
28968 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28969 {
28970 PyThreadState* __tstate = wxPyBeginAllowThreads();
28971 delete arg1;
28972
28973 wxPyEndAllowThreads(__tstate);
28974 if (PyErr_Occurred()) SWIG_fail;
28975 }
28976 resultobj = SWIG_Py_Void();
28977 return resultobj;
28978 fail:
28979 return NULL;
28980 }
28981
28982
28983 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28984 PyObject *resultobj = 0;
28985 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28986 int arg2 ;
28987 int arg3 ;
28988 int arg4 ;
28989 void *argp1 = 0 ;
28990 int res1 = 0 ;
28991 int val2 ;
28992 int ecode2 = 0 ;
28993 int val3 ;
28994 int ecode3 = 0 ;
28995 int val4 ;
28996 int ecode4 = 0 ;
28997 PyObject * obj0 = 0 ;
28998 PyObject * obj1 = 0 ;
28999 PyObject * obj2 = 0 ;
29000 PyObject * obj3 = 0 ;
29001 char * kwnames[] = {
29002 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
29003 };
29004
29005 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
29006 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29007 if (!SWIG_IsOK(res1)) {
29008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_Set" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29009 }
29010 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29011 ecode2 = SWIG_AsVal_int(obj1, &val2);
29012 if (!SWIG_IsOK(ecode2)) {
29013 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AcceleratorEntry_Set" "', expected argument " "2"" of type '" "int""'");
29014 }
29015 arg2 = static_cast< int >(val2);
29016 ecode3 = SWIG_AsVal_int(obj2, &val3);
29017 if (!SWIG_IsOK(ecode3)) {
29018 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AcceleratorEntry_Set" "', expected argument " "3"" of type '" "int""'");
29019 }
29020 arg3 = static_cast< int >(val3);
29021 ecode4 = SWIG_AsVal_int(obj3, &val4);
29022 if (!SWIG_IsOK(ecode4)) {
29023 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AcceleratorEntry_Set" "', expected argument " "4"" of type '" "int""'");
29024 }
29025 arg4 = static_cast< int >(val4);
29026 {
29027 PyThreadState* __tstate = wxPyBeginAllowThreads();
29028 (arg1)->Set(arg2,arg3,arg4);
29029 wxPyEndAllowThreads(__tstate);
29030 if (PyErr_Occurred()) SWIG_fail;
29031 }
29032 resultobj = SWIG_Py_Void();
29033 return resultobj;
29034 fail:
29035 return NULL;
29036 }
29037
29038
29039 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29040 PyObject *resultobj = 0;
29041 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29042 int result;
29043 void *argp1 = 0 ;
29044 int res1 = 0 ;
29045 PyObject *swig_obj[1] ;
29046
29047 if (!args) SWIG_fail;
29048 swig_obj[0] = args;
29049 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29050 if (!SWIG_IsOK(res1)) {
29051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetFlags" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29052 }
29053 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29054 {
29055 PyThreadState* __tstate = wxPyBeginAllowThreads();
29056 result = (int)(arg1)->GetFlags();
29057 wxPyEndAllowThreads(__tstate);
29058 if (PyErr_Occurred()) SWIG_fail;
29059 }
29060 resultobj = SWIG_From_int(static_cast< int >(result));
29061 return resultobj;
29062 fail:
29063 return NULL;
29064 }
29065
29066
29067 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29068 PyObject *resultobj = 0;
29069 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29070 int result;
29071 void *argp1 = 0 ;
29072 int res1 = 0 ;
29073 PyObject *swig_obj[1] ;
29074
29075 if (!args) SWIG_fail;
29076 swig_obj[0] = args;
29077 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29078 if (!SWIG_IsOK(res1)) {
29079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetKeyCode" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29080 }
29081 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29082 {
29083 PyThreadState* __tstate = wxPyBeginAllowThreads();
29084 result = (int)(arg1)->GetKeyCode();
29085 wxPyEndAllowThreads(__tstate);
29086 if (PyErr_Occurred()) SWIG_fail;
29087 }
29088 resultobj = SWIG_From_int(static_cast< int >(result));
29089 return resultobj;
29090 fail:
29091 return NULL;
29092 }
29093
29094
29095 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29096 PyObject *resultobj = 0;
29097 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29098 int result;
29099 void *argp1 = 0 ;
29100 int res1 = 0 ;
29101 PyObject *swig_obj[1] ;
29102
29103 if (!args) SWIG_fail;
29104 swig_obj[0] = args;
29105 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29106 if (!SWIG_IsOK(res1)) {
29107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetCommand" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29108 }
29109 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29110 {
29111 PyThreadState* __tstate = wxPyBeginAllowThreads();
29112 result = (int)(arg1)->GetCommand();
29113 wxPyEndAllowThreads(__tstate);
29114 if (PyErr_Occurred()) SWIG_fail;
29115 }
29116 resultobj = SWIG_From_int(static_cast< int >(result));
29117 return resultobj;
29118 fail:
29119 return NULL;
29120 }
29121
29122
29123 SWIGINTERN PyObject *AcceleratorEntry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29124 PyObject *obj;
29125 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29126 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorEntry, SWIG_NewClientData(obj));
29127 return SWIG_Py_Void();
29128 }
29129
29130 SWIGINTERN PyObject *AcceleratorEntry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29131 return SWIG_Python_InitShadowInstance(args);
29132 }
29133
29134 SWIGINTERN PyObject *_wrap_new_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29135 PyObject *resultobj = 0;
29136 int arg1 ;
29137 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
29138 wxAcceleratorTable *result = 0 ;
29139 PyObject * obj0 = 0 ;
29140 char * kwnames[] = {
29141 (char *) "n", NULL
29142 };
29143
29144 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) SWIG_fail;
29145 {
29146 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
29147 if (arg2) arg1 = PyList_Size(obj0);
29148 else arg1 = 0;
29149 }
29150 {
29151 PyThreadState* __tstate = wxPyBeginAllowThreads();
29152 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
29153 wxPyEndAllowThreads(__tstate);
29154 if (PyErr_Occurred()) SWIG_fail;
29155 }
29156 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_NEW | 0 );
29157 return resultobj;
29158 fail:
29159 return NULL;
29160 }
29161
29162
29163 SWIGINTERN PyObject *_wrap_delete_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29164 PyObject *resultobj = 0;
29165 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
29166 void *argp1 = 0 ;
29167 int res1 = 0 ;
29168 PyObject *swig_obj[1] ;
29169
29170 if (!args) SWIG_fail;
29171 swig_obj[0] = args;
29172 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_DISOWN | 0 );
29173 if (!SWIG_IsOK(res1)) {
29174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorTable" "', expected argument " "1"" of type '" "wxAcceleratorTable *""'");
29175 }
29176 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
29177 {
29178 PyThreadState* __tstate = wxPyBeginAllowThreads();
29179 delete arg1;
29180
29181 wxPyEndAllowThreads(__tstate);
29182 if (PyErr_Occurred()) SWIG_fail;
29183 }
29184 resultobj = SWIG_Py_Void();
29185 return resultobj;
29186 fail:
29187 return NULL;
29188 }
29189
29190
29191 SWIGINTERN PyObject *_wrap_AcceleratorTable_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29192 PyObject *resultobj = 0;
29193 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
29194 bool result;
29195 void *argp1 = 0 ;
29196 int res1 = 0 ;
29197 PyObject *swig_obj[1] ;
29198
29199 if (!args) SWIG_fail;
29200 swig_obj[0] = args;
29201 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
29202 if (!SWIG_IsOK(res1)) {
29203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorTable_Ok" "', expected argument " "1"" of type '" "wxAcceleratorTable const *""'");
29204 }
29205 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
29206 {
29207 PyThreadState* __tstate = wxPyBeginAllowThreads();
29208 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
29209 wxPyEndAllowThreads(__tstate);
29210 if (PyErr_Occurred()) SWIG_fail;
29211 }
29212 {
29213 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29214 }
29215 return resultobj;
29216 fail:
29217 return NULL;
29218 }
29219
29220
29221 SWIGINTERN PyObject *AcceleratorTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29222 PyObject *obj;
29223 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29224 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorTable, SWIG_NewClientData(obj));
29225 return SWIG_Py_Void();
29226 }
29227
29228 SWIGINTERN PyObject *AcceleratorTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29229 return SWIG_Python_InitShadowInstance(args);
29230 }
29231
29232 SWIGINTERN int NullAcceleratorTable_set(PyObject *) {
29233 SWIG_Error(SWIG_AttributeError,"Variable NullAcceleratorTable is read-only.");
29234 return 1;
29235 }
29236
29237
29238 SWIGINTERN PyObject *NullAcceleratorTable_get(void) {
29239 PyObject *pyobj = 0;
29240
29241 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0 );
29242 return pyobj;
29243 }
29244
29245
29246 SWIGINTERN PyObject *_wrap_GetAccelFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29247 PyObject *resultobj = 0;
29248 wxString *arg1 = 0 ;
29249 wxAcceleratorEntry *result = 0 ;
29250 bool temp1 = false ;
29251 PyObject * obj0 = 0 ;
29252 char * kwnames[] = {
29253 (char *) "label", NULL
29254 };
29255
29256 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) SWIG_fail;
29257 {
29258 arg1 = wxString_in_helper(obj0);
29259 if (arg1 == NULL) SWIG_fail;
29260 temp1 = true;
29261 }
29262 {
29263 PyThreadState* __tstate = wxPyBeginAllowThreads();
29264 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
29265 wxPyEndAllowThreads(__tstate);
29266 if (PyErr_Occurred()) SWIG_fail;
29267 }
29268 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29269 {
29270 if (temp1)
29271 delete arg1;
29272 }
29273 return resultobj;
29274 fail:
29275 {
29276 if (temp1)
29277 delete arg1;
29278 }
29279 return NULL;
29280 }
29281
29282
29283 SWIGINTERN int PanelNameStr_set(PyObject *) {
29284 SWIG_Error(SWIG_AttributeError,"Variable PanelNameStr is read-only.");
29285 return 1;
29286 }
29287
29288
29289 SWIGINTERN PyObject *PanelNameStr_get(void) {
29290 PyObject *pyobj = 0;
29291
29292 {
29293 #if wxUSE_UNICODE
29294 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29295 #else
29296 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29297 #endif
29298 }
29299 return pyobj;
29300 }
29301
29302
29303 SWIGINTERN PyObject *_wrap_new_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29304 PyObject *resultobj = 0;
29305 wxVisualAttributes *result = 0 ;
29306
29307 if (!SWIG_Python_UnpackTuple(args,"new_VisualAttributes",0,0,0)) SWIG_fail;
29308 {
29309 PyThreadState* __tstate = wxPyBeginAllowThreads();
29310 result = (wxVisualAttributes *)new_wxVisualAttributes();
29311 wxPyEndAllowThreads(__tstate);
29312 if (PyErr_Occurred()) SWIG_fail;
29313 }
29314 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_NEW | 0 );
29315 return resultobj;
29316 fail:
29317 return NULL;
29318 }
29319
29320
29321 SWIGINTERN PyObject *_wrap_delete_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29322 PyObject *resultobj = 0;
29323 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29324 void *argp1 = 0 ;
29325 int res1 = 0 ;
29326 PyObject *swig_obj[1] ;
29327
29328 if (!args) SWIG_fail;
29329 swig_obj[0] = args;
29330 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_DISOWN | 0 );
29331 if (!SWIG_IsOK(res1)) {
29332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VisualAttributes" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29333 }
29334 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29335 {
29336 PyThreadState* __tstate = wxPyBeginAllowThreads();
29337 delete_wxVisualAttributes(arg1);
29338
29339 wxPyEndAllowThreads(__tstate);
29340 if (PyErr_Occurred()) SWIG_fail;
29341 }
29342 resultobj = SWIG_Py_Void();
29343 return resultobj;
29344 fail:
29345 return NULL;
29346 }
29347
29348
29349 SWIGINTERN PyObject *_wrap_VisualAttributes_font_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29350 PyObject *resultobj = 0;
29351 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29352 wxFont *arg2 = (wxFont *) 0 ;
29353 void *argp1 = 0 ;
29354 int res1 = 0 ;
29355 void *argp2 = 0 ;
29356 int res2 = 0 ;
29357 PyObject *swig_obj[2] ;
29358
29359 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_font_set",2,2,swig_obj)) SWIG_fail;
29360 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29361 if (!SWIG_IsOK(res1)) {
29362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29363 }
29364 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29365 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
29366 if (!SWIG_IsOK(res2)) {
29367 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_font_set" "', expected argument " "2"" of type '" "wxFont *""'");
29368 }
29369 arg2 = reinterpret_cast< wxFont * >(argp2);
29370 if (arg1) (arg1)->font = *arg2;
29371
29372 resultobj = SWIG_Py_Void();
29373 return resultobj;
29374 fail:
29375 return NULL;
29376 }
29377
29378
29379 SWIGINTERN PyObject *_wrap_VisualAttributes_font_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29380 PyObject *resultobj = 0;
29381 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29382 wxFont *result = 0 ;
29383 void *argp1 = 0 ;
29384 int res1 = 0 ;
29385 PyObject *swig_obj[1] ;
29386
29387 if (!args) SWIG_fail;
29388 swig_obj[0] = args;
29389 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29390 if (!SWIG_IsOK(res1)) {
29391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29392 }
29393 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29394 result = (wxFont *)& ((arg1)->font);
29395 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, 0 | 0 );
29396 return resultobj;
29397 fail:
29398 return NULL;
29399 }
29400
29401
29402 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29403 PyObject *resultobj = 0;
29404 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29405 wxColour *arg2 = (wxColour *) 0 ;
29406 void *argp1 = 0 ;
29407 int res1 = 0 ;
29408 void *argp2 = 0 ;
29409 int res2 = 0 ;
29410 PyObject *swig_obj[2] ;
29411
29412 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colFg_set",2,2,swig_obj)) SWIG_fail;
29413 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29414 if (!SWIG_IsOK(res1)) {
29415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29416 }
29417 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29418 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29419 if (!SWIG_IsOK(res2)) {
29420 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colFg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29421 }
29422 arg2 = reinterpret_cast< wxColour * >(argp2);
29423 if (arg1) (arg1)->colFg = *arg2;
29424
29425 resultobj = SWIG_Py_Void();
29426 return resultobj;
29427 fail:
29428 return NULL;
29429 }
29430
29431
29432 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29433 PyObject *resultobj = 0;
29434 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29435 wxColour *result = 0 ;
29436 void *argp1 = 0 ;
29437 int res1 = 0 ;
29438 PyObject *swig_obj[1] ;
29439
29440 if (!args) SWIG_fail;
29441 swig_obj[0] = args;
29442 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29443 if (!SWIG_IsOK(res1)) {
29444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29445 }
29446 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29447 result = (wxColour *)& ((arg1)->colFg);
29448 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29449 return resultobj;
29450 fail:
29451 return NULL;
29452 }
29453
29454
29455 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29456 PyObject *resultobj = 0;
29457 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29458 wxColour *arg2 = (wxColour *) 0 ;
29459 void *argp1 = 0 ;
29460 int res1 = 0 ;
29461 void *argp2 = 0 ;
29462 int res2 = 0 ;
29463 PyObject *swig_obj[2] ;
29464
29465 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colBg_set",2,2,swig_obj)) SWIG_fail;
29466 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29467 if (!SWIG_IsOK(res1)) {
29468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29469 }
29470 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29471 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29472 if (!SWIG_IsOK(res2)) {
29473 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colBg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29474 }
29475 arg2 = reinterpret_cast< wxColour * >(argp2);
29476 if (arg1) (arg1)->colBg = *arg2;
29477
29478 resultobj = SWIG_Py_Void();
29479 return resultobj;
29480 fail:
29481 return NULL;
29482 }
29483
29484
29485 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29486 PyObject *resultobj = 0;
29487 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29488 wxColour *result = 0 ;
29489 void *argp1 = 0 ;
29490 int res1 = 0 ;
29491 PyObject *swig_obj[1] ;
29492
29493 if (!args) SWIG_fail;
29494 swig_obj[0] = args;
29495 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29496 if (!SWIG_IsOK(res1)) {
29497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29498 }
29499 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29500 result = (wxColour *)& ((arg1)->colBg);
29501 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29502 return resultobj;
29503 fail:
29504 return NULL;
29505 }
29506
29507
29508 SWIGINTERN PyObject *VisualAttributes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29509 PyObject *obj;
29510 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29511 SWIG_TypeNewClientData(SWIGTYPE_p_wxVisualAttributes, SWIG_NewClientData(obj));
29512 return SWIG_Py_Void();
29513 }
29514
29515 SWIGINTERN PyObject *VisualAttributes_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29516 return SWIG_Python_InitShadowInstance(args);
29517 }
29518
29519 SWIGINTERN PyObject *_wrap_new_Window(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29520 PyObject *resultobj = 0;
29521 wxWindow *arg1 = (wxWindow *) 0 ;
29522 int arg2 = (int) (int)-1 ;
29523 wxPoint const &arg3_defvalue = wxDefaultPosition ;
29524 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
29525 wxSize const &arg4_defvalue = wxDefaultSize ;
29526 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
29527 long arg5 = (long) 0 ;
29528 wxString const &arg6_defvalue = wxPyPanelNameStr ;
29529 wxString *arg6 = (wxString *) &arg6_defvalue ;
29530 wxWindow *result = 0 ;
29531 void *argp1 = 0 ;
29532 int res1 = 0 ;
29533 int val2 ;
29534 int ecode2 = 0 ;
29535 wxPoint temp3 ;
29536 wxSize temp4 ;
29537 long val5 ;
29538 int ecode5 = 0 ;
29539 bool temp6 = false ;
29540 PyObject * obj0 = 0 ;
29541 PyObject * obj1 = 0 ;
29542 PyObject * obj2 = 0 ;
29543 PyObject * obj3 = 0 ;
29544 PyObject * obj4 = 0 ;
29545 PyObject * obj5 = 0 ;
29546 char * kwnames[] = {
29547 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
29548 };
29549
29550 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
29551 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29552 if (!SWIG_IsOK(res1)) {
29553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Window" "', expected argument " "1"" of type '" "wxWindow *""'");
29554 }
29555 arg1 = reinterpret_cast< wxWindow * >(argp1);
29556 if (obj1) {
29557 ecode2 = SWIG_AsVal_int(obj1, &val2);
29558 if (!SWIG_IsOK(ecode2)) {
29559 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Window" "', expected argument " "2"" of type '" "int""'");
29560 }
29561 arg2 = static_cast< int >(val2);
29562 }
29563 if (obj2) {
29564 {
29565 arg3 = &temp3;
29566 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
29567 }
29568 }
29569 if (obj3) {
29570 {
29571 arg4 = &temp4;
29572 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
29573 }
29574 }
29575 if (obj4) {
29576 ecode5 = SWIG_AsVal_long(obj4, &val5);
29577 if (!SWIG_IsOK(ecode5)) {
29578 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Window" "', expected argument " "5"" of type '" "long""'");
29579 }
29580 arg5 = static_cast< long >(val5);
29581 }
29582 if (obj5) {
29583 {
29584 arg6 = wxString_in_helper(obj5);
29585 if (arg6 == NULL) SWIG_fail;
29586 temp6 = true;
29587 }
29588 }
29589 {
29590 if (!wxPyCheckForApp()) SWIG_fail;
29591 PyThreadState* __tstate = wxPyBeginAllowThreads();
29592 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
29593 wxPyEndAllowThreads(__tstate);
29594 if (PyErr_Occurred()) SWIG_fail;
29595 }
29596 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_NEW | 0 );
29597 {
29598 if (temp6)
29599 delete arg6;
29600 }
29601 return resultobj;
29602 fail:
29603 {
29604 if (temp6)
29605 delete arg6;
29606 }
29607 return NULL;
29608 }
29609
29610
29611 SWIGINTERN PyObject *_wrap_new_PreWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29612 PyObject *resultobj = 0;
29613 wxWindow *result = 0 ;
29614
29615 if (!SWIG_Python_UnpackTuple(args,"new_PreWindow",0,0,0)) SWIG_fail;
29616 {
29617 if (!wxPyCheckForApp()) SWIG_fail;
29618 PyThreadState* __tstate = wxPyBeginAllowThreads();
29619 result = (wxWindow *)new wxWindow();
29620 wxPyEndAllowThreads(__tstate);
29621 if (PyErr_Occurred()) SWIG_fail;
29622 }
29623 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_OWN | 0 );
29624 return resultobj;
29625 fail:
29626 return NULL;
29627 }
29628
29629
29630 SWIGINTERN PyObject *_wrap_Window_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29631 PyObject *resultobj = 0;
29632 wxWindow *arg1 = (wxWindow *) 0 ;
29633 wxWindow *arg2 = (wxWindow *) 0 ;
29634 int arg3 = (int) (int)-1 ;
29635 wxPoint const &arg4_defvalue = wxDefaultPosition ;
29636 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
29637 wxSize const &arg5_defvalue = wxDefaultSize ;
29638 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
29639 long arg6 = (long) 0 ;
29640 wxString const &arg7_defvalue = wxPyPanelNameStr ;
29641 wxString *arg7 = (wxString *) &arg7_defvalue ;
29642 bool result;
29643 void *argp1 = 0 ;
29644 int res1 = 0 ;
29645 void *argp2 = 0 ;
29646 int res2 = 0 ;
29647 int val3 ;
29648 int ecode3 = 0 ;
29649 wxPoint temp4 ;
29650 wxSize temp5 ;
29651 long val6 ;
29652 int ecode6 = 0 ;
29653 bool temp7 = false ;
29654 PyObject * obj0 = 0 ;
29655 PyObject * obj1 = 0 ;
29656 PyObject * obj2 = 0 ;
29657 PyObject * obj3 = 0 ;
29658 PyObject * obj4 = 0 ;
29659 PyObject * obj5 = 0 ;
29660 PyObject * obj6 = 0 ;
29661 char * kwnames[] = {
29662 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
29663 };
29664
29665 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
29666 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29667 if (!SWIG_IsOK(res1)) {
29668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Create" "', expected argument " "1"" of type '" "wxWindow *""'");
29669 }
29670 arg1 = reinterpret_cast< wxWindow * >(argp1);
29671 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
29672 if (!SWIG_IsOK(res2)) {
29673 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
29674 }
29675 arg2 = reinterpret_cast< wxWindow * >(argp2);
29676 if (obj2) {
29677 ecode3 = SWIG_AsVal_int(obj2, &val3);
29678 if (!SWIG_IsOK(ecode3)) {
29679 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Create" "', expected argument " "3"" of type '" "int""'");
29680 }
29681 arg3 = static_cast< int >(val3);
29682 }
29683 if (obj3) {
29684 {
29685 arg4 = &temp4;
29686 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
29687 }
29688 }
29689 if (obj4) {
29690 {
29691 arg5 = &temp5;
29692 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
29693 }
29694 }
29695 if (obj5) {
29696 ecode6 = SWIG_AsVal_long(obj5, &val6);
29697 if (!SWIG_IsOK(ecode6)) {
29698 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_Create" "', expected argument " "6"" of type '" "long""'");
29699 }
29700 arg6 = static_cast< long >(val6);
29701 }
29702 if (obj6) {
29703 {
29704 arg7 = wxString_in_helper(obj6);
29705 if (arg7 == NULL) SWIG_fail;
29706 temp7 = true;
29707 }
29708 }
29709 {
29710 PyThreadState* __tstate = wxPyBeginAllowThreads();
29711 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
29712 wxPyEndAllowThreads(__tstate);
29713 if (PyErr_Occurred()) SWIG_fail;
29714 }
29715 {
29716 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29717 }
29718 {
29719 if (temp7)
29720 delete arg7;
29721 }
29722 return resultobj;
29723 fail:
29724 {
29725 if (temp7)
29726 delete arg7;
29727 }
29728 return NULL;
29729 }
29730
29731
29732 SWIGINTERN PyObject *_wrap_Window_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29733 PyObject *resultobj = 0;
29734 wxWindow *arg1 = (wxWindow *) 0 ;
29735 bool arg2 = (bool) false ;
29736 bool result;
29737 void *argp1 = 0 ;
29738 int res1 = 0 ;
29739 bool val2 ;
29740 int ecode2 = 0 ;
29741 PyObject * obj0 = 0 ;
29742 PyObject * obj1 = 0 ;
29743 char * kwnames[] = {
29744 (char *) "self",(char *) "force", NULL
29745 };
29746
29747 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) SWIG_fail;
29748 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29749 if (!SWIG_IsOK(res1)) {
29750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Close" "', expected argument " "1"" of type '" "wxWindow *""'");
29751 }
29752 arg1 = reinterpret_cast< wxWindow * >(argp1);
29753 if (obj1) {
29754 ecode2 = SWIG_AsVal_bool(obj1, &val2);
29755 if (!SWIG_IsOK(ecode2)) {
29756 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Close" "', expected argument " "2"" of type '" "bool""'");
29757 }
29758 arg2 = static_cast< bool >(val2);
29759 }
29760 {
29761 PyThreadState* __tstate = wxPyBeginAllowThreads();
29762 result = (bool)(arg1)->Close(arg2);
29763 wxPyEndAllowThreads(__tstate);
29764 if (PyErr_Occurred()) SWIG_fail;
29765 }
29766 {
29767 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29768 }
29769 return resultobj;
29770 fail:
29771 return NULL;
29772 }
29773
29774
29775 SWIGINTERN PyObject *_wrap_Window_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29776 PyObject *resultobj = 0;
29777 wxWindow *arg1 = (wxWindow *) 0 ;
29778 bool result;
29779 void *argp1 = 0 ;
29780 int res1 = 0 ;
29781 PyObject *swig_obj[1] ;
29782
29783 if (!args) SWIG_fail;
29784 swig_obj[0] = args;
29785 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29786 if (!SWIG_IsOK(res1)) {
29787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Destroy" "', expected argument " "1"" of type '" "wxWindow *""'");
29788 }
29789 arg1 = reinterpret_cast< wxWindow * >(argp1);
29790 {
29791 PyThreadState* __tstate = wxPyBeginAllowThreads();
29792 result = (bool)(arg1)->Destroy();
29793 wxPyEndAllowThreads(__tstate);
29794 if (PyErr_Occurred()) SWIG_fail;
29795 }
29796 {
29797 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29798 }
29799 return resultobj;
29800 fail:
29801 return NULL;
29802 }
29803
29804
29805 SWIGINTERN PyObject *_wrap_Window_DestroyChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29806 PyObject *resultobj = 0;
29807 wxWindow *arg1 = (wxWindow *) 0 ;
29808 bool result;
29809 void *argp1 = 0 ;
29810 int res1 = 0 ;
29811 PyObject *swig_obj[1] ;
29812
29813 if (!args) SWIG_fail;
29814 swig_obj[0] = args;
29815 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29816 if (!SWIG_IsOK(res1)) {
29817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DestroyChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
29818 }
29819 arg1 = reinterpret_cast< wxWindow * >(argp1);
29820 {
29821 PyThreadState* __tstate = wxPyBeginAllowThreads();
29822 result = (bool)(arg1)->DestroyChildren();
29823 wxPyEndAllowThreads(__tstate);
29824 if (PyErr_Occurred()) SWIG_fail;
29825 }
29826 {
29827 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29828 }
29829 return resultobj;
29830 fail:
29831 return NULL;
29832 }
29833
29834
29835 SWIGINTERN PyObject *_wrap_Window_IsBeingDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29836 PyObject *resultobj = 0;
29837 wxWindow *arg1 = (wxWindow *) 0 ;
29838 bool result;
29839 void *argp1 = 0 ;
29840 int res1 = 0 ;
29841 PyObject *swig_obj[1] ;
29842
29843 if (!args) SWIG_fail;
29844 swig_obj[0] = args;
29845 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29846 if (!SWIG_IsOK(res1)) {
29847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsBeingDeleted" "', expected argument " "1"" of type '" "wxWindow const *""'");
29848 }
29849 arg1 = reinterpret_cast< wxWindow * >(argp1);
29850 {
29851 PyThreadState* __tstate = wxPyBeginAllowThreads();
29852 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
29853 wxPyEndAllowThreads(__tstate);
29854 if (PyErr_Occurred()) SWIG_fail;
29855 }
29856 {
29857 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29858 }
29859 return resultobj;
29860 fail:
29861 return NULL;
29862 }
29863
29864
29865 SWIGINTERN PyObject *_wrap_Window_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29866 PyObject *resultobj = 0;
29867 wxWindow *arg1 = (wxWindow *) 0 ;
29868 wxString *arg2 = 0 ;
29869 void *argp1 = 0 ;
29870 int res1 = 0 ;
29871 bool temp2 = false ;
29872 PyObject * obj0 = 0 ;
29873 PyObject * obj1 = 0 ;
29874 char * kwnames[] = {
29875 (char *) "self",(char *) "label", NULL
29876 };
29877
29878 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
29879 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29880 if (!SWIG_IsOK(res1)) {
29881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLabel" "', expected argument " "1"" of type '" "wxWindow *""'");
29882 }
29883 arg1 = reinterpret_cast< wxWindow * >(argp1);
29884 {
29885 arg2 = wxString_in_helper(obj1);
29886 if (arg2 == NULL) SWIG_fail;
29887 temp2 = true;
29888 }
29889 {
29890 PyThreadState* __tstate = wxPyBeginAllowThreads();
29891 (arg1)->SetLabel((wxString const &)*arg2);
29892 wxPyEndAllowThreads(__tstate);
29893 if (PyErr_Occurred()) SWIG_fail;
29894 }
29895 resultobj = SWIG_Py_Void();
29896 {
29897 if (temp2)
29898 delete arg2;
29899 }
29900 return resultobj;
29901 fail:
29902 {
29903 if (temp2)
29904 delete arg2;
29905 }
29906 return NULL;
29907 }
29908
29909
29910 SWIGINTERN PyObject *_wrap_Window_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29911 PyObject *resultobj = 0;
29912 wxWindow *arg1 = (wxWindow *) 0 ;
29913 wxString result;
29914 void *argp1 = 0 ;
29915 int res1 = 0 ;
29916 PyObject *swig_obj[1] ;
29917
29918 if (!args) SWIG_fail;
29919 swig_obj[0] = args;
29920 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29921 if (!SWIG_IsOK(res1)) {
29922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLabel" "', expected argument " "1"" of type '" "wxWindow const *""'");
29923 }
29924 arg1 = reinterpret_cast< wxWindow * >(argp1);
29925 {
29926 PyThreadState* __tstate = wxPyBeginAllowThreads();
29927 result = ((wxWindow const *)arg1)->GetLabel();
29928 wxPyEndAllowThreads(__tstate);
29929 if (PyErr_Occurred()) SWIG_fail;
29930 }
29931 {
29932 #if wxUSE_UNICODE
29933 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
29934 #else
29935 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
29936 #endif
29937 }
29938 return resultobj;
29939 fail:
29940 return NULL;
29941 }
29942
29943
29944 SWIGINTERN PyObject *_wrap_Window_SetName(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 *) "name", NULL
29955 };
29956
29957 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",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_SetName" "', 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)->SetName((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_GetName(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_GetName" "', expected argument " "1"" of type '" "wxWindow const *""'");
30002 }
30003 arg1 = reinterpret_cast< wxWindow * >(argp1);
30004 {
30005 PyThreadState* __tstate = wxPyBeginAllowThreads();
30006 result = ((wxWindow const *)arg1)->GetName();
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_SetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30024 PyObject *resultobj = 0;
30025 wxWindow *arg1 = (wxWindow *) 0 ;
30026 wxWindowVariant arg2 ;
30027 void *argp1 = 0 ;
30028 int res1 = 0 ;
30029 int val2 ;
30030 int ecode2 = 0 ;
30031 PyObject * obj0 = 0 ;
30032 PyObject * obj1 = 0 ;
30033 char * kwnames[] = {
30034 (char *) "self",(char *) "variant", NULL
30035 };
30036
30037 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) SWIG_fail;
30038 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30039 if (!SWIG_IsOK(res1)) {
30040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowVariant" "', expected argument " "1"" of type '" "wxWindow *""'");
30041 }
30042 arg1 = reinterpret_cast< wxWindow * >(argp1);
30043 ecode2 = SWIG_AsVal_int(obj1, &val2);
30044 if (!SWIG_IsOK(ecode2)) {
30045 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowVariant" "', expected argument " "2"" of type '" "wxWindowVariant""'");
30046 }
30047 arg2 = static_cast< wxWindowVariant >(val2);
30048 {
30049 PyThreadState* __tstate = wxPyBeginAllowThreads();
30050 (arg1)->SetWindowVariant(arg2);
30051 wxPyEndAllowThreads(__tstate);
30052 if (PyErr_Occurred()) SWIG_fail;
30053 }
30054 resultobj = SWIG_Py_Void();
30055 return resultobj;
30056 fail:
30057 return NULL;
30058 }
30059
30060
30061 SWIGINTERN PyObject *_wrap_Window_GetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30062 PyObject *resultobj = 0;
30063 wxWindow *arg1 = (wxWindow *) 0 ;
30064 wxWindowVariant result;
30065 void *argp1 = 0 ;
30066 int res1 = 0 ;
30067 PyObject *swig_obj[1] ;
30068
30069 if (!args) SWIG_fail;
30070 swig_obj[0] = args;
30071 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30072 if (!SWIG_IsOK(res1)) {
30073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowVariant" "', expected argument " "1"" of type '" "wxWindow const *""'");
30074 }
30075 arg1 = reinterpret_cast< wxWindow * >(argp1);
30076 {
30077 PyThreadState* __tstate = wxPyBeginAllowThreads();
30078 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
30079 wxPyEndAllowThreads(__tstate);
30080 if (PyErr_Occurred()) SWIG_fail;
30081 }
30082 resultobj = SWIG_From_int(static_cast< int >(result));
30083 return resultobj;
30084 fail:
30085 return NULL;
30086 }
30087
30088
30089 SWIGINTERN PyObject *_wrap_Window_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30090 PyObject *resultobj = 0;
30091 wxWindow *arg1 = (wxWindow *) 0 ;
30092 int arg2 ;
30093 void *argp1 = 0 ;
30094 int res1 = 0 ;
30095 int val2 ;
30096 int ecode2 = 0 ;
30097 PyObject * obj0 = 0 ;
30098 PyObject * obj1 = 0 ;
30099 char * kwnames[] = {
30100 (char *) "self",(char *) "winid", NULL
30101 };
30102
30103 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
30104 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30105 if (!SWIG_IsOK(res1)) {
30106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetId" "', expected argument " "1"" of type '" "wxWindow *""'");
30107 }
30108 arg1 = reinterpret_cast< wxWindow * >(argp1);
30109 ecode2 = SWIG_AsVal_int(obj1, &val2);
30110 if (!SWIG_IsOK(ecode2)) {
30111 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetId" "', expected argument " "2"" of type '" "int""'");
30112 }
30113 arg2 = static_cast< int >(val2);
30114 {
30115 PyThreadState* __tstate = wxPyBeginAllowThreads();
30116 (arg1)->SetId(arg2);
30117 wxPyEndAllowThreads(__tstate);
30118 if (PyErr_Occurred()) SWIG_fail;
30119 }
30120 resultobj = SWIG_Py_Void();
30121 return resultobj;
30122 fail:
30123 return NULL;
30124 }
30125
30126
30127 SWIGINTERN PyObject *_wrap_Window_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30128 PyObject *resultobj = 0;
30129 wxWindow *arg1 = (wxWindow *) 0 ;
30130 int result;
30131 void *argp1 = 0 ;
30132 int res1 = 0 ;
30133 PyObject *swig_obj[1] ;
30134
30135 if (!args) SWIG_fail;
30136 swig_obj[0] = args;
30137 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30138 if (!SWIG_IsOK(res1)) {
30139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetId" "', expected argument " "1"" of type '" "wxWindow const *""'");
30140 }
30141 arg1 = reinterpret_cast< wxWindow * >(argp1);
30142 {
30143 PyThreadState* __tstate = wxPyBeginAllowThreads();
30144 result = (int)((wxWindow const *)arg1)->GetId();
30145 wxPyEndAllowThreads(__tstate);
30146 if (PyErr_Occurred()) SWIG_fail;
30147 }
30148 resultobj = SWIG_From_int(static_cast< int >(result));
30149 return resultobj;
30150 fail:
30151 return NULL;
30152 }
30153
30154
30155 SWIGINTERN PyObject *_wrap_Window_NewControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30156 PyObject *resultobj = 0;
30157 int result;
30158
30159 if (!SWIG_Python_UnpackTuple(args,"Window_NewControlId",0,0,0)) SWIG_fail;
30160 {
30161 PyThreadState* __tstate = wxPyBeginAllowThreads();
30162 result = (int)wxWindow::NewControlId();
30163 wxPyEndAllowThreads(__tstate);
30164 if (PyErr_Occurred()) SWIG_fail;
30165 }
30166 resultobj = SWIG_From_int(static_cast< int >(result));
30167 return resultobj;
30168 fail:
30169 return NULL;
30170 }
30171
30172
30173 SWIGINTERN PyObject *_wrap_Window_NextControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30174 PyObject *resultobj = 0;
30175 int arg1 ;
30176 int result;
30177 int val1 ;
30178 int ecode1 = 0 ;
30179 PyObject * obj0 = 0 ;
30180 char * kwnames[] = {
30181 (char *) "winid", NULL
30182 };
30183
30184 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) SWIG_fail;
30185 ecode1 = SWIG_AsVal_int(obj0, &val1);
30186 if (!SWIG_IsOK(ecode1)) {
30187 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_NextControlId" "', expected argument " "1"" of type '" "int""'");
30188 }
30189 arg1 = static_cast< int >(val1);
30190 {
30191 PyThreadState* __tstate = wxPyBeginAllowThreads();
30192 result = (int)wxWindow::NextControlId(arg1);
30193 wxPyEndAllowThreads(__tstate);
30194 if (PyErr_Occurred()) SWIG_fail;
30195 }
30196 resultobj = SWIG_From_int(static_cast< int >(result));
30197 return resultobj;
30198 fail:
30199 return NULL;
30200 }
30201
30202
30203 SWIGINTERN PyObject *_wrap_Window_PrevControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30204 PyObject *resultobj = 0;
30205 int arg1 ;
30206 int result;
30207 int val1 ;
30208 int ecode1 = 0 ;
30209 PyObject * obj0 = 0 ;
30210 char * kwnames[] = {
30211 (char *) "winid", NULL
30212 };
30213
30214 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) SWIG_fail;
30215 ecode1 = SWIG_AsVal_int(obj0, &val1);
30216 if (!SWIG_IsOK(ecode1)) {
30217 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_PrevControlId" "', expected argument " "1"" of type '" "int""'");
30218 }
30219 arg1 = static_cast< int >(val1);
30220 {
30221 PyThreadState* __tstate = wxPyBeginAllowThreads();
30222 result = (int)wxWindow::PrevControlId(arg1);
30223 wxPyEndAllowThreads(__tstate);
30224 if (PyErr_Occurred()) SWIG_fail;
30225 }
30226 resultobj = SWIG_From_int(static_cast< int >(result));
30227 return resultobj;
30228 fail:
30229 return NULL;
30230 }
30231
30232
30233 SWIGINTERN PyObject *_wrap_Window_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30234 PyObject *resultobj = 0;
30235 wxWindow *arg1 = (wxWindow *) 0 ;
30236 wxSize *arg2 = 0 ;
30237 void *argp1 = 0 ;
30238 int res1 = 0 ;
30239 wxSize temp2 ;
30240 PyObject * obj0 = 0 ;
30241 PyObject * obj1 = 0 ;
30242 char * kwnames[] = {
30243 (char *) "self",(char *) "size", NULL
30244 };
30245
30246 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
30247 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30248 if (!SWIG_IsOK(res1)) {
30249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30250 }
30251 arg1 = reinterpret_cast< wxWindow * >(argp1);
30252 {
30253 arg2 = &temp2;
30254 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30255 }
30256 {
30257 PyThreadState* __tstate = wxPyBeginAllowThreads();
30258 (arg1)->SetSize((wxSize const &)*arg2);
30259 wxPyEndAllowThreads(__tstate);
30260 if (PyErr_Occurred()) SWIG_fail;
30261 }
30262 resultobj = SWIG_Py_Void();
30263 return resultobj;
30264 fail:
30265 return NULL;
30266 }
30267
30268
30269 SWIGINTERN PyObject *_wrap_Window_SetDimensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30270 PyObject *resultobj = 0;
30271 wxWindow *arg1 = (wxWindow *) 0 ;
30272 int arg2 ;
30273 int arg3 ;
30274 int arg4 ;
30275 int arg5 ;
30276 int arg6 = (int) wxSIZE_AUTO ;
30277 void *argp1 = 0 ;
30278 int res1 = 0 ;
30279 int val2 ;
30280 int ecode2 = 0 ;
30281 int val3 ;
30282 int ecode3 = 0 ;
30283 int val4 ;
30284 int ecode4 = 0 ;
30285 int val5 ;
30286 int ecode5 = 0 ;
30287 int val6 ;
30288 int ecode6 = 0 ;
30289 PyObject * obj0 = 0 ;
30290 PyObject * obj1 = 0 ;
30291 PyObject * obj2 = 0 ;
30292 PyObject * obj3 = 0 ;
30293 PyObject * obj4 = 0 ;
30294 PyObject * obj5 = 0 ;
30295 char * kwnames[] = {
30296 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
30297 };
30298
30299 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
30300 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30301 if (!SWIG_IsOK(res1)) {
30302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDimensions" "', expected argument " "1"" of type '" "wxWindow *""'");
30303 }
30304 arg1 = reinterpret_cast< wxWindow * >(argp1);
30305 ecode2 = SWIG_AsVal_int(obj1, &val2);
30306 if (!SWIG_IsOK(ecode2)) {
30307 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDimensions" "', expected argument " "2"" of type '" "int""'");
30308 }
30309 arg2 = static_cast< int >(val2);
30310 ecode3 = SWIG_AsVal_int(obj2, &val3);
30311 if (!SWIG_IsOK(ecode3)) {
30312 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetDimensions" "', expected argument " "3"" of type '" "int""'");
30313 }
30314 arg3 = static_cast< int >(val3);
30315 ecode4 = SWIG_AsVal_int(obj3, &val4);
30316 if (!SWIG_IsOK(ecode4)) {
30317 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetDimensions" "', expected argument " "4"" of type '" "int""'");
30318 }
30319 arg4 = static_cast< int >(val4);
30320 ecode5 = SWIG_AsVal_int(obj4, &val5);
30321 if (!SWIG_IsOK(ecode5)) {
30322 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetDimensions" "', expected argument " "5"" of type '" "int""'");
30323 }
30324 arg5 = static_cast< int >(val5);
30325 if (obj5) {
30326 ecode6 = SWIG_AsVal_int(obj5, &val6);
30327 if (!SWIG_IsOK(ecode6)) {
30328 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetDimensions" "', expected argument " "6"" of type '" "int""'");
30329 }
30330 arg6 = static_cast< int >(val6);
30331 }
30332 {
30333 PyThreadState* __tstate = wxPyBeginAllowThreads();
30334 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
30335 wxPyEndAllowThreads(__tstate);
30336 if (PyErr_Occurred()) SWIG_fail;
30337 }
30338 resultobj = SWIG_Py_Void();
30339 return resultobj;
30340 fail:
30341 return NULL;
30342 }
30343
30344
30345 SWIGINTERN PyObject *_wrap_Window_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30346 PyObject *resultobj = 0;
30347 wxWindow *arg1 = (wxWindow *) 0 ;
30348 wxRect *arg2 = 0 ;
30349 int arg3 = (int) wxSIZE_AUTO ;
30350 void *argp1 = 0 ;
30351 int res1 = 0 ;
30352 wxRect temp2 ;
30353 int val3 ;
30354 int ecode3 = 0 ;
30355 PyObject * obj0 = 0 ;
30356 PyObject * obj1 = 0 ;
30357 PyObject * obj2 = 0 ;
30358 char * kwnames[] = {
30359 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
30360 };
30361
30362 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30363 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30364 if (!SWIG_IsOK(res1)) {
30365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetRect" "', expected argument " "1"" of type '" "wxWindow *""'");
30366 }
30367 arg1 = reinterpret_cast< wxWindow * >(argp1);
30368 {
30369 arg2 = &temp2;
30370 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30371 }
30372 if (obj2) {
30373 ecode3 = SWIG_AsVal_int(obj2, &val3);
30374 if (!SWIG_IsOK(ecode3)) {
30375 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetRect" "', expected argument " "3"" of type '" "int""'");
30376 }
30377 arg3 = static_cast< int >(val3);
30378 }
30379 {
30380 PyThreadState* __tstate = wxPyBeginAllowThreads();
30381 (arg1)->SetSize((wxRect const &)*arg2,arg3);
30382 wxPyEndAllowThreads(__tstate);
30383 if (PyErr_Occurred()) SWIG_fail;
30384 }
30385 resultobj = SWIG_Py_Void();
30386 return resultobj;
30387 fail:
30388 return NULL;
30389 }
30390
30391
30392 SWIGINTERN PyObject *_wrap_Window_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30393 PyObject *resultobj = 0;
30394 wxWindow *arg1 = (wxWindow *) 0 ;
30395 int arg2 ;
30396 int arg3 ;
30397 void *argp1 = 0 ;
30398 int res1 = 0 ;
30399 int val2 ;
30400 int ecode2 = 0 ;
30401 int val3 ;
30402 int ecode3 = 0 ;
30403 PyObject * obj0 = 0 ;
30404 PyObject * obj1 = 0 ;
30405 PyObject * obj2 = 0 ;
30406 char * kwnames[] = {
30407 (char *) "self",(char *) "width",(char *) "height", NULL
30408 };
30409
30410 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30411 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30412 if (!SWIG_IsOK(res1)) {
30413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
30414 }
30415 arg1 = reinterpret_cast< wxWindow * >(argp1);
30416 ecode2 = SWIG_AsVal_int(obj1, &val2);
30417 if (!SWIG_IsOK(ecode2)) {
30418 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
30419 }
30420 arg2 = static_cast< int >(val2);
30421 ecode3 = SWIG_AsVal_int(obj2, &val3);
30422 if (!SWIG_IsOK(ecode3)) {
30423 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
30424 }
30425 arg3 = static_cast< int >(val3);
30426 {
30427 PyThreadState* __tstate = wxPyBeginAllowThreads();
30428 (arg1)->SetSize(arg2,arg3);
30429 wxPyEndAllowThreads(__tstate);
30430 if (PyErr_Occurred()) SWIG_fail;
30431 }
30432 resultobj = SWIG_Py_Void();
30433 return resultobj;
30434 fail:
30435 return NULL;
30436 }
30437
30438
30439 SWIGINTERN PyObject *_wrap_Window_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30440 PyObject *resultobj = 0;
30441 wxWindow *arg1 = (wxWindow *) 0 ;
30442 wxPoint *arg2 = 0 ;
30443 int arg3 = (int) wxSIZE_USE_EXISTING ;
30444 void *argp1 = 0 ;
30445 int res1 = 0 ;
30446 wxPoint temp2 ;
30447 int val3 ;
30448 int ecode3 = 0 ;
30449 PyObject * obj0 = 0 ;
30450 PyObject * obj1 = 0 ;
30451 PyObject * obj2 = 0 ;
30452 char * kwnames[] = {
30453 (char *) "self",(char *) "pt",(char *) "flags", NULL
30454 };
30455
30456 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30457 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30458 if (!SWIG_IsOK(res1)) {
30459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Move" "', expected argument " "1"" of type '" "wxWindow *""'");
30460 }
30461 arg1 = reinterpret_cast< wxWindow * >(argp1);
30462 {
30463 arg2 = &temp2;
30464 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30465 }
30466 if (obj2) {
30467 ecode3 = SWIG_AsVal_int(obj2, &val3);
30468 if (!SWIG_IsOK(ecode3)) {
30469 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Move" "', expected argument " "3"" of type '" "int""'");
30470 }
30471 arg3 = static_cast< int >(val3);
30472 }
30473 {
30474 PyThreadState* __tstate = wxPyBeginAllowThreads();
30475 (arg1)->Move((wxPoint const &)*arg2,arg3);
30476 wxPyEndAllowThreads(__tstate);
30477 if (PyErr_Occurred()) SWIG_fail;
30478 }
30479 resultobj = SWIG_Py_Void();
30480 return resultobj;
30481 fail:
30482 return NULL;
30483 }
30484
30485
30486 SWIGINTERN PyObject *_wrap_Window_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30487 PyObject *resultobj = 0;
30488 wxWindow *arg1 = (wxWindow *) 0 ;
30489 int arg2 ;
30490 int arg3 ;
30491 int arg4 = (int) wxSIZE_USE_EXISTING ;
30492 void *argp1 = 0 ;
30493 int res1 = 0 ;
30494 int val2 ;
30495 int ecode2 = 0 ;
30496 int val3 ;
30497 int ecode3 = 0 ;
30498 int val4 ;
30499 int ecode4 = 0 ;
30500 PyObject * obj0 = 0 ;
30501 PyObject * obj1 = 0 ;
30502 PyObject * obj2 = 0 ;
30503 PyObject * obj3 = 0 ;
30504 char * kwnames[] = {
30505 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
30506 };
30507
30508 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30509 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30510 if (!SWIG_IsOK(res1)) {
30511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveXY" "', expected argument " "1"" of type '" "wxWindow *""'");
30512 }
30513 arg1 = reinterpret_cast< wxWindow * >(argp1);
30514 ecode2 = SWIG_AsVal_int(obj1, &val2);
30515 if (!SWIG_IsOK(ecode2)) {
30516 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MoveXY" "', expected argument " "2"" of type '" "int""'");
30517 }
30518 arg2 = static_cast< int >(val2);
30519 ecode3 = SWIG_AsVal_int(obj2, &val3);
30520 if (!SWIG_IsOK(ecode3)) {
30521 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_MoveXY" "', expected argument " "3"" of type '" "int""'");
30522 }
30523 arg3 = static_cast< int >(val3);
30524 if (obj3) {
30525 ecode4 = SWIG_AsVal_int(obj3, &val4);
30526 if (!SWIG_IsOK(ecode4)) {
30527 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_MoveXY" "', expected argument " "4"" of type '" "int""'");
30528 }
30529 arg4 = static_cast< int >(val4);
30530 }
30531 {
30532 PyThreadState* __tstate = wxPyBeginAllowThreads();
30533 (arg1)->Move(arg2,arg3,arg4);
30534 wxPyEndAllowThreads(__tstate);
30535 if (PyErr_Occurred()) SWIG_fail;
30536 }
30537 resultobj = SWIG_Py_Void();
30538 return resultobj;
30539 fail:
30540 return NULL;
30541 }
30542
30543
30544 SWIGINTERN PyObject *_wrap_Window_SetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30545 PyObject *resultobj = 0;
30546 wxWindow *arg1 = (wxWindow *) 0 ;
30547 wxSize const &arg2_defvalue = wxDefaultSize ;
30548 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
30549 void *argp1 = 0 ;
30550 int res1 = 0 ;
30551 wxSize temp2 ;
30552 PyObject * obj0 = 0 ;
30553 PyObject * obj1 = 0 ;
30554 char * kwnames[] = {
30555 (char *) "self",(char *) "size", NULL
30556 };
30557
30558 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) SWIG_fail;
30559 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30560 if (!SWIG_IsOK(res1)) {
30561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30562 }
30563 arg1 = reinterpret_cast< wxWindow * >(argp1);
30564 if (obj1) {
30565 {
30566 arg2 = &temp2;
30567 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30568 }
30569 }
30570 {
30571 PyThreadState* __tstate = wxPyBeginAllowThreads();
30572 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
30573 wxPyEndAllowThreads(__tstate);
30574 if (PyErr_Occurred()) SWIG_fail;
30575 }
30576 resultobj = SWIG_Py_Void();
30577 return resultobj;
30578 fail:
30579 return NULL;
30580 }
30581
30582
30583 SWIGINTERN PyObject *_wrap_Window_Raise(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30584 PyObject *resultobj = 0;
30585 wxWindow *arg1 = (wxWindow *) 0 ;
30586 void *argp1 = 0 ;
30587 int res1 = 0 ;
30588 PyObject *swig_obj[1] ;
30589
30590 if (!args) SWIG_fail;
30591 swig_obj[0] = args;
30592 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30593 if (!SWIG_IsOK(res1)) {
30594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Raise" "', expected argument " "1"" of type '" "wxWindow *""'");
30595 }
30596 arg1 = reinterpret_cast< wxWindow * >(argp1);
30597 {
30598 PyThreadState* __tstate = wxPyBeginAllowThreads();
30599 (arg1)->Raise();
30600 wxPyEndAllowThreads(__tstate);
30601 if (PyErr_Occurred()) SWIG_fail;
30602 }
30603 resultobj = SWIG_Py_Void();
30604 return resultobj;
30605 fail:
30606 return NULL;
30607 }
30608
30609
30610 SWIGINTERN PyObject *_wrap_Window_Lower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30611 PyObject *resultobj = 0;
30612 wxWindow *arg1 = (wxWindow *) 0 ;
30613 void *argp1 = 0 ;
30614 int res1 = 0 ;
30615 PyObject *swig_obj[1] ;
30616
30617 if (!args) SWIG_fail;
30618 swig_obj[0] = args;
30619 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30620 if (!SWIG_IsOK(res1)) {
30621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Lower" "', expected argument " "1"" of type '" "wxWindow *""'");
30622 }
30623 arg1 = reinterpret_cast< wxWindow * >(argp1);
30624 {
30625 PyThreadState* __tstate = wxPyBeginAllowThreads();
30626 (arg1)->Lower();
30627 wxPyEndAllowThreads(__tstate);
30628 if (PyErr_Occurred()) SWIG_fail;
30629 }
30630 resultobj = SWIG_Py_Void();
30631 return resultobj;
30632 fail:
30633 return NULL;
30634 }
30635
30636
30637 SWIGINTERN PyObject *_wrap_Window_SetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30638 PyObject *resultobj = 0;
30639 wxWindow *arg1 = (wxWindow *) 0 ;
30640 wxSize *arg2 = 0 ;
30641 void *argp1 = 0 ;
30642 int res1 = 0 ;
30643 wxSize temp2 ;
30644 PyObject * obj0 = 0 ;
30645 PyObject * obj1 = 0 ;
30646 char * kwnames[] = {
30647 (char *) "self",(char *) "size", NULL
30648 };
30649
30650 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) SWIG_fail;
30651 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30652 if (!SWIG_IsOK(res1)) {
30653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30654 }
30655 arg1 = reinterpret_cast< wxWindow * >(argp1);
30656 {
30657 arg2 = &temp2;
30658 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30659 }
30660 {
30661 PyThreadState* __tstate = wxPyBeginAllowThreads();
30662 (arg1)->SetClientSize((wxSize const &)*arg2);
30663 wxPyEndAllowThreads(__tstate);
30664 if (PyErr_Occurred()) SWIG_fail;
30665 }
30666 resultobj = SWIG_Py_Void();
30667 return resultobj;
30668 fail:
30669 return NULL;
30670 }
30671
30672
30673 SWIGINTERN PyObject *_wrap_Window_SetClientSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30674 PyObject *resultobj = 0;
30675 wxWindow *arg1 = (wxWindow *) 0 ;
30676 int arg2 ;
30677 int arg3 ;
30678 void *argp1 = 0 ;
30679 int res1 = 0 ;
30680 int val2 ;
30681 int ecode2 = 0 ;
30682 int val3 ;
30683 int ecode3 = 0 ;
30684 PyObject * obj0 = 0 ;
30685 PyObject * obj1 = 0 ;
30686 PyObject * obj2 = 0 ;
30687 char * kwnames[] = {
30688 (char *) "self",(char *) "width",(char *) "height", NULL
30689 };
30690
30691 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30692 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30693 if (!SWIG_IsOK(res1)) {
30694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
30695 }
30696 arg1 = reinterpret_cast< wxWindow * >(argp1);
30697 ecode2 = SWIG_AsVal_int(obj1, &val2);
30698 if (!SWIG_IsOK(ecode2)) {
30699 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetClientSizeWH" "', expected argument " "2"" of type '" "int""'");
30700 }
30701 arg2 = static_cast< int >(val2);
30702 ecode3 = SWIG_AsVal_int(obj2, &val3);
30703 if (!SWIG_IsOK(ecode3)) {
30704 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetClientSizeWH" "', expected argument " "3"" of type '" "int""'");
30705 }
30706 arg3 = static_cast< int >(val3);
30707 {
30708 PyThreadState* __tstate = wxPyBeginAllowThreads();
30709 (arg1)->SetClientSize(arg2,arg3);
30710 wxPyEndAllowThreads(__tstate);
30711 if (PyErr_Occurred()) SWIG_fail;
30712 }
30713 resultobj = SWIG_Py_Void();
30714 return resultobj;
30715 fail:
30716 return NULL;
30717 }
30718
30719
30720 SWIGINTERN PyObject *_wrap_Window_SetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30721 PyObject *resultobj = 0;
30722 wxWindow *arg1 = (wxWindow *) 0 ;
30723 wxRect *arg2 = 0 ;
30724 void *argp1 = 0 ;
30725 int res1 = 0 ;
30726 wxRect temp2 ;
30727 PyObject * obj0 = 0 ;
30728 PyObject * obj1 = 0 ;
30729 char * kwnames[] = {
30730 (char *) "self",(char *) "rect", NULL
30731 };
30732
30733 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) SWIG_fail;
30734 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30735 if (!SWIG_IsOK(res1)) {
30736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientRect" "', expected argument " "1"" of type '" "wxWindow *""'");
30737 }
30738 arg1 = reinterpret_cast< wxWindow * >(argp1);
30739 {
30740 arg2 = &temp2;
30741 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30742 }
30743 {
30744 PyThreadState* __tstate = wxPyBeginAllowThreads();
30745 (arg1)->SetClientSize((wxRect const &)*arg2);
30746 wxPyEndAllowThreads(__tstate);
30747 if (PyErr_Occurred()) SWIG_fail;
30748 }
30749 resultobj = SWIG_Py_Void();
30750 return resultobj;
30751 fail:
30752 return NULL;
30753 }
30754
30755
30756 SWIGINTERN PyObject *_wrap_Window_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30757 PyObject *resultobj = 0;
30758 wxWindow *arg1 = (wxWindow *) 0 ;
30759 wxPoint result;
30760 void *argp1 = 0 ;
30761 int res1 = 0 ;
30762 PyObject *swig_obj[1] ;
30763
30764 if (!args) SWIG_fail;
30765 swig_obj[0] = args;
30766 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30767 if (!SWIG_IsOK(res1)) {
30768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
30769 }
30770 arg1 = reinterpret_cast< wxWindow * >(argp1);
30771 {
30772 PyThreadState* __tstate = wxPyBeginAllowThreads();
30773 result = ((wxWindow const *)arg1)->GetPosition();
30774 wxPyEndAllowThreads(__tstate);
30775 if (PyErr_Occurred()) SWIG_fail;
30776 }
30777 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
30778 return resultobj;
30779 fail:
30780 return NULL;
30781 }
30782
30783
30784 SWIGINTERN PyObject *_wrap_Window_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30785 PyObject *resultobj = 0;
30786 wxWindow *arg1 = (wxWindow *) 0 ;
30787 int *arg2 = (int *) 0 ;
30788 int *arg3 = (int *) 0 ;
30789 void *argp1 = 0 ;
30790 int res1 = 0 ;
30791 int temp2 ;
30792 int res2 = SWIG_TMPOBJ ;
30793 int temp3 ;
30794 int res3 = SWIG_TMPOBJ ;
30795 PyObject *swig_obj[1] ;
30796
30797 arg2 = &temp2;
30798 arg3 = &temp3;
30799 if (!args) SWIG_fail;
30800 swig_obj[0] = args;
30801 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30802 if (!SWIG_IsOK(res1)) {
30803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30804 }
30805 arg1 = reinterpret_cast< wxWindow * >(argp1);
30806 {
30807 PyThreadState* __tstate = wxPyBeginAllowThreads();
30808 ((wxWindow const *)arg1)->GetPosition(arg2,arg3);
30809 wxPyEndAllowThreads(__tstate);
30810 if (PyErr_Occurred()) SWIG_fail;
30811 }
30812 resultobj = SWIG_Py_Void();
30813 if (SWIG_IsTmpObj(res2)) {
30814 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30815 } else {
30816 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30817 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30818 }
30819 if (SWIG_IsTmpObj(res3)) {
30820 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30821 } else {
30822 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30823 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30824 }
30825 return resultobj;
30826 fail:
30827 return NULL;
30828 }
30829
30830
30831 SWIGINTERN PyObject *_wrap_Window_GetScreenPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30832 PyObject *resultobj = 0;
30833 wxWindow *arg1 = (wxWindow *) 0 ;
30834 wxPoint result;
30835 void *argp1 = 0 ;
30836 int res1 = 0 ;
30837 PyObject *swig_obj[1] ;
30838
30839 if (!args) SWIG_fail;
30840 swig_obj[0] = args;
30841 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30842 if (!SWIG_IsOK(res1)) {
30843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
30844 }
30845 arg1 = reinterpret_cast< wxWindow * >(argp1);
30846 {
30847 PyThreadState* __tstate = wxPyBeginAllowThreads();
30848 result = ((wxWindow const *)arg1)->GetScreenPosition();
30849 wxPyEndAllowThreads(__tstate);
30850 if (PyErr_Occurred()) SWIG_fail;
30851 }
30852 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
30853 return resultobj;
30854 fail:
30855 return NULL;
30856 }
30857
30858
30859 SWIGINTERN PyObject *_wrap_Window_GetScreenPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30860 PyObject *resultobj = 0;
30861 wxWindow *arg1 = (wxWindow *) 0 ;
30862 int *arg2 = (int *) 0 ;
30863 int *arg3 = (int *) 0 ;
30864 void *argp1 = 0 ;
30865 int res1 = 0 ;
30866 int temp2 ;
30867 int res2 = SWIG_TMPOBJ ;
30868 int temp3 ;
30869 int res3 = SWIG_TMPOBJ ;
30870 PyObject *swig_obj[1] ;
30871
30872 arg2 = &temp2;
30873 arg3 = &temp3;
30874 if (!args) SWIG_fail;
30875 swig_obj[0] = args;
30876 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30877 if (!SWIG_IsOK(res1)) {
30878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30879 }
30880 arg1 = reinterpret_cast< wxWindow * >(argp1);
30881 {
30882 PyThreadState* __tstate = wxPyBeginAllowThreads();
30883 ((wxWindow const *)arg1)->GetScreenPosition(arg2,arg3);
30884 wxPyEndAllowThreads(__tstate);
30885 if (PyErr_Occurred()) SWIG_fail;
30886 }
30887 resultobj = SWIG_Py_Void();
30888 if (SWIG_IsTmpObj(res2)) {
30889 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30890 } else {
30891 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30892 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30893 }
30894 if (SWIG_IsTmpObj(res3)) {
30895 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30896 } else {
30897 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30898 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30899 }
30900 return resultobj;
30901 fail:
30902 return NULL;
30903 }
30904
30905
30906 SWIGINTERN PyObject *_wrap_Window_GetScreenRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30907 PyObject *resultobj = 0;
30908 wxWindow *arg1 = (wxWindow *) 0 ;
30909 wxRect result;
30910 void *argp1 = 0 ;
30911 int res1 = 0 ;
30912 PyObject *swig_obj[1] ;
30913
30914 if (!args) SWIG_fail;
30915 swig_obj[0] = args;
30916 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30917 if (!SWIG_IsOK(res1)) {
30918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
30919 }
30920 arg1 = reinterpret_cast< wxWindow * >(argp1);
30921 {
30922 PyThreadState* __tstate = wxPyBeginAllowThreads();
30923 result = ((wxWindow const *)arg1)->GetScreenRect();
30924 wxPyEndAllowThreads(__tstate);
30925 if (PyErr_Occurred()) SWIG_fail;
30926 }
30927 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
30928 return resultobj;
30929 fail:
30930 return NULL;
30931 }
30932
30933
30934 SWIGINTERN PyObject *_wrap_Window_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30935 PyObject *resultobj = 0;
30936 wxWindow *arg1 = (wxWindow *) 0 ;
30937 wxSize result;
30938 void *argp1 = 0 ;
30939 int res1 = 0 ;
30940 PyObject *swig_obj[1] ;
30941
30942 if (!args) SWIG_fail;
30943 swig_obj[0] = args;
30944 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30945 if (!SWIG_IsOK(res1)) {
30946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
30947 }
30948 arg1 = reinterpret_cast< wxWindow * >(argp1);
30949 {
30950 PyThreadState* __tstate = wxPyBeginAllowThreads();
30951 result = ((wxWindow const *)arg1)->GetSize();
30952 wxPyEndAllowThreads(__tstate);
30953 if (PyErr_Occurred()) SWIG_fail;
30954 }
30955 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
30956 return resultobj;
30957 fail:
30958 return NULL;
30959 }
30960
30961
30962 SWIGINTERN PyObject *_wrap_Window_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30963 PyObject *resultobj = 0;
30964 wxWindow *arg1 = (wxWindow *) 0 ;
30965 int *arg2 = (int *) 0 ;
30966 int *arg3 = (int *) 0 ;
30967 void *argp1 = 0 ;
30968 int res1 = 0 ;
30969 int temp2 ;
30970 int res2 = SWIG_TMPOBJ ;
30971 int temp3 ;
30972 int res3 = SWIG_TMPOBJ ;
30973 PyObject *swig_obj[1] ;
30974
30975 arg2 = &temp2;
30976 arg3 = &temp3;
30977 if (!args) SWIG_fail;
30978 swig_obj[0] = args;
30979 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30980 if (!SWIG_IsOK(res1)) {
30981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30982 }
30983 arg1 = reinterpret_cast< wxWindow * >(argp1);
30984 {
30985 PyThreadState* __tstate = wxPyBeginAllowThreads();
30986 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
30987 wxPyEndAllowThreads(__tstate);
30988 if (PyErr_Occurred()) SWIG_fail;
30989 }
30990 resultobj = SWIG_Py_Void();
30991 if (SWIG_IsTmpObj(res2)) {
30992 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30993 } else {
30994 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30995 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30996 }
30997 if (SWIG_IsTmpObj(res3)) {
30998 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30999 } else {
31000 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31001 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31002 }
31003 return resultobj;
31004 fail:
31005 return NULL;
31006 }
31007
31008
31009 SWIGINTERN PyObject *_wrap_Window_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31010 PyObject *resultobj = 0;
31011 wxWindow *arg1 = (wxWindow *) 0 ;
31012 wxRect result;
31013 void *argp1 = 0 ;
31014 int res1 = 0 ;
31015 PyObject *swig_obj[1] ;
31016
31017 if (!args) SWIG_fail;
31018 swig_obj[0] = args;
31019 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31020 if (!SWIG_IsOK(res1)) {
31021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
31022 }
31023 arg1 = reinterpret_cast< wxWindow * >(argp1);
31024 {
31025 PyThreadState* __tstate = wxPyBeginAllowThreads();
31026 result = ((wxWindow const *)arg1)->GetRect();
31027 wxPyEndAllowThreads(__tstate);
31028 if (PyErr_Occurred()) SWIG_fail;
31029 }
31030 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
31031 return resultobj;
31032 fail:
31033 return NULL;
31034 }
31035
31036
31037 SWIGINTERN PyObject *_wrap_Window_GetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31038 PyObject *resultobj = 0;
31039 wxWindow *arg1 = (wxWindow *) 0 ;
31040 wxSize result;
31041 void *argp1 = 0 ;
31042 int res1 = 0 ;
31043 PyObject *swig_obj[1] ;
31044
31045 if (!args) SWIG_fail;
31046 swig_obj[0] = args;
31047 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31048 if (!SWIG_IsOK(res1)) {
31049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31050 }
31051 arg1 = reinterpret_cast< wxWindow * >(argp1);
31052 {
31053 PyThreadState* __tstate = wxPyBeginAllowThreads();
31054 result = ((wxWindow const *)arg1)->GetClientSize();
31055 wxPyEndAllowThreads(__tstate);
31056 if (PyErr_Occurred()) SWIG_fail;
31057 }
31058 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31059 return resultobj;
31060 fail:
31061 return NULL;
31062 }
31063
31064
31065 SWIGINTERN PyObject *_wrap_Window_GetClientSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31066 PyObject *resultobj = 0;
31067 wxWindow *arg1 = (wxWindow *) 0 ;
31068 int *arg2 = (int *) 0 ;
31069 int *arg3 = (int *) 0 ;
31070 void *argp1 = 0 ;
31071 int res1 = 0 ;
31072 int temp2 ;
31073 int res2 = SWIG_TMPOBJ ;
31074 int temp3 ;
31075 int res3 = SWIG_TMPOBJ ;
31076 PyObject *swig_obj[1] ;
31077
31078 arg2 = &temp2;
31079 arg3 = &temp3;
31080 if (!args) SWIG_fail;
31081 swig_obj[0] = args;
31082 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31083 if (!SWIG_IsOK(res1)) {
31084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31085 }
31086 arg1 = reinterpret_cast< wxWindow * >(argp1);
31087 {
31088 PyThreadState* __tstate = wxPyBeginAllowThreads();
31089 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
31090 wxPyEndAllowThreads(__tstate);
31091 if (PyErr_Occurred()) SWIG_fail;
31092 }
31093 resultobj = SWIG_Py_Void();
31094 if (SWIG_IsTmpObj(res2)) {
31095 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31096 } else {
31097 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31098 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31099 }
31100 if (SWIG_IsTmpObj(res3)) {
31101 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31102 } else {
31103 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31104 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31105 }
31106 return resultobj;
31107 fail:
31108 return NULL;
31109 }
31110
31111
31112 SWIGINTERN PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31113 PyObject *resultobj = 0;
31114 wxWindow *arg1 = (wxWindow *) 0 ;
31115 wxPoint result;
31116 void *argp1 = 0 ;
31117 int res1 = 0 ;
31118 PyObject *swig_obj[1] ;
31119
31120 if (!args) SWIG_fail;
31121 swig_obj[0] = args;
31122 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31123 if (!SWIG_IsOK(res1)) {
31124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientAreaOrigin" "', expected argument " "1"" of type '" "wxWindow const *""'");
31125 }
31126 arg1 = reinterpret_cast< wxWindow * >(argp1);
31127 {
31128 PyThreadState* __tstate = wxPyBeginAllowThreads();
31129 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
31130 wxPyEndAllowThreads(__tstate);
31131 if (PyErr_Occurred()) SWIG_fail;
31132 }
31133 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
31134 return resultobj;
31135 fail:
31136 return NULL;
31137 }
31138
31139
31140 SWIGINTERN PyObject *_wrap_Window_GetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31141 PyObject *resultobj = 0;
31142 wxWindow *arg1 = (wxWindow *) 0 ;
31143 wxRect result;
31144 void *argp1 = 0 ;
31145 int res1 = 0 ;
31146 PyObject *swig_obj[1] ;
31147
31148 if (!args) SWIG_fail;
31149 swig_obj[0] = args;
31150 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31151 if (!SWIG_IsOK(res1)) {
31152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
31153 }
31154 arg1 = reinterpret_cast< wxWindow * >(argp1);
31155 {
31156 PyThreadState* __tstate = wxPyBeginAllowThreads();
31157 result = ((wxWindow const *)arg1)->GetClientRect();
31158 wxPyEndAllowThreads(__tstate);
31159 if (PyErr_Occurred()) SWIG_fail;
31160 }
31161 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
31162 return resultobj;
31163 fail:
31164 return NULL;
31165 }
31166
31167
31168 SWIGINTERN PyObject *_wrap_Window_GetBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31169 PyObject *resultobj = 0;
31170 wxWindow *arg1 = (wxWindow *) 0 ;
31171 wxSize result;
31172 void *argp1 = 0 ;
31173 int res1 = 0 ;
31174 PyObject *swig_obj[1] ;
31175
31176 if (!args) SWIG_fail;
31177 swig_obj[0] = args;
31178 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31179 if (!SWIG_IsOK(res1)) {
31180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31181 }
31182 arg1 = reinterpret_cast< wxWindow * >(argp1);
31183 {
31184 PyThreadState* __tstate = wxPyBeginAllowThreads();
31185 result = ((wxWindow const *)arg1)->GetBestSize();
31186 wxPyEndAllowThreads(__tstate);
31187 if (PyErr_Occurred()) SWIG_fail;
31188 }
31189 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31190 return resultobj;
31191 fail:
31192 return NULL;
31193 }
31194
31195
31196 SWIGINTERN PyObject *_wrap_Window_GetBestSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31197 PyObject *resultobj = 0;
31198 wxWindow *arg1 = (wxWindow *) 0 ;
31199 int *arg2 = (int *) 0 ;
31200 int *arg3 = (int *) 0 ;
31201 void *argp1 = 0 ;
31202 int res1 = 0 ;
31203 int temp2 ;
31204 int res2 = SWIG_TMPOBJ ;
31205 int temp3 ;
31206 int res3 = SWIG_TMPOBJ ;
31207 PyObject *swig_obj[1] ;
31208
31209 arg2 = &temp2;
31210 arg3 = &temp3;
31211 if (!args) SWIG_fail;
31212 swig_obj[0] = args;
31213 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31214 if (!SWIG_IsOK(res1)) {
31215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31216 }
31217 arg1 = reinterpret_cast< wxWindow * >(argp1);
31218 {
31219 PyThreadState* __tstate = wxPyBeginAllowThreads();
31220 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
31221 wxPyEndAllowThreads(__tstate);
31222 if (PyErr_Occurred()) SWIG_fail;
31223 }
31224 resultobj = SWIG_Py_Void();
31225 if (SWIG_IsTmpObj(res2)) {
31226 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31227 } else {
31228 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31229 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31230 }
31231 if (SWIG_IsTmpObj(res3)) {
31232 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31233 } else {
31234 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31235 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31236 }
31237 return resultobj;
31238 fail:
31239 return NULL;
31240 }
31241
31242
31243 SWIGINTERN PyObject *_wrap_Window_InvalidateBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31244 PyObject *resultobj = 0;
31245 wxWindow *arg1 = (wxWindow *) 0 ;
31246 void *argp1 = 0 ;
31247 int res1 = 0 ;
31248 PyObject *swig_obj[1] ;
31249
31250 if (!args) SWIG_fail;
31251 swig_obj[0] = args;
31252 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31253 if (!SWIG_IsOK(res1)) {
31254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InvalidateBestSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31255 }
31256 arg1 = reinterpret_cast< wxWindow * >(argp1);
31257 {
31258 PyThreadState* __tstate = wxPyBeginAllowThreads();
31259 (arg1)->InvalidateBestSize();
31260 wxPyEndAllowThreads(__tstate);
31261 if (PyErr_Occurred()) SWIG_fail;
31262 }
31263 resultobj = SWIG_Py_Void();
31264 return resultobj;
31265 fail:
31266 return NULL;
31267 }
31268
31269
31270 SWIGINTERN PyObject *_wrap_Window_CacheBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31271 PyObject *resultobj = 0;
31272 wxWindow *arg1 = (wxWindow *) 0 ;
31273 wxSize *arg2 = 0 ;
31274 void *argp1 = 0 ;
31275 int res1 = 0 ;
31276 wxSize temp2 ;
31277 PyObject * obj0 = 0 ;
31278 PyObject * obj1 = 0 ;
31279 char * kwnames[] = {
31280 (char *) "self",(char *) "size", NULL
31281 };
31282
31283 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) SWIG_fail;
31284 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31285 if (!SWIG_IsOK(res1)) {
31286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CacheBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31287 }
31288 arg1 = reinterpret_cast< wxWindow * >(argp1);
31289 {
31290 arg2 = &temp2;
31291 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31292 }
31293 {
31294 PyThreadState* __tstate = wxPyBeginAllowThreads();
31295 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
31296 wxPyEndAllowThreads(__tstate);
31297 if (PyErr_Occurred()) SWIG_fail;
31298 }
31299 resultobj = SWIG_Py_Void();
31300 return resultobj;
31301 fail:
31302 return NULL;
31303 }
31304
31305
31306 SWIGINTERN PyObject *_wrap_Window_GetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31307 PyObject *resultobj = 0;
31308 wxWindow *arg1 = (wxWindow *) 0 ;
31309 wxSize result;
31310 void *argp1 = 0 ;
31311 int res1 = 0 ;
31312 PyObject *swig_obj[1] ;
31313
31314 if (!args) SWIG_fail;
31315 swig_obj[0] = args;
31316 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31317 if (!SWIG_IsOK(res1)) {
31318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31319 }
31320 arg1 = reinterpret_cast< wxWindow * >(argp1);
31321 {
31322 PyThreadState* __tstate = wxPyBeginAllowThreads();
31323 result = ((wxWindow const *)arg1)->GetBestFittingSize();
31324 wxPyEndAllowThreads(__tstate);
31325 if (PyErr_Occurred()) SWIG_fail;
31326 }
31327 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31328 return resultobj;
31329 fail:
31330 return NULL;
31331 }
31332
31333
31334 SWIGINTERN PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31335 PyObject *resultobj = 0;
31336 wxWindow *arg1 = (wxWindow *) 0 ;
31337 wxSize result;
31338 void *argp1 = 0 ;
31339 int res1 = 0 ;
31340 PyObject *swig_obj[1] ;
31341
31342 if (!args) SWIG_fail;
31343 swig_obj[0] = args;
31344 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31345 if (!SWIG_IsOK(res1)) {
31346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAdjustedBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31347 }
31348 arg1 = reinterpret_cast< wxWindow * >(argp1);
31349 {
31350 PyThreadState* __tstate = wxPyBeginAllowThreads();
31351 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
31352 wxPyEndAllowThreads(__tstate);
31353 if (PyErr_Occurred()) SWIG_fail;
31354 }
31355 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31356 return resultobj;
31357 fail:
31358 return NULL;
31359 }
31360
31361
31362 SWIGINTERN PyObject *_wrap_Window_Center(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31363 PyObject *resultobj = 0;
31364 wxWindow *arg1 = (wxWindow *) 0 ;
31365 int arg2 = (int) wxBOTH ;
31366 void *argp1 = 0 ;
31367 int res1 = 0 ;
31368 int val2 ;
31369 int ecode2 = 0 ;
31370 PyObject * obj0 = 0 ;
31371 PyObject * obj1 = 0 ;
31372 char * kwnames[] = {
31373 (char *) "self",(char *) "direction", NULL
31374 };
31375
31376 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) SWIG_fail;
31377 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31378 if (!SWIG_IsOK(res1)) {
31379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Center" "', expected argument " "1"" of type '" "wxWindow *""'");
31380 }
31381 arg1 = reinterpret_cast< wxWindow * >(argp1);
31382 if (obj1) {
31383 ecode2 = SWIG_AsVal_int(obj1, &val2);
31384 if (!SWIG_IsOK(ecode2)) {
31385 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Center" "', expected argument " "2"" of type '" "int""'");
31386 }
31387 arg2 = static_cast< int >(val2);
31388 }
31389 {
31390 PyThreadState* __tstate = wxPyBeginAllowThreads();
31391 (arg1)->Center(arg2);
31392 wxPyEndAllowThreads(__tstate);
31393 if (PyErr_Occurred()) SWIG_fail;
31394 }
31395 resultobj = SWIG_Py_Void();
31396 return resultobj;
31397 fail:
31398 return NULL;
31399 }
31400
31401
31402 SWIGINTERN PyObject *_wrap_Window_CenterOnParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31403 PyObject *resultobj = 0;
31404 wxWindow *arg1 = (wxWindow *) 0 ;
31405 int arg2 = (int) wxBOTH ;
31406 void *argp1 = 0 ;
31407 int res1 = 0 ;
31408 int val2 ;
31409 int ecode2 = 0 ;
31410 PyObject * obj0 = 0 ;
31411 PyObject * obj1 = 0 ;
31412 char * kwnames[] = {
31413 (char *) "self",(char *) "dir", NULL
31414 };
31415
31416 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) SWIG_fail;
31417 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31418 if (!SWIG_IsOK(res1)) {
31419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CenterOnParent" "', expected argument " "1"" of type '" "wxWindow *""'");
31420 }
31421 arg1 = reinterpret_cast< wxWindow * >(argp1);
31422 if (obj1) {
31423 ecode2 = SWIG_AsVal_int(obj1, &val2);
31424 if (!SWIG_IsOK(ecode2)) {
31425 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_CenterOnParent" "', expected argument " "2"" of type '" "int""'");
31426 }
31427 arg2 = static_cast< int >(val2);
31428 }
31429 {
31430 PyThreadState* __tstate = wxPyBeginAllowThreads();
31431 (arg1)->CenterOnParent(arg2);
31432 wxPyEndAllowThreads(__tstate);
31433 if (PyErr_Occurred()) SWIG_fail;
31434 }
31435 resultobj = SWIG_Py_Void();
31436 return resultobj;
31437 fail:
31438 return NULL;
31439 }
31440
31441
31442 SWIGINTERN PyObject *_wrap_Window_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31443 PyObject *resultobj = 0;
31444 wxWindow *arg1 = (wxWindow *) 0 ;
31445 void *argp1 = 0 ;
31446 int res1 = 0 ;
31447 PyObject *swig_obj[1] ;
31448
31449 if (!args) SWIG_fail;
31450 swig_obj[0] = args;
31451 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31452 if (!SWIG_IsOK(res1)) {
31453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Fit" "', expected argument " "1"" of type '" "wxWindow *""'");
31454 }
31455 arg1 = reinterpret_cast< wxWindow * >(argp1);
31456 {
31457 PyThreadState* __tstate = wxPyBeginAllowThreads();
31458 (arg1)->Fit();
31459 wxPyEndAllowThreads(__tstate);
31460 if (PyErr_Occurred()) SWIG_fail;
31461 }
31462 resultobj = SWIG_Py_Void();
31463 return resultobj;
31464 fail:
31465 return NULL;
31466 }
31467
31468
31469 SWIGINTERN PyObject *_wrap_Window_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31470 PyObject *resultobj = 0;
31471 wxWindow *arg1 = (wxWindow *) 0 ;
31472 void *argp1 = 0 ;
31473 int res1 = 0 ;
31474 PyObject *swig_obj[1] ;
31475
31476 if (!args) SWIG_fail;
31477 swig_obj[0] = args;
31478 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31479 if (!SWIG_IsOK(res1)) {
31480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FitInside" "', expected argument " "1"" of type '" "wxWindow *""'");
31481 }
31482 arg1 = reinterpret_cast< wxWindow * >(argp1);
31483 {
31484 PyThreadState* __tstate = wxPyBeginAllowThreads();
31485 (arg1)->FitInside();
31486 wxPyEndAllowThreads(__tstate);
31487 if (PyErr_Occurred()) SWIG_fail;
31488 }
31489 resultobj = SWIG_Py_Void();
31490 return resultobj;
31491 fail:
31492 return NULL;
31493 }
31494
31495
31496 SWIGINTERN PyObject *_wrap_Window_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31497 PyObject *resultobj = 0;
31498 wxWindow *arg1 = (wxWindow *) 0 ;
31499 int arg2 ;
31500 int arg3 ;
31501 int arg4 = (int) -1 ;
31502 int arg5 = (int) -1 ;
31503 int arg6 = (int) -1 ;
31504 int arg7 = (int) -1 ;
31505 void *argp1 = 0 ;
31506 int res1 = 0 ;
31507 int val2 ;
31508 int ecode2 = 0 ;
31509 int val3 ;
31510 int ecode3 = 0 ;
31511 int val4 ;
31512 int ecode4 = 0 ;
31513 int val5 ;
31514 int ecode5 = 0 ;
31515 int val6 ;
31516 int ecode6 = 0 ;
31517 int val7 ;
31518 int ecode7 = 0 ;
31519 PyObject * obj0 = 0 ;
31520 PyObject * obj1 = 0 ;
31521 PyObject * obj2 = 0 ;
31522 PyObject * obj3 = 0 ;
31523 PyObject * obj4 = 0 ;
31524 PyObject * obj5 = 0 ;
31525 PyObject * obj6 = 0 ;
31526 char * kwnames[] = {
31527 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
31528 };
31529
31530 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
31531 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31532 if (!SWIG_IsOK(res1)) {
31533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
31534 }
31535 arg1 = reinterpret_cast< wxWindow * >(argp1);
31536 ecode2 = SWIG_AsVal_int(obj1, &val2);
31537 if (!SWIG_IsOK(ecode2)) {
31538 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeHints" "', expected argument " "2"" of type '" "int""'");
31539 }
31540 arg2 = static_cast< int >(val2);
31541 ecode3 = SWIG_AsVal_int(obj2, &val3);
31542 if (!SWIG_IsOK(ecode3)) {
31543 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeHints" "', expected argument " "3"" of type '" "int""'");
31544 }
31545 arg3 = static_cast< int >(val3);
31546 if (obj3) {
31547 ecode4 = SWIG_AsVal_int(obj3, &val4);
31548 if (!SWIG_IsOK(ecode4)) {
31549 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetSizeHints" "', expected argument " "4"" of type '" "int""'");
31550 }
31551 arg4 = static_cast< int >(val4);
31552 }
31553 if (obj4) {
31554 ecode5 = SWIG_AsVal_int(obj4, &val5);
31555 if (!SWIG_IsOK(ecode5)) {
31556 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetSizeHints" "', expected argument " "5"" of type '" "int""'");
31557 }
31558 arg5 = static_cast< int >(val5);
31559 }
31560 if (obj5) {
31561 ecode6 = SWIG_AsVal_int(obj5, &val6);
31562 if (!SWIG_IsOK(ecode6)) {
31563 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetSizeHints" "', expected argument " "6"" of type '" "int""'");
31564 }
31565 arg6 = static_cast< int >(val6);
31566 }
31567 if (obj6) {
31568 ecode7 = SWIG_AsVal_int(obj6, &val7);
31569 if (!SWIG_IsOK(ecode7)) {
31570 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Window_SetSizeHints" "', expected argument " "7"" of type '" "int""'");
31571 }
31572 arg7 = static_cast< int >(val7);
31573 }
31574 {
31575 PyThreadState* __tstate = wxPyBeginAllowThreads();
31576 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
31577 wxPyEndAllowThreads(__tstate);
31578 if (PyErr_Occurred()) SWIG_fail;
31579 }
31580 resultobj = SWIG_Py_Void();
31581 return resultobj;
31582 fail:
31583 return NULL;
31584 }
31585
31586
31587 SWIGINTERN PyObject *_wrap_Window_SetSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31588 PyObject *resultobj = 0;
31589 wxWindow *arg1 = (wxWindow *) 0 ;
31590 wxSize *arg2 = 0 ;
31591 wxSize const &arg3_defvalue = wxDefaultSize ;
31592 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
31593 wxSize const &arg4_defvalue = wxDefaultSize ;
31594 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
31595 void *argp1 = 0 ;
31596 int res1 = 0 ;
31597 wxSize temp2 ;
31598 wxSize temp3 ;
31599 wxSize temp4 ;
31600 PyObject * obj0 = 0 ;
31601 PyObject * obj1 = 0 ;
31602 PyObject * obj2 = 0 ;
31603 PyObject * obj3 = 0 ;
31604 char * kwnames[] = {
31605 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
31606 };
31607
31608 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
31609 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31610 if (!SWIG_IsOK(res1)) {
31611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
31612 }
31613 arg1 = reinterpret_cast< wxWindow * >(argp1);
31614 {
31615 arg2 = &temp2;
31616 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31617 }
31618 if (obj2) {
31619 {
31620 arg3 = &temp3;
31621 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
31622 }
31623 }
31624 if (obj3) {
31625 {
31626 arg4 = &temp4;
31627 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
31628 }
31629 }
31630 {
31631 PyThreadState* __tstate = wxPyBeginAllowThreads();
31632 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
31633 wxPyEndAllowThreads(__tstate);
31634 if (PyErr_Occurred()) SWIG_fail;
31635 }
31636 resultobj = SWIG_Py_Void();
31637 return resultobj;
31638 fail:
31639 return NULL;
31640 }
31641
31642
31643 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31644 PyObject *resultobj = 0;
31645 wxWindow *arg1 = (wxWindow *) 0 ;
31646 int arg2 ;
31647 int arg3 ;
31648 int arg4 = (int) -1 ;
31649 int arg5 = (int) -1 ;
31650 void *argp1 = 0 ;
31651 int res1 = 0 ;
31652 int val2 ;
31653 int ecode2 = 0 ;
31654 int val3 ;
31655 int ecode3 = 0 ;
31656 int val4 ;
31657 int ecode4 = 0 ;
31658 int val5 ;
31659 int ecode5 = 0 ;
31660 PyObject * obj0 = 0 ;
31661 PyObject * obj1 = 0 ;
31662 PyObject * obj2 = 0 ;
31663 PyObject * obj3 = 0 ;
31664 PyObject * obj4 = 0 ;
31665 char * kwnames[] = {
31666 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
31667 };
31668
31669 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
31670 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31671 if (!SWIG_IsOK(res1)) {
31672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
31673 }
31674 arg1 = reinterpret_cast< wxWindow * >(argp1);
31675 ecode2 = SWIG_AsVal_int(obj1, &val2);
31676 if (!SWIG_IsOK(ecode2)) {
31677 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "2"" of type '" "int""'");
31678 }
31679 arg2 = static_cast< int >(val2);
31680 ecode3 = SWIG_AsVal_int(obj2, &val3);
31681 if (!SWIG_IsOK(ecode3)) {
31682 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "3"" of type '" "int""'");
31683 }
31684 arg3 = static_cast< int >(val3);
31685 if (obj3) {
31686 ecode4 = SWIG_AsVal_int(obj3, &val4);
31687 if (!SWIG_IsOK(ecode4)) {
31688 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "4"" of type '" "int""'");
31689 }
31690 arg4 = static_cast< int >(val4);
31691 }
31692 if (obj4) {
31693 ecode5 = SWIG_AsVal_int(obj4, &val5);
31694 if (!SWIG_IsOK(ecode5)) {
31695 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "5"" of type '" "int""'");
31696 }
31697 arg5 = static_cast< int >(val5);
31698 }
31699 {
31700 PyThreadState* __tstate = wxPyBeginAllowThreads();
31701 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
31702 wxPyEndAllowThreads(__tstate);
31703 if (PyErr_Occurred()) SWIG_fail;
31704 }
31705 resultobj = SWIG_Py_Void();
31706 return resultobj;
31707 fail:
31708 return NULL;
31709 }
31710
31711
31712 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31713 PyObject *resultobj = 0;
31714 wxWindow *arg1 = (wxWindow *) 0 ;
31715 wxSize *arg2 = 0 ;
31716 wxSize const &arg3_defvalue = wxDefaultSize ;
31717 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
31718 void *argp1 = 0 ;
31719 int res1 = 0 ;
31720 wxSize temp2 ;
31721 wxSize temp3 ;
31722 PyObject * obj0 = 0 ;
31723 PyObject * obj1 = 0 ;
31724 PyObject * obj2 = 0 ;
31725 char * kwnames[] = {
31726 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
31727 };
31728
31729 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31730 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31731 if (!SWIG_IsOK(res1)) {
31732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
31733 }
31734 arg1 = reinterpret_cast< wxWindow * >(argp1);
31735 {
31736 arg2 = &temp2;
31737 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31738 }
31739 if (obj2) {
31740 {
31741 arg3 = &temp3;
31742 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
31743 }
31744 }
31745 {
31746 PyThreadState* __tstate = wxPyBeginAllowThreads();
31747 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
31748 wxPyEndAllowThreads(__tstate);
31749 if (PyErr_Occurred()) SWIG_fail;
31750 }
31751 resultobj = SWIG_Py_Void();
31752 return resultobj;
31753 fail:
31754 return NULL;
31755 }
31756
31757
31758 SWIGINTERN PyObject *_wrap_Window_GetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31759 PyObject *resultobj = 0;
31760 wxWindow *arg1 = (wxWindow *) 0 ;
31761 wxSize result;
31762 void *argp1 = 0 ;
31763 int res1 = 0 ;
31764 PyObject *swig_obj[1] ;
31765
31766 if (!args) SWIG_fail;
31767 swig_obj[0] = args;
31768 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31769 if (!SWIG_IsOK(res1)) {
31770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31771 }
31772 arg1 = reinterpret_cast< wxWindow * >(argp1);
31773 {
31774 PyThreadState* __tstate = wxPyBeginAllowThreads();
31775 result = ((wxWindow const *)arg1)->GetMaxSize();
31776 wxPyEndAllowThreads(__tstate);
31777 if (PyErr_Occurred()) SWIG_fail;
31778 }
31779 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31780 return resultobj;
31781 fail:
31782 return NULL;
31783 }
31784
31785
31786 SWIGINTERN PyObject *_wrap_Window_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31787 PyObject *resultobj = 0;
31788 wxWindow *arg1 = (wxWindow *) 0 ;
31789 wxSize result;
31790 void *argp1 = 0 ;
31791 int res1 = 0 ;
31792 PyObject *swig_obj[1] ;
31793
31794 if (!args) SWIG_fail;
31795 swig_obj[0] = args;
31796 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31797 if (!SWIG_IsOK(res1)) {
31798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31799 }
31800 arg1 = reinterpret_cast< wxWindow * >(argp1);
31801 {
31802 PyThreadState* __tstate = wxPyBeginAllowThreads();
31803 result = ((wxWindow const *)arg1)->GetMinSize();
31804 wxPyEndAllowThreads(__tstate);
31805 if (PyErr_Occurred()) SWIG_fail;
31806 }
31807 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31808 return resultobj;
31809 fail:
31810 return NULL;
31811 }
31812
31813
31814 SWIGINTERN PyObject *_wrap_Window_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31815 PyObject *resultobj = 0;
31816 wxWindow *arg1 = (wxWindow *) 0 ;
31817 wxSize *arg2 = 0 ;
31818 void *argp1 = 0 ;
31819 int res1 = 0 ;
31820 wxSize temp2 ;
31821 PyObject * obj0 = 0 ;
31822 PyObject * obj1 = 0 ;
31823 char * kwnames[] = {
31824 (char *) "self",(char *) "minSize", NULL
31825 };
31826
31827 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
31828 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31829 if (!SWIG_IsOK(res1)) {
31830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMinSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31831 }
31832 arg1 = reinterpret_cast< wxWindow * >(argp1);
31833 {
31834 arg2 = &temp2;
31835 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31836 }
31837 {
31838 PyThreadState* __tstate = wxPyBeginAllowThreads();
31839 (arg1)->SetMinSize((wxSize const &)*arg2);
31840 wxPyEndAllowThreads(__tstate);
31841 if (PyErr_Occurred()) SWIG_fail;
31842 }
31843 resultobj = SWIG_Py_Void();
31844 return resultobj;
31845 fail:
31846 return NULL;
31847 }
31848
31849
31850 SWIGINTERN PyObject *_wrap_Window_SetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31851 PyObject *resultobj = 0;
31852 wxWindow *arg1 = (wxWindow *) 0 ;
31853 wxSize *arg2 = 0 ;
31854 void *argp1 = 0 ;
31855 int res1 = 0 ;
31856 wxSize temp2 ;
31857 PyObject * obj0 = 0 ;
31858 PyObject * obj1 = 0 ;
31859 char * kwnames[] = {
31860 (char *) "self",(char *) "maxSize", NULL
31861 };
31862
31863 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) SWIG_fail;
31864 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31865 if (!SWIG_IsOK(res1)) {
31866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMaxSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31867 }
31868 arg1 = reinterpret_cast< wxWindow * >(argp1);
31869 {
31870 arg2 = &temp2;
31871 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31872 }
31873 {
31874 PyThreadState* __tstate = wxPyBeginAllowThreads();
31875 (arg1)->SetMaxSize((wxSize const &)*arg2);
31876 wxPyEndAllowThreads(__tstate);
31877 if (PyErr_Occurred()) SWIG_fail;
31878 }
31879 resultobj = SWIG_Py_Void();
31880 return resultobj;
31881 fail:
31882 return NULL;
31883 }
31884
31885
31886 SWIGINTERN PyObject *_wrap_Window_GetMinWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31887 PyObject *resultobj = 0;
31888 wxWindow *arg1 = (wxWindow *) 0 ;
31889 int result;
31890 void *argp1 = 0 ;
31891 int res1 = 0 ;
31892 PyObject *swig_obj[1] ;
31893
31894 if (!args) SWIG_fail;
31895 swig_obj[0] = args;
31896 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31897 if (!SWIG_IsOK(res1)) {
31898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
31899 }
31900 arg1 = reinterpret_cast< wxWindow * >(argp1);
31901 {
31902 PyThreadState* __tstate = wxPyBeginAllowThreads();
31903 result = (int)((wxWindow const *)arg1)->GetMinWidth();
31904 wxPyEndAllowThreads(__tstate);
31905 if (PyErr_Occurred()) SWIG_fail;
31906 }
31907 resultobj = SWIG_From_int(static_cast< int >(result));
31908 return resultobj;
31909 fail:
31910 return NULL;
31911 }
31912
31913
31914 SWIGINTERN PyObject *_wrap_Window_GetMinHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31915 PyObject *resultobj = 0;
31916 wxWindow *arg1 = (wxWindow *) 0 ;
31917 int result;
31918 void *argp1 = 0 ;
31919 int res1 = 0 ;
31920 PyObject *swig_obj[1] ;
31921
31922 if (!args) SWIG_fail;
31923 swig_obj[0] = args;
31924 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31925 if (!SWIG_IsOK(res1)) {
31926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
31927 }
31928 arg1 = reinterpret_cast< wxWindow * >(argp1);
31929 {
31930 PyThreadState* __tstate = wxPyBeginAllowThreads();
31931 result = (int)((wxWindow const *)arg1)->GetMinHeight();
31932 wxPyEndAllowThreads(__tstate);
31933 if (PyErr_Occurred()) SWIG_fail;
31934 }
31935 resultobj = SWIG_From_int(static_cast< int >(result));
31936 return resultobj;
31937 fail:
31938 return NULL;
31939 }
31940
31941
31942 SWIGINTERN PyObject *_wrap_Window_GetMaxWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31943 PyObject *resultobj = 0;
31944 wxWindow *arg1 = (wxWindow *) 0 ;
31945 int result;
31946 void *argp1 = 0 ;
31947 int res1 = 0 ;
31948 PyObject *swig_obj[1] ;
31949
31950 if (!args) SWIG_fail;
31951 swig_obj[0] = args;
31952 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31953 if (!SWIG_IsOK(res1)) {
31954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
31955 }
31956 arg1 = reinterpret_cast< wxWindow * >(argp1);
31957 {
31958 PyThreadState* __tstate = wxPyBeginAllowThreads();
31959 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
31960 wxPyEndAllowThreads(__tstate);
31961 if (PyErr_Occurred()) SWIG_fail;
31962 }
31963 resultobj = SWIG_From_int(static_cast< int >(result));
31964 return resultobj;
31965 fail:
31966 return NULL;
31967 }
31968
31969
31970 SWIGINTERN PyObject *_wrap_Window_GetMaxHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31971 PyObject *resultobj = 0;
31972 wxWindow *arg1 = (wxWindow *) 0 ;
31973 int result;
31974 void *argp1 = 0 ;
31975 int res1 = 0 ;
31976 PyObject *swig_obj[1] ;
31977
31978 if (!args) SWIG_fail;
31979 swig_obj[0] = args;
31980 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31981 if (!SWIG_IsOK(res1)) {
31982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
31983 }
31984 arg1 = reinterpret_cast< wxWindow * >(argp1);
31985 {
31986 PyThreadState* __tstate = wxPyBeginAllowThreads();
31987 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
31988 wxPyEndAllowThreads(__tstate);
31989 if (PyErr_Occurred()) SWIG_fail;
31990 }
31991 resultobj = SWIG_From_int(static_cast< int >(result));
31992 return resultobj;
31993 fail:
31994 return NULL;
31995 }
31996
31997
31998 SWIGINTERN PyObject *_wrap_Window_SetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31999 PyObject *resultobj = 0;
32000 wxWindow *arg1 = (wxWindow *) 0 ;
32001 wxSize *arg2 = 0 ;
32002 void *argp1 = 0 ;
32003 int res1 = 0 ;
32004 wxSize temp2 ;
32005 PyObject * obj0 = 0 ;
32006 PyObject * obj1 = 0 ;
32007 char * kwnames[] = {
32008 (char *) "self",(char *) "size", NULL
32009 };
32010
32011 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) SWIG_fail;
32012 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32013 if (!SWIG_IsOK(res1)) {
32014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSize" "', expected argument " "1"" of type '" "wxWindow *""'");
32015 }
32016 arg1 = reinterpret_cast< wxWindow * >(argp1);
32017 {
32018 arg2 = &temp2;
32019 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32020 }
32021 {
32022 PyThreadState* __tstate = wxPyBeginAllowThreads();
32023 (arg1)->SetVirtualSize((wxSize const &)*arg2);
32024 wxPyEndAllowThreads(__tstate);
32025 if (PyErr_Occurred()) SWIG_fail;
32026 }
32027 resultobj = SWIG_Py_Void();
32028 return resultobj;
32029 fail:
32030 return NULL;
32031 }
32032
32033
32034 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32035 PyObject *resultobj = 0;
32036 wxWindow *arg1 = (wxWindow *) 0 ;
32037 int arg2 ;
32038 int arg3 ;
32039 void *argp1 = 0 ;
32040 int res1 = 0 ;
32041 int val2 ;
32042 int ecode2 = 0 ;
32043 int val3 ;
32044 int ecode3 = 0 ;
32045 PyObject * obj0 = 0 ;
32046 PyObject * obj1 = 0 ;
32047 PyObject * obj2 = 0 ;
32048 char * kwnames[] = {
32049 (char *) "self",(char *) "w",(char *) "h", NULL
32050 };
32051
32052 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32053 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32054 if (!SWIG_IsOK(res1)) {
32055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
32056 }
32057 arg1 = reinterpret_cast< wxWindow * >(argp1);
32058 ecode2 = SWIG_AsVal_int(obj1, &val2);
32059 if (!SWIG_IsOK(ecode2)) {
32060 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "2"" of type '" "int""'");
32061 }
32062 arg2 = static_cast< int >(val2);
32063 ecode3 = SWIG_AsVal_int(obj2, &val3);
32064 if (!SWIG_IsOK(ecode3)) {
32065 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "3"" of type '" "int""'");
32066 }
32067 arg3 = static_cast< int >(val3);
32068 {
32069 PyThreadState* __tstate = wxPyBeginAllowThreads();
32070 (arg1)->SetVirtualSize(arg2,arg3);
32071 wxPyEndAllowThreads(__tstate);
32072 if (PyErr_Occurred()) SWIG_fail;
32073 }
32074 resultobj = SWIG_Py_Void();
32075 return resultobj;
32076 fail:
32077 return NULL;
32078 }
32079
32080
32081 SWIGINTERN PyObject *_wrap_Window_GetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32082 PyObject *resultobj = 0;
32083 wxWindow *arg1 = (wxWindow *) 0 ;
32084 wxSize result;
32085 void *argp1 = 0 ;
32086 int res1 = 0 ;
32087 PyObject *swig_obj[1] ;
32088
32089 if (!args) SWIG_fail;
32090 swig_obj[0] = args;
32091 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32092 if (!SWIG_IsOK(res1)) {
32093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32094 }
32095 arg1 = reinterpret_cast< wxWindow * >(argp1);
32096 {
32097 PyThreadState* __tstate = wxPyBeginAllowThreads();
32098 result = ((wxWindow const *)arg1)->GetVirtualSize();
32099 wxPyEndAllowThreads(__tstate);
32100 if (PyErr_Occurred()) SWIG_fail;
32101 }
32102 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32103 return resultobj;
32104 fail:
32105 return NULL;
32106 }
32107
32108
32109 SWIGINTERN PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32110 PyObject *resultobj = 0;
32111 wxWindow *arg1 = (wxWindow *) 0 ;
32112 int *arg2 = (int *) 0 ;
32113 int *arg3 = (int *) 0 ;
32114 void *argp1 = 0 ;
32115 int res1 = 0 ;
32116 int temp2 ;
32117 int res2 = SWIG_TMPOBJ ;
32118 int temp3 ;
32119 int res3 = SWIG_TMPOBJ ;
32120 PyObject *swig_obj[1] ;
32121
32122 arg2 = &temp2;
32123 arg3 = &temp3;
32124 if (!args) SWIG_fail;
32125 swig_obj[0] = args;
32126 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32127 if (!SWIG_IsOK(res1)) {
32128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
32129 }
32130 arg1 = reinterpret_cast< wxWindow * >(argp1);
32131 {
32132 PyThreadState* __tstate = wxPyBeginAllowThreads();
32133 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
32134 wxPyEndAllowThreads(__tstate);
32135 if (PyErr_Occurred()) SWIG_fail;
32136 }
32137 resultobj = SWIG_Py_Void();
32138 if (SWIG_IsTmpObj(res2)) {
32139 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
32140 } else {
32141 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32142 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
32143 }
32144 if (SWIG_IsTmpObj(res3)) {
32145 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
32146 } else {
32147 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32148 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
32149 }
32150 return resultobj;
32151 fail:
32152 return NULL;
32153 }
32154
32155
32156 SWIGINTERN PyObject *_wrap_Window_GetBestVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32157 PyObject *resultobj = 0;
32158 wxWindow *arg1 = (wxWindow *) 0 ;
32159 wxSize result;
32160 void *argp1 = 0 ;
32161 int res1 = 0 ;
32162 PyObject *swig_obj[1] ;
32163
32164 if (!args) SWIG_fail;
32165 swig_obj[0] = args;
32166 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32167 if (!SWIG_IsOK(res1)) {
32168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32169 }
32170 arg1 = reinterpret_cast< wxWindow * >(argp1);
32171 {
32172 PyThreadState* __tstate = wxPyBeginAllowThreads();
32173 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
32174 wxPyEndAllowThreads(__tstate);
32175 if (PyErr_Occurred()) SWIG_fail;
32176 }
32177 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32178 return resultobj;
32179 fail:
32180 return NULL;
32181 }
32182
32183
32184 SWIGINTERN PyObject *_wrap_Window_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32185 PyObject *resultobj = 0;
32186 wxWindow *arg1 = (wxWindow *) 0 ;
32187 bool arg2 = (bool) true ;
32188 bool result;
32189 void *argp1 = 0 ;
32190 int res1 = 0 ;
32191 bool val2 ;
32192 int ecode2 = 0 ;
32193 PyObject * obj0 = 0 ;
32194 PyObject * obj1 = 0 ;
32195 char * kwnames[] = {
32196 (char *) "self",(char *) "show", NULL
32197 };
32198
32199 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) SWIG_fail;
32200 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32201 if (!SWIG_IsOK(res1)) {
32202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Show" "', expected argument " "1"" of type '" "wxWindow *""'");
32203 }
32204 arg1 = reinterpret_cast< wxWindow * >(argp1);
32205 if (obj1) {
32206 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32207 if (!SWIG_IsOK(ecode2)) {
32208 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Show" "', expected argument " "2"" of type '" "bool""'");
32209 }
32210 arg2 = static_cast< bool >(val2);
32211 }
32212 {
32213 PyThreadState* __tstate = wxPyBeginAllowThreads();
32214 result = (bool)(arg1)->Show(arg2);
32215 wxPyEndAllowThreads(__tstate);
32216 if (PyErr_Occurred()) SWIG_fail;
32217 }
32218 {
32219 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32220 }
32221 return resultobj;
32222 fail:
32223 return NULL;
32224 }
32225
32226
32227 SWIGINTERN PyObject *_wrap_Window_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32228 PyObject *resultobj = 0;
32229 wxWindow *arg1 = (wxWindow *) 0 ;
32230 bool result;
32231 void *argp1 = 0 ;
32232 int res1 = 0 ;
32233 PyObject *swig_obj[1] ;
32234
32235 if (!args) SWIG_fail;
32236 swig_obj[0] = args;
32237 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32238 if (!SWIG_IsOK(res1)) {
32239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Hide" "', expected argument " "1"" of type '" "wxWindow *""'");
32240 }
32241 arg1 = reinterpret_cast< wxWindow * >(argp1);
32242 {
32243 PyThreadState* __tstate = wxPyBeginAllowThreads();
32244 result = (bool)(arg1)->Hide();
32245 wxPyEndAllowThreads(__tstate);
32246 if (PyErr_Occurred()) SWIG_fail;
32247 }
32248 {
32249 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32250 }
32251 return resultobj;
32252 fail:
32253 return NULL;
32254 }
32255
32256
32257 SWIGINTERN PyObject *_wrap_Window_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32258 PyObject *resultobj = 0;
32259 wxWindow *arg1 = (wxWindow *) 0 ;
32260 bool arg2 = (bool) true ;
32261 bool result;
32262 void *argp1 = 0 ;
32263 int res1 = 0 ;
32264 bool val2 ;
32265 int ecode2 = 0 ;
32266 PyObject * obj0 = 0 ;
32267 PyObject * obj1 = 0 ;
32268 char * kwnames[] = {
32269 (char *) "self",(char *) "enable", NULL
32270 };
32271
32272 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
32273 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32274 if (!SWIG_IsOK(res1)) {
32275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Enable" "', expected argument " "1"" of type '" "wxWindow *""'");
32276 }
32277 arg1 = reinterpret_cast< wxWindow * >(argp1);
32278 if (obj1) {
32279 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32280 if (!SWIG_IsOK(ecode2)) {
32281 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Enable" "', expected argument " "2"" of type '" "bool""'");
32282 }
32283 arg2 = static_cast< bool >(val2);
32284 }
32285 {
32286 PyThreadState* __tstate = wxPyBeginAllowThreads();
32287 result = (bool)(arg1)->Enable(arg2);
32288 wxPyEndAllowThreads(__tstate);
32289 if (PyErr_Occurred()) SWIG_fail;
32290 }
32291 {
32292 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32293 }
32294 return resultobj;
32295 fail:
32296 return NULL;
32297 }
32298
32299
32300 SWIGINTERN PyObject *_wrap_Window_Disable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32301 PyObject *resultobj = 0;
32302 wxWindow *arg1 = (wxWindow *) 0 ;
32303 bool result;
32304 void *argp1 = 0 ;
32305 int res1 = 0 ;
32306 PyObject *swig_obj[1] ;
32307
32308 if (!args) SWIG_fail;
32309 swig_obj[0] = args;
32310 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32311 if (!SWIG_IsOK(res1)) {
32312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Disable" "', expected argument " "1"" of type '" "wxWindow *""'");
32313 }
32314 arg1 = reinterpret_cast< wxWindow * >(argp1);
32315 {
32316 PyThreadState* __tstate = wxPyBeginAllowThreads();
32317 result = (bool)(arg1)->Disable();
32318 wxPyEndAllowThreads(__tstate);
32319 if (PyErr_Occurred()) SWIG_fail;
32320 }
32321 {
32322 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32323 }
32324 return resultobj;
32325 fail:
32326 return NULL;
32327 }
32328
32329
32330 SWIGINTERN PyObject *_wrap_Window_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32331 PyObject *resultobj = 0;
32332 wxWindow *arg1 = (wxWindow *) 0 ;
32333 bool result;
32334 void *argp1 = 0 ;
32335 int res1 = 0 ;
32336 PyObject *swig_obj[1] ;
32337
32338 if (!args) SWIG_fail;
32339 swig_obj[0] = args;
32340 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32341 if (!SWIG_IsOK(res1)) {
32342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShown" "', expected argument " "1"" of type '" "wxWindow const *""'");
32343 }
32344 arg1 = reinterpret_cast< wxWindow * >(argp1);
32345 {
32346 PyThreadState* __tstate = wxPyBeginAllowThreads();
32347 result = (bool)((wxWindow const *)arg1)->IsShown();
32348 wxPyEndAllowThreads(__tstate);
32349 if (PyErr_Occurred()) SWIG_fail;
32350 }
32351 {
32352 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32353 }
32354 return resultobj;
32355 fail:
32356 return NULL;
32357 }
32358
32359
32360 SWIGINTERN PyObject *_wrap_Window_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32361 PyObject *resultobj = 0;
32362 wxWindow *arg1 = (wxWindow *) 0 ;
32363 bool result;
32364 void *argp1 = 0 ;
32365 int res1 = 0 ;
32366 PyObject *swig_obj[1] ;
32367
32368 if (!args) SWIG_fail;
32369 swig_obj[0] = args;
32370 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32371 if (!SWIG_IsOK(res1)) {
32372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
32373 }
32374 arg1 = reinterpret_cast< wxWindow * >(argp1);
32375 {
32376 PyThreadState* __tstate = wxPyBeginAllowThreads();
32377 result = (bool)((wxWindow const *)arg1)->IsEnabled();
32378 wxPyEndAllowThreads(__tstate);
32379 if (PyErr_Occurred()) SWIG_fail;
32380 }
32381 {
32382 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32383 }
32384 return resultobj;
32385 fail:
32386 return NULL;
32387 }
32388
32389
32390 SWIGINTERN PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32391 PyObject *resultobj = 0;
32392 wxWindow *arg1 = (wxWindow *) 0 ;
32393 long arg2 ;
32394 void *argp1 = 0 ;
32395 int res1 = 0 ;
32396 long val2 ;
32397 int ecode2 = 0 ;
32398 PyObject * obj0 = 0 ;
32399 PyObject * obj1 = 0 ;
32400 char * kwnames[] = {
32401 (char *) "self",(char *) "style", NULL
32402 };
32403
32404 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) SWIG_fail;
32405 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32406 if (!SWIG_IsOK(res1)) {
32407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow *""'");
32408 }
32409 arg1 = reinterpret_cast< wxWindow * >(argp1);
32410 ecode2 = SWIG_AsVal_long(obj1, &val2);
32411 if (!SWIG_IsOK(ecode2)) {
32412 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "2"" of type '" "long""'");
32413 }
32414 arg2 = static_cast< long >(val2);
32415 {
32416 PyThreadState* __tstate = wxPyBeginAllowThreads();
32417 (arg1)->SetWindowStyleFlag(arg2);
32418 wxPyEndAllowThreads(__tstate);
32419 if (PyErr_Occurred()) SWIG_fail;
32420 }
32421 resultobj = SWIG_Py_Void();
32422 return resultobj;
32423 fail:
32424 return NULL;
32425 }
32426
32427
32428 SWIGINTERN PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32429 PyObject *resultobj = 0;
32430 wxWindow *arg1 = (wxWindow *) 0 ;
32431 long result;
32432 void *argp1 = 0 ;
32433 int res1 = 0 ;
32434 PyObject *swig_obj[1] ;
32435
32436 if (!args) SWIG_fail;
32437 swig_obj[0] = args;
32438 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32439 if (!SWIG_IsOK(res1)) {
32440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
32441 }
32442 arg1 = reinterpret_cast< wxWindow * >(argp1);
32443 {
32444 PyThreadState* __tstate = wxPyBeginAllowThreads();
32445 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
32446 wxPyEndAllowThreads(__tstate);
32447 if (PyErr_Occurred()) SWIG_fail;
32448 }
32449 resultobj = SWIG_From_long(static_cast< long >(result));
32450 return resultobj;
32451 fail:
32452 return NULL;
32453 }
32454
32455
32456 SWIGINTERN PyObject *_wrap_Window_HasFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32457 PyObject *resultobj = 0;
32458 wxWindow *arg1 = (wxWindow *) 0 ;
32459 int arg2 ;
32460 bool result;
32461 void *argp1 = 0 ;
32462 int res1 = 0 ;
32463 int val2 ;
32464 int ecode2 = 0 ;
32465 PyObject * obj0 = 0 ;
32466 PyObject * obj1 = 0 ;
32467 char * kwnames[] = {
32468 (char *) "self",(char *) "flag", NULL
32469 };
32470
32471 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) SWIG_fail;
32472 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32473 if (!SWIG_IsOK(res1)) {
32474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
32475 }
32476 arg1 = reinterpret_cast< wxWindow * >(argp1);
32477 ecode2 = SWIG_AsVal_int(obj1, &val2);
32478 if (!SWIG_IsOK(ecode2)) {
32479 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasFlag" "', expected argument " "2"" of type '" "int""'");
32480 }
32481 arg2 = static_cast< int >(val2);
32482 {
32483 PyThreadState* __tstate = wxPyBeginAllowThreads();
32484 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
32485 wxPyEndAllowThreads(__tstate);
32486 if (PyErr_Occurred()) SWIG_fail;
32487 }
32488 {
32489 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32490 }
32491 return resultobj;
32492 fail:
32493 return NULL;
32494 }
32495
32496
32497 SWIGINTERN PyObject *_wrap_Window_IsRetained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32498 PyObject *resultobj = 0;
32499 wxWindow *arg1 = (wxWindow *) 0 ;
32500 bool result;
32501 void *argp1 = 0 ;
32502 int res1 = 0 ;
32503 PyObject *swig_obj[1] ;
32504
32505 if (!args) SWIG_fail;
32506 swig_obj[0] = args;
32507 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32508 if (!SWIG_IsOK(res1)) {
32509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsRetained" "', expected argument " "1"" of type '" "wxWindow const *""'");
32510 }
32511 arg1 = reinterpret_cast< wxWindow * >(argp1);
32512 {
32513 PyThreadState* __tstate = wxPyBeginAllowThreads();
32514 result = (bool)((wxWindow const *)arg1)->IsRetained();
32515 wxPyEndAllowThreads(__tstate);
32516 if (PyErr_Occurred()) SWIG_fail;
32517 }
32518 {
32519 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32520 }
32521 return resultobj;
32522 fail:
32523 return NULL;
32524 }
32525
32526
32527 SWIGINTERN PyObject *_wrap_Window_SetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32528 PyObject *resultobj = 0;
32529 wxWindow *arg1 = (wxWindow *) 0 ;
32530 long arg2 ;
32531 void *argp1 = 0 ;
32532 int res1 = 0 ;
32533 long val2 ;
32534 int ecode2 = 0 ;
32535 PyObject * obj0 = 0 ;
32536 PyObject * obj1 = 0 ;
32537 char * kwnames[] = {
32538 (char *) "self",(char *) "exStyle", NULL
32539 };
32540
32541 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) SWIG_fail;
32542 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32543 if (!SWIG_IsOK(res1)) {
32544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetExtraStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
32545 }
32546 arg1 = reinterpret_cast< wxWindow * >(argp1);
32547 ecode2 = SWIG_AsVal_long(obj1, &val2);
32548 if (!SWIG_IsOK(ecode2)) {
32549 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetExtraStyle" "', expected argument " "2"" of type '" "long""'");
32550 }
32551 arg2 = static_cast< long >(val2);
32552 {
32553 PyThreadState* __tstate = wxPyBeginAllowThreads();
32554 (arg1)->SetExtraStyle(arg2);
32555 wxPyEndAllowThreads(__tstate);
32556 if (PyErr_Occurred()) SWIG_fail;
32557 }
32558 resultobj = SWIG_Py_Void();
32559 return resultobj;
32560 fail:
32561 return NULL;
32562 }
32563
32564
32565 SWIGINTERN PyObject *_wrap_Window_GetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32566 PyObject *resultobj = 0;
32567 wxWindow *arg1 = (wxWindow *) 0 ;
32568 long result;
32569 void *argp1 = 0 ;
32570 int res1 = 0 ;
32571 PyObject *swig_obj[1] ;
32572
32573 if (!args) SWIG_fail;
32574 swig_obj[0] = args;
32575 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32576 if (!SWIG_IsOK(res1)) {
32577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetExtraStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
32578 }
32579 arg1 = reinterpret_cast< wxWindow * >(argp1);
32580 {
32581 PyThreadState* __tstate = wxPyBeginAllowThreads();
32582 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
32583 wxPyEndAllowThreads(__tstate);
32584 if (PyErr_Occurred()) SWIG_fail;
32585 }
32586 resultobj = SWIG_From_long(static_cast< long >(result));
32587 return resultobj;
32588 fail:
32589 return NULL;
32590 }
32591
32592
32593 SWIGINTERN PyObject *_wrap_Window_MakeModal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32594 PyObject *resultobj = 0;
32595 wxWindow *arg1 = (wxWindow *) 0 ;
32596 bool arg2 = (bool) true ;
32597 void *argp1 = 0 ;
32598 int res1 = 0 ;
32599 bool val2 ;
32600 int ecode2 = 0 ;
32601 PyObject * obj0 = 0 ;
32602 PyObject * obj1 = 0 ;
32603 char * kwnames[] = {
32604 (char *) "self",(char *) "modal", NULL
32605 };
32606
32607 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) SWIG_fail;
32608 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32609 if (!SWIG_IsOK(res1)) {
32610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MakeModal" "', expected argument " "1"" of type '" "wxWindow *""'");
32611 }
32612 arg1 = reinterpret_cast< wxWindow * >(argp1);
32613 if (obj1) {
32614 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32615 if (!SWIG_IsOK(ecode2)) {
32616 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MakeModal" "', expected argument " "2"" of type '" "bool""'");
32617 }
32618 arg2 = static_cast< bool >(val2);
32619 }
32620 {
32621 PyThreadState* __tstate = wxPyBeginAllowThreads();
32622 (arg1)->MakeModal(arg2);
32623 wxPyEndAllowThreads(__tstate);
32624 if (PyErr_Occurred()) SWIG_fail;
32625 }
32626 resultobj = SWIG_Py_Void();
32627 return resultobj;
32628 fail:
32629 return NULL;
32630 }
32631
32632
32633 SWIGINTERN PyObject *_wrap_Window_SetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32634 PyObject *resultobj = 0;
32635 wxWindow *arg1 = (wxWindow *) 0 ;
32636 bool arg2 ;
32637 void *argp1 = 0 ;
32638 int res1 = 0 ;
32639 bool val2 ;
32640 int ecode2 = 0 ;
32641 PyObject * obj0 = 0 ;
32642 PyObject * obj1 = 0 ;
32643 char * kwnames[] = {
32644 (char *) "self",(char *) "enableTheme", NULL
32645 };
32646
32647 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
32648 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32649 if (!SWIG_IsOK(res1)) {
32650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow *""'");
32651 }
32652 arg1 = reinterpret_cast< wxWindow * >(argp1);
32653 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32654 if (!SWIG_IsOK(ecode2)) {
32655 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetThemeEnabled" "', expected argument " "2"" of type '" "bool""'");
32656 }
32657 arg2 = static_cast< bool >(val2);
32658 {
32659 PyThreadState* __tstate = wxPyBeginAllowThreads();
32660 (arg1)->SetThemeEnabled(arg2);
32661 wxPyEndAllowThreads(__tstate);
32662 if (PyErr_Occurred()) SWIG_fail;
32663 }
32664 resultobj = SWIG_Py_Void();
32665 return resultobj;
32666 fail:
32667 return NULL;
32668 }
32669
32670
32671 SWIGINTERN PyObject *_wrap_Window_GetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32672 PyObject *resultobj = 0;
32673 wxWindow *arg1 = (wxWindow *) 0 ;
32674 bool result;
32675 void *argp1 = 0 ;
32676 int res1 = 0 ;
32677 PyObject *swig_obj[1] ;
32678
32679 if (!args) SWIG_fail;
32680 swig_obj[0] = args;
32681 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32682 if (!SWIG_IsOK(res1)) {
32683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
32684 }
32685 arg1 = reinterpret_cast< wxWindow * >(argp1);
32686 {
32687 PyThreadState* __tstate = wxPyBeginAllowThreads();
32688 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
32689 wxPyEndAllowThreads(__tstate);
32690 if (PyErr_Occurred()) SWIG_fail;
32691 }
32692 {
32693 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32694 }
32695 return resultobj;
32696 fail:
32697 return NULL;
32698 }
32699
32700
32701 SWIGINTERN PyObject *_wrap_Window_SetFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32702 PyObject *resultobj = 0;
32703 wxWindow *arg1 = (wxWindow *) 0 ;
32704 void *argp1 = 0 ;
32705 int res1 = 0 ;
32706 PyObject *swig_obj[1] ;
32707
32708 if (!args) SWIG_fail;
32709 swig_obj[0] = args;
32710 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32711 if (!SWIG_IsOK(res1)) {
32712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocus" "', expected argument " "1"" of type '" "wxWindow *""'");
32713 }
32714 arg1 = reinterpret_cast< wxWindow * >(argp1);
32715 {
32716 PyThreadState* __tstate = wxPyBeginAllowThreads();
32717 (arg1)->SetFocus();
32718 wxPyEndAllowThreads(__tstate);
32719 if (PyErr_Occurred()) SWIG_fail;
32720 }
32721 resultobj = SWIG_Py_Void();
32722 return resultobj;
32723 fail:
32724 return NULL;
32725 }
32726
32727
32728 SWIGINTERN PyObject *_wrap_Window_SetFocusFromKbd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32729 PyObject *resultobj = 0;
32730 wxWindow *arg1 = (wxWindow *) 0 ;
32731 void *argp1 = 0 ;
32732 int res1 = 0 ;
32733 PyObject *swig_obj[1] ;
32734
32735 if (!args) SWIG_fail;
32736 swig_obj[0] = args;
32737 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32738 if (!SWIG_IsOK(res1)) {
32739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocusFromKbd" "', expected argument " "1"" of type '" "wxWindow *""'");
32740 }
32741 arg1 = reinterpret_cast< wxWindow * >(argp1);
32742 {
32743 PyThreadState* __tstate = wxPyBeginAllowThreads();
32744 (arg1)->SetFocusFromKbd();
32745 wxPyEndAllowThreads(__tstate);
32746 if (PyErr_Occurred()) SWIG_fail;
32747 }
32748 resultobj = SWIG_Py_Void();
32749 return resultobj;
32750 fail:
32751 return NULL;
32752 }
32753
32754
32755 SWIGINTERN PyObject *_wrap_Window_FindFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32756 PyObject *resultobj = 0;
32757 wxWindow *result = 0 ;
32758
32759 if (!SWIG_Python_UnpackTuple(args,"Window_FindFocus",0,0,0)) SWIG_fail;
32760 {
32761 if (!wxPyCheckForApp()) SWIG_fail;
32762 PyThreadState* __tstate = wxPyBeginAllowThreads();
32763 result = (wxWindow *)wxWindow::FindFocus();
32764 wxPyEndAllowThreads(__tstate);
32765 if (PyErr_Occurred()) SWIG_fail;
32766 }
32767 {
32768 resultobj = wxPyMake_wxObject(result, 0);
32769 }
32770 return resultobj;
32771 fail:
32772 return NULL;
32773 }
32774
32775
32776 SWIGINTERN PyObject *_wrap_Window_AcceptsFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32777 PyObject *resultobj = 0;
32778 wxWindow *arg1 = (wxWindow *) 0 ;
32779 bool result;
32780 void *argp1 = 0 ;
32781 int res1 = 0 ;
32782 PyObject *swig_obj[1] ;
32783
32784 if (!args) SWIG_fail;
32785 swig_obj[0] = args;
32786 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32787 if (!SWIG_IsOK(res1)) {
32788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
32789 }
32790 arg1 = reinterpret_cast< wxWindow * >(argp1);
32791 {
32792 PyThreadState* __tstate = wxPyBeginAllowThreads();
32793 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
32794 wxPyEndAllowThreads(__tstate);
32795 if (PyErr_Occurred()) SWIG_fail;
32796 }
32797 {
32798 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32799 }
32800 return resultobj;
32801 fail:
32802 return NULL;
32803 }
32804
32805
32806 SWIGINTERN PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32807 PyObject *resultobj = 0;
32808 wxWindow *arg1 = (wxWindow *) 0 ;
32809 bool result;
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_AcceptsFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
32819 }
32820 arg1 = reinterpret_cast< wxWindow * >(argp1);
32821 {
32822 PyThreadState* __tstate = wxPyBeginAllowThreads();
32823 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
32824 wxPyEndAllowThreads(__tstate);
32825 if (PyErr_Occurred()) SWIG_fail;
32826 }
32827 {
32828 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32829 }
32830 return resultobj;
32831 fail:
32832 return NULL;
32833 }
32834
32835
32836 SWIGINTERN PyObject *_wrap_Window_GetDefaultItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32837 PyObject *resultobj = 0;
32838 wxWindow *arg1 = (wxWindow *) 0 ;
32839 wxWindow *result = 0 ;
32840 void *argp1 = 0 ;
32841 int res1 = 0 ;
32842 PyObject *swig_obj[1] ;
32843
32844 if (!args) SWIG_fail;
32845 swig_obj[0] = args;
32846 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32847 if (!SWIG_IsOK(res1)) {
32848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultItem" "', expected argument " "1"" of type '" "wxWindow const *""'");
32849 }
32850 arg1 = reinterpret_cast< wxWindow * >(argp1);
32851 {
32852 PyThreadState* __tstate = wxPyBeginAllowThreads();
32853 result = (wxWindow *)((wxWindow const *)arg1)->GetDefaultItem();
32854 wxPyEndAllowThreads(__tstate);
32855 if (PyErr_Occurred()) SWIG_fail;
32856 }
32857 {
32858 resultobj = wxPyMake_wxObject(result, 0);
32859 }
32860 return resultobj;
32861 fail:
32862 return NULL;
32863 }
32864
32865
32866 SWIGINTERN PyObject *_wrap_Window_SetDefaultItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32867 PyObject *resultobj = 0;
32868 wxWindow *arg1 = (wxWindow *) 0 ;
32869 wxWindow *arg2 = (wxWindow *) 0 ;
32870 wxWindow *result = 0 ;
32871 void *argp1 = 0 ;
32872 int res1 = 0 ;
32873 void *argp2 = 0 ;
32874 int res2 = 0 ;
32875 PyObject * obj0 = 0 ;
32876 PyObject * obj1 = 0 ;
32877 char * kwnames[] = {
32878 (char *) "self",(char *) "child", NULL
32879 };
32880
32881 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDefaultItem",kwnames,&obj0,&obj1)) SWIG_fail;
32882 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32883 if (!SWIG_IsOK(res1)) {
32884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDefaultItem" "', expected argument " "1"" of type '" "wxWindow *""'");
32885 }
32886 arg1 = reinterpret_cast< wxWindow * >(argp1);
32887 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32888 if (!SWIG_IsOK(res2)) {
32889 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDefaultItem" "', expected argument " "2"" of type '" "wxWindow *""'");
32890 }
32891 arg2 = reinterpret_cast< wxWindow * >(argp2);
32892 {
32893 PyThreadState* __tstate = wxPyBeginAllowThreads();
32894 result = (wxWindow *)(arg1)->SetDefaultItem(arg2);
32895 wxPyEndAllowThreads(__tstate);
32896 if (PyErr_Occurred()) SWIG_fail;
32897 }
32898 {
32899 resultobj = wxPyMake_wxObject(result, 0);
32900 }
32901 return resultobj;
32902 fail:
32903 return NULL;
32904 }
32905
32906
32907 SWIGINTERN PyObject *_wrap_Window_SetTmpDefaultItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32908 PyObject *resultobj = 0;
32909 wxWindow *arg1 = (wxWindow *) 0 ;
32910 wxWindow *arg2 = (wxWindow *) 0 ;
32911 void *argp1 = 0 ;
32912 int res1 = 0 ;
32913 void *argp2 = 0 ;
32914 int res2 = 0 ;
32915 PyObject * obj0 = 0 ;
32916 PyObject * obj1 = 0 ;
32917 char * kwnames[] = {
32918 (char *) "self",(char *) "win", NULL
32919 };
32920
32921 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTmpDefaultItem",kwnames,&obj0,&obj1)) SWIG_fail;
32922 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32923 if (!SWIG_IsOK(res1)) {
32924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetTmpDefaultItem" "', expected argument " "1"" of type '" "wxWindow *""'");
32925 }
32926 arg1 = reinterpret_cast< wxWindow * >(argp1);
32927 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32928 if (!SWIG_IsOK(res2)) {
32929 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetTmpDefaultItem" "', expected argument " "2"" of type '" "wxWindow *""'");
32930 }
32931 arg2 = reinterpret_cast< wxWindow * >(argp2);
32932 {
32933 PyThreadState* __tstate = wxPyBeginAllowThreads();
32934 (arg1)->SetTmpDefaultItem(arg2);
32935 wxPyEndAllowThreads(__tstate);
32936 if (PyErr_Occurred()) SWIG_fail;
32937 }
32938 resultobj = SWIG_Py_Void();
32939 return resultobj;
32940 fail:
32941 return NULL;
32942 }
32943
32944
32945 SWIGINTERN PyObject *_wrap_Window_Navigate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32946 PyObject *resultobj = 0;
32947 wxWindow *arg1 = (wxWindow *) 0 ;
32948 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
32949 bool result;
32950 void *argp1 = 0 ;
32951 int res1 = 0 ;
32952 int val2 ;
32953 int ecode2 = 0 ;
32954 PyObject * obj0 = 0 ;
32955 PyObject * obj1 = 0 ;
32956 char * kwnames[] = {
32957 (char *) "self",(char *) "flags", NULL
32958 };
32959
32960 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) SWIG_fail;
32961 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32962 if (!SWIG_IsOK(res1)) {
32963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Navigate" "', expected argument " "1"" of type '" "wxWindow *""'");
32964 }
32965 arg1 = reinterpret_cast< wxWindow * >(argp1);
32966 if (obj1) {
32967 ecode2 = SWIG_AsVal_int(obj1, &val2);
32968 if (!SWIG_IsOK(ecode2)) {
32969 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Navigate" "', expected argument " "2"" of type '" "int""'");
32970 }
32971 arg2 = static_cast< int >(val2);
32972 }
32973 {
32974 PyThreadState* __tstate = wxPyBeginAllowThreads();
32975 result = (bool)(arg1)->Navigate(arg2);
32976 wxPyEndAllowThreads(__tstate);
32977 if (PyErr_Occurred()) SWIG_fail;
32978 }
32979 {
32980 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32981 }
32982 return resultobj;
32983 fail:
32984 return NULL;
32985 }
32986
32987
32988 SWIGINTERN PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32989 PyObject *resultobj = 0;
32990 wxWindow *arg1 = (wxWindow *) 0 ;
32991 wxWindow *arg2 = (wxWindow *) 0 ;
32992 void *argp1 = 0 ;
32993 int res1 = 0 ;
32994 void *argp2 = 0 ;
32995 int res2 = 0 ;
32996 PyObject * obj0 = 0 ;
32997 PyObject * obj1 = 0 ;
32998 char * kwnames[] = {
32999 (char *) "self",(char *) "win", NULL
33000 };
33001
33002 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
33003 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33004 if (!SWIG_IsOK(res1)) {
33005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
33006 }
33007 arg1 = reinterpret_cast< wxWindow * >(argp1);
33008 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33009 if (!SWIG_IsOK(res2)) {
33010 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
33011 }
33012 arg2 = reinterpret_cast< wxWindow * >(argp2);
33013 {
33014 PyThreadState* __tstate = wxPyBeginAllowThreads();
33015 (arg1)->MoveAfterInTabOrder(arg2);
33016 wxPyEndAllowThreads(__tstate);
33017 if (PyErr_Occurred()) SWIG_fail;
33018 }
33019 resultobj = SWIG_Py_Void();
33020 return resultobj;
33021 fail:
33022 return NULL;
33023 }
33024
33025
33026 SWIGINTERN PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33027 PyObject *resultobj = 0;
33028 wxWindow *arg1 = (wxWindow *) 0 ;
33029 wxWindow *arg2 = (wxWindow *) 0 ;
33030 void *argp1 = 0 ;
33031 int res1 = 0 ;
33032 void *argp2 = 0 ;
33033 int res2 = 0 ;
33034 PyObject * obj0 = 0 ;
33035 PyObject * obj1 = 0 ;
33036 char * kwnames[] = {
33037 (char *) "self",(char *) "win", NULL
33038 };
33039
33040 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
33041 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33042 if (!SWIG_IsOK(res1)) {
33043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
33044 }
33045 arg1 = reinterpret_cast< wxWindow * >(argp1);
33046 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33047 if (!SWIG_IsOK(res2)) {
33048 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
33049 }
33050 arg2 = reinterpret_cast< wxWindow * >(argp2);
33051 {
33052 PyThreadState* __tstate = wxPyBeginAllowThreads();
33053 (arg1)->MoveBeforeInTabOrder(arg2);
33054 wxPyEndAllowThreads(__tstate);
33055 if (PyErr_Occurred()) SWIG_fail;
33056 }
33057 resultobj = SWIG_Py_Void();
33058 return resultobj;
33059 fail:
33060 return NULL;
33061 }
33062
33063
33064 SWIGINTERN PyObject *_wrap_Window_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33065 PyObject *resultobj = 0;
33066 wxWindow *arg1 = (wxWindow *) 0 ;
33067 PyObject *result = 0 ;
33068 void *argp1 = 0 ;
33069 int res1 = 0 ;
33070 PyObject *swig_obj[1] ;
33071
33072 if (!args) SWIG_fail;
33073 swig_obj[0] = args;
33074 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33075 if (!SWIG_IsOK(res1)) {
33076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
33077 }
33078 arg1 = reinterpret_cast< wxWindow * >(argp1);
33079 {
33080 PyThreadState* __tstate = wxPyBeginAllowThreads();
33081 result = (PyObject *)wxWindow_GetChildren(arg1);
33082 wxPyEndAllowThreads(__tstate);
33083 if (PyErr_Occurred()) SWIG_fail;
33084 }
33085 resultobj = result;
33086 return resultobj;
33087 fail:
33088 return NULL;
33089 }
33090
33091
33092 SWIGINTERN PyObject *_wrap_Window_GetParent(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_GetParent" "', 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)->GetParent();
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_GetGrandParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33123 PyObject *resultobj = 0;
33124 wxWindow *arg1 = (wxWindow *) 0 ;
33125 wxWindow *result = 0 ;
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_GetGrandParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
33135 }
33136 arg1 = reinterpret_cast< wxWindow * >(argp1);
33137 {
33138 PyThreadState* __tstate = wxPyBeginAllowThreads();
33139 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
33140 wxPyEndAllowThreads(__tstate);
33141 if (PyErr_Occurred()) SWIG_fail;
33142 }
33143 {
33144 resultobj = wxPyMake_wxObject(result, 0);
33145 }
33146 return resultobj;
33147 fail:
33148 return NULL;
33149 }
33150
33151
33152 SWIGINTERN PyObject *_wrap_Window_IsTopLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33153 PyObject *resultobj = 0;
33154 wxWindow *arg1 = (wxWindow *) 0 ;
33155 bool result;
33156 void *argp1 = 0 ;
33157 int res1 = 0 ;
33158 PyObject *swig_obj[1] ;
33159
33160 if (!args) SWIG_fail;
33161 swig_obj[0] = args;
33162 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33163 if (!SWIG_IsOK(res1)) {
33164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsTopLevel" "', expected argument " "1"" of type '" "wxWindow const *""'");
33165 }
33166 arg1 = reinterpret_cast< wxWindow * >(argp1);
33167 {
33168 PyThreadState* __tstate = wxPyBeginAllowThreads();
33169 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
33170 wxPyEndAllowThreads(__tstate);
33171 if (PyErr_Occurred()) SWIG_fail;
33172 }
33173 {
33174 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33175 }
33176 return resultobj;
33177 fail:
33178 return NULL;
33179 }
33180
33181
33182 SWIGINTERN PyObject *_wrap_Window_Reparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33183 PyObject *resultobj = 0;
33184 wxWindow *arg1 = (wxWindow *) 0 ;
33185 wxWindow *arg2 = (wxWindow *) 0 ;
33186 bool result;
33187 void *argp1 = 0 ;
33188 int res1 = 0 ;
33189 void *argp2 = 0 ;
33190 int res2 = 0 ;
33191 PyObject * obj0 = 0 ;
33192 PyObject * obj1 = 0 ;
33193 char * kwnames[] = {
33194 (char *) "self",(char *) "newParent", NULL
33195 };
33196
33197 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) SWIG_fail;
33198 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33199 if (!SWIG_IsOK(res1)) {
33200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Reparent" "', expected argument " "1"" of type '" "wxWindow *""'");
33201 }
33202 arg1 = reinterpret_cast< wxWindow * >(argp1);
33203 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33204 if (!SWIG_IsOK(res2)) {
33205 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Reparent" "', expected argument " "2"" of type '" "wxWindow *""'");
33206 }
33207 arg2 = reinterpret_cast< wxWindow * >(argp2);
33208 {
33209 PyThreadState* __tstate = wxPyBeginAllowThreads();
33210 result = (bool)(arg1)->Reparent(arg2);
33211 wxPyEndAllowThreads(__tstate);
33212 if (PyErr_Occurred()) SWIG_fail;
33213 }
33214 {
33215 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33216 }
33217 return resultobj;
33218 fail:
33219 return NULL;
33220 }
33221
33222
33223 SWIGINTERN PyObject *_wrap_Window_AddChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33224 PyObject *resultobj = 0;
33225 wxWindow *arg1 = (wxWindow *) 0 ;
33226 wxWindow *arg2 = (wxWindow *) 0 ;
33227 void *argp1 = 0 ;
33228 int res1 = 0 ;
33229 void *argp2 = 0 ;
33230 int res2 = 0 ;
33231 PyObject * obj0 = 0 ;
33232 PyObject * obj1 = 0 ;
33233 char * kwnames[] = {
33234 (char *) "self",(char *) "child", NULL
33235 };
33236
33237 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) SWIG_fail;
33238 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33239 if (!SWIG_IsOK(res1)) {
33240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AddChild" "', expected argument " "1"" of type '" "wxWindow *""'");
33241 }
33242 arg1 = reinterpret_cast< wxWindow * >(argp1);
33243 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33244 if (!SWIG_IsOK(res2)) {
33245 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_AddChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33246 }
33247 arg2 = reinterpret_cast< wxWindow * >(argp2);
33248 {
33249 PyThreadState* __tstate = wxPyBeginAllowThreads();
33250 (arg1)->AddChild(arg2);
33251 wxPyEndAllowThreads(__tstate);
33252 if (PyErr_Occurred()) SWIG_fail;
33253 }
33254 resultobj = SWIG_Py_Void();
33255 return resultobj;
33256 fail:
33257 return NULL;
33258 }
33259
33260
33261 SWIGINTERN PyObject *_wrap_Window_RemoveChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33262 PyObject *resultobj = 0;
33263 wxWindow *arg1 = (wxWindow *) 0 ;
33264 wxWindow *arg2 = (wxWindow *) 0 ;
33265 void *argp1 = 0 ;
33266 int res1 = 0 ;
33267 void *argp2 = 0 ;
33268 int res2 = 0 ;
33269 PyObject * obj0 = 0 ;
33270 PyObject * obj1 = 0 ;
33271 char * kwnames[] = {
33272 (char *) "self",(char *) "child", NULL
33273 };
33274
33275 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) SWIG_fail;
33276 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33277 if (!SWIG_IsOK(res1)) {
33278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveChild" "', expected argument " "1"" of type '" "wxWindow *""'");
33279 }
33280 arg1 = reinterpret_cast< wxWindow * >(argp1);
33281 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33282 if (!SWIG_IsOK(res2)) {
33283 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33284 }
33285 arg2 = reinterpret_cast< wxWindow * >(argp2);
33286 {
33287 PyThreadState* __tstate = wxPyBeginAllowThreads();
33288 (arg1)->RemoveChild(arg2);
33289 wxPyEndAllowThreads(__tstate);
33290 if (PyErr_Occurred()) SWIG_fail;
33291 }
33292 resultobj = SWIG_Py_Void();
33293 return resultobj;
33294 fail:
33295 return NULL;
33296 }
33297
33298
33299 SWIGINTERN PyObject *_wrap_Window_SetDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33300 PyObject *resultobj = 0;
33301 wxWindow *arg1 = (wxWindow *) 0 ;
33302 bool arg2 ;
33303 void *argp1 = 0 ;
33304 int res1 = 0 ;
33305 bool val2 ;
33306 int ecode2 = 0 ;
33307 PyObject * obj0 = 0 ;
33308 PyObject * obj1 = 0 ;
33309 char * kwnames[] = {
33310 (char *) "self",(char *) "on", NULL
33311 };
33312
33313 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDoubleBuffered",kwnames,&obj0,&obj1)) SWIG_fail;
33314 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33315 if (!SWIG_IsOK(res1)) {
33316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow *""'");
33317 }
33318 arg1 = reinterpret_cast< wxWindow * >(argp1);
33319 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33320 if (!SWIG_IsOK(ecode2)) {
33321 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDoubleBuffered" "', expected argument " "2"" of type '" "bool""'");
33322 }
33323 arg2 = static_cast< bool >(val2);
33324 {
33325 PyThreadState* __tstate = wxPyBeginAllowThreads();
33326 (arg1)->SetDoubleBuffered(arg2);
33327 wxPyEndAllowThreads(__tstate);
33328 if (PyErr_Occurred()) SWIG_fail;
33329 }
33330 resultobj = SWIG_Py_Void();
33331 return resultobj;
33332 fail:
33333 return NULL;
33334 }
33335
33336
33337 SWIGINTERN PyObject *_wrap_Window_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33338 PyObject *resultobj = 0;
33339 wxWindow *arg1 = (wxWindow *) 0 ;
33340 long arg2 ;
33341 wxWindow *result = 0 ;
33342 void *argp1 = 0 ;
33343 int res1 = 0 ;
33344 long val2 ;
33345 int ecode2 = 0 ;
33346 PyObject * obj0 = 0 ;
33347 PyObject * obj1 = 0 ;
33348 char * kwnames[] = {
33349 (char *) "self",(char *) "winid", NULL
33350 };
33351
33352 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
33353 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33354 if (!SWIG_IsOK(res1)) {
33355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowById" "', expected argument " "1"" of type '" "wxWindow *""'");
33356 }
33357 arg1 = reinterpret_cast< wxWindow * >(argp1);
33358 ecode2 = SWIG_AsVal_long(obj1, &val2);
33359 if (!SWIG_IsOK(ecode2)) {
33360 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FindWindowById" "', expected argument " "2"" of type '" "long""'");
33361 }
33362 arg2 = static_cast< long >(val2);
33363 {
33364 PyThreadState* __tstate = wxPyBeginAllowThreads();
33365 result = (wxWindow *)(arg1)->FindWindow(arg2);
33366 wxPyEndAllowThreads(__tstate);
33367 if (PyErr_Occurred()) SWIG_fail;
33368 }
33369 {
33370 resultobj = wxPyMake_wxObject(result, 0);
33371 }
33372 return resultobj;
33373 fail:
33374 return NULL;
33375 }
33376
33377
33378 SWIGINTERN PyObject *_wrap_Window_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33379 PyObject *resultobj = 0;
33380 wxWindow *arg1 = (wxWindow *) 0 ;
33381 wxString *arg2 = 0 ;
33382 wxWindow *result = 0 ;
33383 void *argp1 = 0 ;
33384 int res1 = 0 ;
33385 bool temp2 = false ;
33386 PyObject * obj0 = 0 ;
33387 PyObject * obj1 = 0 ;
33388 char * kwnames[] = {
33389 (char *) "self",(char *) "name", NULL
33390 };
33391
33392 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
33393 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33394 if (!SWIG_IsOK(res1)) {
33395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowByName" "', expected argument " "1"" of type '" "wxWindow *""'");
33396 }
33397 arg1 = reinterpret_cast< wxWindow * >(argp1);
33398 {
33399 arg2 = wxString_in_helper(obj1);
33400 if (arg2 == NULL) SWIG_fail;
33401 temp2 = true;
33402 }
33403 {
33404 PyThreadState* __tstate = wxPyBeginAllowThreads();
33405 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
33406 wxPyEndAllowThreads(__tstate);
33407 if (PyErr_Occurred()) SWIG_fail;
33408 }
33409 {
33410 resultobj = wxPyMake_wxObject(result, 0);
33411 }
33412 {
33413 if (temp2)
33414 delete arg2;
33415 }
33416 return resultobj;
33417 fail:
33418 {
33419 if (temp2)
33420 delete arg2;
33421 }
33422 return NULL;
33423 }
33424
33425
33426 SWIGINTERN PyObject *_wrap_Window_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33427 PyObject *resultobj = 0;
33428 wxWindow *arg1 = (wxWindow *) 0 ;
33429 wxEvtHandler *result = 0 ;
33430 void *argp1 = 0 ;
33431 int res1 = 0 ;
33432 PyObject *swig_obj[1] ;
33433
33434 if (!args) SWIG_fail;
33435 swig_obj[0] = args;
33436 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33437 if (!SWIG_IsOK(res1)) {
33438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEventHandler" "', expected argument " "1"" of type '" "wxWindow const *""'");
33439 }
33440 arg1 = reinterpret_cast< wxWindow * >(argp1);
33441 {
33442 PyThreadState* __tstate = wxPyBeginAllowThreads();
33443 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
33444 wxPyEndAllowThreads(__tstate);
33445 if (PyErr_Occurred()) SWIG_fail;
33446 }
33447 {
33448 resultobj = wxPyMake_wxObject(result, 0);
33449 }
33450 return resultobj;
33451 fail:
33452 return NULL;
33453 }
33454
33455
33456 SWIGINTERN PyObject *_wrap_Window_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33457 PyObject *resultobj = 0;
33458 wxWindow *arg1 = (wxWindow *) 0 ;
33459 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33460 void *argp1 = 0 ;
33461 int res1 = 0 ;
33462 void *argp2 = 0 ;
33463 int res2 = 0 ;
33464 PyObject * obj0 = 0 ;
33465 PyObject * obj1 = 0 ;
33466 char * kwnames[] = {
33467 (char *) "self",(char *) "handler", NULL
33468 };
33469
33470 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33471 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33472 if (!SWIG_IsOK(res1)) {
33473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33474 }
33475 arg1 = reinterpret_cast< wxWindow * >(argp1);
33476 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33477 if (!SWIG_IsOK(res2)) {
33478 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33479 }
33480 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33481 {
33482 PyThreadState* __tstate = wxPyBeginAllowThreads();
33483 (arg1)->SetEventHandler(arg2);
33484 wxPyEndAllowThreads(__tstate);
33485 if (PyErr_Occurred()) SWIG_fail;
33486 }
33487 resultobj = SWIG_Py_Void();
33488 return resultobj;
33489 fail:
33490 return NULL;
33491 }
33492
33493
33494 SWIGINTERN PyObject *_wrap_Window_PushEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33495 PyObject *resultobj = 0;
33496 wxWindow *arg1 = (wxWindow *) 0 ;
33497 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33498 void *argp1 = 0 ;
33499 int res1 = 0 ;
33500 void *argp2 = 0 ;
33501 int res2 = 0 ;
33502 PyObject * obj0 = 0 ;
33503 PyObject * obj1 = 0 ;
33504 char * kwnames[] = {
33505 (char *) "self",(char *) "handler", NULL
33506 };
33507
33508 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33509 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33510 if (!SWIG_IsOK(res1)) {
33511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PushEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33512 }
33513 arg1 = reinterpret_cast< wxWindow * >(argp1);
33514 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33515 if (!SWIG_IsOK(res2)) {
33516 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PushEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33517 }
33518 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33519 {
33520 PyThreadState* __tstate = wxPyBeginAllowThreads();
33521 (arg1)->PushEventHandler(arg2);
33522 wxPyEndAllowThreads(__tstate);
33523 if (PyErr_Occurred()) SWIG_fail;
33524 }
33525 resultobj = SWIG_Py_Void();
33526 return resultobj;
33527 fail:
33528 return NULL;
33529 }
33530
33531
33532 SWIGINTERN PyObject *_wrap_Window_PopEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33533 PyObject *resultobj = 0;
33534 wxWindow *arg1 = (wxWindow *) 0 ;
33535 bool arg2 = (bool) false ;
33536 wxEvtHandler *result = 0 ;
33537 void *argp1 = 0 ;
33538 int res1 = 0 ;
33539 bool val2 ;
33540 int ecode2 = 0 ;
33541 PyObject * obj0 = 0 ;
33542 PyObject * obj1 = 0 ;
33543 char * kwnames[] = {
33544 (char *) "self",(char *) "deleteHandler", NULL
33545 };
33546
33547 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33548 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33549 if (!SWIG_IsOK(res1)) {
33550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33551 }
33552 arg1 = reinterpret_cast< wxWindow * >(argp1);
33553 if (obj1) {
33554 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33555 if (!SWIG_IsOK(ecode2)) {
33556 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_PopEventHandler" "', expected argument " "2"" of type '" "bool""'");
33557 }
33558 arg2 = static_cast< bool >(val2);
33559 }
33560 {
33561 PyThreadState* __tstate = wxPyBeginAllowThreads();
33562 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
33563 wxPyEndAllowThreads(__tstate);
33564 if (PyErr_Occurred()) SWIG_fail;
33565 }
33566 {
33567 resultobj = wxPyMake_wxObject(result, 0);
33568 }
33569 return resultobj;
33570 fail:
33571 return NULL;
33572 }
33573
33574
33575 SWIGINTERN PyObject *_wrap_Window_RemoveEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33576 PyObject *resultobj = 0;
33577 wxWindow *arg1 = (wxWindow *) 0 ;
33578 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33579 bool result;
33580 void *argp1 = 0 ;
33581 int res1 = 0 ;
33582 void *argp2 = 0 ;
33583 int res2 = 0 ;
33584 PyObject * obj0 = 0 ;
33585 PyObject * obj1 = 0 ;
33586 char * kwnames[] = {
33587 (char *) "self",(char *) "handler", NULL
33588 };
33589
33590 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33591 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33592 if (!SWIG_IsOK(res1)) {
33593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33594 }
33595 arg1 = reinterpret_cast< wxWindow * >(argp1);
33596 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33597 if (!SWIG_IsOK(res2)) {
33598 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33599 }
33600 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33601 {
33602 PyThreadState* __tstate = wxPyBeginAllowThreads();
33603 result = (bool)(arg1)->RemoveEventHandler(arg2);
33604 wxPyEndAllowThreads(__tstate);
33605 if (PyErr_Occurred()) SWIG_fail;
33606 }
33607 {
33608 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33609 }
33610 return resultobj;
33611 fail:
33612 return NULL;
33613 }
33614
33615
33616 SWIGINTERN PyObject *_wrap_Window_SetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33617 PyObject *resultobj = 0;
33618 wxWindow *arg1 = (wxWindow *) 0 ;
33619 wxValidator *arg2 = 0 ;
33620 void *argp1 = 0 ;
33621 int res1 = 0 ;
33622 void *argp2 = 0 ;
33623 int res2 = 0 ;
33624 PyObject * obj0 = 0 ;
33625 PyObject * obj1 = 0 ;
33626 char * kwnames[] = {
33627 (char *) "self",(char *) "validator", NULL
33628 };
33629
33630 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) SWIG_fail;
33631 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33632 if (!SWIG_IsOK(res1)) {
33633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
33634 }
33635 arg1 = reinterpret_cast< wxWindow * >(argp1);
33636 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxValidator, 0 | 0);
33637 if (!SWIG_IsOK(res2)) {
33638 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
33639 }
33640 if (!argp2) {
33641 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
33642 }
33643 arg2 = reinterpret_cast< wxValidator * >(argp2);
33644 {
33645 PyThreadState* __tstate = wxPyBeginAllowThreads();
33646 (arg1)->SetValidator((wxValidator const &)*arg2);
33647 wxPyEndAllowThreads(__tstate);
33648 if (PyErr_Occurred()) SWIG_fail;
33649 }
33650 resultobj = SWIG_Py_Void();
33651 return resultobj;
33652 fail:
33653 return NULL;
33654 }
33655
33656
33657 SWIGINTERN PyObject *_wrap_Window_GetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33658 PyObject *resultobj = 0;
33659 wxWindow *arg1 = (wxWindow *) 0 ;
33660 wxValidator *result = 0 ;
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_GetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
33670 }
33671 arg1 = reinterpret_cast< wxWindow * >(argp1);
33672 {
33673 PyThreadState* __tstate = wxPyBeginAllowThreads();
33674 result = (wxValidator *)(arg1)->GetValidator();
33675 wxPyEndAllowThreads(__tstate);
33676 if (PyErr_Occurred()) SWIG_fail;
33677 }
33678 {
33679 resultobj = wxPyMake_wxObject(result, (bool)0);
33680 }
33681 return resultobj;
33682 fail:
33683 return NULL;
33684 }
33685
33686
33687 SWIGINTERN PyObject *_wrap_Window_Validate(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_Validate" "', expected argument " "1"" of type '" "wxWindow *""'");
33700 }
33701 arg1 = reinterpret_cast< wxWindow * >(argp1);
33702 {
33703 PyThreadState* __tstate = wxPyBeginAllowThreads();
33704 result = (bool)(arg1)->Validate();
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_TransferDataToWindow(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_TransferDataToWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
33730 }
33731 arg1 = reinterpret_cast< wxWindow * >(argp1);
33732 {
33733 PyThreadState* __tstate = wxPyBeginAllowThreads();
33734 result = (bool)(arg1)->TransferDataToWindow();
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_TransferDataFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33748 PyObject *resultobj = 0;
33749 wxWindow *arg1 = (wxWindow *) 0 ;
33750 bool result;
33751 void *argp1 = 0 ;
33752 int res1 = 0 ;
33753 PyObject *swig_obj[1] ;
33754
33755 if (!args) SWIG_fail;
33756 swig_obj[0] = args;
33757 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33758 if (!SWIG_IsOK(res1)) {
33759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
33760 }
33761 arg1 = reinterpret_cast< wxWindow * >(argp1);
33762 {
33763 PyThreadState* __tstate = wxPyBeginAllowThreads();
33764 result = (bool)(arg1)->TransferDataFromWindow();
33765 wxPyEndAllowThreads(__tstate);
33766 if (PyErr_Occurred()) SWIG_fail;
33767 }
33768 {
33769 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33770 }
33771 return resultobj;
33772 fail:
33773 return NULL;
33774 }
33775
33776
33777 SWIGINTERN PyObject *_wrap_Window_InitDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33778 PyObject *resultobj = 0;
33779 wxWindow *arg1 = (wxWindow *) 0 ;
33780 void *argp1 = 0 ;
33781 int res1 = 0 ;
33782 PyObject *swig_obj[1] ;
33783
33784 if (!args) SWIG_fail;
33785 swig_obj[0] = args;
33786 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33787 if (!SWIG_IsOK(res1)) {
33788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InitDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
33789 }
33790 arg1 = reinterpret_cast< wxWindow * >(argp1);
33791 {
33792 PyThreadState* __tstate = wxPyBeginAllowThreads();
33793 (arg1)->InitDialog();
33794 wxPyEndAllowThreads(__tstate);
33795 if (PyErr_Occurred()) SWIG_fail;
33796 }
33797 resultobj = SWIG_Py_Void();
33798 return resultobj;
33799 fail:
33800 return NULL;
33801 }
33802
33803
33804 SWIGINTERN PyObject *_wrap_Window_SetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33805 PyObject *resultobj = 0;
33806 wxWindow *arg1 = (wxWindow *) 0 ;
33807 wxAcceleratorTable *arg2 = 0 ;
33808 void *argp1 = 0 ;
33809 int res1 = 0 ;
33810 void *argp2 = 0 ;
33811 int res2 = 0 ;
33812 PyObject * obj0 = 0 ;
33813 PyObject * obj1 = 0 ;
33814 char * kwnames[] = {
33815 (char *) "self",(char *) "accel", NULL
33816 };
33817
33818 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) SWIG_fail;
33819 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33820 if (!SWIG_IsOK(res1)) {
33821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
33822 }
33823 arg1 = reinterpret_cast< wxWindow * >(argp1);
33824 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAcceleratorTable, 0 | 0);
33825 if (!SWIG_IsOK(res2)) {
33826 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
33827 }
33828 if (!argp2) {
33829 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
33830 }
33831 arg2 = reinterpret_cast< wxAcceleratorTable * >(argp2);
33832 {
33833 PyThreadState* __tstate = wxPyBeginAllowThreads();
33834 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
33835 wxPyEndAllowThreads(__tstate);
33836 if (PyErr_Occurred()) SWIG_fail;
33837 }
33838 resultobj = SWIG_Py_Void();
33839 return resultobj;
33840 fail:
33841 return NULL;
33842 }
33843
33844
33845 SWIGINTERN PyObject *_wrap_Window_GetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33846 PyObject *resultobj = 0;
33847 wxWindow *arg1 = (wxWindow *) 0 ;
33848 wxAcceleratorTable *result = 0 ;
33849 void *argp1 = 0 ;
33850 int res1 = 0 ;
33851 PyObject *swig_obj[1] ;
33852
33853 if (!args) SWIG_fail;
33854 swig_obj[0] = args;
33855 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33856 if (!SWIG_IsOK(res1)) {
33857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
33858 }
33859 arg1 = reinterpret_cast< wxWindow * >(argp1);
33860 {
33861 PyThreadState* __tstate = wxPyBeginAllowThreads();
33862 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
33863 wxPyEndAllowThreads(__tstate);
33864 if (PyErr_Occurred()) SWIG_fail;
33865 }
33866 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
33867 return resultobj;
33868 fail:
33869 return NULL;
33870 }
33871
33872
33873 SWIGINTERN PyObject *_wrap_Window_RegisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33874 PyObject *resultobj = 0;
33875 wxWindow *arg1 = (wxWindow *) 0 ;
33876 int arg2 ;
33877 int arg3 ;
33878 int arg4 ;
33879 bool result;
33880 void *argp1 = 0 ;
33881 int res1 = 0 ;
33882 int val2 ;
33883 int ecode2 = 0 ;
33884 int val3 ;
33885 int ecode3 = 0 ;
33886 int val4 ;
33887 int ecode4 = 0 ;
33888 PyObject * obj0 = 0 ;
33889 PyObject * obj1 = 0 ;
33890 PyObject * obj2 = 0 ;
33891 PyObject * obj3 = 0 ;
33892 char * kwnames[] = {
33893 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
33894 };
33895
33896 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33897 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33898 if (!SWIG_IsOK(res1)) {
33899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RegisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
33900 }
33901 arg1 = reinterpret_cast< wxWindow * >(argp1);
33902 ecode2 = SWIG_AsVal_int(obj1, &val2);
33903 if (!SWIG_IsOK(ecode2)) {
33904 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_RegisterHotKey" "', expected argument " "2"" of type '" "int""'");
33905 }
33906 arg2 = static_cast< int >(val2);
33907 ecode3 = SWIG_AsVal_int(obj2, &val3);
33908 if (!SWIG_IsOK(ecode3)) {
33909 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RegisterHotKey" "', expected argument " "3"" of type '" "int""'");
33910 }
33911 arg3 = static_cast< int >(val3);
33912 ecode4 = SWIG_AsVal_int(obj3, &val4);
33913 if (!SWIG_IsOK(ecode4)) {
33914 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_RegisterHotKey" "', expected argument " "4"" of type '" "int""'");
33915 }
33916 arg4 = static_cast< int >(val4);
33917 {
33918 PyThreadState* __tstate = wxPyBeginAllowThreads();
33919 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
33920 wxPyEndAllowThreads(__tstate);
33921 if (PyErr_Occurred()) SWIG_fail;
33922 }
33923 {
33924 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33925 }
33926 return resultobj;
33927 fail:
33928 return NULL;
33929 }
33930
33931
33932 SWIGINTERN PyObject *_wrap_Window_UnregisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33933 PyObject *resultobj = 0;
33934 wxWindow *arg1 = (wxWindow *) 0 ;
33935 int arg2 ;
33936 bool result;
33937 void *argp1 = 0 ;
33938 int res1 = 0 ;
33939 int val2 ;
33940 int ecode2 = 0 ;
33941 PyObject * obj0 = 0 ;
33942 PyObject * obj1 = 0 ;
33943 char * kwnames[] = {
33944 (char *) "self",(char *) "hotkeyId", NULL
33945 };
33946
33947 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) SWIG_fail;
33948 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33949 if (!SWIG_IsOK(res1)) {
33950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UnregisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
33951 }
33952 arg1 = reinterpret_cast< wxWindow * >(argp1);
33953 ecode2 = SWIG_AsVal_int(obj1, &val2);
33954 if (!SWIG_IsOK(ecode2)) {
33955 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UnregisterHotKey" "', expected argument " "2"" of type '" "int""'");
33956 }
33957 arg2 = static_cast< int >(val2);
33958 {
33959 PyThreadState* __tstate = wxPyBeginAllowThreads();
33960 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
33961 wxPyEndAllowThreads(__tstate);
33962 if (PyErr_Occurred()) SWIG_fail;
33963 }
33964 {
33965 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33966 }
33967 return resultobj;
33968 fail:
33969 return NULL;
33970 }
33971
33972
33973 SWIGINTERN PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33974 PyObject *resultobj = 0;
33975 wxWindow *arg1 = (wxWindow *) 0 ;
33976 wxPoint *arg2 = 0 ;
33977 wxPoint result;
33978 void *argp1 = 0 ;
33979 int res1 = 0 ;
33980 wxPoint temp2 ;
33981 PyObject * obj0 = 0 ;
33982 PyObject * obj1 = 0 ;
33983 char * kwnames[] = {
33984 (char *) "self",(char *) "pt", NULL
33985 };
33986
33987 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
33988 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33989 if (!SWIG_IsOK(res1)) {
33990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogPointToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
33991 }
33992 arg1 = reinterpret_cast< wxWindow * >(argp1);
33993 {
33994 arg2 = &temp2;
33995 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
33996 }
33997 {
33998 PyThreadState* __tstate = wxPyBeginAllowThreads();
33999 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
34000 wxPyEndAllowThreads(__tstate);
34001 if (PyErr_Occurred()) SWIG_fail;
34002 }
34003 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34004 return resultobj;
34005 fail:
34006 return NULL;
34007 }
34008
34009
34010 SWIGINTERN PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34011 PyObject *resultobj = 0;
34012 wxWindow *arg1 = (wxWindow *) 0 ;
34013 wxSize *arg2 = 0 ;
34014 wxSize result;
34015 void *argp1 = 0 ;
34016 int res1 = 0 ;
34017 wxSize temp2 ;
34018 PyObject * obj0 = 0 ;
34019 PyObject * obj1 = 0 ;
34020 char * kwnames[] = {
34021 (char *) "self",(char *) "sz", NULL
34022 };
34023
34024 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
34025 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34026 if (!SWIG_IsOK(res1)) {
34027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogSizeToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
34028 }
34029 arg1 = reinterpret_cast< wxWindow * >(argp1);
34030 {
34031 arg2 = &temp2;
34032 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34033 }
34034 {
34035 PyThreadState* __tstate = wxPyBeginAllowThreads();
34036 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
34037 wxPyEndAllowThreads(__tstate);
34038 if (PyErr_Occurred()) SWIG_fail;
34039 }
34040 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34041 return resultobj;
34042 fail:
34043 return NULL;
34044 }
34045
34046
34047 SWIGINTERN PyObject *_wrap_Window_DLG_PNT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34048 PyObject *resultobj = 0;
34049 wxWindow *arg1 = (wxWindow *) 0 ;
34050 wxPoint *arg2 = 0 ;
34051 wxPoint result;
34052 void *argp1 = 0 ;
34053 int res1 = 0 ;
34054 wxPoint temp2 ;
34055 PyObject * obj0 = 0 ;
34056 PyObject * obj1 = 0 ;
34057 char * kwnames[] = {
34058 (char *) "self",(char *) "pt", NULL
34059 };
34060
34061 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) SWIG_fail;
34062 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34063 if (!SWIG_IsOK(res1)) {
34064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_PNT" "', expected argument " "1"" of type '" "wxWindow *""'");
34065 }
34066 arg1 = reinterpret_cast< wxWindow * >(argp1);
34067 {
34068 arg2 = &temp2;
34069 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34070 }
34071 {
34072 PyThreadState* __tstate = wxPyBeginAllowThreads();
34073 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
34074 wxPyEndAllowThreads(__tstate);
34075 if (PyErr_Occurred()) SWIG_fail;
34076 }
34077 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34078 return resultobj;
34079 fail:
34080 return NULL;
34081 }
34082
34083
34084 SWIGINTERN PyObject *_wrap_Window_DLG_SZE(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34085 PyObject *resultobj = 0;
34086 wxWindow *arg1 = (wxWindow *) 0 ;
34087 wxSize *arg2 = 0 ;
34088 wxSize result;
34089 void *argp1 = 0 ;
34090 int res1 = 0 ;
34091 wxSize temp2 ;
34092 PyObject * obj0 = 0 ;
34093 PyObject * obj1 = 0 ;
34094 char * kwnames[] = {
34095 (char *) "self",(char *) "sz", NULL
34096 };
34097
34098 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) SWIG_fail;
34099 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34100 if (!SWIG_IsOK(res1)) {
34101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_SZE" "', expected argument " "1"" of type '" "wxWindow *""'");
34102 }
34103 arg1 = reinterpret_cast< wxWindow * >(argp1);
34104 {
34105 arg2 = &temp2;
34106 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34107 }
34108 {
34109 PyThreadState* __tstate = wxPyBeginAllowThreads();
34110 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
34111 wxPyEndAllowThreads(__tstate);
34112 if (PyErr_Occurred()) SWIG_fail;
34113 }
34114 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34115 return resultobj;
34116 fail:
34117 return NULL;
34118 }
34119
34120
34121 SWIGINTERN PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34122 PyObject *resultobj = 0;
34123 wxWindow *arg1 = (wxWindow *) 0 ;
34124 wxPoint *arg2 = 0 ;
34125 wxPoint result;
34126 void *argp1 = 0 ;
34127 int res1 = 0 ;
34128 wxPoint temp2 ;
34129 PyObject * obj0 = 0 ;
34130 PyObject * obj1 = 0 ;
34131 char * kwnames[] = {
34132 (char *) "self",(char *) "pt", NULL
34133 };
34134
34135 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
34136 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34137 if (!SWIG_IsOK(res1)) {
34138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelPointToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
34139 }
34140 arg1 = reinterpret_cast< wxWindow * >(argp1);
34141 {
34142 arg2 = &temp2;
34143 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34144 }
34145 {
34146 PyThreadState* __tstate = wxPyBeginAllowThreads();
34147 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
34148 wxPyEndAllowThreads(__tstate);
34149 if (PyErr_Occurred()) SWIG_fail;
34150 }
34151 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34152 return resultobj;
34153 fail:
34154 return NULL;
34155 }
34156
34157
34158 SWIGINTERN PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34159 PyObject *resultobj = 0;
34160 wxWindow *arg1 = (wxWindow *) 0 ;
34161 wxSize *arg2 = 0 ;
34162 wxSize result;
34163 void *argp1 = 0 ;
34164 int res1 = 0 ;
34165 wxSize temp2 ;
34166 PyObject * obj0 = 0 ;
34167 PyObject * obj1 = 0 ;
34168 char * kwnames[] = {
34169 (char *) "self",(char *) "sz", NULL
34170 };
34171
34172 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
34173 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34174 if (!SWIG_IsOK(res1)) {
34175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelSizeToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
34176 }
34177 arg1 = reinterpret_cast< wxWindow * >(argp1);
34178 {
34179 arg2 = &temp2;
34180 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34181 }
34182 {
34183 PyThreadState* __tstate = wxPyBeginAllowThreads();
34184 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
34185 wxPyEndAllowThreads(__tstate);
34186 if (PyErr_Occurred()) SWIG_fail;
34187 }
34188 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34189 return resultobj;
34190 fail:
34191 return NULL;
34192 }
34193
34194
34195 SWIGINTERN PyObject *_wrap_Window_WarpPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34196 PyObject *resultobj = 0;
34197 wxWindow *arg1 = (wxWindow *) 0 ;
34198 int arg2 ;
34199 int arg3 ;
34200 void *argp1 = 0 ;
34201 int res1 = 0 ;
34202 int val2 ;
34203 int ecode2 = 0 ;
34204 int val3 ;
34205 int ecode3 = 0 ;
34206 PyObject * obj0 = 0 ;
34207 PyObject * obj1 = 0 ;
34208 PyObject * obj2 = 0 ;
34209 char * kwnames[] = {
34210 (char *) "self",(char *) "x",(char *) "y", NULL
34211 };
34212
34213 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34214 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34215 if (!SWIG_IsOK(res1)) {
34216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_WarpPointer" "', expected argument " "1"" of type '" "wxWindow *""'");
34217 }
34218 arg1 = reinterpret_cast< wxWindow * >(argp1);
34219 ecode2 = SWIG_AsVal_int(obj1, &val2);
34220 if (!SWIG_IsOK(ecode2)) {
34221 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_WarpPointer" "', expected argument " "2"" of type '" "int""'");
34222 }
34223 arg2 = static_cast< int >(val2);
34224 ecode3 = SWIG_AsVal_int(obj2, &val3);
34225 if (!SWIG_IsOK(ecode3)) {
34226 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_WarpPointer" "', expected argument " "3"" of type '" "int""'");
34227 }
34228 arg3 = static_cast< int >(val3);
34229 {
34230 PyThreadState* __tstate = wxPyBeginAllowThreads();
34231 (arg1)->WarpPointer(arg2,arg3);
34232 wxPyEndAllowThreads(__tstate);
34233 if (PyErr_Occurred()) SWIG_fail;
34234 }
34235 resultobj = SWIG_Py_Void();
34236 return resultobj;
34237 fail:
34238 return NULL;
34239 }
34240
34241
34242 SWIGINTERN PyObject *_wrap_Window_CaptureMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34243 PyObject *resultobj = 0;
34244 wxWindow *arg1 = (wxWindow *) 0 ;
34245 void *argp1 = 0 ;
34246 int res1 = 0 ;
34247 PyObject *swig_obj[1] ;
34248
34249 if (!args) SWIG_fail;
34250 swig_obj[0] = args;
34251 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34252 if (!SWIG_IsOK(res1)) {
34253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CaptureMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
34254 }
34255 arg1 = reinterpret_cast< wxWindow * >(argp1);
34256 {
34257 PyThreadState* __tstate = wxPyBeginAllowThreads();
34258 (arg1)->CaptureMouse();
34259 wxPyEndAllowThreads(__tstate);
34260 if (PyErr_Occurred()) SWIG_fail;
34261 }
34262 resultobj = SWIG_Py_Void();
34263 return resultobj;
34264 fail:
34265 return NULL;
34266 }
34267
34268
34269 SWIGINTERN PyObject *_wrap_Window_ReleaseMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34270 PyObject *resultobj = 0;
34271 wxWindow *arg1 = (wxWindow *) 0 ;
34272 void *argp1 = 0 ;
34273 int res1 = 0 ;
34274 PyObject *swig_obj[1] ;
34275
34276 if (!args) SWIG_fail;
34277 swig_obj[0] = args;
34278 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34279 if (!SWIG_IsOK(res1)) {
34280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ReleaseMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
34281 }
34282 arg1 = reinterpret_cast< wxWindow * >(argp1);
34283 {
34284 PyThreadState* __tstate = wxPyBeginAllowThreads();
34285 (arg1)->ReleaseMouse();
34286 wxPyEndAllowThreads(__tstate);
34287 if (PyErr_Occurred()) SWIG_fail;
34288 }
34289 resultobj = SWIG_Py_Void();
34290 return resultobj;
34291 fail:
34292 return NULL;
34293 }
34294
34295
34296 SWIGINTERN PyObject *_wrap_Window_GetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34297 PyObject *resultobj = 0;
34298 wxWindow *result = 0 ;
34299
34300 if (!SWIG_Python_UnpackTuple(args,"Window_GetCapture",0,0,0)) SWIG_fail;
34301 {
34302 if (!wxPyCheckForApp()) SWIG_fail;
34303 PyThreadState* __tstate = wxPyBeginAllowThreads();
34304 result = (wxWindow *)wxWindow::GetCapture();
34305 wxPyEndAllowThreads(__tstate);
34306 if (PyErr_Occurred()) SWIG_fail;
34307 }
34308 {
34309 resultobj = wxPyMake_wxObject(result, 0);
34310 }
34311 return resultobj;
34312 fail:
34313 return NULL;
34314 }
34315
34316
34317 SWIGINTERN PyObject *_wrap_Window_HasCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34318 PyObject *resultobj = 0;
34319 wxWindow *arg1 = (wxWindow *) 0 ;
34320 bool result;
34321 void *argp1 = 0 ;
34322 int res1 = 0 ;
34323 PyObject *swig_obj[1] ;
34324
34325 if (!args) SWIG_fail;
34326 swig_obj[0] = args;
34327 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34328 if (!SWIG_IsOK(res1)) {
34329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasCapture" "', expected argument " "1"" of type '" "wxWindow const *""'");
34330 }
34331 arg1 = reinterpret_cast< wxWindow * >(argp1);
34332 {
34333 PyThreadState* __tstate = wxPyBeginAllowThreads();
34334 result = (bool)((wxWindow const *)arg1)->HasCapture();
34335 wxPyEndAllowThreads(__tstate);
34336 if (PyErr_Occurred()) SWIG_fail;
34337 }
34338 {
34339 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34340 }
34341 return resultobj;
34342 fail:
34343 return NULL;
34344 }
34345
34346
34347 SWIGINTERN PyObject *_wrap_Window_Refresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34348 PyObject *resultobj = 0;
34349 wxWindow *arg1 = (wxWindow *) 0 ;
34350 bool arg2 = (bool) true ;
34351 wxRect *arg3 = (wxRect *) NULL ;
34352 void *argp1 = 0 ;
34353 int res1 = 0 ;
34354 bool val2 ;
34355 int ecode2 = 0 ;
34356 void *argp3 = 0 ;
34357 int res3 = 0 ;
34358 PyObject * obj0 = 0 ;
34359 PyObject * obj1 = 0 ;
34360 PyObject * obj2 = 0 ;
34361 char * kwnames[] = {
34362 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
34363 };
34364
34365 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34366 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34367 if (!SWIG_IsOK(res1)) {
34368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Refresh" "', expected argument " "1"" of type '" "wxWindow *""'");
34369 }
34370 arg1 = reinterpret_cast< wxWindow * >(argp1);
34371 if (obj1) {
34372 ecode2 = SWIG_AsVal_bool(obj1, &val2);
34373 if (!SWIG_IsOK(ecode2)) {
34374 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Refresh" "', expected argument " "2"" of type '" "bool""'");
34375 }
34376 arg2 = static_cast< bool >(val2);
34377 }
34378 if (obj2) {
34379 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxRect, 0 | 0 );
34380 if (!SWIG_IsOK(res3)) {
34381 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_Refresh" "', expected argument " "3"" of type '" "wxRect const *""'");
34382 }
34383 arg3 = reinterpret_cast< wxRect * >(argp3);
34384 }
34385 {
34386 PyThreadState* __tstate = wxPyBeginAllowThreads();
34387 (arg1)->Refresh(arg2,(wxRect const *)arg3);
34388 wxPyEndAllowThreads(__tstate);
34389 if (PyErr_Occurred()) SWIG_fail;
34390 }
34391 resultobj = SWIG_Py_Void();
34392 return resultobj;
34393 fail:
34394 return NULL;
34395 }
34396
34397
34398 SWIGINTERN PyObject *_wrap_Window_RefreshRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34399 PyObject *resultobj = 0;
34400 wxWindow *arg1 = (wxWindow *) 0 ;
34401 wxRect *arg2 = 0 ;
34402 bool arg3 = (bool) true ;
34403 void *argp1 = 0 ;
34404 int res1 = 0 ;
34405 wxRect temp2 ;
34406 bool val3 ;
34407 int ecode3 = 0 ;
34408 PyObject * obj0 = 0 ;
34409 PyObject * obj1 = 0 ;
34410 PyObject * obj2 = 0 ;
34411 char * kwnames[] = {
34412 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
34413 };
34414
34415 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34416 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34417 if (!SWIG_IsOK(res1)) {
34418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RefreshRect" "', expected argument " "1"" of type '" "wxWindow *""'");
34419 }
34420 arg1 = reinterpret_cast< wxWindow * >(argp1);
34421 {
34422 arg2 = &temp2;
34423 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34424 }
34425 if (obj2) {
34426 ecode3 = SWIG_AsVal_bool(obj2, &val3);
34427 if (!SWIG_IsOK(ecode3)) {
34428 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RefreshRect" "', expected argument " "3"" of type '" "bool""'");
34429 }
34430 arg3 = static_cast< bool >(val3);
34431 }
34432 {
34433 PyThreadState* __tstate = wxPyBeginAllowThreads();
34434 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
34435 wxPyEndAllowThreads(__tstate);
34436 if (PyErr_Occurred()) SWIG_fail;
34437 }
34438 resultobj = SWIG_Py_Void();
34439 return resultobj;
34440 fail:
34441 return NULL;
34442 }
34443
34444
34445 SWIGINTERN PyObject *_wrap_Window_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34446 PyObject *resultobj = 0;
34447 wxWindow *arg1 = (wxWindow *) 0 ;
34448 void *argp1 = 0 ;
34449 int res1 = 0 ;
34450 PyObject *swig_obj[1] ;
34451
34452 if (!args) SWIG_fail;
34453 swig_obj[0] = args;
34454 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34455 if (!SWIG_IsOK(res1)) {
34456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Update" "', expected argument " "1"" of type '" "wxWindow *""'");
34457 }
34458 arg1 = reinterpret_cast< wxWindow * >(argp1);
34459 {
34460 PyThreadState* __tstate = wxPyBeginAllowThreads();
34461 (arg1)->Update();
34462 wxPyEndAllowThreads(__tstate);
34463 if (PyErr_Occurred()) SWIG_fail;
34464 }
34465 resultobj = SWIG_Py_Void();
34466 return resultobj;
34467 fail:
34468 return NULL;
34469 }
34470
34471
34472 SWIGINTERN PyObject *_wrap_Window_ClearBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34473 PyObject *resultobj = 0;
34474 wxWindow *arg1 = (wxWindow *) 0 ;
34475 void *argp1 = 0 ;
34476 int res1 = 0 ;
34477 PyObject *swig_obj[1] ;
34478
34479 if (!args) SWIG_fail;
34480 swig_obj[0] = args;
34481 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34482 if (!SWIG_IsOK(res1)) {
34483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClearBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
34484 }
34485 arg1 = reinterpret_cast< wxWindow * >(argp1);
34486 {
34487 PyThreadState* __tstate = wxPyBeginAllowThreads();
34488 (arg1)->ClearBackground();
34489 wxPyEndAllowThreads(__tstate);
34490 if (PyErr_Occurred()) SWIG_fail;
34491 }
34492 resultobj = SWIG_Py_Void();
34493 return resultobj;
34494 fail:
34495 return NULL;
34496 }
34497
34498
34499 SWIGINTERN PyObject *_wrap_Window_Freeze(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34500 PyObject *resultobj = 0;
34501 wxWindow *arg1 = (wxWindow *) 0 ;
34502 void *argp1 = 0 ;
34503 int res1 = 0 ;
34504 PyObject *swig_obj[1] ;
34505
34506 if (!args) SWIG_fail;
34507 swig_obj[0] = args;
34508 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34509 if (!SWIG_IsOK(res1)) {
34510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Freeze" "', expected argument " "1"" of type '" "wxWindow *""'");
34511 }
34512 arg1 = reinterpret_cast< wxWindow * >(argp1);
34513 {
34514 PyThreadState* __tstate = wxPyBeginAllowThreads();
34515 (arg1)->Freeze();
34516 wxPyEndAllowThreads(__tstate);
34517 if (PyErr_Occurred()) SWIG_fail;
34518 }
34519 resultobj = SWIG_Py_Void();
34520 return resultobj;
34521 fail:
34522 return NULL;
34523 }
34524
34525
34526 SWIGINTERN PyObject *_wrap_Window_Thaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34527 PyObject *resultobj = 0;
34528 wxWindow *arg1 = (wxWindow *) 0 ;
34529 void *argp1 = 0 ;
34530 int res1 = 0 ;
34531 PyObject *swig_obj[1] ;
34532
34533 if (!args) SWIG_fail;
34534 swig_obj[0] = args;
34535 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34536 if (!SWIG_IsOK(res1)) {
34537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Thaw" "', expected argument " "1"" of type '" "wxWindow *""'");
34538 }
34539 arg1 = reinterpret_cast< wxWindow * >(argp1);
34540 {
34541 PyThreadState* __tstate = wxPyBeginAllowThreads();
34542 (arg1)->Thaw();
34543 wxPyEndAllowThreads(__tstate);
34544 if (PyErr_Occurred()) SWIG_fail;
34545 }
34546 resultobj = SWIG_Py_Void();
34547 return resultobj;
34548 fail:
34549 return NULL;
34550 }
34551
34552
34553 SWIGINTERN PyObject *_wrap_Window_PrepareDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34554 PyObject *resultobj = 0;
34555 wxWindow *arg1 = (wxWindow *) 0 ;
34556 wxDC *arg2 = 0 ;
34557 void *argp1 = 0 ;
34558 int res1 = 0 ;
34559 void *argp2 = 0 ;
34560 int res2 = 0 ;
34561 PyObject * obj0 = 0 ;
34562 PyObject * obj1 = 0 ;
34563 char * kwnames[] = {
34564 (char *) "self",(char *) "dc", NULL
34565 };
34566
34567 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) SWIG_fail;
34568 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34569 if (!SWIG_IsOK(res1)) {
34570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PrepareDC" "', expected argument " "1"" of type '" "wxWindow *""'");
34571 }
34572 arg1 = reinterpret_cast< wxWindow * >(argp1);
34573 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
34574 if (!SWIG_IsOK(res2)) {
34575 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
34576 }
34577 if (!argp2) {
34578 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
34579 }
34580 arg2 = reinterpret_cast< wxDC * >(argp2);
34581 {
34582 PyThreadState* __tstate = wxPyBeginAllowThreads();
34583 (arg1)->PrepareDC(*arg2);
34584 wxPyEndAllowThreads(__tstate);
34585 if (PyErr_Occurred()) SWIG_fail;
34586 }
34587 resultobj = SWIG_Py_Void();
34588 return resultobj;
34589 fail:
34590 return NULL;
34591 }
34592
34593
34594 SWIGINTERN PyObject *_wrap_Window_GetUpdateRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34595 PyObject *resultobj = 0;
34596 wxWindow *arg1 = (wxWindow *) 0 ;
34597 wxRegion *result = 0 ;
34598 void *argp1 = 0 ;
34599 int res1 = 0 ;
34600 PyObject *swig_obj[1] ;
34601
34602 if (!args) SWIG_fail;
34603 swig_obj[0] = args;
34604 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34605 if (!SWIG_IsOK(res1)) {
34606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateRegion" "', expected argument " "1"" of type '" "wxWindow *""'");
34607 }
34608 arg1 = reinterpret_cast< wxWindow * >(argp1);
34609 {
34610 PyThreadState* __tstate = wxPyBeginAllowThreads();
34611 {
34612 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
34613 result = (wxRegion *) &_result_ref;
34614 }
34615 wxPyEndAllowThreads(__tstate);
34616 if (PyErr_Occurred()) SWIG_fail;
34617 }
34618 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, 0 | 0 );
34619 return resultobj;
34620 fail:
34621 return NULL;
34622 }
34623
34624
34625 SWIGINTERN PyObject *_wrap_Window_GetUpdateClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34626 PyObject *resultobj = 0;
34627 wxWindow *arg1 = (wxWindow *) 0 ;
34628 wxRect result;
34629 void *argp1 = 0 ;
34630 int res1 = 0 ;
34631 PyObject *swig_obj[1] ;
34632
34633 if (!args) SWIG_fail;
34634 swig_obj[0] = args;
34635 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34636 if (!SWIG_IsOK(res1)) {
34637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34638 }
34639 arg1 = reinterpret_cast< wxWindow * >(argp1);
34640 {
34641 PyThreadState* __tstate = wxPyBeginAllowThreads();
34642 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
34643 wxPyEndAllowThreads(__tstate);
34644 if (PyErr_Occurred()) SWIG_fail;
34645 }
34646 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34647 return resultobj;
34648 fail:
34649 return NULL;
34650 }
34651
34652
34653 SWIGINTERN PyObject *_wrap_Window_IsExposed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34654 PyObject *resultobj = 0;
34655 wxWindow *arg1 = (wxWindow *) 0 ;
34656 int arg2 ;
34657 int arg3 ;
34658 int arg4 = (int) 1 ;
34659 int arg5 = (int) 1 ;
34660 bool result;
34661 void *argp1 = 0 ;
34662 int res1 = 0 ;
34663 int val2 ;
34664 int ecode2 = 0 ;
34665 int val3 ;
34666 int ecode3 = 0 ;
34667 int val4 ;
34668 int ecode4 = 0 ;
34669 int val5 ;
34670 int ecode5 = 0 ;
34671 PyObject * obj0 = 0 ;
34672 PyObject * obj1 = 0 ;
34673 PyObject * obj2 = 0 ;
34674 PyObject * obj3 = 0 ;
34675 PyObject * obj4 = 0 ;
34676 char * kwnames[] = {
34677 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
34678 };
34679
34680 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
34681 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34682 if (!SWIG_IsOK(res1)) {
34683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposed" "', expected argument " "1"" of type '" "wxWindow const *""'");
34684 }
34685 arg1 = reinterpret_cast< wxWindow * >(argp1);
34686 ecode2 = SWIG_AsVal_int(obj1, &val2);
34687 if (!SWIG_IsOK(ecode2)) {
34688 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_IsExposed" "', expected argument " "2"" of type '" "int""'");
34689 }
34690 arg2 = static_cast< int >(val2);
34691 ecode3 = SWIG_AsVal_int(obj2, &val3);
34692 if (!SWIG_IsOK(ecode3)) {
34693 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_IsExposed" "', expected argument " "3"" of type '" "int""'");
34694 }
34695 arg3 = static_cast< int >(val3);
34696 if (obj3) {
34697 ecode4 = SWIG_AsVal_int(obj3, &val4);
34698 if (!SWIG_IsOK(ecode4)) {
34699 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_IsExposed" "', expected argument " "4"" of type '" "int""'");
34700 }
34701 arg4 = static_cast< int >(val4);
34702 }
34703 if (obj4) {
34704 ecode5 = SWIG_AsVal_int(obj4, &val5);
34705 if (!SWIG_IsOK(ecode5)) {
34706 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_IsExposed" "', expected argument " "5"" of type '" "int""'");
34707 }
34708 arg5 = static_cast< int >(val5);
34709 }
34710 {
34711 PyThreadState* __tstate = wxPyBeginAllowThreads();
34712 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
34713 wxPyEndAllowThreads(__tstate);
34714 if (PyErr_Occurred()) SWIG_fail;
34715 }
34716 {
34717 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34718 }
34719 return resultobj;
34720 fail:
34721 return NULL;
34722 }
34723
34724
34725 SWIGINTERN PyObject *_wrap_Window_IsExposedPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34726 PyObject *resultobj = 0;
34727 wxWindow *arg1 = (wxWindow *) 0 ;
34728 wxPoint *arg2 = 0 ;
34729 bool result;
34730 void *argp1 = 0 ;
34731 int res1 = 0 ;
34732 wxPoint temp2 ;
34733 PyObject * obj0 = 0 ;
34734 PyObject * obj1 = 0 ;
34735 char * kwnames[] = {
34736 (char *) "self",(char *) "pt", NULL
34737 };
34738
34739 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) SWIG_fail;
34740 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34741 if (!SWIG_IsOK(res1)) {
34742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
34743 }
34744 arg1 = reinterpret_cast< wxWindow * >(argp1);
34745 {
34746 arg2 = &temp2;
34747 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34748 }
34749 {
34750 PyThreadState* __tstate = wxPyBeginAllowThreads();
34751 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
34752 wxPyEndAllowThreads(__tstate);
34753 if (PyErr_Occurred()) SWIG_fail;
34754 }
34755 {
34756 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34757 }
34758 return resultobj;
34759 fail:
34760 return NULL;
34761 }
34762
34763
34764 SWIGINTERN PyObject *_wrap_Window_IsExposedRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34765 PyObject *resultobj = 0;
34766 wxWindow *arg1 = (wxWindow *) 0 ;
34767 wxRect *arg2 = 0 ;
34768 bool result;
34769 void *argp1 = 0 ;
34770 int res1 = 0 ;
34771 wxRect temp2 ;
34772 PyObject * obj0 = 0 ;
34773 PyObject * obj1 = 0 ;
34774 char * kwnames[] = {
34775 (char *) "self",(char *) "rect", NULL
34776 };
34777
34778 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) SWIG_fail;
34779 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34780 if (!SWIG_IsOK(res1)) {
34781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34782 }
34783 arg1 = reinterpret_cast< wxWindow * >(argp1);
34784 {
34785 arg2 = &temp2;
34786 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34787 }
34788 {
34789 PyThreadState* __tstate = wxPyBeginAllowThreads();
34790 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
34791 wxPyEndAllowThreads(__tstate);
34792 if (PyErr_Occurred()) SWIG_fail;
34793 }
34794 {
34795 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34796 }
34797 return resultobj;
34798 fail:
34799 return NULL;
34800 }
34801
34802
34803 SWIGINTERN PyObject *_wrap_Window_GetDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34804 PyObject *resultobj = 0;
34805 wxWindow *arg1 = (wxWindow *) 0 ;
34806 SwigValueWrapper<wxVisualAttributes > result;
34807 void *argp1 = 0 ;
34808 int res1 = 0 ;
34809 PyObject *swig_obj[1] ;
34810
34811 if (!args) SWIG_fail;
34812 swig_obj[0] = args;
34813 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34814 if (!SWIG_IsOK(res1)) {
34815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultAttributes" "', expected argument " "1"" of type '" "wxWindow const *""'");
34816 }
34817 arg1 = reinterpret_cast< wxWindow * >(argp1);
34818 {
34819 PyThreadState* __tstate = wxPyBeginAllowThreads();
34820 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
34821 wxPyEndAllowThreads(__tstate);
34822 if (PyErr_Occurred()) SWIG_fail;
34823 }
34824 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
34825 return resultobj;
34826 fail:
34827 return NULL;
34828 }
34829
34830
34831 SWIGINTERN PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34832 PyObject *resultobj = 0;
34833 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
34834 SwigValueWrapper<wxVisualAttributes > result;
34835 int val1 ;
34836 int ecode1 = 0 ;
34837 PyObject * obj0 = 0 ;
34838 char * kwnames[] = {
34839 (char *) "variant", NULL
34840 };
34841
34842 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
34843 if (obj0) {
34844 ecode1 = SWIG_AsVal_int(obj0, &val1);
34845 if (!SWIG_IsOK(ecode1)) {
34846 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
34847 }
34848 arg1 = static_cast< wxWindowVariant >(val1);
34849 }
34850 {
34851 if (!wxPyCheckForApp()) SWIG_fail;
34852 PyThreadState* __tstate = wxPyBeginAllowThreads();
34853 result = wxWindow::GetClassDefaultAttributes(arg1);
34854 wxPyEndAllowThreads(__tstate);
34855 if (PyErr_Occurred()) SWIG_fail;
34856 }
34857 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
34858 return resultobj;
34859 fail:
34860 return NULL;
34861 }
34862
34863
34864 SWIGINTERN PyObject *_wrap_Window_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34865 PyObject *resultobj = 0;
34866 wxWindow *arg1 = (wxWindow *) 0 ;
34867 wxColour *arg2 = 0 ;
34868 bool result;
34869 void *argp1 = 0 ;
34870 int res1 = 0 ;
34871 wxColour temp2 ;
34872 PyObject * obj0 = 0 ;
34873 PyObject * obj1 = 0 ;
34874 char * kwnames[] = {
34875 (char *) "self",(char *) "colour", NULL
34876 };
34877
34878 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34879 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34880 if (!SWIG_IsOK(res1)) {
34881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34882 }
34883 arg1 = reinterpret_cast< wxWindow * >(argp1);
34884 {
34885 arg2 = &temp2;
34886 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34887 }
34888 {
34889 PyThreadState* __tstate = wxPyBeginAllowThreads();
34890 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
34891 wxPyEndAllowThreads(__tstate);
34892 if (PyErr_Occurred()) SWIG_fail;
34893 }
34894 {
34895 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34896 }
34897 return resultobj;
34898 fail:
34899 return NULL;
34900 }
34901
34902
34903 SWIGINTERN PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34904 PyObject *resultobj = 0;
34905 wxWindow *arg1 = (wxWindow *) 0 ;
34906 wxColour *arg2 = 0 ;
34907 void *argp1 = 0 ;
34908 int res1 = 0 ;
34909 wxColour temp2 ;
34910 PyObject * obj0 = 0 ;
34911 PyObject * obj1 = 0 ;
34912 char * kwnames[] = {
34913 (char *) "self",(char *) "colour", NULL
34914 };
34915
34916 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34917 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34918 if (!SWIG_IsOK(res1)) {
34919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34920 }
34921 arg1 = reinterpret_cast< wxWindow * >(argp1);
34922 {
34923 arg2 = &temp2;
34924 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34925 }
34926 {
34927 PyThreadState* __tstate = wxPyBeginAllowThreads();
34928 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
34929 wxPyEndAllowThreads(__tstate);
34930 if (PyErr_Occurred()) SWIG_fail;
34931 }
34932 resultobj = SWIG_Py_Void();
34933 return resultobj;
34934 fail:
34935 return NULL;
34936 }
34937
34938
34939 SWIGINTERN PyObject *_wrap_Window_SetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34940 PyObject *resultobj = 0;
34941 wxWindow *arg1 = (wxWindow *) 0 ;
34942 wxColour *arg2 = 0 ;
34943 bool result;
34944 void *argp1 = 0 ;
34945 int res1 = 0 ;
34946 wxColour temp2 ;
34947 PyObject * obj0 = 0 ;
34948 PyObject * obj1 = 0 ;
34949 char * kwnames[] = {
34950 (char *) "self",(char *) "colour", NULL
34951 };
34952
34953 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34954 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34955 if (!SWIG_IsOK(res1)) {
34956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34957 }
34958 arg1 = reinterpret_cast< wxWindow * >(argp1);
34959 {
34960 arg2 = &temp2;
34961 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34962 }
34963 {
34964 PyThreadState* __tstate = wxPyBeginAllowThreads();
34965 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
34966 wxPyEndAllowThreads(__tstate);
34967 if (PyErr_Occurred()) SWIG_fail;
34968 }
34969 {
34970 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34971 }
34972 return resultobj;
34973 fail:
34974 return NULL;
34975 }
34976
34977
34978 SWIGINTERN PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34979 PyObject *resultobj = 0;
34980 wxWindow *arg1 = (wxWindow *) 0 ;
34981 wxColour *arg2 = 0 ;
34982 void *argp1 = 0 ;
34983 int res1 = 0 ;
34984 wxColour temp2 ;
34985 PyObject * obj0 = 0 ;
34986 PyObject * obj1 = 0 ;
34987 char * kwnames[] = {
34988 (char *) "self",(char *) "colour", NULL
34989 };
34990
34991 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34992 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34993 if (!SWIG_IsOK(res1)) {
34994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34995 }
34996 arg1 = reinterpret_cast< wxWindow * >(argp1);
34997 {
34998 arg2 = &temp2;
34999 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
35000 }
35001 {
35002 PyThreadState* __tstate = wxPyBeginAllowThreads();
35003 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
35004 wxPyEndAllowThreads(__tstate);
35005 if (PyErr_Occurred()) SWIG_fail;
35006 }
35007 resultobj = SWIG_Py_Void();
35008 return resultobj;
35009 fail:
35010 return NULL;
35011 }
35012
35013
35014 SWIGINTERN PyObject *_wrap_Window_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35015 PyObject *resultobj = 0;
35016 wxWindow *arg1 = (wxWindow *) 0 ;
35017 wxColour result;
35018 void *argp1 = 0 ;
35019 int res1 = 0 ;
35020 PyObject *swig_obj[1] ;
35021
35022 if (!args) SWIG_fail;
35023 swig_obj[0] = args;
35024 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35025 if (!SWIG_IsOK(res1)) {
35026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
35027 }
35028 arg1 = reinterpret_cast< wxWindow * >(argp1);
35029 {
35030 PyThreadState* __tstate = wxPyBeginAllowThreads();
35031 result = ((wxWindow const *)arg1)->GetBackgroundColour();
35032 wxPyEndAllowThreads(__tstate);
35033 if (PyErr_Occurred()) SWIG_fail;
35034 }
35035 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
35036 return resultobj;
35037 fail:
35038 return NULL;
35039 }
35040
35041
35042 SWIGINTERN PyObject *_wrap_Window_GetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35043 PyObject *resultobj = 0;
35044 wxWindow *arg1 = (wxWindow *) 0 ;
35045 wxColour result;
35046 void *argp1 = 0 ;
35047 int res1 = 0 ;
35048 PyObject *swig_obj[1] ;
35049
35050 if (!args) SWIG_fail;
35051 swig_obj[0] = args;
35052 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35053 if (!SWIG_IsOK(res1)) {
35054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetForegroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
35055 }
35056 arg1 = reinterpret_cast< wxWindow * >(argp1);
35057 {
35058 PyThreadState* __tstate = wxPyBeginAllowThreads();
35059 result = ((wxWindow const *)arg1)->GetForegroundColour();
35060 wxPyEndAllowThreads(__tstate);
35061 if (PyErr_Occurred()) SWIG_fail;
35062 }
35063 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
35064 return resultobj;
35065 fail:
35066 return NULL;
35067 }
35068
35069
35070 SWIGINTERN PyObject *_wrap_Window_InheritsBackgroundColour(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_InheritsBackgroundColour" "', 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)->InheritsBackgroundColour();
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_UseBgCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35101 PyObject *resultobj = 0;
35102 wxWindow *arg1 = (wxWindow *) 0 ;
35103 bool result;
35104 void *argp1 = 0 ;
35105 int res1 = 0 ;
35106 PyObject *swig_obj[1] ;
35107
35108 if (!args) SWIG_fail;
35109 swig_obj[0] = args;
35110 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35111 if (!SWIG_IsOK(res1)) {
35112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UseBgCol" "', expected argument " "1"" of type '" "wxWindow const *""'");
35113 }
35114 arg1 = reinterpret_cast< wxWindow * >(argp1);
35115 {
35116 PyThreadState* __tstate = wxPyBeginAllowThreads();
35117 result = (bool)((wxWindow const *)arg1)->UseBgCol();
35118 wxPyEndAllowThreads(__tstate);
35119 if (PyErr_Occurred()) SWIG_fail;
35120 }
35121 {
35122 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35123 }
35124 return resultobj;
35125 fail:
35126 return NULL;
35127 }
35128
35129
35130 SWIGINTERN PyObject *_wrap_Window_SetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35131 PyObject *resultobj = 0;
35132 wxWindow *arg1 = (wxWindow *) 0 ;
35133 wxBackgroundStyle arg2 ;
35134 bool result;
35135 void *argp1 = 0 ;
35136 int res1 = 0 ;
35137 int val2 ;
35138 int ecode2 = 0 ;
35139 PyObject * obj0 = 0 ;
35140 PyObject * obj1 = 0 ;
35141 char * kwnames[] = {
35142 (char *) "self",(char *) "style", NULL
35143 };
35144
35145 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) SWIG_fail;
35146 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35147 if (!SWIG_IsOK(res1)) {
35148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
35149 }
35150 arg1 = reinterpret_cast< wxWindow * >(argp1);
35151 ecode2 = SWIG_AsVal_int(obj1, &val2);
35152 if (!SWIG_IsOK(ecode2)) {
35153 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetBackgroundStyle" "', expected argument " "2"" of type '" "wxBackgroundStyle""'");
35154 }
35155 arg2 = static_cast< wxBackgroundStyle >(val2);
35156 {
35157 PyThreadState* __tstate = wxPyBeginAllowThreads();
35158 result = (bool)(arg1)->SetBackgroundStyle(arg2);
35159 wxPyEndAllowThreads(__tstate);
35160 if (PyErr_Occurred()) SWIG_fail;
35161 }
35162 {
35163 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35164 }
35165 return resultobj;
35166 fail:
35167 return NULL;
35168 }
35169
35170
35171 SWIGINTERN PyObject *_wrap_Window_GetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35172 PyObject *resultobj = 0;
35173 wxWindow *arg1 = (wxWindow *) 0 ;
35174 wxBackgroundStyle result;
35175 void *argp1 = 0 ;
35176 int res1 = 0 ;
35177 PyObject *swig_obj[1] ;
35178
35179 if (!args) SWIG_fail;
35180 swig_obj[0] = args;
35181 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35182 if (!SWIG_IsOK(res1)) {
35183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
35184 }
35185 arg1 = reinterpret_cast< wxWindow * >(argp1);
35186 {
35187 PyThreadState* __tstate = wxPyBeginAllowThreads();
35188 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
35189 wxPyEndAllowThreads(__tstate);
35190 if (PyErr_Occurred()) SWIG_fail;
35191 }
35192 resultobj = SWIG_From_int(static_cast< int >(result));
35193 return resultobj;
35194 fail:
35195 return NULL;
35196 }
35197
35198
35199 SWIGINTERN PyObject *_wrap_Window_HasTransparentBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35200 PyObject *resultobj = 0;
35201 wxWindow *arg1 = (wxWindow *) 0 ;
35202 bool result;
35203 void *argp1 = 0 ;
35204 int res1 = 0 ;
35205 PyObject *swig_obj[1] ;
35206
35207 if (!args) SWIG_fail;
35208 swig_obj[0] = args;
35209 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35210 if (!SWIG_IsOK(res1)) {
35211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasTransparentBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
35212 }
35213 arg1 = reinterpret_cast< wxWindow * >(argp1);
35214 {
35215 PyThreadState* __tstate = wxPyBeginAllowThreads();
35216 result = (bool)(arg1)->HasTransparentBackground();
35217 wxPyEndAllowThreads(__tstate);
35218 if (PyErr_Occurred()) SWIG_fail;
35219 }
35220 {
35221 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35222 }
35223 return resultobj;
35224 fail:
35225 return NULL;
35226 }
35227
35228
35229 SWIGINTERN PyObject *_wrap_Window_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35230 PyObject *resultobj = 0;
35231 wxWindow *arg1 = (wxWindow *) 0 ;
35232 wxCursor *arg2 = 0 ;
35233 bool result;
35234 void *argp1 = 0 ;
35235 int res1 = 0 ;
35236 void *argp2 = 0 ;
35237 int res2 = 0 ;
35238 PyObject * obj0 = 0 ;
35239 PyObject * obj1 = 0 ;
35240 char * kwnames[] = {
35241 (char *) "self",(char *) "cursor", NULL
35242 };
35243
35244 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
35245 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35246 if (!SWIG_IsOK(res1)) {
35247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
35248 }
35249 arg1 = reinterpret_cast< wxWindow * >(argp1);
35250 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
35251 if (!SWIG_IsOK(res2)) {
35252 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
35253 }
35254 if (!argp2) {
35255 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
35256 }
35257 arg2 = reinterpret_cast< wxCursor * >(argp2);
35258 {
35259 PyThreadState* __tstate = wxPyBeginAllowThreads();
35260 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
35261 wxPyEndAllowThreads(__tstate);
35262 if (PyErr_Occurred()) SWIG_fail;
35263 }
35264 {
35265 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35266 }
35267 return resultobj;
35268 fail:
35269 return NULL;
35270 }
35271
35272
35273 SWIGINTERN PyObject *_wrap_Window_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35274 PyObject *resultobj = 0;
35275 wxWindow *arg1 = (wxWindow *) 0 ;
35276 wxCursor result;
35277 void *argp1 = 0 ;
35278 int res1 = 0 ;
35279 PyObject *swig_obj[1] ;
35280
35281 if (!args) SWIG_fail;
35282 swig_obj[0] = args;
35283 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35284 if (!SWIG_IsOK(res1)) {
35285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
35286 }
35287 arg1 = reinterpret_cast< wxWindow * >(argp1);
35288 {
35289 PyThreadState* __tstate = wxPyBeginAllowThreads();
35290 result = (arg1)->GetCursor();
35291 wxPyEndAllowThreads(__tstate);
35292 if (PyErr_Occurred()) SWIG_fail;
35293 }
35294 resultobj = SWIG_NewPointerObj((new wxCursor(static_cast< const wxCursor& >(result))), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );
35295 return resultobj;
35296 fail:
35297 return NULL;
35298 }
35299
35300
35301 SWIGINTERN PyObject *_wrap_Window_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35302 PyObject *resultobj = 0;
35303 wxWindow *arg1 = (wxWindow *) 0 ;
35304 wxFont *arg2 = 0 ;
35305 bool result;
35306 void *argp1 = 0 ;
35307 int res1 = 0 ;
35308 void *argp2 = 0 ;
35309 int res2 = 0 ;
35310 PyObject * obj0 = 0 ;
35311 PyObject * obj1 = 0 ;
35312 char * kwnames[] = {
35313 (char *) "self",(char *) "font", NULL
35314 };
35315
35316 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
35317 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35318 if (!SWIG_IsOK(res1)) {
35319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35320 }
35321 arg1 = reinterpret_cast< wxWindow * >(argp1);
35322 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
35323 if (!SWIG_IsOK(res2)) {
35324 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35325 }
35326 if (!argp2) {
35327 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35328 }
35329 arg2 = reinterpret_cast< wxFont * >(argp2);
35330 {
35331 PyThreadState* __tstate = wxPyBeginAllowThreads();
35332 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
35333 wxPyEndAllowThreads(__tstate);
35334 if (PyErr_Occurred()) SWIG_fail;
35335 }
35336 {
35337 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35338 }
35339 return resultobj;
35340 fail:
35341 return NULL;
35342 }
35343
35344
35345 SWIGINTERN PyObject *_wrap_Window_SetOwnFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35346 PyObject *resultobj = 0;
35347 wxWindow *arg1 = (wxWindow *) 0 ;
35348 wxFont *arg2 = 0 ;
35349 void *argp1 = 0 ;
35350 int res1 = 0 ;
35351 void *argp2 = 0 ;
35352 int res2 = 0 ;
35353 PyObject * obj0 = 0 ;
35354 PyObject * obj1 = 0 ;
35355 char * kwnames[] = {
35356 (char *) "self",(char *) "font", NULL
35357 };
35358
35359 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) SWIG_fail;
35360 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35361 if (!SWIG_IsOK(res1)) {
35362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35363 }
35364 arg1 = reinterpret_cast< wxWindow * >(argp1);
35365 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
35366 if (!SWIG_IsOK(res2)) {
35367 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35368 }
35369 if (!argp2) {
35370 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35371 }
35372 arg2 = reinterpret_cast< wxFont * >(argp2);
35373 {
35374 PyThreadState* __tstate = wxPyBeginAllowThreads();
35375 (arg1)->SetOwnFont((wxFont const &)*arg2);
35376 wxPyEndAllowThreads(__tstate);
35377 if (PyErr_Occurred()) SWIG_fail;
35378 }
35379 resultobj = SWIG_Py_Void();
35380 return resultobj;
35381 fail:
35382 return NULL;
35383 }
35384
35385
35386 SWIGINTERN PyObject *_wrap_Window_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35387 PyObject *resultobj = 0;
35388 wxWindow *arg1 = (wxWindow *) 0 ;
35389 wxFont result;
35390 void *argp1 = 0 ;
35391 int res1 = 0 ;
35392 PyObject *swig_obj[1] ;
35393
35394 if (!args) SWIG_fail;
35395 swig_obj[0] = args;
35396 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35397 if (!SWIG_IsOK(res1)) {
35398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35399 }
35400 arg1 = reinterpret_cast< wxWindow * >(argp1);
35401 {
35402 PyThreadState* __tstate = wxPyBeginAllowThreads();
35403 result = (arg1)->GetFont();
35404 wxPyEndAllowThreads(__tstate);
35405 if (PyErr_Occurred()) SWIG_fail;
35406 }
35407 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
35408 return resultobj;
35409 fail:
35410 return NULL;
35411 }
35412
35413
35414 SWIGINTERN PyObject *_wrap_Window_SetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35415 PyObject *resultobj = 0;
35416 wxWindow *arg1 = (wxWindow *) 0 ;
35417 wxCaret *arg2 = (wxCaret *) 0 ;
35418 void *argp1 = 0 ;
35419 int res1 = 0 ;
35420 int res2 = 0 ;
35421 PyObject * obj0 = 0 ;
35422 PyObject * obj1 = 0 ;
35423 char * kwnames[] = {
35424 (char *) "self",(char *) "caret", NULL
35425 };
35426
35427 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) SWIG_fail;
35428 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35429 if (!SWIG_IsOK(res1)) {
35430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCaret" "', expected argument " "1"" of type '" "wxWindow *""'");
35431 }
35432 arg1 = reinterpret_cast< wxWindow * >(argp1);
35433 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
35434 if (!SWIG_IsOK(res2)) {
35435 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCaret" "', expected argument " "2"" of type '" "wxCaret *""'");
35436 }
35437 {
35438 PyThreadState* __tstate = wxPyBeginAllowThreads();
35439 (arg1)->SetCaret(arg2);
35440 wxPyEndAllowThreads(__tstate);
35441 if (PyErr_Occurred()) SWIG_fail;
35442 }
35443 resultobj = SWIG_Py_Void();
35444 return resultobj;
35445 fail:
35446 return NULL;
35447 }
35448
35449
35450 SWIGINTERN PyObject *_wrap_Window_GetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35451 PyObject *resultobj = 0;
35452 wxWindow *arg1 = (wxWindow *) 0 ;
35453 wxCaret *result = 0 ;
35454 void *argp1 = 0 ;
35455 int res1 = 0 ;
35456 PyObject *swig_obj[1] ;
35457
35458 if (!args) SWIG_fail;
35459 swig_obj[0] = args;
35460 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35461 if (!SWIG_IsOK(res1)) {
35462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCaret" "', expected argument " "1"" of type '" "wxWindow const *""'");
35463 }
35464 arg1 = reinterpret_cast< wxWindow * >(argp1);
35465 {
35466 PyThreadState* __tstate = wxPyBeginAllowThreads();
35467 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
35468 wxPyEndAllowThreads(__tstate);
35469 if (PyErr_Occurred()) SWIG_fail;
35470 }
35471 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, 0 | 0 );
35472 return resultobj;
35473 fail:
35474 return NULL;
35475 }
35476
35477
35478 SWIGINTERN PyObject *_wrap_Window_GetCharHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35479 PyObject *resultobj = 0;
35480 wxWindow *arg1 = (wxWindow *) 0 ;
35481 int result;
35482 void *argp1 = 0 ;
35483 int res1 = 0 ;
35484 PyObject *swig_obj[1] ;
35485
35486 if (!args) SWIG_fail;
35487 swig_obj[0] = args;
35488 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35489 if (!SWIG_IsOK(res1)) {
35490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
35491 }
35492 arg1 = reinterpret_cast< wxWindow * >(argp1);
35493 {
35494 PyThreadState* __tstate = wxPyBeginAllowThreads();
35495 result = (int)((wxWindow const *)arg1)->GetCharHeight();
35496 wxPyEndAllowThreads(__tstate);
35497 if (PyErr_Occurred()) SWIG_fail;
35498 }
35499 resultobj = SWIG_From_int(static_cast< int >(result));
35500 return resultobj;
35501 fail:
35502 return NULL;
35503 }
35504
35505
35506 SWIGINTERN PyObject *_wrap_Window_GetCharWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35507 PyObject *resultobj = 0;
35508 wxWindow *arg1 = (wxWindow *) 0 ;
35509 int result;
35510 void *argp1 = 0 ;
35511 int res1 = 0 ;
35512 PyObject *swig_obj[1] ;
35513
35514 if (!args) SWIG_fail;
35515 swig_obj[0] = args;
35516 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35517 if (!SWIG_IsOK(res1)) {
35518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
35519 }
35520 arg1 = reinterpret_cast< wxWindow * >(argp1);
35521 {
35522 PyThreadState* __tstate = wxPyBeginAllowThreads();
35523 result = (int)((wxWindow const *)arg1)->GetCharWidth();
35524 wxPyEndAllowThreads(__tstate);
35525 if (PyErr_Occurred()) SWIG_fail;
35526 }
35527 resultobj = SWIG_From_int(static_cast< int >(result));
35528 return resultobj;
35529 fail:
35530 return NULL;
35531 }
35532
35533
35534 SWIGINTERN PyObject *_wrap_Window_GetTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35535 PyObject *resultobj = 0;
35536 wxWindow *arg1 = (wxWindow *) 0 ;
35537 wxString *arg2 = 0 ;
35538 int *arg3 = (int *) 0 ;
35539 int *arg4 = (int *) 0 ;
35540 void *argp1 = 0 ;
35541 int res1 = 0 ;
35542 bool temp2 = false ;
35543 int temp3 ;
35544 int res3 = SWIG_TMPOBJ ;
35545 int temp4 ;
35546 int res4 = SWIG_TMPOBJ ;
35547 PyObject * obj0 = 0 ;
35548 PyObject * obj1 = 0 ;
35549 char * kwnames[] = {
35550 (char *) "self",(char *) "string", NULL
35551 };
35552
35553 arg3 = &temp3;
35554 arg4 = &temp4;
35555 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) SWIG_fail;
35556 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35557 if (!SWIG_IsOK(res1)) {
35558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
35559 }
35560 arg1 = reinterpret_cast< wxWindow * >(argp1);
35561 {
35562 arg2 = wxString_in_helper(obj1);
35563 if (arg2 == NULL) SWIG_fail;
35564 temp2 = true;
35565 }
35566 {
35567 PyThreadState* __tstate = wxPyBeginAllowThreads();
35568 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
35569 wxPyEndAllowThreads(__tstate);
35570 if (PyErr_Occurred()) SWIG_fail;
35571 }
35572 resultobj = SWIG_Py_Void();
35573 if (SWIG_IsTmpObj(res3)) {
35574 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35575 } else {
35576 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35577 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35578 }
35579 if (SWIG_IsTmpObj(res4)) {
35580 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
35581 } else {
35582 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35583 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
35584 }
35585 {
35586 if (temp2)
35587 delete arg2;
35588 }
35589 return resultobj;
35590 fail:
35591 {
35592 if (temp2)
35593 delete arg2;
35594 }
35595 return NULL;
35596 }
35597
35598
35599 SWIGINTERN PyObject *_wrap_Window_GetFullTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35600 PyObject *resultobj = 0;
35601 wxWindow *arg1 = (wxWindow *) 0 ;
35602 wxString *arg2 = 0 ;
35603 int *arg3 = (int *) 0 ;
35604 int *arg4 = (int *) 0 ;
35605 int *arg5 = (int *) 0 ;
35606 int *arg6 = (int *) 0 ;
35607 wxFont *arg7 = (wxFont *) NULL ;
35608 void *argp1 = 0 ;
35609 int res1 = 0 ;
35610 bool temp2 = false ;
35611 int temp3 ;
35612 int res3 = SWIG_TMPOBJ ;
35613 int temp4 ;
35614 int res4 = SWIG_TMPOBJ ;
35615 int temp5 ;
35616 int res5 = SWIG_TMPOBJ ;
35617 int temp6 ;
35618 int res6 = SWIG_TMPOBJ ;
35619 void *argp7 = 0 ;
35620 int res7 = 0 ;
35621 PyObject * obj0 = 0 ;
35622 PyObject * obj1 = 0 ;
35623 PyObject * obj2 = 0 ;
35624 char * kwnames[] = {
35625 (char *) "self",(char *) "string",(char *) "font", NULL
35626 };
35627
35628 arg3 = &temp3;
35629 arg4 = &temp4;
35630 arg5 = &temp5;
35631 arg6 = &temp6;
35632 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35633 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35634 if (!SWIG_IsOK(res1)) {
35635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFullTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
35636 }
35637 arg1 = reinterpret_cast< wxWindow * >(argp1);
35638 {
35639 arg2 = wxString_in_helper(obj1);
35640 if (arg2 == NULL) SWIG_fail;
35641 temp2 = true;
35642 }
35643 if (obj2) {
35644 res7 = SWIG_ConvertPtr(obj2, &argp7,SWIGTYPE_p_wxFont, 0 | 0 );
35645 if (!SWIG_IsOK(res7)) {
35646 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Window_GetFullTextExtent" "', expected argument " "7"" of type '" "wxFont const *""'");
35647 }
35648 arg7 = reinterpret_cast< wxFont * >(argp7);
35649 }
35650 {
35651 PyThreadState* __tstate = wxPyBeginAllowThreads();
35652 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
35653 wxPyEndAllowThreads(__tstate);
35654 if (PyErr_Occurred()) SWIG_fail;
35655 }
35656 resultobj = SWIG_Py_Void();
35657 if (SWIG_IsTmpObj(res3)) {
35658 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35659 } else {
35660 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35661 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35662 }
35663 if (SWIG_IsTmpObj(res4)) {
35664 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
35665 } else {
35666 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35667 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
35668 }
35669 if (SWIG_IsTmpObj(res5)) {
35670 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
35671 } else {
35672 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35673 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
35674 }
35675 if (SWIG_IsTmpObj(res6)) {
35676 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
35677 } else {
35678 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35679 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
35680 }
35681 {
35682 if (temp2)
35683 delete arg2;
35684 }
35685 return resultobj;
35686 fail:
35687 {
35688 if (temp2)
35689 delete arg2;
35690 }
35691 return NULL;
35692 }
35693
35694
35695 SWIGINTERN PyObject *_wrap_Window_ClientToScreenXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35696 PyObject *resultobj = 0;
35697 wxWindow *arg1 = (wxWindow *) 0 ;
35698 int *arg2 = (int *) 0 ;
35699 int *arg3 = (int *) 0 ;
35700 void *argp1 = 0 ;
35701 int res1 = 0 ;
35702 int temp2 ;
35703 int res2 = 0 ;
35704 int temp3 ;
35705 int res3 = 0 ;
35706 PyObject * obj0 = 0 ;
35707 PyObject * obj1 = 0 ;
35708 PyObject * obj2 = 0 ;
35709 char * kwnames[] = {
35710 (char *) "self",(char *) "x",(char *) "y", NULL
35711 };
35712
35713 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35714 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35715 if (!SWIG_IsOK(res1)) {
35716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreenXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35717 }
35718 arg1 = reinterpret_cast< wxWindow * >(argp1);
35719 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
35720 int val;
35721 int ecode = SWIG_AsVal_int(obj1, &val);
35722 if (!SWIG_IsOK(ecode)) {
35723 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "2"" of type '" "int""'");
35724 }
35725 temp2 = static_cast< int >(val);
35726 arg2 = &temp2;
35727 res2 = SWIG_AddTmpMask(ecode);
35728 }
35729 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
35730 int val;
35731 int ecode = SWIG_AsVal_int(obj2, &val);
35732 if (!SWIG_IsOK(ecode)) {
35733 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "3"" of type '" "int""'");
35734 }
35735 temp3 = static_cast< int >(val);
35736 arg3 = &temp3;
35737 res3 = SWIG_AddTmpMask(ecode);
35738 }
35739 {
35740 PyThreadState* __tstate = wxPyBeginAllowThreads();
35741 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
35742 wxPyEndAllowThreads(__tstate);
35743 if (PyErr_Occurred()) SWIG_fail;
35744 }
35745 resultobj = SWIG_Py_Void();
35746 if (SWIG_IsTmpObj(res2)) {
35747 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35748 } else {
35749 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35750 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35751 }
35752 if (SWIG_IsTmpObj(res3)) {
35753 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35754 } else {
35755 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35756 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35757 }
35758 return resultobj;
35759 fail:
35760 return NULL;
35761 }
35762
35763
35764 SWIGINTERN PyObject *_wrap_Window_ScreenToClientXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35765 PyObject *resultobj = 0;
35766 wxWindow *arg1 = (wxWindow *) 0 ;
35767 int *arg2 = (int *) 0 ;
35768 int *arg3 = (int *) 0 ;
35769 void *argp1 = 0 ;
35770 int res1 = 0 ;
35771 int temp2 ;
35772 int res2 = 0 ;
35773 int temp3 ;
35774 int res3 = 0 ;
35775 PyObject * obj0 = 0 ;
35776 PyObject * obj1 = 0 ;
35777 PyObject * obj2 = 0 ;
35778 char * kwnames[] = {
35779 (char *) "self",(char *) "x",(char *) "y", NULL
35780 };
35781
35782 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35783 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35784 if (!SWIG_IsOK(res1)) {
35785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClientXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35786 }
35787 arg1 = reinterpret_cast< wxWindow * >(argp1);
35788 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
35789 int val;
35790 int ecode = SWIG_AsVal_int(obj1, &val);
35791 if (!SWIG_IsOK(ecode)) {
35792 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "2"" of type '" "int""'");
35793 }
35794 temp2 = static_cast< int >(val);
35795 arg2 = &temp2;
35796 res2 = SWIG_AddTmpMask(ecode);
35797 }
35798 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
35799 int val;
35800 int ecode = SWIG_AsVal_int(obj2, &val);
35801 if (!SWIG_IsOK(ecode)) {
35802 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "3"" of type '" "int""'");
35803 }
35804 temp3 = static_cast< int >(val);
35805 arg3 = &temp3;
35806 res3 = SWIG_AddTmpMask(ecode);
35807 }
35808 {
35809 PyThreadState* __tstate = wxPyBeginAllowThreads();
35810 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
35811 wxPyEndAllowThreads(__tstate);
35812 if (PyErr_Occurred()) SWIG_fail;
35813 }
35814 resultobj = SWIG_Py_Void();
35815 if (SWIG_IsTmpObj(res2)) {
35816 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35817 } else {
35818 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35819 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35820 }
35821 if (SWIG_IsTmpObj(res3)) {
35822 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35823 } else {
35824 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35825 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35826 }
35827 return resultobj;
35828 fail:
35829 return NULL;
35830 }
35831
35832
35833 SWIGINTERN PyObject *_wrap_Window_ClientToScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35834 PyObject *resultobj = 0;
35835 wxWindow *arg1 = (wxWindow *) 0 ;
35836 wxPoint *arg2 = 0 ;
35837 wxPoint result;
35838 void *argp1 = 0 ;
35839 int res1 = 0 ;
35840 wxPoint temp2 ;
35841 PyObject * obj0 = 0 ;
35842 PyObject * obj1 = 0 ;
35843 char * kwnames[] = {
35844 (char *) "self",(char *) "pt", NULL
35845 };
35846
35847 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) SWIG_fail;
35848 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35849 if (!SWIG_IsOK(res1)) {
35850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
35851 }
35852 arg1 = reinterpret_cast< wxWindow * >(argp1);
35853 {
35854 arg2 = &temp2;
35855 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35856 }
35857 {
35858 PyThreadState* __tstate = wxPyBeginAllowThreads();
35859 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
35860 wxPyEndAllowThreads(__tstate);
35861 if (PyErr_Occurred()) SWIG_fail;
35862 }
35863 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35864 return resultobj;
35865 fail:
35866 return NULL;
35867 }
35868
35869
35870 SWIGINTERN PyObject *_wrap_Window_ScreenToClient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35871 PyObject *resultobj = 0;
35872 wxWindow *arg1 = (wxWindow *) 0 ;
35873 wxPoint *arg2 = 0 ;
35874 wxPoint result;
35875 void *argp1 = 0 ;
35876 int res1 = 0 ;
35877 wxPoint temp2 ;
35878 PyObject * obj0 = 0 ;
35879 PyObject * obj1 = 0 ;
35880 char * kwnames[] = {
35881 (char *) "self",(char *) "pt", NULL
35882 };
35883
35884 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) SWIG_fail;
35885 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35886 if (!SWIG_IsOK(res1)) {
35887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClient" "', expected argument " "1"" of type '" "wxWindow const *""'");
35888 }
35889 arg1 = reinterpret_cast< wxWindow * >(argp1);
35890 {
35891 arg2 = &temp2;
35892 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35893 }
35894 {
35895 PyThreadState* __tstate = wxPyBeginAllowThreads();
35896 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
35897 wxPyEndAllowThreads(__tstate);
35898 if (PyErr_Occurred()) SWIG_fail;
35899 }
35900 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35901 return resultobj;
35902 fail:
35903 return NULL;
35904 }
35905
35906
35907 SWIGINTERN PyObject *_wrap_Window_HitTestXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35908 PyObject *resultobj = 0;
35909 wxWindow *arg1 = (wxWindow *) 0 ;
35910 int arg2 ;
35911 int arg3 ;
35912 wxHitTest result;
35913 void *argp1 = 0 ;
35914 int res1 = 0 ;
35915 int val2 ;
35916 int ecode2 = 0 ;
35917 int val3 ;
35918 int ecode3 = 0 ;
35919 PyObject * obj0 = 0 ;
35920 PyObject * obj1 = 0 ;
35921 PyObject * obj2 = 0 ;
35922 char * kwnames[] = {
35923 (char *) "self",(char *) "x",(char *) "y", NULL
35924 };
35925
35926 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35927 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35928 if (!SWIG_IsOK(res1)) {
35929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTestXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35930 }
35931 arg1 = reinterpret_cast< wxWindow * >(argp1);
35932 ecode2 = SWIG_AsVal_int(obj1, &val2);
35933 if (!SWIG_IsOK(ecode2)) {
35934 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HitTestXY" "', expected argument " "2"" of type '" "int""'");
35935 }
35936 arg2 = static_cast< int >(val2);
35937 ecode3 = SWIG_AsVal_int(obj2, &val3);
35938 if (!SWIG_IsOK(ecode3)) {
35939 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_HitTestXY" "', expected argument " "3"" of type '" "int""'");
35940 }
35941 arg3 = static_cast< int >(val3);
35942 {
35943 PyThreadState* __tstate = wxPyBeginAllowThreads();
35944 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
35945 wxPyEndAllowThreads(__tstate);
35946 if (PyErr_Occurred()) SWIG_fail;
35947 }
35948 resultobj = SWIG_From_int(static_cast< int >(result));
35949 return resultobj;
35950 fail:
35951 return NULL;
35952 }
35953
35954
35955 SWIGINTERN PyObject *_wrap_Window_HitTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35956 PyObject *resultobj = 0;
35957 wxWindow *arg1 = (wxWindow *) 0 ;
35958 wxPoint *arg2 = 0 ;
35959 wxHitTest result;
35960 void *argp1 = 0 ;
35961 int res1 = 0 ;
35962 wxPoint temp2 ;
35963 PyObject * obj0 = 0 ;
35964 PyObject * obj1 = 0 ;
35965 char * kwnames[] = {
35966 (char *) "self",(char *) "pt", NULL
35967 };
35968
35969 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) SWIG_fail;
35970 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35971 if (!SWIG_IsOK(res1)) {
35972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTest" "', expected argument " "1"" of type '" "wxWindow const *""'");
35973 }
35974 arg1 = reinterpret_cast< wxWindow * >(argp1);
35975 {
35976 arg2 = &temp2;
35977 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35978 }
35979 {
35980 PyThreadState* __tstate = wxPyBeginAllowThreads();
35981 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
35982 wxPyEndAllowThreads(__tstate);
35983 if (PyErr_Occurred()) SWIG_fail;
35984 }
35985 resultobj = SWIG_From_int(static_cast< int >(result));
35986 return resultobj;
35987 fail:
35988 return NULL;
35989 }
35990
35991
35992 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
35993 PyObject *resultobj = 0;
35994 wxWindow *arg1 = (wxWindow *) 0 ;
35995 long arg2 ;
35996 wxBorder result;
35997 void *argp1 = 0 ;
35998 int res1 = 0 ;
35999 long val2 ;
36000 int ecode2 = 0 ;
36001
36002 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
36003 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36004 if (!SWIG_IsOK(res1)) {
36005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
36006 }
36007 arg1 = reinterpret_cast< wxWindow * >(argp1);
36008 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
36009 if (!SWIG_IsOK(ecode2)) {
36010 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetBorder" "', expected argument " "2"" of type '" "long""'");
36011 }
36012 arg2 = static_cast< long >(val2);
36013 {
36014 PyThreadState* __tstate = wxPyBeginAllowThreads();
36015 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
36016 wxPyEndAllowThreads(__tstate);
36017 if (PyErr_Occurred()) SWIG_fail;
36018 }
36019 resultobj = SWIG_From_int(static_cast< int >(result));
36020 return resultobj;
36021 fail:
36022 return NULL;
36023 }
36024
36025
36026 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
36027 PyObject *resultobj = 0;
36028 wxWindow *arg1 = (wxWindow *) 0 ;
36029 wxBorder result;
36030 void *argp1 = 0 ;
36031 int res1 = 0 ;
36032
36033 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
36034 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36035 if (!SWIG_IsOK(res1)) {
36036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
36037 }
36038 arg1 = reinterpret_cast< wxWindow * >(argp1);
36039 {
36040 PyThreadState* __tstate = wxPyBeginAllowThreads();
36041 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
36042 wxPyEndAllowThreads(__tstate);
36043 if (PyErr_Occurred()) SWIG_fail;
36044 }
36045 resultobj = SWIG_From_int(static_cast< int >(result));
36046 return resultobj;
36047 fail:
36048 return NULL;
36049 }
36050
36051
36052 SWIGINTERN PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
36053 int argc;
36054 PyObject *argv[3];
36055
36056 if (!(argc = SWIG_Python_UnpackTuple(args,"Window_GetBorder",0,2,argv))) SWIG_fail;
36057 --argc;
36058 if (argc == 1) {
36059 return _wrap_Window_GetBorder__SWIG_1(self, argc, argv);
36060 }
36061 if (argc == 2) {
36062 return _wrap_Window_GetBorder__SWIG_0(self, argc, argv);
36063 }
36064
36065 fail:
36066 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
36067 return NULL;
36068 }
36069
36070
36071 SWIGINTERN PyObject *_wrap_Window_UpdateWindowUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36072 PyObject *resultobj = 0;
36073 wxWindow *arg1 = (wxWindow *) 0 ;
36074 long arg2 = (long) wxUPDATE_UI_NONE ;
36075 void *argp1 = 0 ;
36076 int res1 = 0 ;
36077 long val2 ;
36078 int ecode2 = 0 ;
36079 PyObject * obj0 = 0 ;
36080 PyObject * obj1 = 0 ;
36081 char * kwnames[] = {
36082 (char *) "self",(char *) "flags", NULL
36083 };
36084
36085 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) SWIG_fail;
36086 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36087 if (!SWIG_IsOK(res1)) {
36088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UpdateWindowUI" "', expected argument " "1"" of type '" "wxWindow *""'");
36089 }
36090 arg1 = reinterpret_cast< wxWindow * >(argp1);
36091 if (obj1) {
36092 ecode2 = SWIG_AsVal_long(obj1, &val2);
36093 if (!SWIG_IsOK(ecode2)) {
36094 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UpdateWindowUI" "', expected argument " "2"" of type '" "long""'");
36095 }
36096 arg2 = static_cast< long >(val2);
36097 }
36098 {
36099 PyThreadState* __tstate = wxPyBeginAllowThreads();
36100 (arg1)->UpdateWindowUI(arg2);
36101 wxPyEndAllowThreads(__tstate);
36102 if (PyErr_Occurred()) SWIG_fail;
36103 }
36104 resultobj = SWIG_Py_Void();
36105 return resultobj;
36106 fail:
36107 return NULL;
36108 }
36109
36110
36111 SWIGINTERN PyObject *_wrap_Window_PopupMenuXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36112 PyObject *resultobj = 0;
36113 wxWindow *arg1 = (wxWindow *) 0 ;
36114 wxMenu *arg2 = (wxMenu *) 0 ;
36115 int arg3 = (int) -1 ;
36116 int arg4 = (int) -1 ;
36117 bool result;
36118 void *argp1 = 0 ;
36119 int res1 = 0 ;
36120 void *argp2 = 0 ;
36121 int res2 = 0 ;
36122 int val3 ;
36123 int ecode3 = 0 ;
36124 int val4 ;
36125 int ecode4 = 0 ;
36126 PyObject * obj0 = 0 ;
36127 PyObject * obj1 = 0 ;
36128 PyObject * obj2 = 0 ;
36129 PyObject * obj3 = 0 ;
36130 char * kwnames[] = {
36131 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
36132 };
36133
36134 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36135 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36136 if (!SWIG_IsOK(res1)) {
36137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenuXY" "', expected argument " "1"" of type '" "wxWindow *""'");
36138 }
36139 arg1 = reinterpret_cast< wxWindow * >(argp1);
36140 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
36141 if (!SWIG_IsOK(res2)) {
36142 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenuXY" "', expected argument " "2"" of type '" "wxMenu *""'");
36143 }
36144 arg2 = reinterpret_cast< wxMenu * >(argp2);
36145 if (obj2) {
36146 ecode3 = SWIG_AsVal_int(obj2, &val3);
36147 if (!SWIG_IsOK(ecode3)) {
36148 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_PopupMenuXY" "', expected argument " "3"" of type '" "int""'");
36149 }
36150 arg3 = static_cast< int >(val3);
36151 }
36152 if (obj3) {
36153 ecode4 = SWIG_AsVal_int(obj3, &val4);
36154 if (!SWIG_IsOK(ecode4)) {
36155 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_PopupMenuXY" "', expected argument " "4"" of type '" "int""'");
36156 }
36157 arg4 = static_cast< int >(val4);
36158 }
36159 {
36160 PyThreadState* __tstate = wxPyBeginAllowThreads();
36161 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
36162 wxPyEndAllowThreads(__tstate);
36163 if (PyErr_Occurred()) SWIG_fail;
36164 }
36165 {
36166 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36167 }
36168 return resultobj;
36169 fail:
36170 return NULL;
36171 }
36172
36173
36174 SWIGINTERN PyObject *_wrap_Window_PopupMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36175 PyObject *resultobj = 0;
36176 wxWindow *arg1 = (wxWindow *) 0 ;
36177 wxMenu *arg2 = (wxMenu *) 0 ;
36178 wxPoint const &arg3_defvalue = wxDefaultPosition ;
36179 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
36180 bool result;
36181 void *argp1 = 0 ;
36182 int res1 = 0 ;
36183 void *argp2 = 0 ;
36184 int res2 = 0 ;
36185 wxPoint temp3 ;
36186 PyObject * obj0 = 0 ;
36187 PyObject * obj1 = 0 ;
36188 PyObject * obj2 = 0 ;
36189 char * kwnames[] = {
36190 (char *) "self",(char *) "menu",(char *) "pos", NULL
36191 };
36192
36193 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36194 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36195 if (!SWIG_IsOK(res1)) {
36196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenu" "', expected argument " "1"" of type '" "wxWindow *""'");
36197 }
36198 arg1 = reinterpret_cast< wxWindow * >(argp1);
36199 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
36200 if (!SWIG_IsOK(res2)) {
36201 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
36202 }
36203 arg2 = reinterpret_cast< wxMenu * >(argp2);
36204 if (obj2) {
36205 {
36206 arg3 = &temp3;
36207 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
36208 }
36209 }
36210 {
36211 PyThreadState* __tstate = wxPyBeginAllowThreads();
36212 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
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_HasScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36319 PyObject *resultobj = 0;
36320 wxWindow *arg1 = (wxWindow *) 0 ;
36321 int arg2 ;
36322 bool result;
36323 void *argp1 = 0 ;
36324 int res1 = 0 ;
36325 int val2 ;
36326 int ecode2 = 0 ;
36327 PyObject * obj0 = 0 ;
36328 PyObject * obj1 = 0 ;
36329 char * kwnames[] = {
36330 (char *) "self",(char *) "orient", NULL
36331 };
36332
36333 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) SWIG_fail;
36334 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36335 if (!SWIG_IsOK(res1)) {
36336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasScrollbar" "', expected argument " "1"" of type '" "wxWindow const *""'");
36337 }
36338 arg1 = reinterpret_cast< wxWindow * >(argp1);
36339 ecode2 = SWIG_AsVal_int(obj1, &val2);
36340 if (!SWIG_IsOK(ecode2)) {
36341 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasScrollbar" "', expected argument " "2"" of type '" "int""'");
36342 }
36343 arg2 = static_cast< int >(val2);
36344 {
36345 PyThreadState* __tstate = wxPyBeginAllowThreads();
36346 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
36347 wxPyEndAllowThreads(__tstate);
36348 if (PyErr_Occurred()) SWIG_fail;
36349 }
36350 {
36351 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36352 }
36353 return resultobj;
36354 fail:
36355 return NULL;
36356 }
36357
36358
36359 SWIGINTERN PyObject *_wrap_Window_SetScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36360 PyObject *resultobj = 0;
36361 wxWindow *arg1 = (wxWindow *) 0 ;
36362 int arg2 ;
36363 int arg3 ;
36364 int arg4 ;
36365 int arg5 ;
36366 bool arg6 = (bool) true ;
36367 void *argp1 = 0 ;
36368 int res1 = 0 ;
36369 int val2 ;
36370 int ecode2 = 0 ;
36371 int val3 ;
36372 int ecode3 = 0 ;
36373 int val4 ;
36374 int ecode4 = 0 ;
36375 int val5 ;
36376 int ecode5 = 0 ;
36377 bool val6 ;
36378 int ecode6 = 0 ;
36379 PyObject * obj0 = 0 ;
36380 PyObject * obj1 = 0 ;
36381 PyObject * obj2 = 0 ;
36382 PyObject * obj3 = 0 ;
36383 PyObject * obj4 = 0 ;
36384 PyObject * obj5 = 0 ;
36385 char * kwnames[] = {
36386 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
36387 };
36388
36389 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
36390 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36391 if (!SWIG_IsOK(res1)) {
36392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollbar" "', expected argument " "1"" of type '" "wxWindow *""'");
36393 }
36394 arg1 = reinterpret_cast< wxWindow * >(argp1);
36395 ecode2 = SWIG_AsVal_int(obj1, &val2);
36396 if (!SWIG_IsOK(ecode2)) {
36397 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollbar" "', expected argument " "2"" of type '" "int""'");
36398 }
36399 arg2 = static_cast< int >(val2);
36400 ecode3 = SWIG_AsVal_int(obj2, &val3);
36401 if (!SWIG_IsOK(ecode3)) {
36402 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollbar" "', expected argument " "3"" of type '" "int""'");
36403 }
36404 arg3 = static_cast< int >(val3);
36405 ecode4 = SWIG_AsVal_int(obj3, &val4);
36406 if (!SWIG_IsOK(ecode4)) {
36407 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollbar" "', expected argument " "4"" of type '" "int""'");
36408 }
36409 arg4 = static_cast< int >(val4);
36410 ecode5 = SWIG_AsVal_int(obj4, &val5);
36411 if (!SWIG_IsOK(ecode5)) {
36412 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetScrollbar" "', expected argument " "5"" of type '" "int""'");
36413 }
36414 arg5 = static_cast< int >(val5);
36415 if (obj5) {
36416 ecode6 = SWIG_AsVal_bool(obj5, &val6);
36417 if (!SWIG_IsOK(ecode6)) {
36418 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetScrollbar" "', expected argument " "6"" of type '" "bool""'");
36419 }
36420 arg6 = static_cast< bool >(val6);
36421 }
36422 {
36423 PyThreadState* __tstate = wxPyBeginAllowThreads();
36424 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
36425 wxPyEndAllowThreads(__tstate);
36426 if (PyErr_Occurred()) SWIG_fail;
36427 }
36428 resultobj = SWIG_Py_Void();
36429 return resultobj;
36430 fail:
36431 return NULL;
36432 }
36433
36434
36435 SWIGINTERN PyObject *_wrap_Window_SetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36436 PyObject *resultobj = 0;
36437 wxWindow *arg1 = (wxWindow *) 0 ;
36438 int arg2 ;
36439 int arg3 ;
36440 bool arg4 = (bool) true ;
36441 void *argp1 = 0 ;
36442 int res1 = 0 ;
36443 int val2 ;
36444 int ecode2 = 0 ;
36445 int val3 ;
36446 int ecode3 = 0 ;
36447 bool val4 ;
36448 int ecode4 = 0 ;
36449 PyObject * obj0 = 0 ;
36450 PyObject * obj1 = 0 ;
36451 PyObject * obj2 = 0 ;
36452 PyObject * obj3 = 0 ;
36453 char * kwnames[] = {
36454 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
36455 };
36456
36457 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36458 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36459 if (!SWIG_IsOK(res1)) {
36460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollPos" "', expected argument " "1"" of type '" "wxWindow *""'");
36461 }
36462 arg1 = reinterpret_cast< wxWindow * >(argp1);
36463 ecode2 = SWIG_AsVal_int(obj1, &val2);
36464 if (!SWIG_IsOK(ecode2)) {
36465 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollPos" "', expected argument " "2"" of type '" "int""'");
36466 }
36467 arg2 = static_cast< int >(val2);
36468 ecode3 = SWIG_AsVal_int(obj2, &val3);
36469 if (!SWIG_IsOK(ecode3)) {
36470 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollPos" "', expected argument " "3"" of type '" "int""'");
36471 }
36472 arg3 = static_cast< int >(val3);
36473 if (obj3) {
36474 ecode4 = SWIG_AsVal_bool(obj3, &val4);
36475 if (!SWIG_IsOK(ecode4)) {
36476 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollPos" "', expected argument " "4"" of type '" "bool""'");
36477 }
36478 arg4 = static_cast< bool >(val4);
36479 }
36480 {
36481 PyThreadState* __tstate = wxPyBeginAllowThreads();
36482 (arg1)->SetScrollPos(arg2,arg3,arg4);
36483 wxPyEndAllowThreads(__tstate);
36484 if (PyErr_Occurred()) SWIG_fail;
36485 }
36486 resultobj = SWIG_Py_Void();
36487 return resultobj;
36488 fail:
36489 return NULL;
36490 }
36491
36492
36493 SWIGINTERN PyObject *_wrap_Window_GetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36494 PyObject *resultobj = 0;
36495 wxWindow *arg1 = (wxWindow *) 0 ;
36496 int arg2 ;
36497 int result;
36498 void *argp1 = 0 ;
36499 int res1 = 0 ;
36500 int val2 ;
36501 int ecode2 = 0 ;
36502 PyObject * obj0 = 0 ;
36503 PyObject * obj1 = 0 ;
36504 char * kwnames[] = {
36505 (char *) "self",(char *) "orientation", NULL
36506 };
36507
36508 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) SWIG_fail;
36509 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36510 if (!SWIG_IsOK(res1)) {
36511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollPos" "', expected argument " "1"" of type '" "wxWindow const *""'");
36512 }
36513 arg1 = reinterpret_cast< wxWindow * >(argp1);
36514 ecode2 = SWIG_AsVal_int(obj1, &val2);
36515 if (!SWIG_IsOK(ecode2)) {
36516 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollPos" "', expected argument " "2"" of type '" "int""'");
36517 }
36518 arg2 = static_cast< int >(val2);
36519 {
36520 PyThreadState* __tstate = wxPyBeginAllowThreads();
36521 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
36522 wxPyEndAllowThreads(__tstate);
36523 if (PyErr_Occurred()) SWIG_fail;
36524 }
36525 resultobj = SWIG_From_int(static_cast< int >(result));
36526 return resultobj;
36527 fail:
36528 return NULL;
36529 }
36530
36531
36532 SWIGINTERN PyObject *_wrap_Window_GetScrollThumb(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36533 PyObject *resultobj = 0;
36534 wxWindow *arg1 = (wxWindow *) 0 ;
36535 int arg2 ;
36536 int result;
36537 void *argp1 = 0 ;
36538 int res1 = 0 ;
36539 int val2 ;
36540 int ecode2 = 0 ;
36541 PyObject * obj0 = 0 ;
36542 PyObject * obj1 = 0 ;
36543 char * kwnames[] = {
36544 (char *) "self",(char *) "orientation", NULL
36545 };
36546
36547 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) SWIG_fail;
36548 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36549 if (!SWIG_IsOK(res1)) {
36550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollThumb" "', expected argument " "1"" of type '" "wxWindow const *""'");
36551 }
36552 arg1 = reinterpret_cast< wxWindow * >(argp1);
36553 ecode2 = SWIG_AsVal_int(obj1, &val2);
36554 if (!SWIG_IsOK(ecode2)) {
36555 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollThumb" "', expected argument " "2"" of type '" "int""'");
36556 }
36557 arg2 = static_cast< int >(val2);
36558 {
36559 PyThreadState* __tstate = wxPyBeginAllowThreads();
36560 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
36561 wxPyEndAllowThreads(__tstate);
36562 if (PyErr_Occurred()) SWIG_fail;
36563 }
36564 resultobj = SWIG_From_int(static_cast< int >(result));
36565 return resultobj;
36566 fail:
36567 return NULL;
36568 }
36569
36570
36571 SWIGINTERN PyObject *_wrap_Window_GetScrollRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36572 PyObject *resultobj = 0;
36573 wxWindow *arg1 = (wxWindow *) 0 ;
36574 int arg2 ;
36575 int result;
36576 void *argp1 = 0 ;
36577 int res1 = 0 ;
36578 int val2 ;
36579 int ecode2 = 0 ;
36580 PyObject * obj0 = 0 ;
36581 PyObject * obj1 = 0 ;
36582 char * kwnames[] = {
36583 (char *) "self",(char *) "orientation", NULL
36584 };
36585
36586 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) SWIG_fail;
36587 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36588 if (!SWIG_IsOK(res1)) {
36589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollRange" "', expected argument " "1"" of type '" "wxWindow const *""'");
36590 }
36591 arg1 = reinterpret_cast< wxWindow * >(argp1);
36592 ecode2 = SWIG_AsVal_int(obj1, &val2);
36593 if (!SWIG_IsOK(ecode2)) {
36594 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollRange" "', expected argument " "2"" of type '" "int""'");
36595 }
36596 arg2 = static_cast< int >(val2);
36597 {
36598 PyThreadState* __tstate = wxPyBeginAllowThreads();
36599 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
36600 wxPyEndAllowThreads(__tstate);
36601 if (PyErr_Occurred()) SWIG_fail;
36602 }
36603 resultobj = SWIG_From_int(static_cast< int >(result));
36604 return resultobj;
36605 fail:
36606 return NULL;
36607 }
36608
36609
36610 SWIGINTERN PyObject *_wrap_Window_ScrollWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36611 PyObject *resultobj = 0;
36612 wxWindow *arg1 = (wxWindow *) 0 ;
36613 int arg2 ;
36614 int arg3 ;
36615 wxRect *arg4 = (wxRect *) NULL ;
36616 void *argp1 = 0 ;
36617 int res1 = 0 ;
36618 int val2 ;
36619 int ecode2 = 0 ;
36620 int val3 ;
36621 int ecode3 = 0 ;
36622 void *argp4 = 0 ;
36623 int res4 = 0 ;
36624 PyObject * obj0 = 0 ;
36625 PyObject * obj1 = 0 ;
36626 PyObject * obj2 = 0 ;
36627 PyObject * obj3 = 0 ;
36628 char * kwnames[] = {
36629 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
36630 };
36631
36632 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36633 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36634 if (!SWIG_IsOK(res1)) {
36635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
36636 }
36637 arg1 = reinterpret_cast< wxWindow * >(argp1);
36638 ecode2 = SWIG_AsVal_int(obj1, &val2);
36639 if (!SWIG_IsOK(ecode2)) {
36640 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollWindow" "', expected argument " "2"" of type '" "int""'");
36641 }
36642 arg2 = static_cast< int >(val2);
36643 ecode3 = SWIG_AsVal_int(obj2, &val3);
36644 if (!SWIG_IsOK(ecode3)) {
36645 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_ScrollWindow" "', expected argument " "3"" of type '" "int""'");
36646 }
36647 arg3 = static_cast< int >(val3);
36648 if (obj3) {
36649 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxRect, 0 | 0 );
36650 if (!SWIG_IsOK(res4)) {
36651 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Window_ScrollWindow" "', expected argument " "4"" of type '" "wxRect const *""'");
36652 }
36653 arg4 = reinterpret_cast< wxRect * >(argp4);
36654 }
36655 {
36656 PyThreadState* __tstate = wxPyBeginAllowThreads();
36657 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
36658 wxPyEndAllowThreads(__tstate);
36659 if (PyErr_Occurred()) SWIG_fail;
36660 }
36661 resultobj = SWIG_Py_Void();
36662 return resultobj;
36663 fail:
36664 return NULL;
36665 }
36666
36667
36668 SWIGINTERN PyObject *_wrap_Window_ScrollLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36669 PyObject *resultobj = 0;
36670 wxWindow *arg1 = (wxWindow *) 0 ;
36671 int arg2 ;
36672 bool result;
36673 void *argp1 = 0 ;
36674 int res1 = 0 ;
36675 int val2 ;
36676 int ecode2 = 0 ;
36677 PyObject * obj0 = 0 ;
36678 PyObject * obj1 = 0 ;
36679 char * kwnames[] = {
36680 (char *) "self",(char *) "lines", NULL
36681 };
36682
36683 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) SWIG_fail;
36684 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36685 if (!SWIG_IsOK(res1)) {
36686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollLines" "', expected argument " "1"" of type '" "wxWindow *""'");
36687 }
36688 arg1 = reinterpret_cast< wxWindow * >(argp1);
36689 ecode2 = SWIG_AsVal_int(obj1, &val2);
36690 if (!SWIG_IsOK(ecode2)) {
36691 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollLines" "', expected argument " "2"" of type '" "int""'");
36692 }
36693 arg2 = static_cast< int >(val2);
36694 {
36695 PyThreadState* __tstate = wxPyBeginAllowThreads();
36696 result = (bool)(arg1)->ScrollLines(arg2);
36697 wxPyEndAllowThreads(__tstate);
36698 if (PyErr_Occurred()) SWIG_fail;
36699 }
36700 {
36701 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36702 }
36703 return resultobj;
36704 fail:
36705 return NULL;
36706 }
36707
36708
36709 SWIGINTERN PyObject *_wrap_Window_ScrollPages(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 *) "pages", NULL
36722 };
36723
36724 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",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_ScrollPages" "', 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_ScrollPages" "', expected argument " "2"" of type '" "int""'");
36733 }
36734 arg2 = static_cast< int >(val2);
36735 {
36736 PyThreadState* __tstate = wxPyBeginAllowThreads();
36737 result = (bool)(arg1)->ScrollPages(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_LineUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36751 PyObject *resultobj = 0;
36752 wxWindow *arg1 = (wxWindow *) 0 ;
36753 bool result;
36754 void *argp1 = 0 ;
36755 int res1 = 0 ;
36756 PyObject *swig_obj[1] ;
36757
36758 if (!args) SWIG_fail;
36759 swig_obj[0] = args;
36760 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36761 if (!SWIG_IsOK(res1)) {
36762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineUp" "', expected argument " "1"" of type '" "wxWindow *""'");
36763 }
36764 arg1 = reinterpret_cast< wxWindow * >(argp1);
36765 {
36766 PyThreadState* __tstate = wxPyBeginAllowThreads();
36767 result = (bool)(arg1)->LineUp();
36768 wxPyEndAllowThreads(__tstate);
36769 if (PyErr_Occurred()) SWIG_fail;
36770 }
36771 {
36772 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36773 }
36774 return resultobj;
36775 fail:
36776 return NULL;
36777 }
36778
36779
36780 SWIGINTERN PyObject *_wrap_Window_LineDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36781 PyObject *resultobj = 0;
36782 wxWindow *arg1 = (wxWindow *) 0 ;
36783 bool result;
36784 void *argp1 = 0 ;
36785 int res1 = 0 ;
36786 PyObject *swig_obj[1] ;
36787
36788 if (!args) SWIG_fail;
36789 swig_obj[0] = args;
36790 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36791 if (!SWIG_IsOK(res1)) {
36792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineDown" "', expected argument " "1"" of type '" "wxWindow *""'");
36793 }
36794 arg1 = reinterpret_cast< wxWindow * >(argp1);
36795 {
36796 PyThreadState* __tstate = wxPyBeginAllowThreads();
36797 result = (bool)(arg1)->LineDown();
36798 wxPyEndAllowThreads(__tstate);
36799 if (PyErr_Occurred()) SWIG_fail;
36800 }
36801 {
36802 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36803 }
36804 return resultobj;
36805 fail:
36806 return NULL;
36807 }
36808
36809
36810 SWIGINTERN PyObject *_wrap_Window_PageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36811 PyObject *resultobj = 0;
36812 wxWindow *arg1 = (wxWindow *) 0 ;
36813 bool result;
36814 void *argp1 = 0 ;
36815 int res1 = 0 ;
36816 PyObject *swig_obj[1] ;
36817
36818 if (!args) SWIG_fail;
36819 swig_obj[0] = args;
36820 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36821 if (!SWIG_IsOK(res1)) {
36822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageUp" "', expected argument " "1"" of type '" "wxWindow *""'");
36823 }
36824 arg1 = reinterpret_cast< wxWindow * >(argp1);
36825 {
36826 PyThreadState* __tstate = wxPyBeginAllowThreads();
36827 result = (bool)(arg1)->PageUp();
36828 wxPyEndAllowThreads(__tstate);
36829 if (PyErr_Occurred()) SWIG_fail;
36830 }
36831 {
36832 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36833 }
36834 return resultobj;
36835 fail:
36836 return NULL;
36837 }
36838
36839
36840 SWIGINTERN PyObject *_wrap_Window_PageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36841 PyObject *resultobj = 0;
36842 wxWindow *arg1 = (wxWindow *) 0 ;
36843 bool result;
36844 void *argp1 = 0 ;
36845 int res1 = 0 ;
36846 PyObject *swig_obj[1] ;
36847
36848 if (!args) SWIG_fail;
36849 swig_obj[0] = args;
36850 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36851 if (!SWIG_IsOK(res1)) {
36852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageDown" "', expected argument " "1"" of type '" "wxWindow *""'");
36853 }
36854 arg1 = reinterpret_cast< wxWindow * >(argp1);
36855 {
36856 PyThreadState* __tstate = wxPyBeginAllowThreads();
36857 result = (bool)(arg1)->PageDown();
36858 wxPyEndAllowThreads(__tstate);
36859 if (PyErr_Occurred()) SWIG_fail;
36860 }
36861 {
36862 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36863 }
36864 return resultobj;
36865 fail:
36866 return NULL;
36867 }
36868
36869
36870 SWIGINTERN PyObject *_wrap_Window_SetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36871 PyObject *resultobj = 0;
36872 wxWindow *arg1 = (wxWindow *) 0 ;
36873 wxString *arg2 = 0 ;
36874 void *argp1 = 0 ;
36875 int res1 = 0 ;
36876 bool temp2 = false ;
36877 PyObject * obj0 = 0 ;
36878 PyObject * obj1 = 0 ;
36879 char * kwnames[] = {
36880 (char *) "self",(char *) "text", NULL
36881 };
36882
36883 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) SWIG_fail;
36884 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36885 if (!SWIG_IsOK(res1)) {
36886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpText" "', expected argument " "1"" of type '" "wxWindow *""'");
36887 }
36888 arg1 = reinterpret_cast< wxWindow * >(argp1);
36889 {
36890 arg2 = wxString_in_helper(obj1);
36891 if (arg2 == NULL) SWIG_fail;
36892 temp2 = true;
36893 }
36894 {
36895 PyThreadState* __tstate = wxPyBeginAllowThreads();
36896 (arg1)->SetHelpText((wxString const &)*arg2);
36897 wxPyEndAllowThreads(__tstate);
36898 if (PyErr_Occurred()) SWIG_fail;
36899 }
36900 resultobj = SWIG_Py_Void();
36901 {
36902 if (temp2)
36903 delete arg2;
36904 }
36905 return resultobj;
36906 fail:
36907 {
36908 if (temp2)
36909 delete arg2;
36910 }
36911 return NULL;
36912 }
36913
36914
36915 SWIGINTERN PyObject *_wrap_Window_SetHelpTextForId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36916 PyObject *resultobj = 0;
36917 wxWindow *arg1 = (wxWindow *) 0 ;
36918 wxString *arg2 = 0 ;
36919 void *argp1 = 0 ;
36920 int res1 = 0 ;
36921 bool temp2 = false ;
36922 PyObject * obj0 = 0 ;
36923 PyObject * obj1 = 0 ;
36924 char * kwnames[] = {
36925 (char *) "self",(char *) "text", NULL
36926 };
36927
36928 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) SWIG_fail;
36929 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36930 if (!SWIG_IsOK(res1)) {
36931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpTextForId" "', expected argument " "1"" of type '" "wxWindow *""'");
36932 }
36933 arg1 = reinterpret_cast< wxWindow * >(argp1);
36934 {
36935 arg2 = wxString_in_helper(obj1);
36936 if (arg2 == NULL) SWIG_fail;
36937 temp2 = true;
36938 }
36939 {
36940 PyThreadState* __tstate = wxPyBeginAllowThreads();
36941 (arg1)->SetHelpTextForId((wxString const &)*arg2);
36942 wxPyEndAllowThreads(__tstate);
36943 if (PyErr_Occurred()) SWIG_fail;
36944 }
36945 resultobj = SWIG_Py_Void();
36946 {
36947 if (temp2)
36948 delete arg2;
36949 }
36950 return resultobj;
36951 fail:
36952 {
36953 if (temp2)
36954 delete arg2;
36955 }
36956 return NULL;
36957 }
36958
36959
36960 SWIGINTERN PyObject *_wrap_Window_GetHelpTextAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36961 PyObject *resultobj = 0;
36962 wxWindow *arg1 = (wxWindow *) 0 ;
36963 wxPoint *arg2 = 0 ;
36964 wxHelpEvent::Origin arg3 ;
36965 wxString result;
36966 void *argp1 = 0 ;
36967 int res1 = 0 ;
36968 wxPoint temp2 ;
36969 void *argp3 ;
36970 int res3 = 0 ;
36971 PyObject * obj0 = 0 ;
36972 PyObject * obj1 = 0 ;
36973 PyObject * obj2 = 0 ;
36974 char * kwnames[] = {
36975 (char *) "self",(char *) "pt",(char *) "origin", NULL
36976 };
36977
36978 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_GetHelpTextAtPoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36979 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36980 if (!SWIG_IsOK(res1)) {
36981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
36982 }
36983 arg1 = reinterpret_cast< wxWindow * >(argp1);
36984 {
36985 arg2 = &temp2;
36986 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
36987 }
36988 {
36989 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxHelpEvent__Origin, 0 | 0);
36990 if (!SWIG_IsOK(res3)) {
36991 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
36992 }
36993 if (!argp3) {
36994 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
36995 } else {
36996 wxHelpEvent::Origin * temp = reinterpret_cast< wxHelpEvent::Origin * >(argp3);
36997 arg3 = *temp;
36998 if (SWIG_IsNewObj(res3)) delete temp;
36999 }
37000 }
37001 {
37002 PyThreadState* __tstate = wxPyBeginAllowThreads();
37003 result = ((wxWindow const *)arg1)->GetHelpTextAtPoint((wxPoint const &)*arg2,arg3);
37004 wxPyEndAllowThreads(__tstate);
37005 if (PyErr_Occurred()) SWIG_fail;
37006 }
37007 {
37008 #if wxUSE_UNICODE
37009 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37010 #else
37011 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37012 #endif
37013 }
37014 return resultobj;
37015 fail:
37016 return NULL;
37017 }
37018
37019
37020 SWIGINTERN PyObject *_wrap_Window_GetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37021 PyObject *resultobj = 0;
37022 wxWindow *arg1 = (wxWindow *) 0 ;
37023 wxString result;
37024 void *argp1 = 0 ;
37025 int res1 = 0 ;
37026 PyObject *swig_obj[1] ;
37027
37028 if (!args) SWIG_fail;
37029 swig_obj[0] = args;
37030 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37031 if (!SWIG_IsOK(res1)) {
37032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpText" "', expected argument " "1"" of type '" "wxWindow const *""'");
37033 }
37034 arg1 = reinterpret_cast< wxWindow * >(argp1);
37035 {
37036 PyThreadState* __tstate = wxPyBeginAllowThreads();
37037 result = ((wxWindow const *)arg1)->GetHelpText();
37038 wxPyEndAllowThreads(__tstate);
37039 if (PyErr_Occurred()) SWIG_fail;
37040 }
37041 {
37042 #if wxUSE_UNICODE
37043 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37044 #else
37045 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37046 #endif
37047 }
37048 return resultobj;
37049 fail:
37050 return NULL;
37051 }
37052
37053
37054 SWIGINTERN PyObject *_wrap_Window_SetToolTipString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37055 PyObject *resultobj = 0;
37056 wxWindow *arg1 = (wxWindow *) 0 ;
37057 wxString *arg2 = 0 ;
37058 void *argp1 = 0 ;
37059 int res1 = 0 ;
37060 bool temp2 = false ;
37061 PyObject * obj0 = 0 ;
37062 PyObject * obj1 = 0 ;
37063 char * kwnames[] = {
37064 (char *) "self",(char *) "tip", NULL
37065 };
37066
37067 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) SWIG_fail;
37068 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37069 if (!SWIG_IsOK(res1)) {
37070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTipString" "', expected argument " "1"" of type '" "wxWindow *""'");
37071 }
37072 arg1 = reinterpret_cast< wxWindow * >(argp1);
37073 {
37074 arg2 = wxString_in_helper(obj1);
37075 if (arg2 == NULL) SWIG_fail;
37076 temp2 = true;
37077 }
37078 {
37079 PyThreadState* __tstate = wxPyBeginAllowThreads();
37080 (arg1)->SetToolTip((wxString const &)*arg2);
37081 wxPyEndAllowThreads(__tstate);
37082 if (PyErr_Occurred()) SWIG_fail;
37083 }
37084 resultobj = SWIG_Py_Void();
37085 {
37086 if (temp2)
37087 delete arg2;
37088 }
37089 return resultobj;
37090 fail:
37091 {
37092 if (temp2)
37093 delete arg2;
37094 }
37095 return NULL;
37096 }
37097
37098
37099 SWIGINTERN PyObject *_wrap_Window_SetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37100 PyObject *resultobj = 0;
37101 wxWindow *arg1 = (wxWindow *) 0 ;
37102 wxToolTip *arg2 = (wxToolTip *) 0 ;
37103 void *argp1 = 0 ;
37104 int res1 = 0 ;
37105 int res2 = 0 ;
37106 PyObject * obj0 = 0 ;
37107 PyObject * obj1 = 0 ;
37108 char * kwnames[] = {
37109 (char *) "self",(char *) "tip", NULL
37110 };
37111
37112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) SWIG_fail;
37113 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37114 if (!SWIG_IsOK(res1)) {
37115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTip" "', expected argument " "1"" of type '" "wxWindow *""'");
37116 }
37117 arg1 = reinterpret_cast< wxWindow * >(argp1);
37118 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
37119 if (!SWIG_IsOK(res2)) {
37120 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetToolTip" "', expected argument " "2"" of type '" "wxToolTip *""'");
37121 }
37122 {
37123 PyThreadState* __tstate = wxPyBeginAllowThreads();
37124 (arg1)->SetToolTip(arg2);
37125 wxPyEndAllowThreads(__tstate);
37126 if (PyErr_Occurred()) SWIG_fail;
37127 }
37128 resultobj = SWIG_Py_Void();
37129 return resultobj;
37130 fail:
37131 return NULL;
37132 }
37133
37134
37135 SWIGINTERN PyObject *_wrap_Window_GetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37136 PyObject *resultobj = 0;
37137 wxWindow *arg1 = (wxWindow *) 0 ;
37138 wxToolTip *result = 0 ;
37139 void *argp1 = 0 ;
37140 int res1 = 0 ;
37141 PyObject *swig_obj[1] ;
37142
37143 if (!args) SWIG_fail;
37144 swig_obj[0] = args;
37145 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37146 if (!SWIG_IsOK(res1)) {
37147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetToolTip" "', expected argument " "1"" of type '" "wxWindow const *""'");
37148 }
37149 arg1 = reinterpret_cast< wxWindow * >(argp1);
37150 {
37151 PyThreadState* __tstate = wxPyBeginAllowThreads();
37152 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
37153 wxPyEndAllowThreads(__tstate);
37154 if (PyErr_Occurred()) SWIG_fail;
37155 }
37156 {
37157 resultobj = wxPyMake_wxObject(result, (bool)0);
37158 }
37159 return resultobj;
37160 fail:
37161 return NULL;
37162 }
37163
37164
37165 SWIGINTERN PyObject *_wrap_Window_SetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37166 PyObject *resultobj = 0;
37167 wxWindow *arg1 = (wxWindow *) 0 ;
37168 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
37169 void *argp1 = 0 ;
37170 int res1 = 0 ;
37171 int res2 = 0 ;
37172 PyObject * obj0 = 0 ;
37173 PyObject * obj1 = 0 ;
37174 char * kwnames[] = {
37175 (char *) "self",(char *) "dropTarget", NULL
37176 };
37177
37178 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) SWIG_fail;
37179 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37180 if (!SWIG_IsOK(res1)) {
37181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDropTarget" "', expected argument " "1"" of type '" "wxWindow *""'");
37182 }
37183 arg1 = reinterpret_cast< wxWindow * >(argp1);
37184 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
37185 if (!SWIG_IsOK(res2)) {
37186 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDropTarget" "', expected argument " "2"" of type '" "wxPyDropTarget *""'");
37187 }
37188 {
37189 PyThreadState* __tstate = wxPyBeginAllowThreads();
37190 (arg1)->SetDropTarget(arg2);
37191 wxPyEndAllowThreads(__tstate);
37192 if (PyErr_Occurred()) SWIG_fail;
37193 }
37194 resultobj = SWIG_Py_Void();
37195 return resultobj;
37196 fail:
37197 return NULL;
37198 }
37199
37200
37201 SWIGINTERN PyObject *_wrap_Window_GetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37202 PyObject *resultobj = 0;
37203 wxWindow *arg1 = (wxWindow *) 0 ;
37204 wxPyDropTarget *result = 0 ;
37205 void *argp1 = 0 ;
37206 int res1 = 0 ;
37207 PyObject *swig_obj[1] ;
37208
37209 if (!args) SWIG_fail;
37210 swig_obj[0] = args;
37211 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37212 if (!SWIG_IsOK(res1)) {
37213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDropTarget" "', expected argument " "1"" of type '" "wxWindow const *""'");
37214 }
37215 arg1 = reinterpret_cast< wxWindow * >(argp1);
37216 {
37217 PyThreadState* __tstate = wxPyBeginAllowThreads();
37218 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
37219 wxPyEndAllowThreads(__tstate);
37220 if (PyErr_Occurred()) SWIG_fail;
37221 }
37222 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
37223 return resultobj;
37224 fail:
37225 return NULL;
37226 }
37227
37228
37229 SWIGINTERN PyObject *_wrap_Window_DragAcceptFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37230 PyObject *resultobj = 0;
37231 wxWindow *arg1 = (wxWindow *) 0 ;
37232 bool arg2 ;
37233 void *argp1 = 0 ;
37234 int res1 = 0 ;
37235 bool val2 ;
37236 int ecode2 = 0 ;
37237 PyObject * obj0 = 0 ;
37238 PyObject * obj1 = 0 ;
37239 char * kwnames[] = {
37240 (char *) "self",(char *) "accept", NULL
37241 };
37242
37243 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) SWIG_fail;
37244 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37245 if (!SWIG_IsOK(res1)) {
37246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DragAcceptFiles" "', expected argument " "1"" of type '" "wxWindow *""'");
37247 }
37248 arg1 = reinterpret_cast< wxWindow * >(argp1);
37249 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37250 if (!SWIG_IsOK(ecode2)) {
37251 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_DragAcceptFiles" "', expected argument " "2"" of type '" "bool""'");
37252 }
37253 arg2 = static_cast< bool >(val2);
37254 {
37255 PyThreadState* __tstate = wxPyBeginAllowThreads();
37256 wxWindow_DragAcceptFiles(arg1,arg2);
37257 wxPyEndAllowThreads(__tstate);
37258 if (PyErr_Occurred()) SWIG_fail;
37259 }
37260 resultobj = SWIG_Py_Void();
37261 return resultobj;
37262 fail:
37263 return NULL;
37264 }
37265
37266
37267 SWIGINTERN PyObject *_wrap_Window_SetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37268 PyObject *resultobj = 0;
37269 wxWindow *arg1 = (wxWindow *) 0 ;
37270 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
37271 void *argp1 = 0 ;
37272 int res1 = 0 ;
37273 int res2 = 0 ;
37274 PyObject * obj0 = 0 ;
37275 PyObject * obj1 = 0 ;
37276 char * kwnames[] = {
37277 (char *) "self",(char *) "constraints", NULL
37278 };
37279
37280 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
37281 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37282 if (!SWIG_IsOK(res1)) {
37283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetConstraints" "', expected argument " "1"" of type '" "wxWindow *""'");
37284 }
37285 arg1 = reinterpret_cast< wxWindow * >(argp1);
37286 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
37287 if (!SWIG_IsOK(res2)) {
37288 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetConstraints" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
37289 }
37290 {
37291 PyThreadState* __tstate = wxPyBeginAllowThreads();
37292 (arg1)->SetConstraints(arg2);
37293 wxPyEndAllowThreads(__tstate);
37294 if (PyErr_Occurred()) SWIG_fail;
37295 }
37296 resultobj = SWIG_Py_Void();
37297 return resultobj;
37298 fail:
37299 return NULL;
37300 }
37301
37302
37303 SWIGINTERN PyObject *_wrap_Window_GetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37304 PyObject *resultobj = 0;
37305 wxWindow *arg1 = (wxWindow *) 0 ;
37306 wxLayoutConstraints *result = 0 ;
37307 void *argp1 = 0 ;
37308 int res1 = 0 ;
37309 PyObject *swig_obj[1] ;
37310
37311 if (!args) SWIG_fail;
37312 swig_obj[0] = args;
37313 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37314 if (!SWIG_IsOK(res1)) {
37315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetConstraints" "', expected argument " "1"" of type '" "wxWindow const *""'");
37316 }
37317 arg1 = reinterpret_cast< wxWindow * >(argp1);
37318 {
37319 PyThreadState* __tstate = wxPyBeginAllowThreads();
37320 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
37321 wxPyEndAllowThreads(__tstate);
37322 if (PyErr_Occurred()) SWIG_fail;
37323 }
37324 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
37325 return resultobj;
37326 fail:
37327 return NULL;
37328 }
37329
37330
37331 SWIGINTERN PyObject *_wrap_Window_SetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37332 PyObject *resultobj = 0;
37333 wxWindow *arg1 = (wxWindow *) 0 ;
37334 bool arg2 ;
37335 void *argp1 = 0 ;
37336 int res1 = 0 ;
37337 bool val2 ;
37338 int ecode2 = 0 ;
37339 PyObject * obj0 = 0 ;
37340 PyObject * obj1 = 0 ;
37341 char * kwnames[] = {
37342 (char *) "self",(char *) "autoLayout", NULL
37343 };
37344
37345 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) SWIG_fail;
37346 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37347 if (!SWIG_IsOK(res1)) {
37348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAutoLayout" "', expected argument " "1"" of type '" "wxWindow *""'");
37349 }
37350 arg1 = reinterpret_cast< wxWindow * >(argp1);
37351 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37352 if (!SWIG_IsOK(ecode2)) {
37353 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetAutoLayout" "', expected argument " "2"" of type '" "bool""'");
37354 }
37355 arg2 = static_cast< bool >(val2);
37356 {
37357 PyThreadState* __tstate = wxPyBeginAllowThreads();
37358 (arg1)->SetAutoLayout(arg2);
37359 wxPyEndAllowThreads(__tstate);
37360 if (PyErr_Occurred()) SWIG_fail;
37361 }
37362 resultobj = SWIG_Py_Void();
37363 return resultobj;
37364 fail:
37365 return NULL;
37366 }
37367
37368
37369 SWIGINTERN PyObject *_wrap_Window_GetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37370 PyObject *resultobj = 0;
37371 wxWindow *arg1 = (wxWindow *) 0 ;
37372 bool result;
37373 void *argp1 = 0 ;
37374 int res1 = 0 ;
37375 PyObject *swig_obj[1] ;
37376
37377 if (!args) SWIG_fail;
37378 swig_obj[0] = args;
37379 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37380 if (!SWIG_IsOK(res1)) {
37381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAutoLayout" "', expected argument " "1"" of type '" "wxWindow const *""'");
37382 }
37383 arg1 = reinterpret_cast< wxWindow * >(argp1);
37384 {
37385 PyThreadState* __tstate = wxPyBeginAllowThreads();
37386 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
37387 wxPyEndAllowThreads(__tstate);
37388 if (PyErr_Occurred()) SWIG_fail;
37389 }
37390 {
37391 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37392 }
37393 return resultobj;
37394 fail:
37395 return NULL;
37396 }
37397
37398
37399 SWIGINTERN PyObject *_wrap_Window_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37400 PyObject *resultobj = 0;
37401 wxWindow *arg1 = (wxWindow *) 0 ;
37402 bool result;
37403 void *argp1 = 0 ;
37404 int res1 = 0 ;
37405 PyObject *swig_obj[1] ;
37406
37407 if (!args) SWIG_fail;
37408 swig_obj[0] = args;
37409 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37410 if (!SWIG_IsOK(res1)) {
37411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Layout" "', expected argument " "1"" of type '" "wxWindow *""'");
37412 }
37413 arg1 = reinterpret_cast< wxWindow * >(argp1);
37414 {
37415 PyThreadState* __tstate = wxPyBeginAllowThreads();
37416 result = (bool)(arg1)->Layout();
37417 wxPyEndAllowThreads(__tstate);
37418 if (PyErr_Occurred()) SWIG_fail;
37419 }
37420 {
37421 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37422 }
37423 return resultobj;
37424 fail:
37425 return NULL;
37426 }
37427
37428
37429 SWIGINTERN PyObject *_wrap_Window_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37430 PyObject *resultobj = 0;
37431 wxWindow *arg1 = (wxWindow *) 0 ;
37432 wxSizer *arg2 = (wxSizer *) 0 ;
37433 bool arg3 = (bool) true ;
37434 void *argp1 = 0 ;
37435 int res1 = 0 ;
37436 int res2 = 0 ;
37437 bool val3 ;
37438 int ecode3 = 0 ;
37439 PyObject * obj0 = 0 ;
37440 PyObject * obj1 = 0 ;
37441 PyObject * obj2 = 0 ;
37442 char * kwnames[] = {
37443 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
37444 };
37445
37446 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37447 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37448 if (!SWIG_IsOK(res1)) {
37449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
37450 }
37451 arg1 = reinterpret_cast< wxWindow * >(argp1);
37452 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
37453 if (!SWIG_IsOK(res2)) {
37454 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
37455 }
37456 if (obj2) {
37457 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37458 if (!SWIG_IsOK(ecode3)) {
37459 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizer" "', expected argument " "3"" of type '" "bool""'");
37460 }
37461 arg3 = static_cast< bool >(val3);
37462 }
37463 {
37464 PyThreadState* __tstate = wxPyBeginAllowThreads();
37465 (arg1)->SetSizer(arg2,arg3);
37466 wxPyEndAllowThreads(__tstate);
37467 if (PyErr_Occurred()) SWIG_fail;
37468 }
37469 resultobj = SWIG_Py_Void();
37470 return resultobj;
37471 fail:
37472 return NULL;
37473 }
37474
37475
37476 SWIGINTERN PyObject *_wrap_Window_SetSizerAndFit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37477 PyObject *resultobj = 0;
37478 wxWindow *arg1 = (wxWindow *) 0 ;
37479 wxSizer *arg2 = (wxSizer *) 0 ;
37480 bool arg3 = (bool) true ;
37481 void *argp1 = 0 ;
37482 int res1 = 0 ;
37483 int res2 = 0 ;
37484 bool val3 ;
37485 int ecode3 = 0 ;
37486 PyObject * obj0 = 0 ;
37487 PyObject * obj1 = 0 ;
37488 PyObject * obj2 = 0 ;
37489 char * kwnames[] = {
37490 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
37491 };
37492
37493 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37494 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37495 if (!SWIG_IsOK(res1)) {
37496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizerAndFit" "', expected argument " "1"" of type '" "wxWindow *""'");
37497 }
37498 arg1 = reinterpret_cast< wxWindow * >(argp1);
37499 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
37500 if (!SWIG_IsOK(res2)) {
37501 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizerAndFit" "', expected argument " "2"" of type '" "wxSizer *""'");
37502 }
37503 if (obj2) {
37504 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37505 if (!SWIG_IsOK(ecode3)) {
37506 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizerAndFit" "', expected argument " "3"" of type '" "bool""'");
37507 }
37508 arg3 = static_cast< bool >(val3);
37509 }
37510 {
37511 PyThreadState* __tstate = wxPyBeginAllowThreads();
37512 (arg1)->SetSizerAndFit(arg2,arg3);
37513 wxPyEndAllowThreads(__tstate);
37514 if (PyErr_Occurred()) SWIG_fail;
37515 }
37516 resultobj = SWIG_Py_Void();
37517 return resultobj;
37518 fail:
37519 return NULL;
37520 }
37521
37522
37523 SWIGINTERN PyObject *_wrap_Window_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37524 PyObject *resultobj = 0;
37525 wxWindow *arg1 = (wxWindow *) 0 ;
37526 wxSizer *result = 0 ;
37527 void *argp1 = 0 ;
37528 int res1 = 0 ;
37529 PyObject *swig_obj[1] ;
37530
37531 if (!args) SWIG_fail;
37532 swig_obj[0] = args;
37533 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37534 if (!SWIG_IsOK(res1)) {
37535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
37536 }
37537 arg1 = reinterpret_cast< wxWindow * >(argp1);
37538 {
37539 PyThreadState* __tstate = wxPyBeginAllowThreads();
37540 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
37541 wxPyEndAllowThreads(__tstate);
37542 if (PyErr_Occurred()) SWIG_fail;
37543 }
37544 {
37545 resultobj = wxPyMake_wxObject(result, (bool)0);
37546 }
37547 return resultobj;
37548 fail:
37549 return NULL;
37550 }
37551
37552
37553 SWIGINTERN PyObject *_wrap_Window_SetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37554 PyObject *resultobj = 0;
37555 wxWindow *arg1 = (wxWindow *) 0 ;
37556 wxSizer *arg2 = (wxSizer *) 0 ;
37557 void *argp1 = 0 ;
37558 int res1 = 0 ;
37559 void *argp2 = 0 ;
37560 int res2 = 0 ;
37561 PyObject * obj0 = 0 ;
37562 PyObject * obj1 = 0 ;
37563 char * kwnames[] = {
37564 (char *) "self",(char *) "sizer", NULL
37565 };
37566
37567 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) SWIG_fail;
37568 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37569 if (!SWIG_IsOK(res1)) {
37570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetContainingSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
37571 }
37572 arg1 = reinterpret_cast< wxWindow * >(argp1);
37573 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
37574 if (!SWIG_IsOK(res2)) {
37575 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetContainingSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
37576 }
37577 arg2 = reinterpret_cast< wxSizer * >(argp2);
37578 {
37579 PyThreadState* __tstate = wxPyBeginAllowThreads();
37580 (arg1)->SetContainingSizer(arg2);
37581 wxPyEndAllowThreads(__tstate);
37582 if (PyErr_Occurred()) SWIG_fail;
37583 }
37584 resultobj = SWIG_Py_Void();
37585 return resultobj;
37586 fail:
37587 return NULL;
37588 }
37589
37590
37591 SWIGINTERN PyObject *_wrap_Window_GetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37592 PyObject *resultobj = 0;
37593 wxWindow *arg1 = (wxWindow *) 0 ;
37594 wxSizer *result = 0 ;
37595 void *argp1 = 0 ;
37596 int res1 = 0 ;
37597 PyObject *swig_obj[1] ;
37598
37599 if (!args) SWIG_fail;
37600 swig_obj[0] = args;
37601 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37602 if (!SWIG_IsOK(res1)) {
37603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetContainingSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
37604 }
37605 arg1 = reinterpret_cast< wxWindow * >(argp1);
37606 {
37607 PyThreadState* __tstate = wxPyBeginAllowThreads();
37608 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
37609 wxPyEndAllowThreads(__tstate);
37610 if (PyErr_Occurred()) SWIG_fail;
37611 }
37612 {
37613 resultobj = wxPyMake_wxObject(result, (bool)0);
37614 }
37615 return resultobj;
37616 fail:
37617 return NULL;
37618 }
37619
37620
37621 SWIGINTERN PyObject *_wrap_Window_InheritAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37622 PyObject *resultobj = 0;
37623 wxWindow *arg1 = (wxWindow *) 0 ;
37624 void *argp1 = 0 ;
37625 int res1 = 0 ;
37626 PyObject *swig_obj[1] ;
37627
37628 if (!args) SWIG_fail;
37629 swig_obj[0] = args;
37630 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37631 if (!SWIG_IsOK(res1)) {
37632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritAttributes" "', expected argument " "1"" of type '" "wxWindow *""'");
37633 }
37634 arg1 = reinterpret_cast< wxWindow * >(argp1);
37635 {
37636 PyThreadState* __tstate = wxPyBeginAllowThreads();
37637 (arg1)->InheritAttributes();
37638 wxPyEndAllowThreads(__tstate);
37639 if (PyErr_Occurred()) SWIG_fail;
37640 }
37641 resultobj = SWIG_Py_Void();
37642 return resultobj;
37643 fail:
37644 return NULL;
37645 }
37646
37647
37648 SWIGINTERN PyObject *_wrap_Window_ShouldInheritColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37649 PyObject *resultobj = 0;
37650 wxWindow *arg1 = (wxWindow *) 0 ;
37651 bool result;
37652 void *argp1 = 0 ;
37653 int res1 = 0 ;
37654 PyObject *swig_obj[1] ;
37655
37656 if (!args) SWIG_fail;
37657 swig_obj[0] = args;
37658 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37659 if (!SWIG_IsOK(res1)) {
37660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ShouldInheritColours" "', expected argument " "1"" of type '" "wxWindow const *""'");
37661 }
37662 arg1 = reinterpret_cast< wxWindow * >(argp1);
37663 {
37664 PyThreadState* __tstate = wxPyBeginAllowThreads();
37665 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
37666 wxPyEndAllowThreads(__tstate);
37667 if (PyErr_Occurred()) SWIG_fail;
37668 }
37669 {
37670 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37671 }
37672 return resultobj;
37673 fail:
37674 return NULL;
37675 }
37676
37677
37678 SWIGINTERN PyObject *Window_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37679 PyObject *obj;
37680 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37681 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindow, SWIG_NewClientData(obj));
37682 return SWIG_Py_Void();
37683 }
37684
37685 SWIGINTERN PyObject *Window_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37686 return SWIG_Python_InitShadowInstance(args);
37687 }
37688
37689 SWIGINTERN PyObject *_wrap_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37690 PyObject *resultobj = 0;
37691 long arg1 ;
37692 wxWindow *arg2 = (wxWindow *) NULL ;
37693 wxWindow *result = 0 ;
37694 long val1 ;
37695 int ecode1 = 0 ;
37696 void *argp2 = 0 ;
37697 int res2 = 0 ;
37698 PyObject * obj0 = 0 ;
37699 PyObject * obj1 = 0 ;
37700 char * kwnames[] = {
37701 (char *) "id",(char *) "parent", NULL
37702 };
37703
37704 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
37705 ecode1 = SWIG_AsVal_long(obj0, &val1);
37706 if (!SWIG_IsOK(ecode1)) {
37707 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FindWindowById" "', expected argument " "1"" of type '" "long""'");
37708 }
37709 arg1 = static_cast< long >(val1);
37710 if (obj1) {
37711 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37712 if (!SWIG_IsOK(res2)) {
37713 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowById" "', expected argument " "2"" of type '" "wxWindow const *""'");
37714 }
37715 arg2 = reinterpret_cast< wxWindow * >(argp2);
37716 }
37717 {
37718 if (!wxPyCheckForApp()) SWIG_fail;
37719 PyThreadState* __tstate = wxPyBeginAllowThreads();
37720 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
37721 wxPyEndAllowThreads(__tstate);
37722 if (PyErr_Occurred()) SWIG_fail;
37723 }
37724 {
37725 resultobj = wxPyMake_wxObject(result, 0);
37726 }
37727 return resultobj;
37728 fail:
37729 return NULL;
37730 }
37731
37732
37733 SWIGINTERN PyObject *_wrap_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37734 PyObject *resultobj = 0;
37735 wxString *arg1 = 0 ;
37736 wxWindow *arg2 = (wxWindow *) NULL ;
37737 wxWindow *result = 0 ;
37738 bool temp1 = false ;
37739 void *argp2 = 0 ;
37740 int res2 = 0 ;
37741 PyObject * obj0 = 0 ;
37742 PyObject * obj1 = 0 ;
37743 char * kwnames[] = {
37744 (char *) "name",(char *) "parent", NULL
37745 };
37746
37747 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
37748 {
37749 arg1 = wxString_in_helper(obj0);
37750 if (arg1 == NULL) SWIG_fail;
37751 temp1 = true;
37752 }
37753 if (obj1) {
37754 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37755 if (!SWIG_IsOK(res2)) {
37756 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByName" "', expected argument " "2"" of type '" "wxWindow const *""'");
37757 }
37758 arg2 = reinterpret_cast< wxWindow * >(argp2);
37759 }
37760 {
37761 if (!wxPyCheckForApp()) SWIG_fail;
37762 PyThreadState* __tstate = wxPyBeginAllowThreads();
37763 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
37764 wxPyEndAllowThreads(__tstate);
37765 if (PyErr_Occurred()) SWIG_fail;
37766 }
37767 {
37768 resultobj = wxPyMake_wxObject(result, 0);
37769 }
37770 {
37771 if (temp1)
37772 delete arg1;
37773 }
37774 return resultobj;
37775 fail:
37776 {
37777 if (temp1)
37778 delete arg1;
37779 }
37780 return NULL;
37781 }
37782
37783
37784 SWIGINTERN PyObject *_wrap_FindWindowByLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37785 PyObject *resultobj = 0;
37786 wxString *arg1 = 0 ;
37787 wxWindow *arg2 = (wxWindow *) NULL ;
37788 wxWindow *result = 0 ;
37789 bool temp1 = false ;
37790 void *argp2 = 0 ;
37791 int res2 = 0 ;
37792 PyObject * obj0 = 0 ;
37793 PyObject * obj1 = 0 ;
37794 char * kwnames[] = {
37795 (char *) "label",(char *) "parent", NULL
37796 };
37797
37798 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) SWIG_fail;
37799 {
37800 arg1 = wxString_in_helper(obj0);
37801 if (arg1 == NULL) SWIG_fail;
37802 temp1 = true;
37803 }
37804 if (obj1) {
37805 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37806 if (!SWIG_IsOK(res2)) {
37807 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByLabel" "', expected argument " "2"" of type '" "wxWindow const *""'");
37808 }
37809 arg2 = reinterpret_cast< wxWindow * >(argp2);
37810 }
37811 {
37812 if (!wxPyCheckForApp()) SWIG_fail;
37813 PyThreadState* __tstate = wxPyBeginAllowThreads();
37814 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
37815 wxPyEndAllowThreads(__tstate);
37816 if (PyErr_Occurred()) SWIG_fail;
37817 }
37818 {
37819 resultobj = wxPyMake_wxObject(result, 0);
37820 }
37821 {
37822 if (temp1)
37823 delete arg1;
37824 }
37825 return resultobj;
37826 fail:
37827 {
37828 if (temp1)
37829 delete arg1;
37830 }
37831 return NULL;
37832 }
37833
37834
37835 SWIGINTERN PyObject *_wrap_Window_FromHWND(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37836 PyObject *resultobj = 0;
37837 wxWindow *arg1 = (wxWindow *) 0 ;
37838 unsigned long arg2 ;
37839 wxWindow *result = 0 ;
37840 void *argp1 = 0 ;
37841 int res1 = 0 ;
37842 unsigned long val2 ;
37843 int ecode2 = 0 ;
37844 PyObject * obj0 = 0 ;
37845 PyObject * obj1 = 0 ;
37846 char * kwnames[] = {
37847 (char *) "parent",(char *) "_hWnd", NULL
37848 };
37849
37850 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) SWIG_fail;
37851 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37852 if (!SWIG_IsOK(res1)) {
37853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FromHWND" "', expected argument " "1"" of type '" "wxWindow *""'");
37854 }
37855 arg1 = reinterpret_cast< wxWindow * >(argp1);
37856 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
37857 if (!SWIG_IsOK(ecode2)) {
37858 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FromHWND" "', expected argument " "2"" of type '" "unsigned long""'");
37859 }
37860 arg2 = static_cast< unsigned long >(val2);
37861 {
37862 PyThreadState* __tstate = wxPyBeginAllowThreads();
37863 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
37864 wxPyEndAllowThreads(__tstate);
37865 if (PyErr_Occurred()) SWIG_fail;
37866 }
37867 {
37868 resultobj = wxPyMake_wxObject(result, 0);
37869 }
37870 return resultobj;
37871 fail:
37872 return NULL;
37873 }
37874
37875
37876 SWIGINTERN PyObject *_wrap_GetTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37877 PyObject *resultobj = 0;
37878 PyObject *result = 0 ;
37879
37880 if (!SWIG_Python_UnpackTuple(args,"GetTopLevelWindows",0,0,0)) SWIG_fail;
37881 {
37882 PyThreadState* __tstate = wxPyBeginAllowThreads();
37883 result = (PyObject *)GetTopLevelWindows();
37884 wxPyEndAllowThreads(__tstate);
37885 if (PyErr_Occurred()) SWIG_fail;
37886 }
37887 resultobj = result;
37888 return resultobj;
37889 fail:
37890 return NULL;
37891 }
37892
37893
37894 SWIGINTERN PyObject *_wrap_new_Validator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37895 PyObject *resultobj = 0;
37896 wxValidator *result = 0 ;
37897
37898 if (!SWIG_Python_UnpackTuple(args,"new_Validator",0,0,0)) SWIG_fail;
37899 {
37900 PyThreadState* __tstate = wxPyBeginAllowThreads();
37901 result = (wxValidator *)new wxValidator();
37902 wxPyEndAllowThreads(__tstate);
37903 if (PyErr_Occurred()) SWIG_fail;
37904 }
37905 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxValidator, SWIG_POINTER_NEW | 0 );
37906 return resultobj;
37907 fail:
37908 return NULL;
37909 }
37910
37911
37912 SWIGINTERN PyObject *_wrap_Validator_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37913 PyObject *resultobj = 0;
37914 wxValidator *arg1 = (wxValidator *) 0 ;
37915 wxValidator *result = 0 ;
37916 void *argp1 = 0 ;
37917 int res1 = 0 ;
37918 PyObject *swig_obj[1] ;
37919
37920 if (!args) SWIG_fail;
37921 swig_obj[0] = args;
37922 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37923 if (!SWIG_IsOK(res1)) {
37924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Clone" "', expected argument " "1"" of type '" "wxValidator *""'");
37925 }
37926 arg1 = reinterpret_cast< wxValidator * >(argp1);
37927 {
37928 PyThreadState* __tstate = wxPyBeginAllowThreads();
37929 result = (wxValidator *)(arg1)->Clone();
37930 wxPyEndAllowThreads(__tstate);
37931 if (PyErr_Occurred()) SWIG_fail;
37932 }
37933 {
37934 resultobj = wxPyMake_wxObject(result, 0);
37935 }
37936 return resultobj;
37937 fail:
37938 return NULL;
37939 }
37940
37941
37942 SWIGINTERN PyObject *_wrap_Validator_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37943 PyObject *resultobj = 0;
37944 wxValidator *arg1 = (wxValidator *) 0 ;
37945 wxWindow *arg2 = (wxWindow *) 0 ;
37946 bool result;
37947 void *argp1 = 0 ;
37948 int res1 = 0 ;
37949 void *argp2 = 0 ;
37950 int res2 = 0 ;
37951 PyObject * obj0 = 0 ;
37952 PyObject * obj1 = 0 ;
37953 char * kwnames[] = {
37954 (char *) "self",(char *) "parent", NULL
37955 };
37956
37957 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) SWIG_fail;
37958 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37959 if (!SWIG_IsOK(res1)) {
37960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Validate" "', expected argument " "1"" of type '" "wxValidator *""'");
37961 }
37962 arg1 = reinterpret_cast< wxValidator * >(argp1);
37963 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37964 if (!SWIG_IsOK(res2)) {
37965 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_Validate" "', expected argument " "2"" of type '" "wxWindow *""'");
37966 }
37967 arg2 = reinterpret_cast< wxWindow * >(argp2);
37968 {
37969 PyThreadState* __tstate = wxPyBeginAllowThreads();
37970 result = (bool)(arg1)->Validate(arg2);
37971 wxPyEndAllowThreads(__tstate);
37972 if (PyErr_Occurred()) SWIG_fail;
37973 }
37974 {
37975 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37976 }
37977 return resultobj;
37978 fail:
37979 return NULL;
37980 }
37981
37982
37983 SWIGINTERN PyObject *_wrap_Validator_TransferToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37984 PyObject *resultobj = 0;
37985 wxValidator *arg1 = (wxValidator *) 0 ;
37986 bool result;
37987 void *argp1 = 0 ;
37988 int res1 = 0 ;
37989 PyObject *swig_obj[1] ;
37990
37991 if (!args) SWIG_fail;
37992 swig_obj[0] = args;
37993 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37994 if (!SWIG_IsOK(res1)) {
37995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferToWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
37996 }
37997 arg1 = reinterpret_cast< wxValidator * >(argp1);
37998 {
37999 PyThreadState* __tstate = wxPyBeginAllowThreads();
38000 result = (bool)(arg1)->TransferToWindow();
38001 wxPyEndAllowThreads(__tstate);
38002 if (PyErr_Occurred()) SWIG_fail;
38003 }
38004 {
38005 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38006 }
38007 return resultobj;
38008 fail:
38009 return NULL;
38010 }
38011
38012
38013 SWIGINTERN PyObject *_wrap_Validator_TransferFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38014 PyObject *resultobj = 0;
38015 wxValidator *arg1 = (wxValidator *) 0 ;
38016 bool result;
38017 void *argp1 = 0 ;
38018 int res1 = 0 ;
38019 PyObject *swig_obj[1] ;
38020
38021 if (!args) SWIG_fail;
38022 swig_obj[0] = args;
38023 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38024 if (!SWIG_IsOK(res1)) {
38025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferFromWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38026 }
38027 arg1 = reinterpret_cast< wxValidator * >(argp1);
38028 {
38029 PyThreadState* __tstate = wxPyBeginAllowThreads();
38030 result = (bool)(arg1)->TransferFromWindow();
38031 wxPyEndAllowThreads(__tstate);
38032 if (PyErr_Occurred()) SWIG_fail;
38033 }
38034 {
38035 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38036 }
38037 return resultobj;
38038 fail:
38039 return NULL;
38040 }
38041
38042
38043 SWIGINTERN PyObject *_wrap_Validator_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38044 PyObject *resultobj = 0;
38045 wxValidator *arg1 = (wxValidator *) 0 ;
38046 wxWindow *result = 0 ;
38047 void *argp1 = 0 ;
38048 int res1 = 0 ;
38049 PyObject *swig_obj[1] ;
38050
38051 if (!args) SWIG_fail;
38052 swig_obj[0] = args;
38053 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38054 if (!SWIG_IsOK(res1)) {
38055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_GetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38056 }
38057 arg1 = reinterpret_cast< wxValidator * >(argp1);
38058 {
38059 PyThreadState* __tstate = wxPyBeginAllowThreads();
38060 result = (wxWindow *)(arg1)->GetWindow();
38061 wxPyEndAllowThreads(__tstate);
38062 if (PyErr_Occurred()) SWIG_fail;
38063 }
38064 {
38065 resultobj = wxPyMake_wxObject(result, 0);
38066 }
38067 return resultobj;
38068 fail:
38069 return NULL;
38070 }
38071
38072
38073 SWIGINTERN PyObject *_wrap_Validator_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38074 PyObject *resultobj = 0;
38075 wxValidator *arg1 = (wxValidator *) 0 ;
38076 wxWindow *arg2 = (wxWindow *) 0 ;
38077 void *argp1 = 0 ;
38078 int res1 = 0 ;
38079 void *argp2 = 0 ;
38080 int res2 = 0 ;
38081 PyObject * obj0 = 0 ;
38082 PyObject * obj1 = 0 ;
38083 char * kwnames[] = {
38084 (char *) "self",(char *) "window", NULL
38085 };
38086
38087 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
38088 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38089 if (!SWIG_IsOK(res1)) {
38090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_SetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38091 }
38092 arg1 = reinterpret_cast< wxValidator * >(argp1);
38093 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38094 if (!SWIG_IsOK(res2)) {
38095 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
38096 }
38097 arg2 = reinterpret_cast< wxWindow * >(argp2);
38098 {
38099 PyThreadState* __tstate = wxPyBeginAllowThreads();
38100 (arg1)->SetWindow(arg2);
38101 wxPyEndAllowThreads(__tstate);
38102 if (PyErr_Occurred()) SWIG_fail;
38103 }
38104 resultobj = SWIG_Py_Void();
38105 return resultobj;
38106 fail:
38107 return NULL;
38108 }
38109
38110
38111 SWIGINTERN PyObject *_wrap_Validator_IsSilent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38112 PyObject *resultobj = 0;
38113 bool result;
38114
38115 if (!SWIG_Python_UnpackTuple(args,"Validator_IsSilent",0,0,0)) SWIG_fail;
38116 {
38117 PyThreadState* __tstate = wxPyBeginAllowThreads();
38118 result = (bool)wxValidator::IsSilent();
38119 wxPyEndAllowThreads(__tstate);
38120 if (PyErr_Occurred()) SWIG_fail;
38121 }
38122 {
38123 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38124 }
38125 return resultobj;
38126 fail:
38127 return NULL;
38128 }
38129
38130
38131 SWIGINTERN PyObject *_wrap_Validator_SetBellOnError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38132 PyObject *resultobj = 0;
38133 int arg1 = (int) true ;
38134 int val1 ;
38135 int ecode1 = 0 ;
38136 PyObject * obj0 = 0 ;
38137 char * kwnames[] = {
38138 (char *) "doIt", NULL
38139 };
38140
38141 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) SWIG_fail;
38142 if (obj0) {
38143 ecode1 = SWIG_AsVal_int(obj0, &val1);
38144 if (!SWIG_IsOK(ecode1)) {
38145 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Validator_SetBellOnError" "', expected argument " "1"" of type '" "int""'");
38146 }
38147 arg1 = static_cast< int >(val1);
38148 }
38149 {
38150 PyThreadState* __tstate = wxPyBeginAllowThreads();
38151 wxValidator::SetBellOnError(arg1);
38152 wxPyEndAllowThreads(__tstate);
38153 if (PyErr_Occurred()) SWIG_fail;
38154 }
38155 resultobj = SWIG_Py_Void();
38156 return resultobj;
38157 fail:
38158 return NULL;
38159 }
38160
38161
38162 SWIGINTERN PyObject *Validator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38163 PyObject *obj;
38164 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
38165 SWIG_TypeNewClientData(SWIGTYPE_p_wxValidator, SWIG_NewClientData(obj));
38166 return SWIG_Py_Void();
38167 }
38168
38169 SWIGINTERN PyObject *Validator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38170 return SWIG_Python_InitShadowInstance(args);
38171 }
38172
38173 SWIGINTERN PyObject *_wrap_new_PyValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38174 PyObject *resultobj = 0;
38175 wxPyValidator *result = 0 ;
38176
38177 if (!SWIG_Python_UnpackTuple(args,"new_PyValidator",0,0,0)) SWIG_fail;
38178 {
38179 PyThreadState* __tstate = wxPyBeginAllowThreads();
38180 result = (wxPyValidator *)new wxPyValidator();
38181 wxPyEndAllowThreads(__tstate);
38182 if (PyErr_Occurred()) SWIG_fail;
38183 }
38184 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyValidator, SWIG_POINTER_NEW | 0 );
38185 return resultobj;
38186 fail:
38187 return NULL;
38188 }
38189
38190
38191 SWIGINTERN PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38192 PyObject *resultobj = 0;
38193 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
38194 PyObject *arg2 = (PyObject *) 0 ;
38195 PyObject *arg3 = (PyObject *) 0 ;
38196 int arg4 = (int) true ;
38197 void *argp1 = 0 ;
38198 int res1 = 0 ;
38199 int val4 ;
38200 int ecode4 = 0 ;
38201 PyObject * obj0 = 0 ;
38202 PyObject * obj1 = 0 ;
38203 PyObject * obj2 = 0 ;
38204 PyObject * obj3 = 0 ;
38205 char * kwnames[] = {
38206 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
38207 };
38208
38209 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38210 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyValidator, 0 | 0 );
38211 if (!SWIG_IsOK(res1)) {
38212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyValidator *""'");
38213 }
38214 arg1 = reinterpret_cast< wxPyValidator * >(argp1);
38215 arg2 = obj1;
38216 arg3 = obj2;
38217 if (obj3) {
38218 ecode4 = SWIG_AsVal_int(obj3, &val4);
38219 if (!SWIG_IsOK(ecode4)) {
38220 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
38221 }
38222 arg4 = static_cast< int >(val4);
38223 }
38224 {
38225 PyThreadState* __tstate = wxPyBeginAllowThreads();
38226 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
38227 wxPyEndAllowThreads(__tstate);
38228 if (PyErr_Occurred()) SWIG_fail;
38229 }
38230 resultobj = SWIG_Py_Void();
38231 return resultobj;
38232 fail:
38233 return NULL;
38234 }
38235
38236
38237 SWIGINTERN PyObject *PyValidator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38238 PyObject *obj;
38239 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
38240 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyValidator, SWIG_NewClientData(obj));
38241 return SWIG_Py_Void();
38242 }
38243
38244 SWIGINTERN PyObject *PyValidator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38245 return SWIG_Python_InitShadowInstance(args);
38246 }
38247
38248 SWIGINTERN int DefaultValidator_set(PyObject *) {
38249 SWIG_Error(SWIG_AttributeError,"Variable DefaultValidator is read-only.");
38250 return 1;
38251 }
38252
38253
38254 SWIGINTERN PyObject *DefaultValidator_get(void) {
38255 PyObject *pyobj = 0;
38256
38257 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0 );
38258 return pyobj;
38259 }
38260
38261
38262 SWIGINTERN PyObject *_wrap_new_Menu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38263 PyObject *resultobj = 0;
38264 wxString const &arg1_defvalue = wxPyEmptyString ;
38265 wxString *arg1 = (wxString *) &arg1_defvalue ;
38266 long arg2 = (long) 0 ;
38267 wxMenu *result = 0 ;
38268 bool temp1 = false ;
38269 long val2 ;
38270 int ecode2 = 0 ;
38271 PyObject * obj0 = 0 ;
38272 PyObject * obj1 = 0 ;
38273 char * kwnames[] = {
38274 (char *) "title",(char *) "style", NULL
38275 };
38276
38277 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) SWIG_fail;
38278 if (obj0) {
38279 {
38280 arg1 = wxString_in_helper(obj0);
38281 if (arg1 == NULL) SWIG_fail;
38282 temp1 = true;
38283 }
38284 }
38285 if (obj1) {
38286 ecode2 = SWIG_AsVal_long(obj1, &val2);
38287 if (!SWIG_IsOK(ecode2)) {
38288 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Menu" "', expected argument " "2"" of type '" "long""'");
38289 }
38290 arg2 = static_cast< long >(val2);
38291 }
38292 {
38293 if (!wxPyCheckForApp()) SWIG_fail;
38294 PyThreadState* __tstate = wxPyBeginAllowThreads();
38295 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
38296 wxPyEndAllowThreads(__tstate);
38297 if (PyErr_Occurred()) SWIG_fail;
38298 }
38299 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenu, SWIG_POINTER_NEW | 0 );
38300 {
38301 if (temp1)
38302 delete arg1;
38303 }
38304 return resultobj;
38305 fail:
38306 {
38307 if (temp1)
38308 delete arg1;
38309 }
38310 return NULL;
38311 }
38312
38313
38314 SWIGINTERN PyObject *_wrap_Menu_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38315 PyObject *resultobj = 0;
38316 wxMenu *arg1 = (wxMenu *) 0 ;
38317 int arg2 ;
38318 wxString *arg3 = 0 ;
38319 wxString const &arg4_defvalue = wxPyEmptyString ;
38320 wxString *arg4 = (wxString *) &arg4_defvalue ;
38321 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
38322 wxMenuItem *result = 0 ;
38323 void *argp1 = 0 ;
38324 int res1 = 0 ;
38325 int val2 ;
38326 int ecode2 = 0 ;
38327 bool temp3 = false ;
38328 bool temp4 = false ;
38329 int val5 ;
38330 int ecode5 = 0 ;
38331 PyObject * obj0 = 0 ;
38332 PyObject * obj1 = 0 ;
38333 PyObject * obj2 = 0 ;
38334 PyObject * obj3 = 0 ;
38335 PyObject * obj4 = 0 ;
38336 char * kwnames[] = {
38337 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
38338 };
38339
38340 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38341 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38342 if (!SWIG_IsOK(res1)) {
38343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Append" "', expected argument " "1"" of type '" "wxMenu *""'");
38344 }
38345 arg1 = reinterpret_cast< wxMenu * >(argp1);
38346 ecode2 = SWIG_AsVal_int(obj1, &val2);
38347 if (!SWIG_IsOK(ecode2)) {
38348 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Append" "', expected argument " "2"" of type '" "int""'");
38349 }
38350 arg2 = static_cast< int >(val2);
38351 {
38352 arg3 = wxString_in_helper(obj2);
38353 if (arg3 == NULL) SWIG_fail;
38354 temp3 = true;
38355 }
38356 if (obj3) {
38357 {
38358 arg4 = wxString_in_helper(obj3);
38359 if (arg4 == NULL) SWIG_fail;
38360 temp4 = true;
38361 }
38362 }
38363 if (obj4) {
38364 ecode5 = SWIG_AsVal_int(obj4, &val5);
38365 if (!SWIG_IsOK(ecode5)) {
38366 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Append" "', expected argument " "5"" of type '" "wxItemKind""'");
38367 }
38368 arg5 = static_cast< wxItemKind >(val5);
38369 }
38370 {
38371 PyThreadState* __tstate = wxPyBeginAllowThreads();
38372 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
38373 wxPyEndAllowThreads(__tstate);
38374 if (PyErr_Occurred()) SWIG_fail;
38375 }
38376 {
38377 resultobj = wxPyMake_wxObject(result, (bool)0);
38378 }
38379 {
38380 if (temp3)
38381 delete arg3;
38382 }
38383 {
38384 if (temp4)
38385 delete arg4;
38386 }
38387 return resultobj;
38388 fail:
38389 {
38390 if (temp3)
38391 delete arg3;
38392 }
38393 {
38394 if (temp4)
38395 delete arg4;
38396 }
38397 return NULL;
38398 }
38399
38400
38401 SWIGINTERN PyObject *_wrap_Menu_AppendSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38402 PyObject *resultobj = 0;
38403 wxMenu *arg1 = (wxMenu *) 0 ;
38404 wxMenuItem *result = 0 ;
38405 void *argp1 = 0 ;
38406 int res1 = 0 ;
38407 PyObject *swig_obj[1] ;
38408
38409 if (!args) SWIG_fail;
38410 swig_obj[0] = args;
38411 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38412 if (!SWIG_IsOK(res1)) {
38413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
38414 }
38415 arg1 = reinterpret_cast< wxMenu * >(argp1);
38416 {
38417 PyThreadState* __tstate = wxPyBeginAllowThreads();
38418 result = (wxMenuItem *)(arg1)->AppendSeparator();
38419 wxPyEndAllowThreads(__tstate);
38420 if (PyErr_Occurred()) SWIG_fail;
38421 }
38422 {
38423 resultobj = wxPyMake_wxObject(result, (bool)0);
38424 }
38425 return resultobj;
38426 fail:
38427 return NULL;
38428 }
38429
38430
38431 SWIGINTERN PyObject *_wrap_Menu_AppendCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38432 PyObject *resultobj = 0;
38433 wxMenu *arg1 = (wxMenu *) 0 ;
38434 int arg2 ;
38435 wxString *arg3 = 0 ;
38436 wxString const &arg4_defvalue = wxPyEmptyString ;
38437 wxString *arg4 = (wxString *) &arg4_defvalue ;
38438 wxMenuItem *result = 0 ;
38439 void *argp1 = 0 ;
38440 int res1 = 0 ;
38441 int val2 ;
38442 int ecode2 = 0 ;
38443 bool temp3 = false ;
38444 bool temp4 = false ;
38445 PyObject * obj0 = 0 ;
38446 PyObject * obj1 = 0 ;
38447 PyObject * obj2 = 0 ;
38448 PyObject * obj3 = 0 ;
38449 char * kwnames[] = {
38450 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
38451 };
38452
38453 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38454 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38455 if (!SWIG_IsOK(res1)) {
38456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38457 }
38458 arg1 = reinterpret_cast< wxMenu * >(argp1);
38459 ecode2 = SWIG_AsVal_int(obj1, &val2);
38460 if (!SWIG_IsOK(ecode2)) {
38461 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendCheckItem" "', expected argument " "2"" of type '" "int""'");
38462 }
38463 arg2 = static_cast< int >(val2);
38464 {
38465 arg3 = wxString_in_helper(obj2);
38466 if (arg3 == NULL) SWIG_fail;
38467 temp3 = true;
38468 }
38469 if (obj3) {
38470 {
38471 arg4 = wxString_in_helper(obj3);
38472 if (arg4 == NULL) SWIG_fail;
38473 temp4 = true;
38474 }
38475 }
38476 {
38477 PyThreadState* __tstate = wxPyBeginAllowThreads();
38478 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38479 wxPyEndAllowThreads(__tstate);
38480 if (PyErr_Occurred()) SWIG_fail;
38481 }
38482 {
38483 resultobj = wxPyMake_wxObject(result, (bool)0);
38484 }
38485 {
38486 if (temp3)
38487 delete arg3;
38488 }
38489 {
38490 if (temp4)
38491 delete arg4;
38492 }
38493 return resultobj;
38494 fail:
38495 {
38496 if (temp3)
38497 delete arg3;
38498 }
38499 {
38500 if (temp4)
38501 delete arg4;
38502 }
38503 return NULL;
38504 }
38505
38506
38507 SWIGINTERN PyObject *_wrap_Menu_AppendRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38508 PyObject *resultobj = 0;
38509 wxMenu *arg1 = (wxMenu *) 0 ;
38510 int arg2 ;
38511 wxString *arg3 = 0 ;
38512 wxString const &arg4_defvalue = wxPyEmptyString ;
38513 wxString *arg4 = (wxString *) &arg4_defvalue ;
38514 wxMenuItem *result = 0 ;
38515 void *argp1 = 0 ;
38516 int res1 = 0 ;
38517 int val2 ;
38518 int ecode2 = 0 ;
38519 bool temp3 = false ;
38520 bool temp4 = false ;
38521 PyObject * obj0 = 0 ;
38522 PyObject * obj1 = 0 ;
38523 PyObject * obj2 = 0 ;
38524 PyObject * obj3 = 0 ;
38525 char * kwnames[] = {
38526 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
38527 };
38528
38529 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38530 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38531 if (!SWIG_IsOK(res1)) {
38532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38533 }
38534 arg1 = reinterpret_cast< wxMenu * >(argp1);
38535 ecode2 = SWIG_AsVal_int(obj1, &val2);
38536 if (!SWIG_IsOK(ecode2)) {
38537 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendRadioItem" "', expected argument " "2"" of type '" "int""'");
38538 }
38539 arg2 = static_cast< int >(val2);
38540 {
38541 arg3 = wxString_in_helper(obj2);
38542 if (arg3 == NULL) SWIG_fail;
38543 temp3 = true;
38544 }
38545 if (obj3) {
38546 {
38547 arg4 = wxString_in_helper(obj3);
38548 if (arg4 == NULL) SWIG_fail;
38549 temp4 = true;
38550 }
38551 }
38552 {
38553 PyThreadState* __tstate = wxPyBeginAllowThreads();
38554 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38555 wxPyEndAllowThreads(__tstate);
38556 if (PyErr_Occurred()) SWIG_fail;
38557 }
38558 {
38559 resultobj = wxPyMake_wxObject(result, (bool)0);
38560 }
38561 {
38562 if (temp3)
38563 delete arg3;
38564 }
38565 {
38566 if (temp4)
38567 delete arg4;
38568 }
38569 return resultobj;
38570 fail:
38571 {
38572 if (temp3)
38573 delete arg3;
38574 }
38575 {
38576 if (temp4)
38577 delete arg4;
38578 }
38579 return NULL;
38580 }
38581
38582
38583 SWIGINTERN PyObject *_wrap_Menu_AppendMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38584 PyObject *resultobj = 0;
38585 wxMenu *arg1 = (wxMenu *) 0 ;
38586 int arg2 ;
38587 wxString *arg3 = 0 ;
38588 wxMenu *arg4 = (wxMenu *) 0 ;
38589 wxString const &arg5_defvalue = wxPyEmptyString ;
38590 wxString *arg5 = (wxString *) &arg5_defvalue ;
38591 wxMenuItem *result = 0 ;
38592 void *argp1 = 0 ;
38593 int res1 = 0 ;
38594 int val2 ;
38595 int ecode2 = 0 ;
38596 bool temp3 = false ;
38597 void *argp4 = 0 ;
38598 int res4 = 0 ;
38599 bool temp5 = false ;
38600 PyObject * obj0 = 0 ;
38601 PyObject * obj1 = 0 ;
38602 PyObject * obj2 = 0 ;
38603 PyObject * obj3 = 0 ;
38604 PyObject * obj4 = 0 ;
38605 char * kwnames[] = {
38606 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
38607 };
38608
38609 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38610 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38611 if (!SWIG_IsOK(res1)) {
38612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
38613 }
38614 arg1 = reinterpret_cast< wxMenu * >(argp1);
38615 ecode2 = SWIG_AsVal_int(obj1, &val2);
38616 if (!SWIG_IsOK(ecode2)) {
38617 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendMenu" "', expected argument " "2"" of type '" "int""'");
38618 }
38619 arg2 = static_cast< int >(val2);
38620 {
38621 arg3 = wxString_in_helper(obj2);
38622 if (arg3 == NULL) SWIG_fail;
38623 temp3 = true;
38624 }
38625 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
38626 if (!SWIG_IsOK(res4)) {
38627 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_AppendMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
38628 }
38629 arg4 = reinterpret_cast< wxMenu * >(argp4);
38630 if (obj4) {
38631 {
38632 arg5 = wxString_in_helper(obj4);
38633 if (arg5 == NULL) SWIG_fail;
38634 temp5 = true;
38635 }
38636 }
38637 {
38638 PyThreadState* __tstate = wxPyBeginAllowThreads();
38639 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
38640 wxPyEndAllowThreads(__tstate);
38641 if (PyErr_Occurred()) SWIG_fail;
38642 }
38643 {
38644 resultobj = wxPyMake_wxObject(result, (bool)0);
38645 }
38646 {
38647 if (temp3)
38648 delete arg3;
38649 }
38650 {
38651 if (temp5)
38652 delete arg5;
38653 }
38654 return resultobj;
38655 fail:
38656 {
38657 if (temp3)
38658 delete arg3;
38659 }
38660 {
38661 if (temp5)
38662 delete arg5;
38663 }
38664 return NULL;
38665 }
38666
38667
38668 SWIGINTERN PyObject *_wrap_Menu_AppendSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38669 PyObject *resultobj = 0;
38670 wxMenu *arg1 = (wxMenu *) 0 ;
38671 wxMenu *arg2 = (wxMenu *) 0 ;
38672 wxString *arg3 = 0 ;
38673 wxString const &arg4_defvalue = wxPyEmptyString ;
38674 wxString *arg4 = (wxString *) &arg4_defvalue ;
38675 wxMenuItem *result = 0 ;
38676 void *argp1 = 0 ;
38677 int res1 = 0 ;
38678 void *argp2 = 0 ;
38679 int res2 = 0 ;
38680 bool temp3 = false ;
38681 bool temp4 = false ;
38682 PyObject * obj0 = 0 ;
38683 PyObject * obj1 = 0 ;
38684 PyObject * obj2 = 0 ;
38685 PyObject * obj3 = 0 ;
38686 char * kwnames[] = {
38687 (char *) "self",(char *) "submenu",(char *) "text",(char *) "help", NULL
38688 };
38689
38690 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendSubMenu",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38691 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38692 if (!SWIG_IsOK(res1)) {
38693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSubMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
38694 }
38695 arg1 = reinterpret_cast< wxMenu * >(argp1);
38696 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
38697 if (!SWIG_IsOK(res2)) {
38698 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
38699 }
38700 arg2 = reinterpret_cast< wxMenu * >(argp2);
38701 {
38702 arg3 = wxString_in_helper(obj2);
38703 if (arg3 == NULL) SWIG_fail;
38704 temp3 = true;
38705 }
38706 if (obj3) {
38707 {
38708 arg4 = wxString_in_helper(obj3);
38709 if (arg4 == NULL) SWIG_fail;
38710 temp4 = true;
38711 }
38712 }
38713 {
38714 PyThreadState* __tstate = wxPyBeginAllowThreads();
38715 result = (wxMenuItem *)(arg1)->AppendSubMenu(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38716 wxPyEndAllowThreads(__tstate);
38717 if (PyErr_Occurred()) SWIG_fail;
38718 }
38719 {
38720 resultobj = wxPyMake_wxObject(result, (bool)0);
38721 }
38722 {
38723 if (temp3)
38724 delete arg3;
38725 }
38726 {
38727 if (temp4)
38728 delete arg4;
38729 }
38730 return resultobj;
38731 fail:
38732 {
38733 if (temp3)
38734 delete arg3;
38735 }
38736 {
38737 if (temp4)
38738 delete arg4;
38739 }
38740 return NULL;
38741 }
38742
38743
38744 SWIGINTERN PyObject *_wrap_Menu_AppendItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38745 PyObject *resultobj = 0;
38746 wxMenu *arg1 = (wxMenu *) 0 ;
38747 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
38748 wxMenuItem *result = 0 ;
38749 void *argp1 = 0 ;
38750 int res1 = 0 ;
38751 int res2 = 0 ;
38752 PyObject * obj0 = 0 ;
38753 PyObject * obj1 = 0 ;
38754 char * kwnames[] = {
38755 (char *) "self",(char *) "item", NULL
38756 };
38757
38758 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) SWIG_fail;
38759 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38760 if (!SWIG_IsOK(res1)) {
38761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38762 }
38763 arg1 = reinterpret_cast< wxMenu * >(argp1);
38764 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38765 if (!SWIG_IsOK(res2)) {
38766 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
38767 }
38768 {
38769 PyThreadState* __tstate = wxPyBeginAllowThreads();
38770 result = (wxMenuItem *)(arg1)->Append(arg2);
38771 wxPyEndAllowThreads(__tstate);
38772 if (PyErr_Occurred()) SWIG_fail;
38773 }
38774 {
38775 resultobj = wxPyMake_wxObject(result, (bool)0);
38776 }
38777 return resultobj;
38778 fail:
38779 return NULL;
38780 }
38781
38782
38783 SWIGINTERN PyObject *_wrap_Menu_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38784 PyObject *resultobj = 0;
38785 wxMenu *arg1 = (wxMenu *) 0 ;
38786 size_t arg2 ;
38787 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
38788 wxMenuItem *result = 0 ;
38789 void *argp1 = 0 ;
38790 int res1 = 0 ;
38791 size_t val2 ;
38792 int ecode2 = 0 ;
38793 int res3 = 0 ;
38794 PyObject * obj0 = 0 ;
38795 PyObject * obj1 = 0 ;
38796 PyObject * obj2 = 0 ;
38797 char * kwnames[] = {
38798 (char *) "self",(char *) "pos",(char *) "item", NULL
38799 };
38800
38801 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38802 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38803 if (!SWIG_IsOK(res1)) {
38804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38805 }
38806 arg1 = reinterpret_cast< wxMenu * >(argp1);
38807 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38808 if (!SWIG_IsOK(ecode2)) {
38809 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
38810 }
38811 arg2 = static_cast< size_t >(val2);
38812 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38813 if (!SWIG_IsOK(res3)) {
38814 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Menu_InsertItem" "', expected argument " "3"" of type '" "wxMenuItem *""'");
38815 }
38816 {
38817 PyThreadState* __tstate = wxPyBeginAllowThreads();
38818 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
38819 wxPyEndAllowThreads(__tstate);
38820 if (PyErr_Occurred()) SWIG_fail;
38821 }
38822 {
38823 resultobj = wxPyMake_wxObject(result, (bool)0);
38824 }
38825 return resultobj;
38826 fail:
38827 return NULL;
38828 }
38829
38830
38831 SWIGINTERN PyObject *_wrap_Menu_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38832 PyObject *resultobj = 0;
38833 wxMenu *arg1 = (wxMenu *) 0 ;
38834 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
38835 wxMenuItem *result = 0 ;
38836 void *argp1 = 0 ;
38837 int res1 = 0 ;
38838 int res2 = 0 ;
38839 PyObject * obj0 = 0 ;
38840 PyObject * obj1 = 0 ;
38841 char * kwnames[] = {
38842 (char *) "self",(char *) "item", NULL
38843 };
38844
38845 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
38846 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38847 if (!SWIG_IsOK(res1)) {
38848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38849 }
38850 arg1 = reinterpret_cast< wxMenu * >(argp1);
38851 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38852 if (!SWIG_IsOK(res2)) {
38853 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_PrependItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
38854 }
38855 {
38856 PyThreadState* __tstate = wxPyBeginAllowThreads();
38857 result = (wxMenuItem *)(arg1)->Prepend(arg2);
38858 wxPyEndAllowThreads(__tstate);
38859 if (PyErr_Occurred()) SWIG_fail;
38860 }
38861 {
38862 resultobj = wxPyMake_wxObject(result, (bool)0);
38863 }
38864 return resultobj;
38865 fail:
38866 return NULL;
38867 }
38868
38869
38870 SWIGINTERN PyObject *_wrap_Menu_Break(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38871 PyObject *resultobj = 0;
38872 wxMenu *arg1 = (wxMenu *) 0 ;
38873 void *argp1 = 0 ;
38874 int res1 = 0 ;
38875 PyObject *swig_obj[1] ;
38876
38877 if (!args) SWIG_fail;
38878 swig_obj[0] = args;
38879 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38880 if (!SWIG_IsOK(res1)) {
38881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Break" "', expected argument " "1"" of type '" "wxMenu *""'");
38882 }
38883 arg1 = reinterpret_cast< wxMenu * >(argp1);
38884 {
38885 PyThreadState* __tstate = wxPyBeginAllowThreads();
38886 (arg1)->Break();
38887 wxPyEndAllowThreads(__tstate);
38888 if (PyErr_Occurred()) SWIG_fail;
38889 }
38890 resultobj = SWIG_Py_Void();
38891 return resultobj;
38892 fail:
38893 return NULL;
38894 }
38895
38896
38897 SWIGINTERN PyObject *_wrap_Menu_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38898 PyObject *resultobj = 0;
38899 wxMenu *arg1 = (wxMenu *) 0 ;
38900 size_t arg2 ;
38901 int arg3 ;
38902 wxString *arg4 = 0 ;
38903 wxString const &arg5_defvalue = wxPyEmptyString ;
38904 wxString *arg5 = (wxString *) &arg5_defvalue ;
38905 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
38906 wxMenuItem *result = 0 ;
38907 void *argp1 = 0 ;
38908 int res1 = 0 ;
38909 size_t val2 ;
38910 int ecode2 = 0 ;
38911 int val3 ;
38912 int ecode3 = 0 ;
38913 bool temp4 = false ;
38914 bool temp5 = false ;
38915 int val6 ;
38916 int ecode6 = 0 ;
38917 PyObject * obj0 = 0 ;
38918 PyObject * obj1 = 0 ;
38919 PyObject * obj2 = 0 ;
38920 PyObject * obj3 = 0 ;
38921 PyObject * obj4 = 0 ;
38922 PyObject * obj5 = 0 ;
38923 char * kwnames[] = {
38924 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
38925 };
38926
38927 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
38928 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38929 if (!SWIG_IsOK(res1)) {
38930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Insert" "', expected argument " "1"" of type '" "wxMenu *""'");
38931 }
38932 arg1 = reinterpret_cast< wxMenu * >(argp1);
38933 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38934 if (!SWIG_IsOK(ecode2)) {
38935 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Insert" "', expected argument " "2"" of type '" "size_t""'");
38936 }
38937 arg2 = static_cast< size_t >(val2);
38938 ecode3 = SWIG_AsVal_int(obj2, &val3);
38939 if (!SWIG_IsOK(ecode3)) {
38940 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Insert" "', expected argument " "3"" of type '" "int""'");
38941 }
38942 arg3 = static_cast< int >(val3);
38943 {
38944 arg4 = wxString_in_helper(obj3);
38945 if (arg4 == NULL) SWIG_fail;
38946 temp4 = true;
38947 }
38948 if (obj4) {
38949 {
38950 arg5 = wxString_in_helper(obj4);
38951 if (arg5 == NULL) SWIG_fail;
38952 temp5 = true;
38953 }
38954 }
38955 if (obj5) {
38956 ecode6 = SWIG_AsVal_int(obj5, &val6);
38957 if (!SWIG_IsOK(ecode6)) {
38958 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Menu_Insert" "', expected argument " "6"" of type '" "wxItemKind""'");
38959 }
38960 arg6 = static_cast< wxItemKind >(val6);
38961 }
38962 {
38963 PyThreadState* __tstate = wxPyBeginAllowThreads();
38964 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6);
38965 wxPyEndAllowThreads(__tstate);
38966 if (PyErr_Occurred()) SWIG_fail;
38967 }
38968 {
38969 resultobj = wxPyMake_wxObject(result, (bool)0);
38970 }
38971 {
38972 if (temp4)
38973 delete arg4;
38974 }
38975 {
38976 if (temp5)
38977 delete arg5;
38978 }
38979 return resultobj;
38980 fail:
38981 {
38982 if (temp4)
38983 delete arg4;
38984 }
38985 {
38986 if (temp5)
38987 delete arg5;
38988 }
38989 return NULL;
38990 }
38991
38992
38993 SWIGINTERN PyObject *_wrap_Menu_InsertSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38994 PyObject *resultobj = 0;
38995 wxMenu *arg1 = (wxMenu *) 0 ;
38996 size_t arg2 ;
38997 wxMenuItem *result = 0 ;
38998 void *argp1 = 0 ;
38999 int res1 = 0 ;
39000 size_t val2 ;
39001 int ecode2 = 0 ;
39002 PyObject * obj0 = 0 ;
39003 PyObject * obj1 = 0 ;
39004 char * kwnames[] = {
39005 (char *) "self",(char *) "pos", NULL
39006 };
39007
39008 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) SWIG_fail;
39009 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39010 if (!SWIG_IsOK(res1)) {
39011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
39012 }
39013 arg1 = reinterpret_cast< wxMenu * >(argp1);
39014 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39015 if (!SWIG_IsOK(ecode2)) {
39016 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertSeparator" "', expected argument " "2"" of type '" "size_t""'");
39017 }
39018 arg2 = static_cast< size_t >(val2);
39019 {
39020 PyThreadState* __tstate = wxPyBeginAllowThreads();
39021 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
39022 wxPyEndAllowThreads(__tstate);
39023 if (PyErr_Occurred()) SWIG_fail;
39024 }
39025 {
39026 resultobj = wxPyMake_wxObject(result, (bool)0);
39027 }
39028 return resultobj;
39029 fail:
39030 return NULL;
39031 }
39032
39033
39034 SWIGINTERN PyObject *_wrap_Menu_InsertCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39035 PyObject *resultobj = 0;
39036 wxMenu *arg1 = (wxMenu *) 0 ;
39037 size_t arg2 ;
39038 int arg3 ;
39039 wxString *arg4 = 0 ;
39040 wxString const &arg5_defvalue = wxPyEmptyString ;
39041 wxString *arg5 = (wxString *) &arg5_defvalue ;
39042 wxMenuItem *result = 0 ;
39043 void *argp1 = 0 ;
39044 int res1 = 0 ;
39045 size_t val2 ;
39046 int ecode2 = 0 ;
39047 int val3 ;
39048 int ecode3 = 0 ;
39049 bool temp4 = false ;
39050 bool temp5 = false ;
39051 PyObject * obj0 = 0 ;
39052 PyObject * obj1 = 0 ;
39053 PyObject * obj2 = 0 ;
39054 PyObject * obj3 = 0 ;
39055 PyObject * obj4 = 0 ;
39056 char * kwnames[] = {
39057 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
39058 };
39059
39060 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39061 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39062 if (!SWIG_IsOK(res1)) {
39063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39064 }
39065 arg1 = reinterpret_cast< wxMenu * >(argp1);
39066 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39067 if (!SWIG_IsOK(ecode2)) {
39068 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertCheckItem" "', expected argument " "2"" of type '" "size_t""'");
39069 }
39070 arg2 = static_cast< size_t >(val2);
39071 ecode3 = SWIG_AsVal_int(obj2, &val3);
39072 if (!SWIG_IsOK(ecode3)) {
39073 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertCheckItem" "', expected argument " "3"" of type '" "int""'");
39074 }
39075 arg3 = static_cast< int >(val3);
39076 {
39077 arg4 = wxString_in_helper(obj3);
39078 if (arg4 == NULL) SWIG_fail;
39079 temp4 = true;
39080 }
39081 if (obj4) {
39082 {
39083 arg5 = wxString_in_helper(obj4);
39084 if (arg5 == NULL) SWIG_fail;
39085 temp5 = true;
39086 }
39087 }
39088 {
39089 PyThreadState* __tstate = wxPyBeginAllowThreads();
39090 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
39091 wxPyEndAllowThreads(__tstate);
39092 if (PyErr_Occurred()) SWIG_fail;
39093 }
39094 {
39095 resultobj = wxPyMake_wxObject(result, (bool)0);
39096 }
39097 {
39098 if (temp4)
39099 delete arg4;
39100 }
39101 {
39102 if (temp5)
39103 delete arg5;
39104 }
39105 return resultobj;
39106 fail:
39107 {
39108 if (temp4)
39109 delete arg4;
39110 }
39111 {
39112 if (temp5)
39113 delete arg5;
39114 }
39115 return NULL;
39116 }
39117
39118
39119 SWIGINTERN PyObject *_wrap_Menu_InsertRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39120 PyObject *resultobj = 0;
39121 wxMenu *arg1 = (wxMenu *) 0 ;
39122 size_t arg2 ;
39123 int arg3 ;
39124 wxString *arg4 = 0 ;
39125 wxString const &arg5_defvalue = wxPyEmptyString ;
39126 wxString *arg5 = (wxString *) &arg5_defvalue ;
39127 wxMenuItem *result = 0 ;
39128 void *argp1 = 0 ;
39129 int res1 = 0 ;
39130 size_t val2 ;
39131 int ecode2 = 0 ;
39132 int val3 ;
39133 int ecode3 = 0 ;
39134 bool temp4 = false ;
39135 bool temp5 = false ;
39136 PyObject * obj0 = 0 ;
39137 PyObject * obj1 = 0 ;
39138 PyObject * obj2 = 0 ;
39139 PyObject * obj3 = 0 ;
39140 PyObject * obj4 = 0 ;
39141 char * kwnames[] = {
39142 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
39143 };
39144
39145 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39146 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39147 if (!SWIG_IsOK(res1)) {
39148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39149 }
39150 arg1 = reinterpret_cast< wxMenu * >(argp1);
39151 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39152 if (!SWIG_IsOK(ecode2)) {
39153 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertRadioItem" "', expected argument " "2"" of type '" "size_t""'");
39154 }
39155 arg2 = static_cast< size_t >(val2);
39156 ecode3 = SWIG_AsVal_int(obj2, &val3);
39157 if (!SWIG_IsOK(ecode3)) {
39158 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertRadioItem" "', expected argument " "3"" of type '" "int""'");
39159 }
39160 arg3 = static_cast< int >(val3);
39161 {
39162 arg4 = wxString_in_helper(obj3);
39163 if (arg4 == NULL) SWIG_fail;
39164 temp4 = true;
39165 }
39166 if (obj4) {
39167 {
39168 arg5 = wxString_in_helper(obj4);
39169 if (arg5 == NULL) SWIG_fail;
39170 temp5 = true;
39171 }
39172 }
39173 {
39174 PyThreadState* __tstate = wxPyBeginAllowThreads();
39175 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
39176 wxPyEndAllowThreads(__tstate);
39177 if (PyErr_Occurred()) SWIG_fail;
39178 }
39179 {
39180 resultobj = wxPyMake_wxObject(result, (bool)0);
39181 }
39182 {
39183 if (temp4)
39184 delete arg4;
39185 }
39186 {
39187 if (temp5)
39188 delete arg5;
39189 }
39190 return resultobj;
39191 fail:
39192 {
39193 if (temp4)
39194 delete arg4;
39195 }
39196 {
39197 if (temp5)
39198 delete arg5;
39199 }
39200 return NULL;
39201 }
39202
39203
39204 SWIGINTERN PyObject *_wrap_Menu_InsertMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39205 PyObject *resultobj = 0;
39206 wxMenu *arg1 = (wxMenu *) 0 ;
39207 size_t arg2 ;
39208 int arg3 ;
39209 wxString *arg4 = 0 ;
39210 wxMenu *arg5 = (wxMenu *) 0 ;
39211 wxString const &arg6_defvalue = wxPyEmptyString ;
39212 wxString *arg6 = (wxString *) &arg6_defvalue ;
39213 wxMenuItem *result = 0 ;
39214 void *argp1 = 0 ;
39215 int res1 = 0 ;
39216 size_t val2 ;
39217 int ecode2 = 0 ;
39218 int val3 ;
39219 int ecode3 = 0 ;
39220 bool temp4 = false ;
39221 void *argp5 = 0 ;
39222 int res5 = 0 ;
39223 bool temp6 = false ;
39224 PyObject * obj0 = 0 ;
39225 PyObject * obj1 = 0 ;
39226 PyObject * obj2 = 0 ;
39227 PyObject * obj3 = 0 ;
39228 PyObject * obj4 = 0 ;
39229 PyObject * obj5 = 0 ;
39230 char * kwnames[] = {
39231 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39232 };
39233
39234 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
39235 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39236 if (!SWIG_IsOK(res1)) {
39237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39238 }
39239 arg1 = reinterpret_cast< wxMenu * >(argp1);
39240 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39241 if (!SWIG_IsOK(ecode2)) {
39242 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertMenu" "', expected argument " "2"" of type '" "size_t""'");
39243 }
39244 arg2 = static_cast< size_t >(val2);
39245 ecode3 = SWIG_AsVal_int(obj2, &val3);
39246 if (!SWIG_IsOK(ecode3)) {
39247 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertMenu" "', expected argument " "3"" of type '" "int""'");
39248 }
39249 arg3 = static_cast< int >(val3);
39250 {
39251 arg4 = wxString_in_helper(obj3);
39252 if (arg4 == NULL) SWIG_fail;
39253 temp4 = true;
39254 }
39255 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxMenu, 0 | 0 );
39256 if (!SWIG_IsOK(res5)) {
39257 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Menu_InsertMenu" "', expected argument " "5"" of type '" "wxMenu *""'");
39258 }
39259 arg5 = reinterpret_cast< wxMenu * >(argp5);
39260 if (obj5) {
39261 {
39262 arg6 = wxString_in_helper(obj5);
39263 if (arg6 == NULL) SWIG_fail;
39264 temp6 = true;
39265 }
39266 }
39267 {
39268 PyThreadState* __tstate = wxPyBeginAllowThreads();
39269 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
39270 wxPyEndAllowThreads(__tstate);
39271 if (PyErr_Occurred()) SWIG_fail;
39272 }
39273 {
39274 resultobj = wxPyMake_wxObject(result, (bool)0);
39275 }
39276 {
39277 if (temp4)
39278 delete arg4;
39279 }
39280 {
39281 if (temp6)
39282 delete arg6;
39283 }
39284 return resultobj;
39285 fail:
39286 {
39287 if (temp4)
39288 delete arg4;
39289 }
39290 {
39291 if (temp6)
39292 delete arg6;
39293 }
39294 return NULL;
39295 }
39296
39297
39298 SWIGINTERN PyObject *_wrap_Menu_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39299 PyObject *resultobj = 0;
39300 wxMenu *arg1 = (wxMenu *) 0 ;
39301 int arg2 ;
39302 wxString *arg3 = 0 ;
39303 wxString const &arg4_defvalue = wxPyEmptyString ;
39304 wxString *arg4 = (wxString *) &arg4_defvalue ;
39305 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
39306 wxMenuItem *result = 0 ;
39307 void *argp1 = 0 ;
39308 int res1 = 0 ;
39309 int val2 ;
39310 int ecode2 = 0 ;
39311 bool temp3 = false ;
39312 bool temp4 = false ;
39313 int val5 ;
39314 int ecode5 = 0 ;
39315 PyObject * obj0 = 0 ;
39316 PyObject * obj1 = 0 ;
39317 PyObject * obj2 = 0 ;
39318 PyObject * obj3 = 0 ;
39319 PyObject * obj4 = 0 ;
39320 char * kwnames[] = {
39321 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
39322 };
39323
39324 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39325 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39326 if (!SWIG_IsOK(res1)) {
39327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Prepend" "', expected argument " "1"" of type '" "wxMenu *""'");
39328 }
39329 arg1 = reinterpret_cast< wxMenu * >(argp1);
39330 ecode2 = SWIG_AsVal_int(obj1, &val2);
39331 if (!SWIG_IsOK(ecode2)) {
39332 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Prepend" "', expected argument " "2"" of type '" "int""'");
39333 }
39334 arg2 = static_cast< int >(val2);
39335 {
39336 arg3 = wxString_in_helper(obj2);
39337 if (arg3 == NULL) SWIG_fail;
39338 temp3 = true;
39339 }
39340 if (obj3) {
39341 {
39342 arg4 = wxString_in_helper(obj3);
39343 if (arg4 == NULL) SWIG_fail;
39344 temp4 = true;
39345 }
39346 }
39347 if (obj4) {
39348 ecode5 = SWIG_AsVal_int(obj4, &val5);
39349 if (!SWIG_IsOK(ecode5)) {
39350 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Prepend" "', expected argument " "5"" of type '" "wxItemKind""'");
39351 }
39352 arg5 = static_cast< wxItemKind >(val5);
39353 }
39354 {
39355 PyThreadState* __tstate = wxPyBeginAllowThreads();
39356 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
39357 wxPyEndAllowThreads(__tstate);
39358 if (PyErr_Occurred()) SWIG_fail;
39359 }
39360 {
39361 resultobj = wxPyMake_wxObject(result, (bool)0);
39362 }
39363 {
39364 if (temp3)
39365 delete arg3;
39366 }
39367 {
39368 if (temp4)
39369 delete arg4;
39370 }
39371 return resultobj;
39372 fail:
39373 {
39374 if (temp3)
39375 delete arg3;
39376 }
39377 {
39378 if (temp4)
39379 delete arg4;
39380 }
39381 return NULL;
39382 }
39383
39384
39385 SWIGINTERN PyObject *_wrap_Menu_PrependSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39386 PyObject *resultobj = 0;
39387 wxMenu *arg1 = (wxMenu *) 0 ;
39388 wxMenuItem *result = 0 ;
39389 void *argp1 = 0 ;
39390 int res1 = 0 ;
39391 PyObject *swig_obj[1] ;
39392
39393 if (!args) SWIG_fail;
39394 swig_obj[0] = args;
39395 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39396 if (!SWIG_IsOK(res1)) {
39397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
39398 }
39399 arg1 = reinterpret_cast< wxMenu * >(argp1);
39400 {
39401 PyThreadState* __tstate = wxPyBeginAllowThreads();
39402 result = (wxMenuItem *)(arg1)->PrependSeparator();
39403 wxPyEndAllowThreads(__tstate);
39404 if (PyErr_Occurred()) SWIG_fail;
39405 }
39406 {
39407 resultobj = wxPyMake_wxObject(result, (bool)0);
39408 }
39409 return resultobj;
39410 fail:
39411 return NULL;
39412 }
39413
39414
39415 SWIGINTERN PyObject *_wrap_Menu_PrependCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39416 PyObject *resultobj = 0;
39417 wxMenu *arg1 = (wxMenu *) 0 ;
39418 int arg2 ;
39419 wxString *arg3 = 0 ;
39420 wxString const &arg4_defvalue = wxPyEmptyString ;
39421 wxString *arg4 = (wxString *) &arg4_defvalue ;
39422 wxMenuItem *result = 0 ;
39423 void *argp1 = 0 ;
39424 int res1 = 0 ;
39425 int val2 ;
39426 int ecode2 = 0 ;
39427 bool temp3 = false ;
39428 bool temp4 = false ;
39429 PyObject * obj0 = 0 ;
39430 PyObject * obj1 = 0 ;
39431 PyObject * obj2 = 0 ;
39432 PyObject * obj3 = 0 ;
39433 char * kwnames[] = {
39434 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39435 };
39436
39437 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39438 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39439 if (!SWIG_IsOK(res1)) {
39440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39441 }
39442 arg1 = reinterpret_cast< wxMenu * >(argp1);
39443 ecode2 = SWIG_AsVal_int(obj1, &val2);
39444 if (!SWIG_IsOK(ecode2)) {
39445 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependCheckItem" "', expected argument " "2"" of type '" "int""'");
39446 }
39447 arg2 = static_cast< int >(val2);
39448 {
39449 arg3 = wxString_in_helper(obj2);
39450 if (arg3 == NULL) SWIG_fail;
39451 temp3 = true;
39452 }
39453 if (obj3) {
39454 {
39455 arg4 = wxString_in_helper(obj3);
39456 if (arg4 == NULL) SWIG_fail;
39457 temp4 = true;
39458 }
39459 }
39460 {
39461 PyThreadState* __tstate = wxPyBeginAllowThreads();
39462 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39463 wxPyEndAllowThreads(__tstate);
39464 if (PyErr_Occurred()) SWIG_fail;
39465 }
39466 {
39467 resultobj = wxPyMake_wxObject(result, (bool)0);
39468 }
39469 {
39470 if (temp3)
39471 delete arg3;
39472 }
39473 {
39474 if (temp4)
39475 delete arg4;
39476 }
39477 return resultobj;
39478 fail:
39479 {
39480 if (temp3)
39481 delete arg3;
39482 }
39483 {
39484 if (temp4)
39485 delete arg4;
39486 }
39487 return NULL;
39488 }
39489
39490
39491 SWIGINTERN PyObject *_wrap_Menu_PrependRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39492 PyObject *resultobj = 0;
39493 wxMenu *arg1 = (wxMenu *) 0 ;
39494 int arg2 ;
39495 wxString *arg3 = 0 ;
39496 wxString const &arg4_defvalue = wxPyEmptyString ;
39497 wxString *arg4 = (wxString *) &arg4_defvalue ;
39498 wxMenuItem *result = 0 ;
39499 void *argp1 = 0 ;
39500 int res1 = 0 ;
39501 int val2 ;
39502 int ecode2 = 0 ;
39503 bool temp3 = false ;
39504 bool temp4 = false ;
39505 PyObject * obj0 = 0 ;
39506 PyObject * obj1 = 0 ;
39507 PyObject * obj2 = 0 ;
39508 PyObject * obj3 = 0 ;
39509 char * kwnames[] = {
39510 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39511 };
39512
39513 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39514 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39515 if (!SWIG_IsOK(res1)) {
39516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39517 }
39518 arg1 = reinterpret_cast< wxMenu * >(argp1);
39519 ecode2 = SWIG_AsVal_int(obj1, &val2);
39520 if (!SWIG_IsOK(ecode2)) {
39521 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependRadioItem" "', expected argument " "2"" of type '" "int""'");
39522 }
39523 arg2 = static_cast< int >(val2);
39524 {
39525 arg3 = wxString_in_helper(obj2);
39526 if (arg3 == NULL) SWIG_fail;
39527 temp3 = true;
39528 }
39529 if (obj3) {
39530 {
39531 arg4 = wxString_in_helper(obj3);
39532 if (arg4 == NULL) SWIG_fail;
39533 temp4 = true;
39534 }
39535 }
39536 {
39537 PyThreadState* __tstate = wxPyBeginAllowThreads();
39538 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39539 wxPyEndAllowThreads(__tstate);
39540 if (PyErr_Occurred()) SWIG_fail;
39541 }
39542 {
39543 resultobj = wxPyMake_wxObject(result, (bool)0);
39544 }
39545 {
39546 if (temp3)
39547 delete arg3;
39548 }
39549 {
39550 if (temp4)
39551 delete arg4;
39552 }
39553 return resultobj;
39554 fail:
39555 {
39556 if (temp3)
39557 delete arg3;
39558 }
39559 {
39560 if (temp4)
39561 delete arg4;
39562 }
39563 return NULL;
39564 }
39565
39566
39567 SWIGINTERN PyObject *_wrap_Menu_PrependMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39568 PyObject *resultobj = 0;
39569 wxMenu *arg1 = (wxMenu *) 0 ;
39570 int arg2 ;
39571 wxString *arg3 = 0 ;
39572 wxMenu *arg4 = (wxMenu *) 0 ;
39573 wxString const &arg5_defvalue = wxPyEmptyString ;
39574 wxString *arg5 = (wxString *) &arg5_defvalue ;
39575 wxMenuItem *result = 0 ;
39576 void *argp1 = 0 ;
39577 int res1 = 0 ;
39578 int val2 ;
39579 int ecode2 = 0 ;
39580 bool temp3 = false ;
39581 void *argp4 = 0 ;
39582 int res4 = 0 ;
39583 bool temp5 = false ;
39584 PyObject * obj0 = 0 ;
39585 PyObject * obj1 = 0 ;
39586 PyObject * obj2 = 0 ;
39587 PyObject * obj3 = 0 ;
39588 PyObject * obj4 = 0 ;
39589 char * kwnames[] = {
39590 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39591 };
39592
39593 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39594 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39595 if (!SWIG_IsOK(res1)) {
39596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39597 }
39598 arg1 = reinterpret_cast< wxMenu * >(argp1);
39599 ecode2 = SWIG_AsVal_int(obj1, &val2);
39600 if (!SWIG_IsOK(ecode2)) {
39601 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependMenu" "', expected argument " "2"" of type '" "int""'");
39602 }
39603 arg2 = static_cast< int >(val2);
39604 {
39605 arg3 = wxString_in_helper(obj2);
39606 if (arg3 == NULL) SWIG_fail;
39607 temp3 = true;
39608 }
39609 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
39610 if (!SWIG_IsOK(res4)) {
39611 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_PrependMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
39612 }
39613 arg4 = reinterpret_cast< wxMenu * >(argp4);
39614 if (obj4) {
39615 {
39616 arg5 = wxString_in_helper(obj4);
39617 if (arg5 == NULL) SWIG_fail;
39618 temp5 = true;
39619 }
39620 }
39621 {
39622 PyThreadState* __tstate = wxPyBeginAllowThreads();
39623 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
39624 wxPyEndAllowThreads(__tstate);
39625 if (PyErr_Occurred()) SWIG_fail;
39626 }
39627 {
39628 resultobj = wxPyMake_wxObject(result, (bool)0);
39629 }
39630 {
39631 if (temp3)
39632 delete arg3;
39633 }
39634 {
39635 if (temp5)
39636 delete arg5;
39637 }
39638 return resultobj;
39639 fail:
39640 {
39641 if (temp3)
39642 delete arg3;
39643 }
39644 {
39645 if (temp5)
39646 delete arg5;
39647 }
39648 return NULL;
39649 }
39650
39651
39652 SWIGINTERN PyObject *_wrap_Menu_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39653 PyObject *resultobj = 0;
39654 wxMenu *arg1 = (wxMenu *) 0 ;
39655 int arg2 ;
39656 wxMenuItem *result = 0 ;
39657 void *argp1 = 0 ;
39658 int res1 = 0 ;
39659 int val2 ;
39660 int ecode2 = 0 ;
39661 PyObject * obj0 = 0 ;
39662 PyObject * obj1 = 0 ;
39663 char * kwnames[] = {
39664 (char *) "self",(char *) "id", NULL
39665 };
39666
39667 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
39668 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39669 if (!SWIG_IsOK(res1)) {
39670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Remove" "', expected argument " "1"" of type '" "wxMenu *""'");
39671 }
39672 arg1 = reinterpret_cast< wxMenu * >(argp1);
39673 ecode2 = SWIG_AsVal_int(obj1, &val2);
39674 if (!SWIG_IsOK(ecode2)) {
39675 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Remove" "', expected argument " "2"" of type '" "int""'");
39676 }
39677 arg2 = static_cast< int >(val2);
39678 {
39679 PyThreadState* __tstate = wxPyBeginAllowThreads();
39680 result = (wxMenuItem *)(arg1)->Remove(arg2);
39681 wxPyEndAllowThreads(__tstate);
39682 if (PyErr_Occurred()) SWIG_fail;
39683 }
39684 {
39685 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
39686 }
39687 return resultobj;
39688 fail:
39689 return NULL;
39690 }
39691
39692
39693 SWIGINTERN PyObject *_wrap_Menu_RemoveItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39694 PyObject *resultobj = 0;
39695 wxMenu *arg1 = (wxMenu *) 0 ;
39696 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39697 wxMenuItem *result = 0 ;
39698 void *argp1 = 0 ;
39699 int res1 = 0 ;
39700 void *argp2 = 0 ;
39701 int res2 = 0 ;
39702 PyObject * obj0 = 0 ;
39703 PyObject * obj1 = 0 ;
39704 char * kwnames[] = {
39705 (char *) "self",(char *) "item", NULL
39706 };
39707
39708 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",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_RemoveItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39712 }
39713 arg1 = reinterpret_cast< wxMenu * >(argp1);
39714 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39715 if (!SWIG_IsOK(res2)) {
39716 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_RemoveItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39717 }
39718 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
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_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39735 PyObject *resultobj = 0;
39736 wxMenu *arg1 = (wxMenu *) 0 ;
39737 int arg2 ;
39738 bool result;
39739 void *argp1 = 0 ;
39740 int res1 = 0 ;
39741 int val2 ;
39742 int ecode2 = 0 ;
39743 PyObject * obj0 = 0 ;
39744 PyObject * obj1 = 0 ;
39745 char * kwnames[] = {
39746 (char *) "self",(char *) "id", NULL
39747 };
39748
39749 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",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_Delete" "', expected argument " "1"" of type '" "wxMenu *""'");
39753 }
39754 arg1 = reinterpret_cast< wxMenu * >(argp1);
39755 ecode2 = SWIG_AsVal_int(obj1, &val2);
39756 if (!SWIG_IsOK(ecode2)) {
39757 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Delete" "', expected argument " "2"" of type '" "int""'");
39758 }
39759 arg2 = static_cast< int >(val2);
39760 {
39761 PyThreadState* __tstate = wxPyBeginAllowThreads();
39762 result = (bool)(arg1)->Delete(arg2);
39763 wxPyEndAllowThreads(__tstate);
39764 if (PyErr_Occurred()) SWIG_fail;
39765 }
39766 {
39767 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39768 }
39769 return resultobj;
39770 fail:
39771 return NULL;
39772 }
39773
39774
39775 SWIGINTERN PyObject *_wrap_Menu_DeleteItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39776 PyObject *resultobj = 0;
39777 wxMenu *arg1 = (wxMenu *) 0 ;
39778 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39779 bool result;
39780 void *argp1 = 0 ;
39781 int res1 = 0 ;
39782 void *argp2 = 0 ;
39783 int res2 = 0 ;
39784 PyObject * obj0 = 0 ;
39785 PyObject * obj1 = 0 ;
39786 char * kwnames[] = {
39787 (char *) "self",(char *) "item", NULL
39788 };
39789
39790 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",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_DeleteItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39794 }
39795 arg1 = reinterpret_cast< wxMenu * >(argp1);
39796 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39797 if (!SWIG_IsOK(res2)) {
39798 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DeleteItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39799 }
39800 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
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_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39817 PyObject *resultobj = 0;
39818 wxMenu *arg1 = (wxMenu *) 0 ;
39819 void *argp1 = 0 ;
39820 int res1 = 0 ;
39821 PyObject *swig_obj[1] ;
39822
39823 if (!args) SWIG_fail;
39824 swig_obj[0] = args;
39825 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39826 if (!SWIG_IsOK(res1)) {
39827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Destroy" "', expected argument " "1"" of type '" "wxMenu *""'");
39828 }
39829 arg1 = reinterpret_cast< wxMenu * >(argp1);
39830 {
39831 PyThreadState* __tstate = wxPyBeginAllowThreads();
39832 wxMenu_Destroy(arg1);
39833 wxPyEndAllowThreads(__tstate);
39834 if (PyErr_Occurred()) SWIG_fail;
39835 }
39836 resultobj = SWIG_Py_Void();
39837 return resultobj;
39838 fail:
39839 return NULL;
39840 }
39841
39842
39843 SWIGINTERN PyObject *_wrap_Menu_DestroyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39844 PyObject *resultobj = 0;
39845 wxMenu *arg1 = (wxMenu *) 0 ;
39846 int arg2 ;
39847 bool result;
39848 void *argp1 = 0 ;
39849 int res1 = 0 ;
39850 int val2 ;
39851 int ecode2 = 0 ;
39852 PyObject * obj0 = 0 ;
39853 PyObject * obj1 = 0 ;
39854 char * kwnames[] = {
39855 (char *) "self",(char *) "id", NULL
39856 };
39857
39858 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) SWIG_fail;
39859 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39860 if (!SWIG_IsOK(res1)) {
39861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyId" "', expected argument " "1"" of type '" "wxMenu *""'");
39862 }
39863 arg1 = reinterpret_cast< wxMenu * >(argp1);
39864 ecode2 = SWIG_AsVal_int(obj1, &val2);
39865 if (!SWIG_IsOK(ecode2)) {
39866 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_DestroyId" "', expected argument " "2"" of type '" "int""'");
39867 }
39868 arg2 = static_cast< int >(val2);
39869 {
39870 PyThreadState* __tstate = wxPyBeginAllowThreads();
39871 result = (bool)(arg1)->Destroy(arg2);
39872 wxPyEndAllowThreads(__tstate);
39873 if (PyErr_Occurred()) SWIG_fail;
39874 }
39875 {
39876 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39877 }
39878 return resultobj;
39879 fail:
39880 return NULL;
39881 }
39882
39883
39884 SWIGINTERN PyObject *_wrap_Menu_DestroyItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39885 PyObject *resultobj = 0;
39886 wxMenu *arg1 = (wxMenu *) 0 ;
39887 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39888 bool result;
39889 void *argp1 = 0 ;
39890 int res1 = 0 ;
39891 void *argp2 = 0 ;
39892 int res2 = 0 ;
39893 PyObject * obj0 = 0 ;
39894 PyObject * obj1 = 0 ;
39895 char * kwnames[] = {
39896 (char *) "self",(char *) "item", NULL
39897 };
39898
39899 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",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_DestroyItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39903 }
39904 arg1 = reinterpret_cast< wxMenu * >(argp1);
39905 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39906 if (!SWIG_IsOK(res2)) {
39907 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DestroyItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39908 }
39909 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
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_GetMenuItemCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39926 PyObject *resultobj = 0;
39927 wxMenu *arg1 = (wxMenu *) 0 ;
39928 size_t result;
39929 void *argp1 = 0 ;
39930 int res1 = 0 ;
39931 PyObject *swig_obj[1] ;
39932
39933 if (!args) SWIG_fail;
39934 swig_obj[0] = args;
39935 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39936 if (!SWIG_IsOK(res1)) {
39937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItemCount" "', expected argument " "1"" of type '" "wxMenu const *""'");
39938 }
39939 arg1 = reinterpret_cast< wxMenu * >(argp1);
39940 {
39941 PyThreadState* __tstate = wxPyBeginAllowThreads();
39942 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
39943 wxPyEndAllowThreads(__tstate);
39944 if (PyErr_Occurred()) SWIG_fail;
39945 }
39946 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
39947 return resultobj;
39948 fail:
39949 return NULL;
39950 }
39951
39952
39953 SWIGINTERN PyObject *_wrap_Menu_GetMenuItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39954 PyObject *resultobj = 0;
39955 wxMenu *arg1 = (wxMenu *) 0 ;
39956 PyObject *result = 0 ;
39957 void *argp1 = 0 ;
39958 int res1 = 0 ;
39959 PyObject *swig_obj[1] ;
39960
39961 if (!args) SWIG_fail;
39962 swig_obj[0] = args;
39963 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39964 if (!SWIG_IsOK(res1)) {
39965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItems" "', expected argument " "1"" of type '" "wxMenu *""'");
39966 }
39967 arg1 = reinterpret_cast< wxMenu * >(argp1);
39968 {
39969 PyThreadState* __tstate = wxPyBeginAllowThreads();
39970 result = (PyObject *)wxMenu_GetMenuItems(arg1);
39971 wxPyEndAllowThreads(__tstate);
39972 if (PyErr_Occurred()) SWIG_fail;
39973 }
39974 resultobj = result;
39975 return resultobj;
39976 fail:
39977 return NULL;
39978 }
39979
39980
39981 SWIGINTERN PyObject *_wrap_Menu_FindItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39982 PyObject *resultobj = 0;
39983 wxMenu *arg1 = (wxMenu *) 0 ;
39984 wxString *arg2 = 0 ;
39985 int result;
39986 void *argp1 = 0 ;
39987 int res1 = 0 ;
39988 bool temp2 = false ;
39989 PyObject * obj0 = 0 ;
39990 PyObject * obj1 = 0 ;
39991 char * kwnames[] = {
39992 (char *) "self",(char *) "item", NULL
39993 };
39994
39995 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) SWIG_fail;
39996 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39997 if (!SWIG_IsOK(res1)) {
39998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItem" "', expected argument " "1"" of type '" "wxMenu const *""'");
39999 }
40000 arg1 = reinterpret_cast< wxMenu * >(argp1);
40001 {
40002 arg2 = wxString_in_helper(obj1);
40003 if (arg2 == NULL) SWIG_fail;
40004 temp2 = true;
40005 }
40006 {
40007 PyThreadState* __tstate = wxPyBeginAllowThreads();
40008 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
40009 wxPyEndAllowThreads(__tstate);
40010 if (PyErr_Occurred()) SWIG_fail;
40011 }
40012 resultobj = SWIG_From_int(static_cast< int >(result));
40013 {
40014 if (temp2)
40015 delete arg2;
40016 }
40017 return resultobj;
40018 fail:
40019 {
40020 if (temp2)
40021 delete arg2;
40022 }
40023 return NULL;
40024 }
40025
40026
40027 SWIGINTERN PyObject *_wrap_Menu_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40028 PyObject *resultobj = 0;
40029 wxMenu *arg1 = (wxMenu *) 0 ;
40030 int arg2 ;
40031 wxMenuItem *result = 0 ;
40032 void *argp1 = 0 ;
40033 int res1 = 0 ;
40034 int val2 ;
40035 int ecode2 = 0 ;
40036 PyObject * obj0 = 0 ;
40037 PyObject * obj1 = 0 ;
40038 char * kwnames[] = {
40039 (char *) "self",(char *) "id", NULL
40040 };
40041
40042 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
40043 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40044 if (!SWIG_IsOK(res1)) {
40045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemById" "', expected argument " "1"" of type '" "wxMenu const *""'");
40046 }
40047 arg1 = reinterpret_cast< wxMenu * >(argp1);
40048 ecode2 = SWIG_AsVal_int(obj1, &val2);
40049 if (!SWIG_IsOK(ecode2)) {
40050 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemById" "', expected argument " "2"" of type '" "int""'");
40051 }
40052 arg2 = static_cast< int >(val2);
40053 {
40054 PyThreadState* __tstate = wxPyBeginAllowThreads();
40055 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
40056 wxPyEndAllowThreads(__tstate);
40057 if (PyErr_Occurred()) SWIG_fail;
40058 }
40059 {
40060 resultobj = wxPyMake_wxObject(result, (bool)0);
40061 }
40062 return resultobj;
40063 fail:
40064 return NULL;
40065 }
40066
40067
40068 SWIGINTERN PyObject *_wrap_Menu_FindItemByPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40069 PyObject *resultobj = 0;
40070 wxMenu *arg1 = (wxMenu *) 0 ;
40071 size_t arg2 ;
40072 wxMenuItem *result = 0 ;
40073 void *argp1 = 0 ;
40074 int res1 = 0 ;
40075 size_t val2 ;
40076 int ecode2 = 0 ;
40077 PyObject * obj0 = 0 ;
40078 PyObject * obj1 = 0 ;
40079 char * kwnames[] = {
40080 (char *) "self",(char *) "position", NULL
40081 };
40082
40083 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",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_FindItemByPosition" "', expected argument " "1"" of type '" "wxMenu const *""'");
40087 }
40088 arg1 = reinterpret_cast< wxMenu * >(argp1);
40089 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40090 if (!SWIG_IsOK(ecode2)) {
40091 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemByPosition" "', expected argument " "2"" of type '" "size_t""'");
40092 }
40093 arg2 = static_cast< size_t >(val2);
40094 {
40095 PyThreadState* __tstate = wxPyBeginAllowThreads();
40096 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(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_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40110 PyObject *resultobj = 0;
40111 wxMenu *arg1 = (wxMenu *) 0 ;
40112 int arg2 ;
40113 bool arg3 ;
40114 void *argp1 = 0 ;
40115 int res1 = 0 ;
40116 int val2 ;
40117 int ecode2 = 0 ;
40118 bool val3 ;
40119 int ecode3 = 0 ;
40120 PyObject * obj0 = 0 ;
40121 PyObject * obj1 = 0 ;
40122 PyObject * obj2 = 0 ;
40123 char * kwnames[] = {
40124 (char *) "self",(char *) "id",(char *) "enable", NULL
40125 };
40126
40127 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40128 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40129 if (!SWIG_IsOK(res1)) {
40130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Enable" "', expected argument " "1"" of type '" "wxMenu *""'");
40131 }
40132 arg1 = reinterpret_cast< wxMenu * >(argp1);
40133 ecode2 = SWIG_AsVal_int(obj1, &val2);
40134 if (!SWIG_IsOK(ecode2)) {
40135 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Enable" "', expected argument " "2"" of type '" "int""'");
40136 }
40137 arg2 = static_cast< int >(val2);
40138 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40139 if (!SWIG_IsOK(ecode3)) {
40140 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Enable" "', expected argument " "3"" of type '" "bool""'");
40141 }
40142 arg3 = static_cast< bool >(val3);
40143 {
40144 PyThreadState* __tstate = wxPyBeginAllowThreads();
40145 (arg1)->Enable(arg2,arg3);
40146 wxPyEndAllowThreads(__tstate);
40147 if (PyErr_Occurred()) SWIG_fail;
40148 }
40149 resultobj = SWIG_Py_Void();
40150 return resultobj;
40151 fail:
40152 return NULL;
40153 }
40154
40155
40156 SWIGINTERN PyObject *_wrap_Menu_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40157 PyObject *resultobj = 0;
40158 wxMenu *arg1 = (wxMenu *) 0 ;
40159 int arg2 ;
40160 bool result;
40161 void *argp1 = 0 ;
40162 int res1 = 0 ;
40163 int val2 ;
40164 int ecode2 = 0 ;
40165 PyObject * obj0 = 0 ;
40166 PyObject * obj1 = 0 ;
40167 char * kwnames[] = {
40168 (char *) "self",(char *) "id", NULL
40169 };
40170
40171 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
40172 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40173 if (!SWIG_IsOK(res1)) {
40174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsEnabled" "', expected argument " "1"" of type '" "wxMenu const *""'");
40175 }
40176 arg1 = reinterpret_cast< wxMenu * >(argp1);
40177 ecode2 = SWIG_AsVal_int(obj1, &val2);
40178 if (!SWIG_IsOK(ecode2)) {
40179 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsEnabled" "', expected argument " "2"" of type '" "int""'");
40180 }
40181 arg2 = static_cast< int >(val2);
40182 {
40183 PyThreadState* __tstate = wxPyBeginAllowThreads();
40184 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
40185 wxPyEndAllowThreads(__tstate);
40186 if (PyErr_Occurred()) SWIG_fail;
40187 }
40188 {
40189 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40190 }
40191 return resultobj;
40192 fail:
40193 return NULL;
40194 }
40195
40196
40197 SWIGINTERN PyObject *_wrap_Menu_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40198 PyObject *resultobj = 0;
40199 wxMenu *arg1 = (wxMenu *) 0 ;
40200 int arg2 ;
40201 bool arg3 ;
40202 void *argp1 = 0 ;
40203 int res1 = 0 ;
40204 int val2 ;
40205 int ecode2 = 0 ;
40206 bool val3 ;
40207 int ecode3 = 0 ;
40208 PyObject * obj0 = 0 ;
40209 PyObject * obj1 = 0 ;
40210 PyObject * obj2 = 0 ;
40211 char * kwnames[] = {
40212 (char *) "self",(char *) "id",(char *) "check", NULL
40213 };
40214
40215 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40216 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40217 if (!SWIG_IsOK(res1)) {
40218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Check" "', expected argument " "1"" of type '" "wxMenu *""'");
40219 }
40220 arg1 = reinterpret_cast< wxMenu * >(argp1);
40221 ecode2 = SWIG_AsVal_int(obj1, &val2);
40222 if (!SWIG_IsOK(ecode2)) {
40223 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Check" "', expected argument " "2"" of type '" "int""'");
40224 }
40225 arg2 = static_cast< int >(val2);
40226 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40227 if (!SWIG_IsOK(ecode3)) {
40228 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Check" "', expected argument " "3"" of type '" "bool""'");
40229 }
40230 arg3 = static_cast< bool >(val3);
40231 {
40232 PyThreadState* __tstate = wxPyBeginAllowThreads();
40233 (arg1)->Check(arg2,arg3);
40234 wxPyEndAllowThreads(__tstate);
40235 if (PyErr_Occurred()) SWIG_fail;
40236 }
40237 resultobj = SWIG_Py_Void();
40238 return resultobj;
40239 fail:
40240 return NULL;
40241 }
40242
40243
40244 SWIGINTERN PyObject *_wrap_Menu_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40245 PyObject *resultobj = 0;
40246 wxMenu *arg1 = (wxMenu *) 0 ;
40247 int arg2 ;
40248 bool result;
40249 void *argp1 = 0 ;
40250 int res1 = 0 ;
40251 int val2 ;
40252 int ecode2 = 0 ;
40253 PyObject * obj0 = 0 ;
40254 PyObject * obj1 = 0 ;
40255 char * kwnames[] = {
40256 (char *) "self",(char *) "id", NULL
40257 };
40258
40259 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
40260 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40261 if (!SWIG_IsOK(res1)) {
40262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsChecked" "', expected argument " "1"" of type '" "wxMenu const *""'");
40263 }
40264 arg1 = reinterpret_cast< wxMenu * >(argp1);
40265 ecode2 = SWIG_AsVal_int(obj1, &val2);
40266 if (!SWIG_IsOK(ecode2)) {
40267 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsChecked" "', expected argument " "2"" of type '" "int""'");
40268 }
40269 arg2 = static_cast< int >(val2);
40270 {
40271 PyThreadState* __tstate = wxPyBeginAllowThreads();
40272 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
40273 wxPyEndAllowThreads(__tstate);
40274 if (PyErr_Occurred()) SWIG_fail;
40275 }
40276 {
40277 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40278 }
40279 return resultobj;
40280 fail:
40281 return NULL;
40282 }
40283
40284
40285 SWIGINTERN PyObject *_wrap_Menu_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40286 PyObject *resultobj = 0;
40287 wxMenu *arg1 = (wxMenu *) 0 ;
40288 int arg2 ;
40289 wxString *arg3 = 0 ;
40290 void *argp1 = 0 ;
40291 int res1 = 0 ;
40292 int val2 ;
40293 int ecode2 = 0 ;
40294 bool temp3 = false ;
40295 PyObject * obj0 = 0 ;
40296 PyObject * obj1 = 0 ;
40297 PyObject * obj2 = 0 ;
40298 char * kwnames[] = {
40299 (char *) "self",(char *) "id",(char *) "label", NULL
40300 };
40301
40302 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40303 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40304 if (!SWIG_IsOK(res1)) {
40305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetLabel" "', expected argument " "1"" of type '" "wxMenu *""'");
40306 }
40307 arg1 = reinterpret_cast< wxMenu * >(argp1);
40308 ecode2 = SWIG_AsVal_int(obj1, &val2);
40309 if (!SWIG_IsOK(ecode2)) {
40310 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetLabel" "', expected argument " "2"" of type '" "int""'");
40311 }
40312 arg2 = static_cast< int >(val2);
40313 {
40314 arg3 = wxString_in_helper(obj2);
40315 if (arg3 == NULL) SWIG_fail;
40316 temp3 = true;
40317 }
40318 {
40319 PyThreadState* __tstate = wxPyBeginAllowThreads();
40320 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
40321 wxPyEndAllowThreads(__tstate);
40322 if (PyErr_Occurred()) SWIG_fail;
40323 }
40324 resultobj = SWIG_Py_Void();
40325 {
40326 if (temp3)
40327 delete arg3;
40328 }
40329 return resultobj;
40330 fail:
40331 {
40332 if (temp3)
40333 delete arg3;
40334 }
40335 return NULL;
40336 }
40337
40338
40339 SWIGINTERN PyObject *_wrap_Menu_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40340 PyObject *resultobj = 0;
40341 wxMenu *arg1 = (wxMenu *) 0 ;
40342 int arg2 ;
40343 wxString result;
40344 void *argp1 = 0 ;
40345 int res1 = 0 ;
40346 int val2 ;
40347 int ecode2 = 0 ;
40348 PyObject * obj0 = 0 ;
40349 PyObject * obj1 = 0 ;
40350 char * kwnames[] = {
40351 (char *) "self",(char *) "id", NULL
40352 };
40353
40354 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
40355 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40356 if (!SWIG_IsOK(res1)) {
40357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetLabel" "', expected argument " "1"" of type '" "wxMenu const *""'");
40358 }
40359 arg1 = reinterpret_cast< wxMenu * >(argp1);
40360 ecode2 = SWIG_AsVal_int(obj1, &val2);
40361 if (!SWIG_IsOK(ecode2)) {
40362 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetLabel" "', expected argument " "2"" of type '" "int""'");
40363 }
40364 arg2 = static_cast< int >(val2);
40365 {
40366 PyThreadState* __tstate = wxPyBeginAllowThreads();
40367 result = ((wxMenu const *)arg1)->GetLabel(arg2);
40368 wxPyEndAllowThreads(__tstate);
40369 if (PyErr_Occurred()) SWIG_fail;
40370 }
40371 {
40372 #if wxUSE_UNICODE
40373 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40374 #else
40375 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40376 #endif
40377 }
40378 return resultobj;
40379 fail:
40380 return NULL;
40381 }
40382
40383
40384 SWIGINTERN PyObject *_wrap_Menu_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40385 PyObject *resultobj = 0;
40386 wxMenu *arg1 = (wxMenu *) 0 ;
40387 int arg2 ;
40388 wxString *arg3 = 0 ;
40389 void *argp1 = 0 ;
40390 int res1 = 0 ;
40391 int val2 ;
40392 int ecode2 = 0 ;
40393 bool temp3 = false ;
40394 PyObject * obj0 = 0 ;
40395 PyObject * obj1 = 0 ;
40396 PyObject * obj2 = 0 ;
40397 char * kwnames[] = {
40398 (char *) "self",(char *) "id",(char *) "helpString", NULL
40399 };
40400
40401 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40402 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40403 if (!SWIG_IsOK(res1)) {
40404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetHelpString" "', expected argument " "1"" of type '" "wxMenu *""'");
40405 }
40406 arg1 = reinterpret_cast< wxMenu * >(argp1);
40407 ecode2 = SWIG_AsVal_int(obj1, &val2);
40408 if (!SWIG_IsOK(ecode2)) {
40409 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetHelpString" "', expected argument " "2"" of type '" "int""'");
40410 }
40411 arg2 = static_cast< int >(val2);
40412 {
40413 arg3 = wxString_in_helper(obj2);
40414 if (arg3 == NULL) SWIG_fail;
40415 temp3 = true;
40416 }
40417 {
40418 PyThreadState* __tstate = wxPyBeginAllowThreads();
40419 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
40420 wxPyEndAllowThreads(__tstate);
40421 if (PyErr_Occurred()) SWIG_fail;
40422 }
40423 resultobj = SWIG_Py_Void();
40424 {
40425 if (temp3)
40426 delete arg3;
40427 }
40428 return resultobj;
40429 fail:
40430 {
40431 if (temp3)
40432 delete arg3;
40433 }
40434 return NULL;
40435 }
40436
40437
40438 SWIGINTERN PyObject *_wrap_Menu_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40439 PyObject *resultobj = 0;
40440 wxMenu *arg1 = (wxMenu *) 0 ;
40441 int arg2 ;
40442 wxString result;
40443 void *argp1 = 0 ;
40444 int res1 = 0 ;
40445 int val2 ;
40446 int ecode2 = 0 ;
40447 PyObject * obj0 = 0 ;
40448 PyObject * obj1 = 0 ;
40449 char * kwnames[] = {
40450 (char *) "self",(char *) "id", NULL
40451 };
40452
40453 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
40454 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40455 if (!SWIG_IsOK(res1)) {
40456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetHelpString" "', expected argument " "1"" of type '" "wxMenu const *""'");
40457 }
40458 arg1 = reinterpret_cast< wxMenu * >(argp1);
40459 ecode2 = SWIG_AsVal_int(obj1, &val2);
40460 if (!SWIG_IsOK(ecode2)) {
40461 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetHelpString" "', expected argument " "2"" of type '" "int""'");
40462 }
40463 arg2 = static_cast< int >(val2);
40464 {
40465 PyThreadState* __tstate = wxPyBeginAllowThreads();
40466 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
40467 wxPyEndAllowThreads(__tstate);
40468 if (PyErr_Occurred()) SWIG_fail;
40469 }
40470 {
40471 #if wxUSE_UNICODE
40472 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40473 #else
40474 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40475 #endif
40476 }
40477 return resultobj;
40478 fail:
40479 return NULL;
40480 }
40481
40482
40483 SWIGINTERN PyObject *_wrap_Menu_SetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40484 PyObject *resultobj = 0;
40485 wxMenu *arg1 = (wxMenu *) 0 ;
40486 wxString *arg2 = 0 ;
40487 void *argp1 = 0 ;
40488 int res1 = 0 ;
40489 bool temp2 = false ;
40490 PyObject * obj0 = 0 ;
40491 PyObject * obj1 = 0 ;
40492 char * kwnames[] = {
40493 (char *) "self",(char *) "title", NULL
40494 };
40495
40496 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) SWIG_fail;
40497 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40498 if (!SWIG_IsOK(res1)) {
40499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetTitle" "', expected argument " "1"" of type '" "wxMenu *""'");
40500 }
40501 arg1 = reinterpret_cast< wxMenu * >(argp1);
40502 {
40503 arg2 = wxString_in_helper(obj1);
40504 if (arg2 == NULL) SWIG_fail;
40505 temp2 = true;
40506 }
40507 {
40508 PyThreadState* __tstate = wxPyBeginAllowThreads();
40509 (arg1)->SetTitle((wxString const &)*arg2);
40510 wxPyEndAllowThreads(__tstate);
40511 if (PyErr_Occurred()) SWIG_fail;
40512 }
40513 resultobj = SWIG_Py_Void();
40514 {
40515 if (temp2)
40516 delete arg2;
40517 }
40518 return resultobj;
40519 fail:
40520 {
40521 if (temp2)
40522 delete arg2;
40523 }
40524 return NULL;
40525 }
40526
40527
40528 SWIGINTERN PyObject *_wrap_Menu_GetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40529 PyObject *resultobj = 0;
40530 wxMenu *arg1 = (wxMenu *) 0 ;
40531 wxString result;
40532 void *argp1 = 0 ;
40533 int res1 = 0 ;
40534 PyObject *swig_obj[1] ;
40535
40536 if (!args) SWIG_fail;
40537 swig_obj[0] = args;
40538 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40539 if (!SWIG_IsOK(res1)) {
40540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetTitle" "', expected argument " "1"" of type '" "wxMenu const *""'");
40541 }
40542 arg1 = reinterpret_cast< wxMenu * >(argp1);
40543 {
40544 PyThreadState* __tstate = wxPyBeginAllowThreads();
40545 result = ((wxMenu const *)arg1)->GetTitle();
40546 wxPyEndAllowThreads(__tstate);
40547 if (PyErr_Occurred()) SWIG_fail;
40548 }
40549 {
40550 #if wxUSE_UNICODE
40551 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40552 #else
40553 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40554 #endif
40555 }
40556 return resultobj;
40557 fail:
40558 return NULL;
40559 }
40560
40561
40562 SWIGINTERN PyObject *_wrap_Menu_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40563 PyObject *resultobj = 0;
40564 wxMenu *arg1 = (wxMenu *) 0 ;
40565 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
40566 void *argp1 = 0 ;
40567 int res1 = 0 ;
40568 void *argp2 = 0 ;
40569 int res2 = 0 ;
40570 PyObject * obj0 = 0 ;
40571 PyObject * obj1 = 0 ;
40572 char * kwnames[] = {
40573 (char *) "self",(char *) "handler", NULL
40574 };
40575
40576 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
40577 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40578 if (!SWIG_IsOK(res1)) {
40579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetEventHandler" "', expected argument " "1"" of type '" "wxMenu *""'");
40580 }
40581 arg1 = reinterpret_cast< wxMenu * >(argp1);
40582 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
40583 if (!SWIG_IsOK(res2)) {
40584 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
40585 }
40586 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
40587 {
40588 PyThreadState* __tstate = wxPyBeginAllowThreads();
40589 (arg1)->SetEventHandler(arg2);
40590 wxPyEndAllowThreads(__tstate);
40591 if (PyErr_Occurred()) SWIG_fail;
40592 }
40593 resultobj = SWIG_Py_Void();
40594 return resultobj;
40595 fail:
40596 return NULL;
40597 }
40598
40599
40600 SWIGINTERN PyObject *_wrap_Menu_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40601 PyObject *resultobj = 0;
40602 wxMenu *arg1 = (wxMenu *) 0 ;
40603 wxEvtHandler *result = 0 ;
40604 void *argp1 = 0 ;
40605 int res1 = 0 ;
40606 PyObject *swig_obj[1] ;
40607
40608 if (!args) SWIG_fail;
40609 swig_obj[0] = args;
40610 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40611 if (!SWIG_IsOK(res1)) {
40612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetEventHandler" "', expected argument " "1"" of type '" "wxMenu const *""'");
40613 }
40614 arg1 = reinterpret_cast< wxMenu * >(argp1);
40615 {
40616 PyThreadState* __tstate = wxPyBeginAllowThreads();
40617 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
40618 wxPyEndAllowThreads(__tstate);
40619 if (PyErr_Occurred()) SWIG_fail;
40620 }
40621 {
40622 resultobj = wxPyMake_wxObject(result, 0);
40623 }
40624 return resultobj;
40625 fail:
40626 return NULL;
40627 }
40628
40629
40630 SWIGINTERN PyObject *_wrap_Menu_SetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40631 PyObject *resultobj = 0;
40632 wxMenu *arg1 = (wxMenu *) 0 ;
40633 wxWindow *arg2 = (wxWindow *) 0 ;
40634 void *argp1 = 0 ;
40635 int res1 = 0 ;
40636 void *argp2 = 0 ;
40637 int res2 = 0 ;
40638 PyObject * obj0 = 0 ;
40639 PyObject * obj1 = 0 ;
40640 char * kwnames[] = {
40641 (char *) "self",(char *) "win", NULL
40642 };
40643
40644 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
40645 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40646 if (!SWIG_IsOK(res1)) {
40647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu *""'");
40648 }
40649 arg1 = reinterpret_cast< wxMenu * >(argp1);
40650 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
40651 if (!SWIG_IsOK(res2)) {
40652 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetInvokingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
40653 }
40654 arg2 = reinterpret_cast< wxWindow * >(argp2);
40655 {
40656 PyThreadState* __tstate = wxPyBeginAllowThreads();
40657 (arg1)->SetInvokingWindow(arg2);
40658 wxPyEndAllowThreads(__tstate);
40659 if (PyErr_Occurred()) SWIG_fail;
40660 }
40661 resultobj = SWIG_Py_Void();
40662 return resultobj;
40663 fail:
40664 return NULL;
40665 }
40666
40667
40668 SWIGINTERN PyObject *_wrap_Menu_GetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40669 PyObject *resultobj = 0;
40670 wxMenu *arg1 = (wxMenu *) 0 ;
40671 wxWindow *result = 0 ;
40672 void *argp1 = 0 ;
40673 int res1 = 0 ;
40674 PyObject *swig_obj[1] ;
40675
40676 if (!args) SWIG_fail;
40677 swig_obj[0] = args;
40678 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40679 if (!SWIG_IsOK(res1)) {
40680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu const *""'");
40681 }
40682 arg1 = reinterpret_cast< wxMenu * >(argp1);
40683 {
40684 PyThreadState* __tstate = wxPyBeginAllowThreads();
40685 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
40686 wxPyEndAllowThreads(__tstate);
40687 if (PyErr_Occurred()) SWIG_fail;
40688 }
40689 {
40690 resultobj = wxPyMake_wxObject(result, 0);
40691 }
40692 return resultobj;
40693 fail:
40694 return NULL;
40695 }
40696
40697
40698 SWIGINTERN PyObject *_wrap_Menu_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40699 PyObject *resultobj = 0;
40700 wxMenu *arg1 = (wxMenu *) 0 ;
40701 long result;
40702 void *argp1 = 0 ;
40703 int res1 = 0 ;
40704 PyObject *swig_obj[1] ;
40705
40706 if (!args) SWIG_fail;
40707 swig_obj[0] = args;
40708 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40709 if (!SWIG_IsOK(res1)) {
40710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetStyle" "', expected argument " "1"" of type '" "wxMenu const *""'");
40711 }
40712 arg1 = reinterpret_cast< wxMenu * >(argp1);
40713 {
40714 PyThreadState* __tstate = wxPyBeginAllowThreads();
40715 result = (long)((wxMenu const *)arg1)->GetStyle();
40716 wxPyEndAllowThreads(__tstate);
40717 if (PyErr_Occurred()) SWIG_fail;
40718 }
40719 resultobj = SWIG_From_long(static_cast< long >(result));
40720 return resultobj;
40721 fail:
40722 return NULL;
40723 }
40724
40725
40726 SWIGINTERN PyObject *_wrap_Menu_UpdateUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40727 PyObject *resultobj = 0;
40728 wxMenu *arg1 = (wxMenu *) 0 ;
40729 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
40730 void *argp1 = 0 ;
40731 int res1 = 0 ;
40732 void *argp2 = 0 ;
40733 int res2 = 0 ;
40734 PyObject * obj0 = 0 ;
40735 PyObject * obj1 = 0 ;
40736 char * kwnames[] = {
40737 (char *) "self",(char *) "source", NULL
40738 };
40739
40740 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) SWIG_fail;
40741 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40742 if (!SWIG_IsOK(res1)) {
40743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_UpdateUI" "', expected argument " "1"" of type '" "wxMenu *""'");
40744 }
40745 arg1 = reinterpret_cast< wxMenu * >(argp1);
40746 if (obj1) {
40747 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
40748 if (!SWIG_IsOK(res2)) {
40749 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_UpdateUI" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
40750 }
40751 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
40752 }
40753 {
40754 PyThreadState* __tstate = wxPyBeginAllowThreads();
40755 (arg1)->UpdateUI(arg2);
40756 wxPyEndAllowThreads(__tstate);
40757 if (PyErr_Occurred()) SWIG_fail;
40758 }
40759 resultobj = SWIG_Py_Void();
40760 return resultobj;
40761 fail:
40762 return NULL;
40763 }
40764
40765
40766 SWIGINTERN PyObject *_wrap_Menu_GetMenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40767 PyObject *resultobj = 0;
40768 wxMenu *arg1 = (wxMenu *) 0 ;
40769 wxMenuBar *result = 0 ;
40770 void *argp1 = 0 ;
40771 int res1 = 0 ;
40772 PyObject *swig_obj[1] ;
40773
40774 if (!args) SWIG_fail;
40775 swig_obj[0] = args;
40776 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40777 if (!SWIG_IsOK(res1)) {
40778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuBar" "', expected argument " "1"" of type '" "wxMenu const *""'");
40779 }
40780 arg1 = reinterpret_cast< wxMenu * >(argp1);
40781 {
40782 PyThreadState* __tstate = wxPyBeginAllowThreads();
40783 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
40784 wxPyEndAllowThreads(__tstate);
40785 if (PyErr_Occurred()) SWIG_fail;
40786 }
40787 {
40788 resultobj = wxPyMake_wxObject(result, (bool)0);
40789 }
40790 return resultobj;
40791 fail:
40792 return NULL;
40793 }
40794
40795
40796 SWIGINTERN PyObject *_wrap_Menu_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40797 PyObject *resultobj = 0;
40798 wxMenu *arg1 = (wxMenu *) 0 ;
40799 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
40800 void *argp1 = 0 ;
40801 int res1 = 0 ;
40802 void *argp2 = 0 ;
40803 int res2 = 0 ;
40804 PyObject * obj0 = 0 ;
40805 PyObject * obj1 = 0 ;
40806 char * kwnames[] = {
40807 (char *) "self",(char *) "menubar", NULL
40808 };
40809
40810 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
40811 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40812 if (!SWIG_IsOK(res1)) {
40813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Attach" "', expected argument " "1"" of type '" "wxMenu *""'");
40814 }
40815 arg1 = reinterpret_cast< wxMenu * >(argp1);
40816 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuBarBase, 0 | 0 );
40817 if (!SWIG_IsOK(res2)) {
40818 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_Attach" "', expected argument " "2"" of type '" "wxMenuBarBase *""'");
40819 }
40820 arg2 = reinterpret_cast< wxMenuBarBase * >(argp2);
40821 {
40822 PyThreadState* __tstate = wxPyBeginAllowThreads();
40823 (arg1)->Attach(arg2);
40824 wxPyEndAllowThreads(__tstate);
40825 if (PyErr_Occurred()) SWIG_fail;
40826 }
40827 resultobj = SWIG_Py_Void();
40828 return resultobj;
40829 fail:
40830 return NULL;
40831 }
40832
40833
40834 SWIGINTERN PyObject *_wrap_Menu_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40835 PyObject *resultobj = 0;
40836 wxMenu *arg1 = (wxMenu *) 0 ;
40837 void *argp1 = 0 ;
40838 int res1 = 0 ;
40839 PyObject *swig_obj[1] ;
40840
40841 if (!args) SWIG_fail;
40842 swig_obj[0] = args;
40843 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40844 if (!SWIG_IsOK(res1)) {
40845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Detach" "', expected argument " "1"" of type '" "wxMenu *""'");
40846 }
40847 arg1 = reinterpret_cast< wxMenu * >(argp1);
40848 {
40849 PyThreadState* __tstate = wxPyBeginAllowThreads();
40850 (arg1)->Detach();
40851 wxPyEndAllowThreads(__tstate);
40852 if (PyErr_Occurred()) SWIG_fail;
40853 }
40854 resultobj = SWIG_Py_Void();
40855 return resultobj;
40856 fail:
40857 return NULL;
40858 }
40859
40860
40861 SWIGINTERN PyObject *_wrap_Menu_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40862 PyObject *resultobj = 0;
40863 wxMenu *arg1 = (wxMenu *) 0 ;
40864 bool result;
40865 void *argp1 = 0 ;
40866 int res1 = 0 ;
40867 PyObject *swig_obj[1] ;
40868
40869 if (!args) SWIG_fail;
40870 swig_obj[0] = args;
40871 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40872 if (!SWIG_IsOK(res1)) {
40873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsAttached" "', expected argument " "1"" of type '" "wxMenu const *""'");
40874 }
40875 arg1 = reinterpret_cast< wxMenu * >(argp1);
40876 {
40877 PyThreadState* __tstate = wxPyBeginAllowThreads();
40878 result = (bool)((wxMenu const *)arg1)->IsAttached();
40879 wxPyEndAllowThreads(__tstate);
40880 if (PyErr_Occurred()) SWIG_fail;
40881 }
40882 {
40883 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40884 }
40885 return resultobj;
40886 fail:
40887 return NULL;
40888 }
40889
40890
40891 SWIGINTERN PyObject *_wrap_Menu_SetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40892 PyObject *resultobj = 0;
40893 wxMenu *arg1 = (wxMenu *) 0 ;
40894 wxMenu *arg2 = (wxMenu *) 0 ;
40895 void *argp1 = 0 ;
40896 int res1 = 0 ;
40897 void *argp2 = 0 ;
40898 int res2 = 0 ;
40899 PyObject * obj0 = 0 ;
40900 PyObject * obj1 = 0 ;
40901 char * kwnames[] = {
40902 (char *) "self",(char *) "parent", NULL
40903 };
40904
40905 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) SWIG_fail;
40906 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40907 if (!SWIG_IsOK(res1)) {
40908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetParent" "', expected argument " "1"" of type '" "wxMenu *""'");
40909 }
40910 arg1 = reinterpret_cast< wxMenu * >(argp1);
40911 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
40912 if (!SWIG_IsOK(res2)) {
40913 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetParent" "', expected argument " "2"" of type '" "wxMenu *""'");
40914 }
40915 arg2 = reinterpret_cast< wxMenu * >(argp2);
40916 {
40917 PyThreadState* __tstate = wxPyBeginAllowThreads();
40918 (arg1)->SetParent(arg2);
40919 wxPyEndAllowThreads(__tstate);
40920 if (PyErr_Occurred()) SWIG_fail;
40921 }
40922 resultobj = SWIG_Py_Void();
40923 return resultobj;
40924 fail:
40925 return NULL;
40926 }
40927
40928
40929 SWIGINTERN PyObject *_wrap_Menu_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40930 PyObject *resultobj = 0;
40931 wxMenu *arg1 = (wxMenu *) 0 ;
40932 wxMenu *result = 0 ;
40933 void *argp1 = 0 ;
40934 int res1 = 0 ;
40935 PyObject *swig_obj[1] ;
40936
40937 if (!args) SWIG_fail;
40938 swig_obj[0] = args;
40939 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40940 if (!SWIG_IsOK(res1)) {
40941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetParent" "', expected argument " "1"" of type '" "wxMenu const *""'");
40942 }
40943 arg1 = reinterpret_cast< wxMenu * >(argp1);
40944 {
40945 PyThreadState* __tstate = wxPyBeginAllowThreads();
40946 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
40947 wxPyEndAllowThreads(__tstate);
40948 if (PyErr_Occurred()) SWIG_fail;
40949 }
40950 {
40951 resultobj = wxPyMake_wxObject(result, 0);
40952 }
40953 return resultobj;
40954 fail:
40955 return NULL;
40956 }
40957
40958
40959 SWIGINTERN PyObject *Menu_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40960 PyObject *obj;
40961 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
40962 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenu, SWIG_NewClientData(obj));
40963 return SWIG_Py_Void();
40964 }
40965
40966 SWIGINTERN PyObject *Menu_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40967 return SWIG_Python_InitShadowInstance(args);
40968 }
40969
40970 SWIGINTERN PyObject *_wrap_new_MenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40971 PyObject *resultobj = 0;
40972 long arg1 = (long) 0 ;
40973 wxMenuBar *result = 0 ;
40974 long val1 ;
40975 int ecode1 = 0 ;
40976 PyObject * obj0 = 0 ;
40977 char * kwnames[] = {
40978 (char *) "style", NULL
40979 };
40980
40981 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) SWIG_fail;
40982 if (obj0) {
40983 ecode1 = SWIG_AsVal_long(obj0, &val1);
40984 if (!SWIG_IsOK(ecode1)) {
40985 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuBar" "', expected argument " "1"" of type '" "long""'");
40986 }
40987 arg1 = static_cast< long >(val1);
40988 }
40989 {
40990 if (!wxPyCheckForApp()) SWIG_fail;
40991 PyThreadState* __tstate = wxPyBeginAllowThreads();
40992 result = (wxMenuBar *)new wxMenuBar(arg1);
40993 wxPyEndAllowThreads(__tstate);
40994 if (PyErr_Occurred()) SWIG_fail;
40995 }
40996 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuBar, SWIG_POINTER_NEW | 0 );
40997 return resultobj;
40998 fail:
40999 return NULL;
41000 }
41001
41002
41003 SWIGINTERN PyObject *_wrap_MenuBar_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41004 PyObject *resultobj = 0;
41005 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41006 wxMenu *arg2 = (wxMenu *) 0 ;
41007 wxString *arg3 = 0 ;
41008 bool result;
41009 void *argp1 = 0 ;
41010 int res1 = 0 ;
41011 void *argp2 = 0 ;
41012 int res2 = 0 ;
41013 bool temp3 = false ;
41014 PyObject * obj0 = 0 ;
41015 PyObject * obj1 = 0 ;
41016 PyObject * obj2 = 0 ;
41017 char * kwnames[] = {
41018 (char *) "self",(char *) "menu",(char *) "title", NULL
41019 };
41020
41021 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41022 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41023 if (!SWIG_IsOK(res1)) {
41024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Append" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41025 }
41026 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41027 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
41028 if (!SWIG_IsOK(res2)) {
41029 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Append" "', expected argument " "2"" of type '" "wxMenu *""'");
41030 }
41031 arg2 = reinterpret_cast< wxMenu * >(argp2);
41032 {
41033 arg3 = wxString_in_helper(obj2);
41034 if (arg3 == NULL) SWIG_fail;
41035 temp3 = true;
41036 }
41037 {
41038 PyThreadState* __tstate = wxPyBeginAllowThreads();
41039 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
41040 wxPyEndAllowThreads(__tstate);
41041 if (PyErr_Occurred()) SWIG_fail;
41042 }
41043 {
41044 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41045 }
41046 {
41047 if (temp3)
41048 delete arg3;
41049 }
41050 return resultobj;
41051 fail:
41052 {
41053 if (temp3)
41054 delete arg3;
41055 }
41056 return NULL;
41057 }
41058
41059
41060 SWIGINTERN PyObject *_wrap_MenuBar_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41061 PyObject *resultobj = 0;
41062 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41063 size_t arg2 ;
41064 wxMenu *arg3 = (wxMenu *) 0 ;
41065 wxString *arg4 = 0 ;
41066 bool result;
41067 void *argp1 = 0 ;
41068 int res1 = 0 ;
41069 size_t val2 ;
41070 int ecode2 = 0 ;
41071 void *argp3 = 0 ;
41072 int res3 = 0 ;
41073 bool temp4 = false ;
41074 PyObject * obj0 = 0 ;
41075 PyObject * obj1 = 0 ;
41076 PyObject * obj2 = 0 ;
41077 PyObject * obj3 = 0 ;
41078 char * kwnames[] = {
41079 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
41080 };
41081
41082 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41083 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41084 if (!SWIG_IsOK(res1)) {
41085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Insert" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41086 }
41087 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41088 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41089 if (!SWIG_IsOK(ecode2)) {
41090 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Insert" "', expected argument " "2"" of type '" "size_t""'");
41091 }
41092 arg2 = static_cast< size_t >(val2);
41093 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
41094 if (!SWIG_IsOK(res3)) {
41095 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Insert" "', expected argument " "3"" of type '" "wxMenu *""'");
41096 }
41097 arg3 = reinterpret_cast< wxMenu * >(argp3);
41098 {
41099 arg4 = wxString_in_helper(obj3);
41100 if (arg4 == NULL) SWIG_fail;
41101 temp4 = true;
41102 }
41103 {
41104 PyThreadState* __tstate = wxPyBeginAllowThreads();
41105 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
41106 wxPyEndAllowThreads(__tstate);
41107 if (PyErr_Occurred()) SWIG_fail;
41108 }
41109 {
41110 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41111 }
41112 {
41113 if (temp4)
41114 delete arg4;
41115 }
41116 return resultobj;
41117 fail:
41118 {
41119 if (temp4)
41120 delete arg4;
41121 }
41122 return NULL;
41123 }
41124
41125
41126 SWIGINTERN PyObject *_wrap_MenuBar_GetMenuCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41127 PyObject *resultobj = 0;
41128 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41129 size_t result;
41130 void *argp1 = 0 ;
41131 int res1 = 0 ;
41132 PyObject *swig_obj[1] ;
41133
41134 if (!args) SWIG_fail;
41135 swig_obj[0] = args;
41136 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41137 if (!SWIG_IsOK(res1)) {
41138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenuCount" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41139 }
41140 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41141 {
41142 PyThreadState* __tstate = wxPyBeginAllowThreads();
41143 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
41144 wxPyEndAllowThreads(__tstate);
41145 if (PyErr_Occurred()) SWIG_fail;
41146 }
41147 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
41148 return resultobj;
41149 fail:
41150 return NULL;
41151 }
41152
41153
41154 SWIGINTERN PyObject *_wrap_MenuBar_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41155 PyObject *resultobj = 0;
41156 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41157 size_t arg2 ;
41158 wxMenu *result = 0 ;
41159 void *argp1 = 0 ;
41160 int res1 = 0 ;
41161 size_t val2 ;
41162 int ecode2 = 0 ;
41163 PyObject * obj0 = 0 ;
41164 PyObject * obj1 = 0 ;
41165 char * kwnames[] = {
41166 (char *) "self",(char *) "pos", NULL
41167 };
41168
41169 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
41170 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41171 if (!SWIG_IsOK(res1)) {
41172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenu" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41173 }
41174 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41175 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41176 if (!SWIG_IsOK(ecode2)) {
41177 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetMenu" "', expected argument " "2"" of type '" "size_t""'");
41178 }
41179 arg2 = static_cast< size_t >(val2);
41180 {
41181 PyThreadState* __tstate = wxPyBeginAllowThreads();
41182 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
41183 wxPyEndAllowThreads(__tstate);
41184 if (PyErr_Occurred()) SWIG_fail;
41185 }
41186 {
41187 resultobj = wxPyMake_wxObject(result, 0);
41188 }
41189 return resultobj;
41190 fail:
41191 return NULL;
41192 }
41193
41194
41195 SWIGINTERN PyObject *_wrap_MenuBar_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41196 PyObject *resultobj = 0;
41197 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41198 size_t arg2 ;
41199 wxMenu *arg3 = (wxMenu *) 0 ;
41200 wxString *arg4 = 0 ;
41201 wxMenu *result = 0 ;
41202 void *argp1 = 0 ;
41203 int res1 = 0 ;
41204 size_t val2 ;
41205 int ecode2 = 0 ;
41206 void *argp3 = 0 ;
41207 int res3 = 0 ;
41208 bool temp4 = false ;
41209 PyObject * obj0 = 0 ;
41210 PyObject * obj1 = 0 ;
41211 PyObject * obj2 = 0 ;
41212 PyObject * obj3 = 0 ;
41213 char * kwnames[] = {
41214 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
41215 };
41216
41217 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41218 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41219 if (!SWIG_IsOK(res1)) {
41220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Replace" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41221 }
41222 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41223 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41224 if (!SWIG_IsOK(ecode2)) {
41225 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Replace" "', expected argument " "2"" of type '" "size_t""'");
41226 }
41227 arg2 = static_cast< size_t >(val2);
41228 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
41229 if (!SWIG_IsOK(res3)) {
41230 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Replace" "', expected argument " "3"" of type '" "wxMenu *""'");
41231 }
41232 arg3 = reinterpret_cast< wxMenu * >(argp3);
41233 {
41234 arg4 = wxString_in_helper(obj3);
41235 if (arg4 == NULL) SWIG_fail;
41236 temp4 = true;
41237 }
41238 {
41239 PyThreadState* __tstate = wxPyBeginAllowThreads();
41240 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
41241 wxPyEndAllowThreads(__tstate);
41242 if (PyErr_Occurred()) SWIG_fail;
41243 }
41244 {
41245 resultobj = wxPyMake_wxObject(result, 0);
41246 }
41247 {
41248 if (temp4)
41249 delete arg4;
41250 }
41251 return resultobj;
41252 fail:
41253 {
41254 if (temp4)
41255 delete arg4;
41256 }
41257 return NULL;
41258 }
41259
41260
41261 SWIGINTERN PyObject *_wrap_MenuBar_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41262 PyObject *resultobj = 0;
41263 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41264 size_t arg2 ;
41265 wxMenu *result = 0 ;
41266 void *argp1 = 0 ;
41267 int res1 = 0 ;
41268 size_t val2 ;
41269 int ecode2 = 0 ;
41270 PyObject * obj0 = 0 ;
41271 PyObject * obj1 = 0 ;
41272 char * kwnames[] = {
41273 (char *) "self",(char *) "pos", NULL
41274 };
41275
41276 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
41277 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41278 if (!SWIG_IsOK(res1)) {
41279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Remove" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41280 }
41281 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41282 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41283 if (!SWIG_IsOK(ecode2)) {
41284 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Remove" "', expected argument " "2"" of type '" "size_t""'");
41285 }
41286 arg2 = static_cast< size_t >(val2);
41287 {
41288 PyThreadState* __tstate = wxPyBeginAllowThreads();
41289 result = (wxMenu *)(arg1)->Remove(arg2);
41290 wxPyEndAllowThreads(__tstate);
41291 if (PyErr_Occurred()) SWIG_fail;
41292 }
41293 {
41294 resultobj = wxPyMake_wxObject(result, 0);
41295 }
41296 return resultobj;
41297 fail:
41298 return NULL;
41299 }
41300
41301
41302 SWIGINTERN PyObject *_wrap_MenuBar_EnableTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41303 PyObject *resultobj = 0;
41304 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41305 size_t arg2 ;
41306 bool arg3 ;
41307 void *argp1 = 0 ;
41308 int res1 = 0 ;
41309 size_t val2 ;
41310 int ecode2 = 0 ;
41311 bool val3 ;
41312 int ecode3 = 0 ;
41313 PyObject * obj0 = 0 ;
41314 PyObject * obj1 = 0 ;
41315 PyObject * obj2 = 0 ;
41316 char * kwnames[] = {
41317 (char *) "self",(char *) "pos",(char *) "enable", NULL
41318 };
41319
41320 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41321 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41322 if (!SWIG_IsOK(res1)) {
41323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_EnableTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41324 }
41325 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41326 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41327 if (!SWIG_IsOK(ecode2)) {
41328 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_EnableTop" "', expected argument " "2"" of type '" "size_t""'");
41329 }
41330 arg2 = static_cast< size_t >(val2);
41331 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41332 if (!SWIG_IsOK(ecode3)) {
41333 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_EnableTop" "', expected argument " "3"" of type '" "bool""'");
41334 }
41335 arg3 = static_cast< bool >(val3);
41336 {
41337 PyThreadState* __tstate = wxPyBeginAllowThreads();
41338 (arg1)->EnableTop(arg2,arg3);
41339 wxPyEndAllowThreads(__tstate);
41340 if (PyErr_Occurred()) SWIG_fail;
41341 }
41342 resultobj = SWIG_Py_Void();
41343 return resultobj;
41344 fail:
41345 return NULL;
41346 }
41347
41348
41349 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41350 PyObject *resultobj = 0;
41351 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41352 size_t arg2 ;
41353 bool result;
41354 void *argp1 = 0 ;
41355 int res1 = 0 ;
41356 size_t val2 ;
41357 int ecode2 = 0 ;
41358 PyObject * obj0 = 0 ;
41359 PyObject * obj1 = 0 ;
41360 char * kwnames[] = {
41361 (char *) "self",(char *) "pos", NULL
41362 };
41363
41364 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) SWIG_fail;
41365 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41366 if (!SWIG_IsOK(res1)) {
41367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41368 }
41369 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41370 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41371 if (!SWIG_IsOK(ecode2)) {
41372 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "2"" of type '" "size_t""'");
41373 }
41374 arg2 = static_cast< size_t >(val2);
41375 {
41376 PyThreadState* __tstate = wxPyBeginAllowThreads();
41377 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
41378 wxPyEndAllowThreads(__tstate);
41379 if (PyErr_Occurred()) SWIG_fail;
41380 }
41381 {
41382 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41383 }
41384 return resultobj;
41385 fail:
41386 return NULL;
41387 }
41388
41389
41390 SWIGINTERN PyObject *_wrap_MenuBar_SetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41391 PyObject *resultobj = 0;
41392 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41393 size_t arg2 ;
41394 wxString *arg3 = 0 ;
41395 void *argp1 = 0 ;
41396 int res1 = 0 ;
41397 size_t val2 ;
41398 int ecode2 = 0 ;
41399 bool temp3 = false ;
41400 PyObject * obj0 = 0 ;
41401 PyObject * obj1 = 0 ;
41402 PyObject * obj2 = 0 ;
41403 char * kwnames[] = {
41404 (char *) "self",(char *) "pos",(char *) "label", NULL
41405 };
41406
41407 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41408 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41409 if (!SWIG_IsOK(res1)) {
41410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41411 }
41412 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41413 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41414 if (!SWIG_IsOK(ecode2)) {
41415 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
41416 }
41417 arg2 = static_cast< size_t >(val2);
41418 {
41419 arg3 = wxString_in_helper(obj2);
41420 if (arg3 == NULL) SWIG_fail;
41421 temp3 = true;
41422 }
41423 {
41424 PyThreadState* __tstate = wxPyBeginAllowThreads();
41425 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
41426 wxPyEndAllowThreads(__tstate);
41427 if (PyErr_Occurred()) SWIG_fail;
41428 }
41429 resultobj = SWIG_Py_Void();
41430 {
41431 if (temp3)
41432 delete arg3;
41433 }
41434 return resultobj;
41435 fail:
41436 {
41437 if (temp3)
41438 delete arg3;
41439 }
41440 return NULL;
41441 }
41442
41443
41444 SWIGINTERN PyObject *_wrap_MenuBar_GetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41445 PyObject *resultobj = 0;
41446 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41447 size_t arg2 ;
41448 wxString result;
41449 void *argp1 = 0 ;
41450 int res1 = 0 ;
41451 size_t val2 ;
41452 int ecode2 = 0 ;
41453 PyObject * obj0 = 0 ;
41454 PyObject * obj1 = 0 ;
41455 char * kwnames[] = {
41456 (char *) "self",(char *) "pos", NULL
41457 };
41458
41459 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) SWIG_fail;
41460 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41461 if (!SWIG_IsOK(res1)) {
41462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41463 }
41464 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41465 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41466 if (!SWIG_IsOK(ecode2)) {
41467 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
41468 }
41469 arg2 = static_cast< size_t >(val2);
41470 {
41471 PyThreadState* __tstate = wxPyBeginAllowThreads();
41472 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
41473 wxPyEndAllowThreads(__tstate);
41474 if (PyErr_Occurred()) SWIG_fail;
41475 }
41476 {
41477 #if wxUSE_UNICODE
41478 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41479 #else
41480 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41481 #endif
41482 }
41483 return resultobj;
41484 fail:
41485 return NULL;
41486 }
41487
41488
41489 SWIGINTERN PyObject *_wrap_MenuBar_FindMenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41490 PyObject *resultobj = 0;
41491 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41492 wxString *arg2 = 0 ;
41493 wxString *arg3 = 0 ;
41494 int result;
41495 void *argp1 = 0 ;
41496 int res1 = 0 ;
41497 bool temp2 = false ;
41498 bool temp3 = false ;
41499 PyObject * obj0 = 0 ;
41500 PyObject * obj1 = 0 ;
41501 PyObject * obj2 = 0 ;
41502 char * kwnames[] = {
41503 (char *) "self",(char *) "menu",(char *) "item", NULL
41504 };
41505
41506 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41507 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41508 if (!SWIG_IsOK(res1)) {
41509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenuItem" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41510 }
41511 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41512 {
41513 arg2 = wxString_in_helper(obj1);
41514 if (arg2 == NULL) SWIG_fail;
41515 temp2 = true;
41516 }
41517 {
41518 arg3 = wxString_in_helper(obj2);
41519 if (arg3 == NULL) SWIG_fail;
41520 temp3 = true;
41521 }
41522 {
41523 PyThreadState* __tstate = wxPyBeginAllowThreads();
41524 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
41525 wxPyEndAllowThreads(__tstate);
41526 if (PyErr_Occurred()) SWIG_fail;
41527 }
41528 resultobj = SWIG_From_int(static_cast< int >(result));
41529 {
41530 if (temp2)
41531 delete arg2;
41532 }
41533 {
41534 if (temp3)
41535 delete arg3;
41536 }
41537 return resultobj;
41538 fail:
41539 {
41540 if (temp2)
41541 delete arg2;
41542 }
41543 {
41544 if (temp3)
41545 delete arg3;
41546 }
41547 return NULL;
41548 }
41549
41550
41551 SWIGINTERN PyObject *_wrap_MenuBar_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41552 PyObject *resultobj = 0;
41553 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41554 int arg2 ;
41555 wxMenuItem *result = 0 ;
41556 void *argp1 = 0 ;
41557 int res1 = 0 ;
41558 int val2 ;
41559 int ecode2 = 0 ;
41560 PyObject * obj0 = 0 ;
41561 PyObject * obj1 = 0 ;
41562 char * kwnames[] = {
41563 (char *) "self",(char *) "id", NULL
41564 };
41565
41566 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
41567 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41568 if (!SWIG_IsOK(res1)) {
41569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindItemById" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41570 }
41571 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41572 ecode2 = SWIG_AsVal_int(obj1, &val2);
41573 if (!SWIG_IsOK(ecode2)) {
41574 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_FindItemById" "', expected argument " "2"" of type '" "int""'");
41575 }
41576 arg2 = static_cast< int >(val2);
41577 {
41578 PyThreadState* __tstate = wxPyBeginAllowThreads();
41579 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
41580 wxPyEndAllowThreads(__tstate);
41581 if (PyErr_Occurred()) SWIG_fail;
41582 }
41583 {
41584 resultobj = wxPyMake_wxObject(result, (bool)0);
41585 }
41586 return resultobj;
41587 fail:
41588 return NULL;
41589 }
41590
41591
41592 SWIGINTERN PyObject *_wrap_MenuBar_FindMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41593 PyObject *resultobj = 0;
41594 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41595 wxString *arg2 = 0 ;
41596 int result;
41597 void *argp1 = 0 ;
41598 int res1 = 0 ;
41599 bool temp2 = false ;
41600 PyObject * obj0 = 0 ;
41601 PyObject * obj1 = 0 ;
41602 char * kwnames[] = {
41603 (char *) "self",(char *) "title", NULL
41604 };
41605
41606 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) SWIG_fail;
41607 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41608 if (!SWIG_IsOK(res1)) {
41609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenu" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41610 }
41611 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41612 {
41613 arg2 = wxString_in_helper(obj1);
41614 if (arg2 == NULL) SWIG_fail;
41615 temp2 = true;
41616 }
41617 {
41618 PyThreadState* __tstate = wxPyBeginAllowThreads();
41619 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
41620 wxPyEndAllowThreads(__tstate);
41621 if (PyErr_Occurred()) SWIG_fail;
41622 }
41623 resultobj = SWIG_From_int(static_cast< int >(result));
41624 {
41625 if (temp2)
41626 delete arg2;
41627 }
41628 return resultobj;
41629 fail:
41630 {
41631 if (temp2)
41632 delete arg2;
41633 }
41634 return NULL;
41635 }
41636
41637
41638 SWIGINTERN PyObject *_wrap_MenuBar_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41639 PyObject *resultobj = 0;
41640 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41641 int arg2 ;
41642 bool arg3 ;
41643 void *argp1 = 0 ;
41644 int res1 = 0 ;
41645 int val2 ;
41646 int ecode2 = 0 ;
41647 bool val3 ;
41648 int ecode3 = 0 ;
41649 PyObject * obj0 = 0 ;
41650 PyObject * obj1 = 0 ;
41651 PyObject * obj2 = 0 ;
41652 char * kwnames[] = {
41653 (char *) "self",(char *) "id",(char *) "enable", NULL
41654 };
41655
41656 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41657 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41658 if (!SWIG_IsOK(res1)) {
41659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Enable" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41660 }
41661 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41662 ecode2 = SWIG_AsVal_int(obj1, &val2);
41663 if (!SWIG_IsOK(ecode2)) {
41664 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Enable" "', expected argument " "2"" of type '" "int""'");
41665 }
41666 arg2 = static_cast< int >(val2);
41667 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41668 if (!SWIG_IsOK(ecode3)) {
41669 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Enable" "', expected argument " "3"" of type '" "bool""'");
41670 }
41671 arg3 = static_cast< bool >(val3);
41672 {
41673 PyThreadState* __tstate = wxPyBeginAllowThreads();
41674 (arg1)->Enable(arg2,arg3);
41675 wxPyEndAllowThreads(__tstate);
41676 if (PyErr_Occurred()) SWIG_fail;
41677 }
41678 resultobj = SWIG_Py_Void();
41679 return resultobj;
41680 fail:
41681 return NULL;
41682 }
41683
41684
41685 SWIGINTERN PyObject *_wrap_MenuBar_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41686 PyObject *resultobj = 0;
41687 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41688 int arg2 ;
41689 bool arg3 ;
41690 void *argp1 = 0 ;
41691 int res1 = 0 ;
41692 int val2 ;
41693 int ecode2 = 0 ;
41694 bool val3 ;
41695 int ecode3 = 0 ;
41696 PyObject * obj0 = 0 ;
41697 PyObject * obj1 = 0 ;
41698 PyObject * obj2 = 0 ;
41699 char * kwnames[] = {
41700 (char *) "self",(char *) "id",(char *) "check", NULL
41701 };
41702
41703 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41704 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41705 if (!SWIG_IsOK(res1)) {
41706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Check" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41707 }
41708 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41709 ecode2 = SWIG_AsVal_int(obj1, &val2);
41710 if (!SWIG_IsOK(ecode2)) {
41711 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Check" "', expected argument " "2"" of type '" "int""'");
41712 }
41713 arg2 = static_cast< int >(val2);
41714 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41715 if (!SWIG_IsOK(ecode3)) {
41716 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Check" "', expected argument " "3"" of type '" "bool""'");
41717 }
41718 arg3 = static_cast< bool >(val3);
41719 {
41720 PyThreadState* __tstate = wxPyBeginAllowThreads();
41721 (arg1)->Check(arg2,arg3);
41722 wxPyEndAllowThreads(__tstate);
41723 if (PyErr_Occurred()) SWIG_fail;
41724 }
41725 resultobj = SWIG_Py_Void();
41726 return resultobj;
41727 fail:
41728 return NULL;
41729 }
41730
41731
41732 SWIGINTERN PyObject *_wrap_MenuBar_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41733 PyObject *resultobj = 0;
41734 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41735 int arg2 ;
41736 bool result;
41737 void *argp1 = 0 ;
41738 int res1 = 0 ;
41739 int val2 ;
41740 int ecode2 = 0 ;
41741 PyObject * obj0 = 0 ;
41742 PyObject * obj1 = 0 ;
41743 char * kwnames[] = {
41744 (char *) "self",(char *) "id", NULL
41745 };
41746
41747 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
41748 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41749 if (!SWIG_IsOK(res1)) {
41750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsChecked" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41751 }
41752 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41753 ecode2 = SWIG_AsVal_int(obj1, &val2);
41754 if (!SWIG_IsOK(ecode2)) {
41755 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsChecked" "', expected argument " "2"" of type '" "int""'");
41756 }
41757 arg2 = static_cast< int >(val2);
41758 {
41759 PyThreadState* __tstate = wxPyBeginAllowThreads();
41760 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
41761 wxPyEndAllowThreads(__tstate);
41762 if (PyErr_Occurred()) SWIG_fail;
41763 }
41764 {
41765 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41766 }
41767 return resultobj;
41768 fail:
41769 return NULL;
41770 }
41771
41772
41773 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabled(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_IsEnabled",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_IsEnabled" "', 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_IsEnabled" "', expected argument " "2"" of type '" "int""'");
41797 }
41798 arg2 = static_cast< int >(val2);
41799 {
41800 PyThreadState* __tstate = wxPyBeginAllowThreads();
41801 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(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_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41815 PyObject *resultobj = 0;
41816 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41817 int arg2 ;
41818 wxString *arg3 = 0 ;
41819 void *argp1 = 0 ;
41820 int res1 = 0 ;
41821 int val2 ;
41822 int ecode2 = 0 ;
41823 bool temp3 = false ;
41824 PyObject * obj0 = 0 ;
41825 PyObject * obj1 = 0 ;
41826 PyObject * obj2 = 0 ;
41827 char * kwnames[] = {
41828 (char *) "self",(char *) "id",(char *) "label", NULL
41829 };
41830
41831 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41832 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41833 if (!SWIG_IsOK(res1)) {
41834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabel" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41835 }
41836 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41837 ecode2 = SWIG_AsVal_int(obj1, &val2);
41838 if (!SWIG_IsOK(ecode2)) {
41839 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabel" "', expected argument " "2"" of type '" "int""'");
41840 }
41841 arg2 = static_cast< int >(val2);
41842 {
41843 arg3 = wxString_in_helper(obj2);
41844 if (arg3 == NULL) SWIG_fail;
41845 temp3 = true;
41846 }
41847 {
41848 PyThreadState* __tstate = wxPyBeginAllowThreads();
41849 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
41850 wxPyEndAllowThreads(__tstate);
41851 if (PyErr_Occurred()) SWIG_fail;
41852 }
41853 resultobj = SWIG_Py_Void();
41854 {
41855 if (temp3)
41856 delete arg3;
41857 }
41858 return resultobj;
41859 fail:
41860 {
41861 if (temp3)
41862 delete arg3;
41863 }
41864 return NULL;
41865 }
41866
41867
41868 SWIGINTERN PyObject *_wrap_MenuBar_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41869 PyObject *resultobj = 0;
41870 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41871 int arg2 ;
41872 wxString result;
41873 void *argp1 = 0 ;
41874 int res1 = 0 ;
41875 int val2 ;
41876 int ecode2 = 0 ;
41877 PyObject * obj0 = 0 ;
41878 PyObject * obj1 = 0 ;
41879 char * kwnames[] = {
41880 (char *) "self",(char *) "id", NULL
41881 };
41882
41883 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
41884 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41885 if (!SWIG_IsOK(res1)) {
41886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabel" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41887 }
41888 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41889 ecode2 = SWIG_AsVal_int(obj1, &val2);
41890 if (!SWIG_IsOK(ecode2)) {
41891 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabel" "', expected argument " "2"" of type '" "int""'");
41892 }
41893 arg2 = static_cast< int >(val2);
41894 {
41895 PyThreadState* __tstate = wxPyBeginAllowThreads();
41896 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
41897 wxPyEndAllowThreads(__tstate);
41898 if (PyErr_Occurred()) SWIG_fail;
41899 }
41900 {
41901 #if wxUSE_UNICODE
41902 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41903 #else
41904 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41905 #endif
41906 }
41907 return resultobj;
41908 fail:
41909 return NULL;
41910 }
41911
41912
41913 SWIGINTERN PyObject *_wrap_MenuBar_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41914 PyObject *resultobj = 0;
41915 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41916 int arg2 ;
41917 wxString *arg3 = 0 ;
41918 void *argp1 = 0 ;
41919 int res1 = 0 ;
41920 int val2 ;
41921 int ecode2 = 0 ;
41922 bool temp3 = false ;
41923 PyObject * obj0 = 0 ;
41924 PyObject * obj1 = 0 ;
41925 PyObject * obj2 = 0 ;
41926 char * kwnames[] = {
41927 (char *) "self",(char *) "id",(char *) "helpString", NULL
41928 };
41929
41930 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41931 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41932 if (!SWIG_IsOK(res1)) {
41933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetHelpString" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41934 }
41935 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41936 ecode2 = SWIG_AsVal_int(obj1, &val2);
41937 if (!SWIG_IsOK(ecode2)) {
41938 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetHelpString" "', expected argument " "2"" of type '" "int""'");
41939 }
41940 arg2 = static_cast< int >(val2);
41941 {
41942 arg3 = wxString_in_helper(obj2);
41943 if (arg3 == NULL) SWIG_fail;
41944 temp3 = true;
41945 }
41946 {
41947 PyThreadState* __tstate = wxPyBeginAllowThreads();
41948 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
41949 wxPyEndAllowThreads(__tstate);
41950 if (PyErr_Occurred()) SWIG_fail;
41951 }
41952 resultobj = SWIG_Py_Void();
41953 {
41954 if (temp3)
41955 delete arg3;
41956 }
41957 return resultobj;
41958 fail:
41959 {
41960 if (temp3)
41961 delete arg3;
41962 }
41963 return NULL;
41964 }
41965
41966
41967 SWIGINTERN PyObject *_wrap_MenuBar_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41968 PyObject *resultobj = 0;
41969 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41970 int arg2 ;
41971 wxString result;
41972 void *argp1 = 0 ;
41973 int res1 = 0 ;
41974 int val2 ;
41975 int ecode2 = 0 ;
41976 PyObject * obj0 = 0 ;
41977 PyObject * obj1 = 0 ;
41978 char * kwnames[] = {
41979 (char *) "self",(char *) "id", NULL
41980 };
41981
41982 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
41983 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41984 if (!SWIG_IsOK(res1)) {
41985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetHelpString" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41986 }
41987 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41988 ecode2 = SWIG_AsVal_int(obj1, &val2);
41989 if (!SWIG_IsOK(ecode2)) {
41990 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetHelpString" "', expected argument " "2"" of type '" "int""'");
41991 }
41992 arg2 = static_cast< int >(val2);
41993 {
41994 PyThreadState* __tstate = wxPyBeginAllowThreads();
41995 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
41996 wxPyEndAllowThreads(__tstate);
41997 if (PyErr_Occurred()) SWIG_fail;
41998 }
41999 {
42000 #if wxUSE_UNICODE
42001 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42002 #else
42003 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42004 #endif
42005 }
42006 return resultobj;
42007 fail:
42008 return NULL;
42009 }
42010
42011
42012 SWIGINTERN PyObject *_wrap_MenuBar_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42013 PyObject *resultobj = 0;
42014 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42015 wxFrame *result = 0 ;
42016 void *argp1 = 0 ;
42017 int res1 = 0 ;
42018 PyObject *swig_obj[1] ;
42019
42020 if (!args) SWIG_fail;
42021 swig_obj[0] = args;
42022 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42023 if (!SWIG_IsOK(res1)) {
42024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetFrame" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42025 }
42026 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42027 {
42028 PyThreadState* __tstate = wxPyBeginAllowThreads();
42029 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
42030 wxPyEndAllowThreads(__tstate);
42031 if (PyErr_Occurred()) SWIG_fail;
42032 }
42033 {
42034 resultobj = wxPyMake_wxObject(result, (bool)0);
42035 }
42036 return resultobj;
42037 fail:
42038 return NULL;
42039 }
42040
42041
42042 SWIGINTERN PyObject *_wrap_MenuBar_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42043 PyObject *resultobj = 0;
42044 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42045 bool result;
42046 void *argp1 = 0 ;
42047 int res1 = 0 ;
42048 PyObject *swig_obj[1] ;
42049
42050 if (!args) SWIG_fail;
42051 swig_obj[0] = args;
42052 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42053 if (!SWIG_IsOK(res1)) {
42054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsAttached" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42055 }
42056 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42057 {
42058 PyThreadState* __tstate = wxPyBeginAllowThreads();
42059 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
42060 wxPyEndAllowThreads(__tstate);
42061 if (PyErr_Occurred()) SWIG_fail;
42062 }
42063 {
42064 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42065 }
42066 return resultobj;
42067 fail:
42068 return NULL;
42069 }
42070
42071
42072 SWIGINTERN PyObject *_wrap_MenuBar_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42073 PyObject *resultobj = 0;
42074 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42075 wxFrame *arg2 = (wxFrame *) 0 ;
42076 void *argp1 = 0 ;
42077 int res1 = 0 ;
42078 void *argp2 = 0 ;
42079 int res2 = 0 ;
42080 PyObject * obj0 = 0 ;
42081 PyObject * obj1 = 0 ;
42082 char * kwnames[] = {
42083 (char *) "self",(char *) "frame", NULL
42084 };
42085
42086 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
42087 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42088 if (!SWIG_IsOK(res1)) {
42089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Attach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42090 }
42091 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42092 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFrame, 0 | 0 );
42093 if (!SWIG_IsOK(res2)) {
42094 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Attach" "', expected argument " "2"" of type '" "wxFrame *""'");
42095 }
42096 arg2 = reinterpret_cast< wxFrame * >(argp2);
42097 {
42098 PyThreadState* __tstate = wxPyBeginAllowThreads();
42099 (arg1)->Attach(arg2);
42100 wxPyEndAllowThreads(__tstate);
42101 if (PyErr_Occurred()) SWIG_fail;
42102 }
42103 resultobj = SWIG_Py_Void();
42104 return resultobj;
42105 fail:
42106 return NULL;
42107 }
42108
42109
42110 SWIGINTERN PyObject *_wrap_MenuBar_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42111 PyObject *resultobj = 0;
42112 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42113 void *argp1 = 0 ;
42114 int res1 = 0 ;
42115 PyObject *swig_obj[1] ;
42116
42117 if (!args) SWIG_fail;
42118 swig_obj[0] = args;
42119 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42120 if (!SWIG_IsOK(res1)) {
42121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Detach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42122 }
42123 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42124 {
42125 PyThreadState* __tstate = wxPyBeginAllowThreads();
42126 (arg1)->Detach();
42127 wxPyEndAllowThreads(__tstate);
42128 if (PyErr_Occurred()) SWIG_fail;
42129 }
42130 resultobj = SWIG_Py_Void();
42131 return resultobj;
42132 fail:
42133 return NULL;
42134 }
42135
42136
42137 SWIGINTERN PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42138 PyObject *resultobj = 0;
42139 bool arg1 ;
42140 bool val1 ;
42141 int ecode1 = 0 ;
42142 PyObject * obj0 = 0 ;
42143 char * kwnames[] = {
42144 (char *) "enable", NULL
42145 };
42146
42147 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) SWIG_fail;
42148 ecode1 = SWIG_AsVal_bool(obj0, &val1);
42149 if (!SWIG_IsOK(ecode1)) {
42150 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MenuBar_SetAutoWindowMenu" "', expected argument " "1"" of type '" "bool""'");
42151 }
42152 arg1 = static_cast< bool >(val1);
42153 {
42154 PyThreadState* __tstate = wxPyBeginAllowThreads();
42155 wxMenuBar_SetAutoWindowMenu(arg1);
42156 wxPyEndAllowThreads(__tstate);
42157 if (PyErr_Occurred()) SWIG_fail;
42158 }
42159 resultobj = SWIG_Py_Void();
42160 return resultobj;
42161 fail:
42162 return NULL;
42163 }
42164
42165
42166 SWIGINTERN PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42167 PyObject *resultobj = 0;
42168 bool result;
42169
42170 if (!SWIG_Python_UnpackTuple(args,"MenuBar_GetAutoWindowMenu",0,0,0)) SWIG_fail;
42171 {
42172 PyThreadState* __tstate = wxPyBeginAllowThreads();
42173 result = (bool)wxMenuBar_GetAutoWindowMenu();
42174 wxPyEndAllowThreads(__tstate);
42175 if (PyErr_Occurred()) SWIG_fail;
42176 }
42177 {
42178 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42179 }
42180 return resultobj;
42181 fail:
42182 return NULL;
42183 }
42184
42185
42186 SWIGINTERN PyObject *MenuBar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42187 PyObject *obj;
42188 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
42189 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuBar, SWIG_NewClientData(obj));
42190 return SWIG_Py_Void();
42191 }
42192
42193 SWIGINTERN PyObject *MenuBar_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42194 return SWIG_Python_InitShadowInstance(args);
42195 }
42196
42197 SWIGINTERN PyObject *_wrap_new_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42198 PyObject *resultobj = 0;
42199 wxMenu *arg1 = (wxMenu *) NULL ;
42200 int arg2 = (int) wxID_ANY ;
42201 wxString const &arg3_defvalue = wxPyEmptyString ;
42202 wxString *arg3 = (wxString *) &arg3_defvalue ;
42203 wxString const &arg4_defvalue = wxPyEmptyString ;
42204 wxString *arg4 = (wxString *) &arg4_defvalue ;
42205 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
42206 wxMenu *arg6 = (wxMenu *) NULL ;
42207 wxMenuItem *result = 0 ;
42208 void *argp1 = 0 ;
42209 int res1 = 0 ;
42210 int val2 ;
42211 int ecode2 = 0 ;
42212 bool temp3 = false ;
42213 bool temp4 = false ;
42214 int val5 ;
42215 int ecode5 = 0 ;
42216 void *argp6 = 0 ;
42217 int res6 = 0 ;
42218 PyObject * obj0 = 0 ;
42219 PyObject * obj1 = 0 ;
42220 PyObject * obj2 = 0 ;
42221 PyObject * obj3 = 0 ;
42222 PyObject * obj4 = 0 ;
42223 PyObject * obj5 = 0 ;
42224 char * kwnames[] = {
42225 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
42226 };
42227
42228 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
42229 if (obj0) {
42230 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42231 if (!SWIG_IsOK(res1)) {
42232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MenuItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42233 }
42234 arg1 = reinterpret_cast< wxMenu * >(argp1);
42235 }
42236 if (obj1) {
42237 ecode2 = SWIG_AsVal_int(obj1, &val2);
42238 if (!SWIG_IsOK(ecode2)) {
42239 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuItem" "', expected argument " "2"" of type '" "int""'");
42240 }
42241 arg2 = static_cast< int >(val2);
42242 }
42243 if (obj2) {
42244 {
42245 arg3 = wxString_in_helper(obj2);
42246 if (arg3 == NULL) SWIG_fail;
42247 temp3 = true;
42248 }
42249 }
42250 if (obj3) {
42251 {
42252 arg4 = wxString_in_helper(obj3);
42253 if (arg4 == NULL) SWIG_fail;
42254 temp4 = true;
42255 }
42256 }
42257 if (obj4) {
42258 ecode5 = SWIG_AsVal_int(obj4, &val5);
42259 if (!SWIG_IsOK(ecode5)) {
42260 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MenuItem" "', expected argument " "5"" of type '" "wxItemKind""'");
42261 }
42262 arg5 = static_cast< wxItemKind >(val5);
42263 }
42264 if (obj5) {
42265 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxMenu, 0 | 0 );
42266 if (!SWIG_IsOK(res6)) {
42267 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MenuItem" "', expected argument " "6"" of type '" "wxMenu *""'");
42268 }
42269 arg6 = reinterpret_cast< wxMenu * >(argp6);
42270 }
42271 {
42272 PyThreadState* __tstate = wxPyBeginAllowThreads();
42273 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
42274 wxPyEndAllowThreads(__tstate);
42275 if (PyErr_Occurred()) SWIG_fail;
42276 }
42277 {
42278 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
42279 }
42280 {
42281 if (temp3)
42282 delete arg3;
42283 }
42284 {
42285 if (temp4)
42286 delete arg4;
42287 }
42288 return resultobj;
42289 fail:
42290 {
42291 if (temp3)
42292 delete arg3;
42293 }
42294 {
42295 if (temp4)
42296 delete arg4;
42297 }
42298 return NULL;
42299 }
42300
42301
42302 SWIGINTERN PyObject *_wrap_delete_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42303 PyObject *resultobj = 0;
42304 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42305 void *argp1 = 0 ;
42306 int res1 = 0 ;
42307 PyObject *swig_obj[1] ;
42308
42309 if (!args) SWIG_fail;
42310 swig_obj[0] = args;
42311 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42312 if (!SWIG_IsOK(res1)) {
42313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MenuItem" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42314 }
42315 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42316 {
42317 PyThreadState* __tstate = wxPyBeginAllowThreads();
42318 delete arg1;
42319
42320 wxPyEndAllowThreads(__tstate);
42321 if (PyErr_Occurred()) SWIG_fail;
42322 }
42323 resultobj = SWIG_Py_Void();
42324 return resultobj;
42325 fail:
42326 return NULL;
42327 }
42328
42329
42330 SWIGINTERN PyObject *_wrap_MenuItem_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42331 PyObject *resultobj = 0;
42332 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42333 wxMenu *result = 0 ;
42334 void *argp1 = 0 ;
42335 int res1 = 0 ;
42336 PyObject *swig_obj[1] ;
42337
42338 if (!args) SWIG_fail;
42339 swig_obj[0] = args;
42340 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42341 if (!SWIG_IsOK(res1)) {
42342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42343 }
42344 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42345 {
42346 PyThreadState* __tstate = wxPyBeginAllowThreads();
42347 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
42348 wxPyEndAllowThreads(__tstate);
42349 if (PyErr_Occurred()) SWIG_fail;
42350 }
42351 {
42352 resultobj = wxPyMake_wxObject(result, 0);
42353 }
42354 return resultobj;
42355 fail:
42356 return NULL;
42357 }
42358
42359
42360 SWIGINTERN PyObject *_wrap_MenuItem_SetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42361 PyObject *resultobj = 0;
42362 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42363 wxMenu *arg2 = (wxMenu *) 0 ;
42364 void *argp1 = 0 ;
42365 int res1 = 0 ;
42366 void *argp2 = 0 ;
42367 int res2 = 0 ;
42368 PyObject * obj0 = 0 ;
42369 PyObject * obj1 = 0 ;
42370 char * kwnames[] = {
42371 (char *) "self",(char *) "menu", NULL
42372 };
42373
42374 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42375 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42376 if (!SWIG_IsOK(res1)) {
42377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42378 }
42379 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42380 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42381 if (!SWIG_IsOK(res2)) {
42382 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
42383 }
42384 arg2 = reinterpret_cast< wxMenu * >(argp2);
42385 {
42386 PyThreadState* __tstate = wxPyBeginAllowThreads();
42387 (arg1)->SetMenu(arg2);
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_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42399 PyObject *resultobj = 0;
42400 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42401 int arg2 ;
42402 void *argp1 = 0 ;
42403 int res1 = 0 ;
42404 int val2 ;
42405 int ecode2 = 0 ;
42406 PyObject * obj0 = 0 ;
42407 PyObject * obj1 = 0 ;
42408 char * kwnames[] = {
42409 (char *) "self",(char *) "id", NULL
42410 };
42411
42412 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
42413 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42414 if (!SWIG_IsOK(res1)) {
42415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetId" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42416 }
42417 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42418 ecode2 = SWIG_AsVal_int(obj1, &val2);
42419 if (!SWIG_IsOK(ecode2)) {
42420 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetId" "', expected argument " "2"" of type '" "int""'");
42421 }
42422 arg2 = static_cast< int >(val2);
42423 {
42424 PyThreadState* __tstate = wxPyBeginAllowThreads();
42425 (arg1)->SetId(arg2);
42426 wxPyEndAllowThreads(__tstate);
42427 if (PyErr_Occurred()) SWIG_fail;
42428 }
42429 resultobj = SWIG_Py_Void();
42430 return resultobj;
42431 fail:
42432 return NULL;
42433 }
42434
42435
42436 SWIGINTERN PyObject *_wrap_MenuItem_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42437 PyObject *resultobj = 0;
42438 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42439 int result;
42440 void *argp1 = 0 ;
42441 int res1 = 0 ;
42442 PyObject *swig_obj[1] ;
42443
42444 if (!args) SWIG_fail;
42445 swig_obj[0] = args;
42446 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42447 if (!SWIG_IsOK(res1)) {
42448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetId" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42449 }
42450 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42451 {
42452 PyThreadState* __tstate = wxPyBeginAllowThreads();
42453 result = (int)((wxMenuItem const *)arg1)->GetId();
42454 wxPyEndAllowThreads(__tstate);
42455 if (PyErr_Occurred()) SWIG_fail;
42456 }
42457 resultobj = SWIG_From_int(static_cast< int >(result));
42458 return resultobj;
42459 fail:
42460 return NULL;
42461 }
42462
42463
42464 SWIGINTERN PyObject *_wrap_MenuItem_IsSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42465 PyObject *resultobj = 0;
42466 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42467 bool result;
42468 void *argp1 = 0 ;
42469 int res1 = 0 ;
42470 PyObject *swig_obj[1] ;
42471
42472 if (!args) SWIG_fail;
42473 swig_obj[0] = args;
42474 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42475 if (!SWIG_IsOK(res1)) {
42476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSeparator" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42477 }
42478 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42479 {
42480 PyThreadState* __tstate = wxPyBeginAllowThreads();
42481 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
42482 wxPyEndAllowThreads(__tstate);
42483 if (PyErr_Occurred()) SWIG_fail;
42484 }
42485 {
42486 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42487 }
42488 return resultobj;
42489 fail:
42490 return NULL;
42491 }
42492
42493
42494 SWIGINTERN PyObject *_wrap_MenuItem_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42495 PyObject *resultobj = 0;
42496 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42497 wxString *arg2 = 0 ;
42498 void *argp1 = 0 ;
42499 int res1 = 0 ;
42500 bool temp2 = false ;
42501 PyObject * obj0 = 0 ;
42502 PyObject * obj1 = 0 ;
42503 char * kwnames[] = {
42504 (char *) "self",(char *) "str", NULL
42505 };
42506
42507 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
42508 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42509 if (!SWIG_IsOK(res1)) {
42510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetText" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42511 }
42512 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42513 {
42514 arg2 = wxString_in_helper(obj1);
42515 if (arg2 == NULL) SWIG_fail;
42516 temp2 = true;
42517 }
42518 {
42519 PyThreadState* __tstate = wxPyBeginAllowThreads();
42520 (arg1)->SetText((wxString const &)*arg2);
42521 wxPyEndAllowThreads(__tstate);
42522 if (PyErr_Occurred()) SWIG_fail;
42523 }
42524 resultobj = SWIG_Py_Void();
42525 {
42526 if (temp2)
42527 delete arg2;
42528 }
42529 return resultobj;
42530 fail:
42531 {
42532 if (temp2)
42533 delete arg2;
42534 }
42535 return NULL;
42536 }
42537
42538
42539 SWIGINTERN PyObject *_wrap_MenuItem_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42540 PyObject *resultobj = 0;
42541 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42542 wxString result;
42543 void *argp1 = 0 ;
42544 int res1 = 0 ;
42545 PyObject *swig_obj[1] ;
42546
42547 if (!args) SWIG_fail;
42548 swig_obj[0] = args;
42549 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42550 if (!SWIG_IsOK(res1)) {
42551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetLabel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42552 }
42553 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42554 {
42555 PyThreadState* __tstate = wxPyBeginAllowThreads();
42556 result = ((wxMenuItem const *)arg1)->GetLabel();
42557 wxPyEndAllowThreads(__tstate);
42558 if (PyErr_Occurred()) SWIG_fail;
42559 }
42560 {
42561 #if wxUSE_UNICODE
42562 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42563 #else
42564 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42565 #endif
42566 }
42567 return resultobj;
42568 fail:
42569 return NULL;
42570 }
42571
42572
42573 SWIGINTERN PyObject *_wrap_MenuItem_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42574 PyObject *resultobj = 0;
42575 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42576 wxString *result = 0 ;
42577 void *argp1 = 0 ;
42578 int res1 = 0 ;
42579 PyObject *swig_obj[1] ;
42580
42581 if (!args) SWIG_fail;
42582 swig_obj[0] = args;
42583 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42584 if (!SWIG_IsOK(res1)) {
42585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetText" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42586 }
42587 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42588 {
42589 PyThreadState* __tstate = wxPyBeginAllowThreads();
42590 {
42591 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
42592 result = (wxString *) &_result_ref;
42593 }
42594 wxPyEndAllowThreads(__tstate);
42595 if (PyErr_Occurred()) SWIG_fail;
42596 }
42597 {
42598 #if wxUSE_UNICODE
42599 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
42600 #else
42601 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
42602 #endif
42603 }
42604 return resultobj;
42605 fail:
42606 return NULL;
42607 }
42608
42609
42610 SWIGINTERN PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42611 PyObject *resultobj = 0;
42612 wxString *arg1 = 0 ;
42613 wxString result;
42614 bool temp1 = false ;
42615 PyObject * obj0 = 0 ;
42616 char * kwnames[] = {
42617 (char *) "text", NULL
42618 };
42619
42620 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) SWIG_fail;
42621 {
42622 arg1 = wxString_in_helper(obj0);
42623 if (arg1 == NULL) SWIG_fail;
42624 temp1 = true;
42625 }
42626 {
42627 PyThreadState* __tstate = wxPyBeginAllowThreads();
42628 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
42629 wxPyEndAllowThreads(__tstate);
42630 if (PyErr_Occurred()) SWIG_fail;
42631 }
42632 {
42633 #if wxUSE_UNICODE
42634 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42635 #else
42636 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42637 #endif
42638 }
42639 {
42640 if (temp1)
42641 delete arg1;
42642 }
42643 return resultobj;
42644 fail:
42645 {
42646 if (temp1)
42647 delete arg1;
42648 }
42649 return NULL;
42650 }
42651
42652
42653 SWIGINTERN PyObject *_wrap_MenuItem_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42654 PyObject *resultobj = 0;
42655 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42656 wxItemKind result;
42657 void *argp1 = 0 ;
42658 int res1 = 0 ;
42659 PyObject *swig_obj[1] ;
42660
42661 if (!args) SWIG_fail;
42662 swig_obj[0] = args;
42663 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42664 if (!SWIG_IsOK(res1)) {
42665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetKind" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42666 }
42667 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42668 {
42669 PyThreadState* __tstate = wxPyBeginAllowThreads();
42670 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
42671 wxPyEndAllowThreads(__tstate);
42672 if (PyErr_Occurred()) SWIG_fail;
42673 }
42674 resultobj = SWIG_From_int(static_cast< int >(result));
42675 return resultobj;
42676 fail:
42677 return NULL;
42678 }
42679
42680
42681 SWIGINTERN PyObject *_wrap_MenuItem_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42682 PyObject *resultobj = 0;
42683 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42684 wxItemKind arg2 ;
42685 void *argp1 = 0 ;
42686 int res1 = 0 ;
42687 int val2 ;
42688 int ecode2 = 0 ;
42689 PyObject * obj0 = 0 ;
42690 PyObject * obj1 = 0 ;
42691 char * kwnames[] = {
42692 (char *) "self",(char *) "kind", NULL
42693 };
42694
42695 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
42696 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42697 if (!SWIG_IsOK(res1)) {
42698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetKind" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42699 }
42700 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42701 ecode2 = SWIG_AsVal_int(obj1, &val2);
42702 if (!SWIG_IsOK(ecode2)) {
42703 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetKind" "', expected argument " "2"" of type '" "wxItemKind""'");
42704 }
42705 arg2 = static_cast< wxItemKind >(val2);
42706 {
42707 PyThreadState* __tstate = wxPyBeginAllowThreads();
42708 (arg1)->SetKind(arg2);
42709 wxPyEndAllowThreads(__tstate);
42710 if (PyErr_Occurred()) SWIG_fail;
42711 }
42712 resultobj = SWIG_Py_Void();
42713 return resultobj;
42714 fail:
42715 return NULL;
42716 }
42717
42718
42719 SWIGINTERN PyObject *_wrap_MenuItem_SetCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42720 PyObject *resultobj = 0;
42721 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42722 bool arg2 ;
42723 void *argp1 = 0 ;
42724 int res1 = 0 ;
42725 bool val2 ;
42726 int ecode2 = 0 ;
42727 PyObject * obj0 = 0 ;
42728 PyObject * obj1 = 0 ;
42729 char * kwnames[] = {
42730 (char *) "self",(char *) "checkable", NULL
42731 };
42732
42733 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) SWIG_fail;
42734 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42735 if (!SWIG_IsOK(res1)) {
42736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetCheckable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42737 }
42738 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42739 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42740 if (!SWIG_IsOK(ecode2)) {
42741 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetCheckable" "', expected argument " "2"" of type '" "bool""'");
42742 }
42743 arg2 = static_cast< bool >(val2);
42744 {
42745 PyThreadState* __tstate = wxPyBeginAllowThreads();
42746 (arg1)->SetCheckable(arg2);
42747 wxPyEndAllowThreads(__tstate);
42748 if (PyErr_Occurred()) SWIG_fail;
42749 }
42750 resultobj = SWIG_Py_Void();
42751 return resultobj;
42752 fail:
42753 return NULL;
42754 }
42755
42756
42757 SWIGINTERN PyObject *_wrap_MenuItem_IsCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42758 PyObject *resultobj = 0;
42759 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42760 bool result;
42761 void *argp1 = 0 ;
42762 int res1 = 0 ;
42763 PyObject *swig_obj[1] ;
42764
42765 if (!args) SWIG_fail;
42766 swig_obj[0] = args;
42767 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42768 if (!SWIG_IsOK(res1)) {
42769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsCheckable" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42770 }
42771 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42772 {
42773 PyThreadState* __tstate = wxPyBeginAllowThreads();
42774 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
42775 wxPyEndAllowThreads(__tstate);
42776 if (PyErr_Occurred()) SWIG_fail;
42777 }
42778 {
42779 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42780 }
42781 return resultobj;
42782 fail:
42783 return NULL;
42784 }
42785
42786
42787 SWIGINTERN PyObject *_wrap_MenuItem_IsSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42788 PyObject *resultobj = 0;
42789 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42790 bool result;
42791 void *argp1 = 0 ;
42792 int res1 = 0 ;
42793 PyObject *swig_obj[1] ;
42794
42795 if (!args) SWIG_fail;
42796 swig_obj[0] = args;
42797 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42798 if (!SWIG_IsOK(res1)) {
42799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42800 }
42801 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42802 {
42803 PyThreadState* __tstate = wxPyBeginAllowThreads();
42804 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
42805 wxPyEndAllowThreads(__tstate);
42806 if (PyErr_Occurred()) SWIG_fail;
42807 }
42808 {
42809 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42810 }
42811 return resultobj;
42812 fail:
42813 return NULL;
42814 }
42815
42816
42817 SWIGINTERN PyObject *_wrap_MenuItem_SetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42818 PyObject *resultobj = 0;
42819 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42820 wxMenu *arg2 = (wxMenu *) 0 ;
42821 void *argp1 = 0 ;
42822 int res1 = 0 ;
42823 void *argp2 = 0 ;
42824 int res2 = 0 ;
42825 PyObject * obj0 = 0 ;
42826 PyObject * obj1 = 0 ;
42827 char * kwnames[] = {
42828 (char *) "self",(char *) "menu", NULL
42829 };
42830
42831 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42832 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42833 if (!SWIG_IsOK(res1)) {
42834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42835 }
42836 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42837 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42838 if (!SWIG_IsOK(res2)) {
42839 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
42840 }
42841 arg2 = reinterpret_cast< wxMenu * >(argp2);
42842 {
42843 PyThreadState* __tstate = wxPyBeginAllowThreads();
42844 (arg1)->SetSubMenu(arg2);
42845 wxPyEndAllowThreads(__tstate);
42846 if (PyErr_Occurred()) SWIG_fail;
42847 }
42848 resultobj = SWIG_Py_Void();
42849 return resultobj;
42850 fail:
42851 return NULL;
42852 }
42853
42854
42855 SWIGINTERN PyObject *_wrap_MenuItem_GetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42856 PyObject *resultobj = 0;
42857 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42858 wxMenu *result = 0 ;
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_GetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42868 }
42869 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42870 {
42871 PyThreadState* __tstate = wxPyBeginAllowThreads();
42872 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
42873 wxPyEndAllowThreads(__tstate);
42874 if (PyErr_Occurred()) SWIG_fail;
42875 }
42876 {
42877 resultobj = wxPyMake_wxObject(result, 0);
42878 }
42879 return resultobj;
42880 fail:
42881 return NULL;
42882 }
42883
42884
42885 SWIGINTERN PyObject *_wrap_MenuItem_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42886 PyObject *resultobj = 0;
42887 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42888 bool arg2 = (bool) true ;
42889 void *argp1 = 0 ;
42890 int res1 = 0 ;
42891 bool val2 ;
42892 int ecode2 = 0 ;
42893 PyObject * obj0 = 0 ;
42894 PyObject * obj1 = 0 ;
42895 char * kwnames[] = {
42896 (char *) "self",(char *) "enable", NULL
42897 };
42898
42899 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",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_Enable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42903 }
42904 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42905 if (obj1) {
42906 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42907 if (!SWIG_IsOK(ecode2)) {
42908 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Enable" "', expected argument " "2"" of type '" "bool""'");
42909 }
42910 arg2 = static_cast< bool >(val2);
42911 }
42912 {
42913 PyThreadState* __tstate = wxPyBeginAllowThreads();
42914 (arg1)->Enable(arg2);
42915 wxPyEndAllowThreads(__tstate);
42916 if (PyErr_Occurred()) SWIG_fail;
42917 }
42918 resultobj = SWIG_Py_Void();
42919 return resultobj;
42920 fail:
42921 return NULL;
42922 }
42923
42924
42925 SWIGINTERN PyObject *_wrap_MenuItem_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42926 PyObject *resultobj = 0;
42927 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42928 bool result;
42929 void *argp1 = 0 ;
42930 int res1 = 0 ;
42931 PyObject *swig_obj[1] ;
42932
42933 if (!args) SWIG_fail;
42934 swig_obj[0] = args;
42935 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42936 if (!SWIG_IsOK(res1)) {
42937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsEnabled" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42938 }
42939 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42940 {
42941 PyThreadState* __tstate = wxPyBeginAllowThreads();
42942 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
42943 wxPyEndAllowThreads(__tstate);
42944 if (PyErr_Occurred()) SWIG_fail;
42945 }
42946 {
42947 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42948 }
42949 return resultobj;
42950 fail:
42951 return NULL;
42952 }
42953
42954
42955 SWIGINTERN PyObject *_wrap_MenuItem_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42956 PyObject *resultobj = 0;
42957 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42958 bool arg2 = (bool) true ;
42959 void *argp1 = 0 ;
42960 int res1 = 0 ;
42961 bool val2 ;
42962 int ecode2 = 0 ;
42963 PyObject * obj0 = 0 ;
42964 PyObject * obj1 = 0 ;
42965 char * kwnames[] = {
42966 (char *) "self",(char *) "check", NULL
42967 };
42968
42969 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) SWIG_fail;
42970 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42971 if (!SWIG_IsOK(res1)) {
42972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Check" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42973 }
42974 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42975 if (obj1) {
42976 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42977 if (!SWIG_IsOK(ecode2)) {
42978 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Check" "', expected argument " "2"" of type '" "bool""'");
42979 }
42980 arg2 = static_cast< bool >(val2);
42981 }
42982 {
42983 PyThreadState* __tstate = wxPyBeginAllowThreads();
42984 (arg1)->Check(arg2);
42985 wxPyEndAllowThreads(__tstate);
42986 if (PyErr_Occurred()) SWIG_fail;
42987 }
42988 resultobj = SWIG_Py_Void();
42989 return resultobj;
42990 fail:
42991 return NULL;
42992 }
42993
42994
42995 SWIGINTERN PyObject *_wrap_MenuItem_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42996 PyObject *resultobj = 0;
42997 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42998 bool result;
42999 void *argp1 = 0 ;
43000 int res1 = 0 ;
43001 PyObject *swig_obj[1] ;
43002
43003 if (!args) SWIG_fail;
43004 swig_obj[0] = args;
43005 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43006 if (!SWIG_IsOK(res1)) {
43007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsChecked" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43008 }
43009 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43010 {
43011 PyThreadState* __tstate = wxPyBeginAllowThreads();
43012 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
43013 wxPyEndAllowThreads(__tstate);
43014 if (PyErr_Occurred()) SWIG_fail;
43015 }
43016 {
43017 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43018 }
43019 return resultobj;
43020 fail:
43021 return NULL;
43022 }
43023
43024
43025 SWIGINTERN PyObject *_wrap_MenuItem_Toggle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43026 PyObject *resultobj = 0;
43027 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43028 void *argp1 = 0 ;
43029 int res1 = 0 ;
43030 PyObject *swig_obj[1] ;
43031
43032 if (!args) SWIG_fail;
43033 swig_obj[0] = args;
43034 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43035 if (!SWIG_IsOK(res1)) {
43036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Toggle" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43037 }
43038 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43039 {
43040 PyThreadState* __tstate = wxPyBeginAllowThreads();
43041 (arg1)->Toggle();
43042 wxPyEndAllowThreads(__tstate);
43043 if (PyErr_Occurred()) SWIG_fail;
43044 }
43045 resultobj = SWIG_Py_Void();
43046 return resultobj;
43047 fail:
43048 return NULL;
43049 }
43050
43051
43052 SWIGINTERN PyObject *_wrap_MenuItem_SetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43053 PyObject *resultobj = 0;
43054 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43055 wxString *arg2 = 0 ;
43056 void *argp1 = 0 ;
43057 int res1 = 0 ;
43058 bool temp2 = false ;
43059 PyObject * obj0 = 0 ;
43060 PyObject * obj1 = 0 ;
43061 char * kwnames[] = {
43062 (char *) "self",(char *) "str", NULL
43063 };
43064
43065 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) SWIG_fail;
43066 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43067 if (!SWIG_IsOK(res1)) {
43068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetHelp" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43069 }
43070 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43071 {
43072 arg2 = wxString_in_helper(obj1);
43073 if (arg2 == NULL) SWIG_fail;
43074 temp2 = true;
43075 }
43076 {
43077 PyThreadState* __tstate = wxPyBeginAllowThreads();
43078 (arg1)->SetHelp((wxString const &)*arg2);
43079 wxPyEndAllowThreads(__tstate);
43080 if (PyErr_Occurred()) SWIG_fail;
43081 }
43082 resultobj = SWIG_Py_Void();
43083 {
43084 if (temp2)
43085 delete arg2;
43086 }
43087 return resultobj;
43088 fail:
43089 {
43090 if (temp2)
43091 delete arg2;
43092 }
43093 return NULL;
43094 }
43095
43096
43097 SWIGINTERN PyObject *_wrap_MenuItem_GetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43098 PyObject *resultobj = 0;
43099 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43100 wxString *result = 0 ;
43101 void *argp1 = 0 ;
43102 int res1 = 0 ;
43103 PyObject *swig_obj[1] ;
43104
43105 if (!args) SWIG_fail;
43106 swig_obj[0] = args;
43107 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43108 if (!SWIG_IsOK(res1)) {
43109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetHelp" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43110 }
43111 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43112 {
43113 PyThreadState* __tstate = wxPyBeginAllowThreads();
43114 {
43115 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
43116 result = (wxString *) &_result_ref;
43117 }
43118 wxPyEndAllowThreads(__tstate);
43119 if (PyErr_Occurred()) SWIG_fail;
43120 }
43121 {
43122 #if wxUSE_UNICODE
43123 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
43124 #else
43125 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
43126 #endif
43127 }
43128 return resultobj;
43129 fail:
43130 return NULL;
43131 }
43132
43133
43134 SWIGINTERN PyObject *_wrap_MenuItem_GetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43135 PyObject *resultobj = 0;
43136 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43137 wxAcceleratorEntry *result = 0 ;
43138 void *argp1 = 0 ;
43139 int res1 = 0 ;
43140 PyObject *swig_obj[1] ;
43141
43142 if (!args) SWIG_fail;
43143 swig_obj[0] = args;
43144 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43145 if (!SWIG_IsOK(res1)) {
43146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetAccel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43147 }
43148 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43149 {
43150 PyThreadState* __tstate = wxPyBeginAllowThreads();
43151 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
43152 wxPyEndAllowThreads(__tstate);
43153 if (PyErr_Occurred()) SWIG_fail;
43154 }
43155 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
43156 return resultobj;
43157 fail:
43158 return NULL;
43159 }
43160
43161
43162 SWIGINTERN PyObject *_wrap_MenuItem_SetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43163 PyObject *resultobj = 0;
43164 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43165 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
43166 void *argp1 = 0 ;
43167 int res1 = 0 ;
43168 void *argp2 = 0 ;
43169 int res2 = 0 ;
43170 PyObject * obj0 = 0 ;
43171 PyObject * obj1 = 0 ;
43172 char * kwnames[] = {
43173 (char *) "self",(char *) "accel", NULL
43174 };
43175
43176 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) SWIG_fail;
43177 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43178 if (!SWIG_IsOK(res1)) {
43179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetAccel" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43180 }
43181 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43182 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
43183 if (!SWIG_IsOK(res2)) {
43184 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetAccel" "', expected argument " "2"" of type '" "wxAcceleratorEntry *""'");
43185 }
43186 arg2 = reinterpret_cast< wxAcceleratorEntry * >(argp2);
43187 {
43188 PyThreadState* __tstate = wxPyBeginAllowThreads();
43189 (arg1)->SetAccel(arg2);
43190 wxPyEndAllowThreads(__tstate);
43191 if (PyErr_Occurred()) SWIG_fail;
43192 }
43193 resultobj = SWIG_Py_Void();
43194 return resultobj;
43195 fail:
43196 return NULL;
43197 }
43198
43199
43200 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43201 PyObject *resultobj = 0;
43202 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43203 wxBitmap *arg2 = 0 ;
43204 void *argp1 = 0 ;
43205 int res1 = 0 ;
43206 void *argp2 = 0 ;
43207 int res2 = 0 ;
43208 PyObject * obj0 = 0 ;
43209 PyObject * obj1 = 0 ;
43210 char * kwnames[] = {
43211 (char *) "self",(char *) "bitmap", NULL
43212 };
43213
43214 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
43215 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43216 if (!SWIG_IsOK(res1)) {
43217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43218 }
43219 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43220 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43221 if (!SWIG_IsOK(res2)) {
43222 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43223 }
43224 if (!argp2) {
43225 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43226 }
43227 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43228 {
43229 PyThreadState* __tstate = wxPyBeginAllowThreads();
43230 (arg1)->SetBitmap((wxBitmap const &)*arg2);
43231 wxPyEndAllowThreads(__tstate);
43232 if (PyErr_Occurred()) SWIG_fail;
43233 }
43234 resultobj = SWIG_Py_Void();
43235 return resultobj;
43236 fail:
43237 return NULL;
43238 }
43239
43240
43241 SWIGINTERN PyObject *_wrap_MenuItem_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43242 PyObject *resultobj = 0;
43243 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43244 wxBitmap *result = 0 ;
43245 void *argp1 = 0 ;
43246 int res1 = 0 ;
43247 PyObject *swig_obj[1] ;
43248
43249 if (!args) SWIG_fail;
43250 swig_obj[0] = args;
43251 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43252 if (!SWIG_IsOK(res1)) {
43253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43254 }
43255 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43256 {
43257 PyThreadState* __tstate = wxPyBeginAllowThreads();
43258 {
43259 wxBitmap const &_result_ref = (arg1)->GetBitmap();
43260 result = (wxBitmap *) &_result_ref;
43261 }
43262 wxPyEndAllowThreads(__tstate);
43263 if (PyErr_Occurred()) SWIG_fail;
43264 }
43265 {
43266 wxBitmap* resultptr = new wxBitmap(*result);
43267 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
43268 }
43269 return resultobj;
43270 fail:
43271 return NULL;
43272 }
43273
43274
43275 SWIGINTERN PyObject *_wrap_MenuItem_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43276 PyObject *resultobj = 0;
43277 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43278 wxFont *arg2 = 0 ;
43279 void *argp1 = 0 ;
43280 int res1 = 0 ;
43281 void *argp2 = 0 ;
43282 int res2 = 0 ;
43283 PyObject * obj0 = 0 ;
43284 PyObject * obj1 = 0 ;
43285 char * kwnames[] = {
43286 (char *) "self",(char *) "font", NULL
43287 };
43288
43289 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
43290 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43291 if (!SWIG_IsOK(res1)) {
43292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43293 }
43294 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43295 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
43296 if (!SWIG_IsOK(res2)) {
43297 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
43298 }
43299 if (!argp2) {
43300 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
43301 }
43302 arg2 = reinterpret_cast< wxFont * >(argp2);
43303 {
43304 PyThreadState* __tstate = wxPyBeginAllowThreads();
43305 wxMenuItem_SetFont(arg1,(wxFont const &)*arg2);
43306 wxPyEndAllowThreads(__tstate);
43307 if (PyErr_Occurred()) SWIG_fail;
43308 }
43309 resultobj = SWIG_Py_Void();
43310 return resultobj;
43311 fail:
43312 return NULL;
43313 }
43314
43315
43316 SWIGINTERN PyObject *_wrap_MenuItem_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43317 PyObject *resultobj = 0;
43318 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43319 wxFont result;
43320 void *argp1 = 0 ;
43321 int res1 = 0 ;
43322 PyObject *swig_obj[1] ;
43323
43324 if (!args) SWIG_fail;
43325 swig_obj[0] = args;
43326 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43327 if (!SWIG_IsOK(res1)) {
43328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43329 }
43330 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43331 {
43332 PyThreadState* __tstate = wxPyBeginAllowThreads();
43333 result = wxMenuItem_GetFont(arg1);
43334 wxPyEndAllowThreads(__tstate);
43335 if (PyErr_Occurred()) SWIG_fail;
43336 }
43337 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
43338 return resultobj;
43339 fail:
43340 return NULL;
43341 }
43342
43343
43344 SWIGINTERN PyObject *_wrap_MenuItem_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43345 PyObject *resultobj = 0;
43346 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43347 wxColour *arg2 = 0 ;
43348 void *argp1 = 0 ;
43349 int res1 = 0 ;
43350 wxColour temp2 ;
43351 PyObject * obj0 = 0 ;
43352 PyObject * obj1 = 0 ;
43353 char * kwnames[] = {
43354 (char *) "self",(char *) "colText", NULL
43355 };
43356
43357 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",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_SetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43361 }
43362 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43363 {
43364 arg2 = &temp2;
43365 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
43366 }
43367 {
43368 PyThreadState* __tstate = wxPyBeginAllowThreads();
43369 wxMenuItem_SetTextColour(arg1,(wxColour const &)*arg2);
43370 wxPyEndAllowThreads(__tstate);
43371 if (PyErr_Occurred()) SWIG_fail;
43372 }
43373 resultobj = SWIG_Py_Void();
43374 return resultobj;
43375 fail:
43376 return NULL;
43377 }
43378
43379
43380 SWIGINTERN PyObject *_wrap_MenuItem_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43381 PyObject *resultobj = 0;
43382 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43383 wxColour result;
43384 void *argp1 = 0 ;
43385 int res1 = 0 ;
43386 PyObject *swig_obj[1] ;
43387
43388 if (!args) SWIG_fail;
43389 swig_obj[0] = args;
43390 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43391 if (!SWIG_IsOK(res1)) {
43392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43393 }
43394 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43395 {
43396 PyThreadState* __tstate = wxPyBeginAllowThreads();
43397 result = wxMenuItem_GetTextColour(arg1);
43398 wxPyEndAllowThreads(__tstate);
43399 if (PyErr_Occurred()) SWIG_fail;
43400 }
43401 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
43402 return resultobj;
43403 fail:
43404 return NULL;
43405 }
43406
43407
43408 SWIGINTERN PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43409 PyObject *resultobj = 0;
43410 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43411 wxColour *arg2 = 0 ;
43412 void *argp1 = 0 ;
43413 int res1 = 0 ;
43414 wxColour temp2 ;
43415 PyObject * obj0 = 0 ;
43416 PyObject * obj1 = 0 ;
43417 char * kwnames[] = {
43418 (char *) "self",(char *) "colBack", NULL
43419 };
43420
43421 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
43422 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43423 if (!SWIG_IsOK(res1)) {
43424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43425 }
43426 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43427 {
43428 arg2 = &temp2;
43429 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
43430 }
43431 {
43432 PyThreadState* __tstate = wxPyBeginAllowThreads();
43433 wxMenuItem_SetBackgroundColour(arg1,(wxColour const &)*arg2);
43434 wxPyEndAllowThreads(__tstate);
43435 if (PyErr_Occurred()) SWIG_fail;
43436 }
43437 resultobj = SWIG_Py_Void();
43438 return resultobj;
43439 fail:
43440 return NULL;
43441 }
43442
43443
43444 SWIGINTERN PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43445 PyObject *resultobj = 0;
43446 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43447 wxColour result;
43448 void *argp1 = 0 ;
43449 int res1 = 0 ;
43450 PyObject *swig_obj[1] ;
43451
43452 if (!args) SWIG_fail;
43453 swig_obj[0] = args;
43454 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43455 if (!SWIG_IsOK(res1)) {
43456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43457 }
43458 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43459 {
43460 PyThreadState* __tstate = wxPyBeginAllowThreads();
43461 result = wxMenuItem_GetBackgroundColour(arg1);
43462 wxPyEndAllowThreads(__tstate);
43463 if (PyErr_Occurred()) SWIG_fail;
43464 }
43465 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
43466 return resultobj;
43467 fail:
43468 return NULL;
43469 }
43470
43471
43472 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43473 PyObject *resultobj = 0;
43474 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43475 wxBitmap *arg2 = 0 ;
43476 wxBitmap const &arg3_defvalue = wxNullBitmap ;
43477 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
43478 void *argp1 = 0 ;
43479 int res1 = 0 ;
43480 void *argp2 = 0 ;
43481 int res2 = 0 ;
43482 void *argp3 = 0 ;
43483 int res3 = 0 ;
43484 PyObject * obj0 = 0 ;
43485 PyObject * obj1 = 0 ;
43486 PyObject * obj2 = 0 ;
43487 char * kwnames[] = {
43488 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
43489 };
43490
43491 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43492 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43493 if (!SWIG_IsOK(res1)) {
43494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmaps" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43495 }
43496 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43497 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43498 if (!SWIG_IsOK(res2)) {
43499 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43500 }
43501 if (!argp2) {
43502 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43503 }
43504 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43505 if (obj2) {
43506 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
43507 if (!SWIG_IsOK(res3)) {
43508 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
43509 }
43510 if (!argp3) {
43511 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
43512 }
43513 arg3 = reinterpret_cast< wxBitmap * >(argp3);
43514 }
43515 {
43516 PyThreadState* __tstate = wxPyBeginAllowThreads();
43517 wxMenuItem_SetBitmaps(arg1,(wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
43518 wxPyEndAllowThreads(__tstate);
43519 if (PyErr_Occurred()) SWIG_fail;
43520 }
43521 resultobj = SWIG_Py_Void();
43522 return resultobj;
43523 fail:
43524 return NULL;
43525 }
43526
43527
43528 SWIGINTERN PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43529 PyObject *resultobj = 0;
43530 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43531 wxBitmap *arg2 = 0 ;
43532 void *argp1 = 0 ;
43533 int res1 = 0 ;
43534 void *argp2 = 0 ;
43535 int res2 = 0 ;
43536 PyObject * obj0 = 0 ;
43537 PyObject * obj1 = 0 ;
43538 char * kwnames[] = {
43539 (char *) "self",(char *) "bmpDisabled", NULL
43540 };
43541
43542 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
43543 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43544 if (!SWIG_IsOK(res1)) {
43545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43546 }
43547 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43548 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43549 if (!SWIG_IsOK(res2)) {
43550 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43551 }
43552 if (!argp2) {
43553 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43554 }
43555 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43556 {
43557 PyThreadState* __tstate = wxPyBeginAllowThreads();
43558 wxMenuItem_SetDisabledBitmap(arg1,(wxBitmap const &)*arg2);
43559 wxPyEndAllowThreads(__tstate);
43560 if (PyErr_Occurred()) SWIG_fail;
43561 }
43562 resultobj = SWIG_Py_Void();
43563 return resultobj;
43564 fail:
43565 return NULL;
43566 }
43567
43568
43569 SWIGINTERN PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43570 PyObject *resultobj = 0;
43571 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43572 wxBitmap *result = 0 ;
43573 void *argp1 = 0 ;
43574 int res1 = 0 ;
43575 PyObject *swig_obj[1] ;
43576
43577 if (!args) SWIG_fail;
43578 swig_obj[0] = args;
43579 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43580 if (!SWIG_IsOK(res1)) {
43581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43582 }
43583 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43584 {
43585 PyThreadState* __tstate = wxPyBeginAllowThreads();
43586 {
43587 wxBitmap const &_result_ref = wxMenuItem_GetDisabledBitmap((wxMenuItem const *)arg1);
43588 result = (wxBitmap *) &_result_ref;
43589 }
43590 wxPyEndAllowThreads(__tstate);
43591 if (PyErr_Occurred()) SWIG_fail;
43592 }
43593 {
43594 wxBitmap* resultptr = new wxBitmap(*result);
43595 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
43596 }
43597 return resultobj;
43598 fail:
43599 return NULL;
43600 }
43601
43602
43603 SWIGINTERN PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43604 PyObject *resultobj = 0;
43605 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43606 int arg2 ;
43607 void *argp1 = 0 ;
43608 int res1 = 0 ;
43609 int val2 ;
43610 int ecode2 = 0 ;
43611 PyObject * obj0 = 0 ;
43612 PyObject * obj1 = 0 ;
43613 char * kwnames[] = {
43614 (char *) "self",(char *) "nWidth", NULL
43615 };
43616
43617 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) SWIG_fail;
43618 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43619 if (!SWIG_IsOK(res1)) {
43620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43621 }
43622 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43623 ecode2 = SWIG_AsVal_int(obj1, &val2);
43624 if (!SWIG_IsOK(ecode2)) {
43625 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "2"" of type '" "int""'");
43626 }
43627 arg2 = static_cast< int >(val2);
43628 {
43629 PyThreadState* __tstate = wxPyBeginAllowThreads();
43630 wxMenuItem_SetMarginWidth(arg1,arg2);
43631 wxPyEndAllowThreads(__tstate);
43632 if (PyErr_Occurred()) SWIG_fail;
43633 }
43634 resultobj = SWIG_Py_Void();
43635 return resultobj;
43636 fail:
43637 return NULL;
43638 }
43639
43640
43641 SWIGINTERN PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43642 PyObject *resultobj = 0;
43643 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43644 int result;
43645 void *argp1 = 0 ;
43646 int res1 = 0 ;
43647 PyObject *swig_obj[1] ;
43648
43649 if (!args) SWIG_fail;
43650 swig_obj[0] = args;
43651 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43652 if (!SWIG_IsOK(res1)) {
43653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43654 }
43655 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43656 {
43657 PyThreadState* __tstate = wxPyBeginAllowThreads();
43658 result = (int)wxMenuItem_GetMarginWidth(arg1);
43659 wxPyEndAllowThreads(__tstate);
43660 if (PyErr_Occurred()) SWIG_fail;
43661 }
43662 resultobj = SWIG_From_int(static_cast< int >(result));
43663 return resultobj;
43664 fail:
43665 return NULL;
43666 }
43667
43668
43669 SWIGINTERN PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43670 PyObject *resultobj = 0;
43671 int result;
43672
43673 if (!SWIG_Python_UnpackTuple(args,"MenuItem_GetDefaultMarginWidth",0,0,0)) SWIG_fail;
43674 {
43675 PyThreadState* __tstate = wxPyBeginAllowThreads();
43676 result = (int)wxMenuItem_GetDefaultMarginWidth();
43677 wxPyEndAllowThreads(__tstate);
43678 if (PyErr_Occurred()) SWIG_fail;
43679 }
43680 resultobj = SWIG_From_int(static_cast< int >(result));
43681 return resultobj;
43682 fail:
43683 return NULL;
43684 }
43685
43686
43687 SWIGINTERN PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43688 PyObject *resultobj = 0;
43689 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43690 bool result;
43691 void *argp1 = 0 ;
43692 int res1 = 0 ;
43693 PyObject *swig_obj[1] ;
43694
43695 if (!args) SWIG_fail;
43696 swig_obj[0] = args;
43697 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43698 if (!SWIG_IsOK(res1)) {
43699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43700 }
43701 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43702 {
43703 PyThreadState* __tstate = wxPyBeginAllowThreads();
43704 result = (bool)wxMenuItem_IsOwnerDrawn(arg1);
43705 wxPyEndAllowThreads(__tstate);
43706 if (PyErr_Occurred()) SWIG_fail;
43707 }
43708 {
43709 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43710 }
43711 return resultobj;
43712 fail:
43713 return NULL;
43714 }
43715
43716
43717 SWIGINTERN PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43718 PyObject *resultobj = 0;
43719 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43720 bool arg2 = (bool) true ;
43721 void *argp1 = 0 ;
43722 int res1 = 0 ;
43723 bool val2 ;
43724 int ecode2 = 0 ;
43725 PyObject * obj0 = 0 ;
43726 PyObject * obj1 = 0 ;
43727 char * kwnames[] = {
43728 (char *) "self",(char *) "ownerDrawn", NULL
43729 };
43730
43731 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) SWIG_fail;
43732 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43733 if (!SWIG_IsOK(res1)) {
43734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43735 }
43736 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43737 if (obj1) {
43738 ecode2 = SWIG_AsVal_bool(obj1, &val2);
43739 if (!SWIG_IsOK(ecode2)) {
43740 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "2"" of type '" "bool""'");
43741 }
43742 arg2 = static_cast< bool >(val2);
43743 }
43744 {
43745 PyThreadState* __tstate = wxPyBeginAllowThreads();
43746 wxMenuItem_SetOwnerDrawn(arg1,arg2);
43747 wxPyEndAllowThreads(__tstate);
43748 if (PyErr_Occurred()) SWIG_fail;
43749 }
43750 resultobj = SWIG_Py_Void();
43751 return resultobj;
43752 fail:
43753 return NULL;
43754 }
43755
43756
43757 SWIGINTERN PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43758 PyObject *resultobj = 0;
43759 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43760 void *argp1 = 0 ;
43761 int res1 = 0 ;
43762 PyObject *swig_obj[1] ;
43763
43764 if (!args) SWIG_fail;
43765 swig_obj[0] = args;
43766 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43767 if (!SWIG_IsOK(res1)) {
43768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_ResetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43769 }
43770 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43771 {
43772 PyThreadState* __tstate = wxPyBeginAllowThreads();
43773 wxMenuItem_ResetOwnerDrawn(arg1);
43774 wxPyEndAllowThreads(__tstate);
43775 if (PyErr_Occurred()) SWIG_fail;
43776 }
43777 resultobj = SWIG_Py_Void();
43778 return resultobj;
43779 fail:
43780 return NULL;
43781 }
43782
43783
43784 SWIGINTERN PyObject *MenuItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43785 PyObject *obj;
43786 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
43787 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuItem, SWIG_NewClientData(obj));
43788 return SWIG_Py_Void();
43789 }
43790
43791 SWIGINTERN PyObject *MenuItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43792 return SWIG_Python_InitShadowInstance(args);
43793 }
43794
43795 SWIGINTERN int ControlNameStr_set(PyObject *) {
43796 SWIG_Error(SWIG_AttributeError,"Variable ControlNameStr is read-only.");
43797 return 1;
43798 }
43799
43800
43801 SWIGINTERN PyObject *ControlNameStr_get(void) {
43802 PyObject *pyobj = 0;
43803
43804 {
43805 #if wxUSE_UNICODE
43806 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
43807 #else
43808 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
43809 #endif
43810 }
43811 return pyobj;
43812 }
43813
43814
43815 SWIGINTERN PyObject *_wrap_new_Control(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43816 PyObject *resultobj = 0;
43817 wxWindow *arg1 = (wxWindow *) 0 ;
43818 int arg2 = (int) -1 ;
43819 wxPoint const &arg3_defvalue = wxDefaultPosition ;
43820 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
43821 wxSize const &arg4_defvalue = wxDefaultSize ;
43822 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
43823 long arg5 = (long) 0 ;
43824 wxValidator const &arg6_defvalue = wxDefaultValidator ;
43825 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
43826 wxString const &arg7_defvalue = wxPyControlNameStr ;
43827 wxString *arg7 = (wxString *) &arg7_defvalue ;
43828 wxControl *result = 0 ;
43829 void *argp1 = 0 ;
43830 int res1 = 0 ;
43831 int val2 ;
43832 int ecode2 = 0 ;
43833 wxPoint temp3 ;
43834 wxSize temp4 ;
43835 long val5 ;
43836 int ecode5 = 0 ;
43837 void *argp6 = 0 ;
43838 int res6 = 0 ;
43839 bool temp7 = false ;
43840 PyObject * obj0 = 0 ;
43841 PyObject * obj1 = 0 ;
43842 PyObject * obj2 = 0 ;
43843 PyObject * obj3 = 0 ;
43844 PyObject * obj4 = 0 ;
43845 PyObject * obj5 = 0 ;
43846 PyObject * obj6 = 0 ;
43847 char * kwnames[] = {
43848 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
43849 };
43850
43851 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
43852 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
43853 if (!SWIG_IsOK(res1)) {
43854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Control" "', expected argument " "1"" of type '" "wxWindow *""'");
43855 }
43856 arg1 = reinterpret_cast< wxWindow * >(argp1);
43857 if (obj1) {
43858 ecode2 = SWIG_AsVal_int(obj1, &val2);
43859 if (!SWIG_IsOK(ecode2)) {
43860 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Control" "', expected argument " "2"" of type '" "int""'");
43861 }
43862 arg2 = static_cast< int >(val2);
43863 }
43864 if (obj2) {
43865 {
43866 arg3 = &temp3;
43867 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
43868 }
43869 }
43870 if (obj3) {
43871 {
43872 arg4 = &temp4;
43873 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
43874 }
43875 }
43876 if (obj4) {
43877 ecode5 = SWIG_AsVal_long(obj4, &val5);
43878 if (!SWIG_IsOK(ecode5)) {
43879 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Control" "', expected argument " "5"" of type '" "long""'");
43880 }
43881 arg5 = static_cast< long >(val5);
43882 }
43883 if (obj5) {
43884 res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_wxValidator, 0 | 0);
43885 if (!SWIG_IsOK(res6)) {
43886 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
43887 }
43888 if (!argp6) {
43889 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
43890 }
43891 arg6 = reinterpret_cast< wxValidator * >(argp6);
43892 }
43893 if (obj6) {
43894 {
43895 arg7 = wxString_in_helper(obj6);
43896 if (arg7 == NULL) SWIG_fail;
43897 temp7 = true;
43898 }
43899 }
43900 {
43901 if (!wxPyCheckForApp()) SWIG_fail;
43902 PyThreadState* __tstate = wxPyBeginAllowThreads();
43903 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
43904 wxPyEndAllowThreads(__tstate);
43905 if (PyErr_Occurred()) SWIG_fail;
43906 }
43907 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_NEW | 0 );
43908 {
43909 if (temp7)
43910 delete arg7;
43911 }
43912 return resultobj;
43913 fail:
43914 {
43915 if (temp7)
43916 delete arg7;
43917 }
43918 return NULL;
43919 }
43920
43921
43922 SWIGINTERN PyObject *_wrap_new_PreControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43923 PyObject *resultobj = 0;
43924 wxControl *result = 0 ;
43925
43926 if (!SWIG_Python_UnpackTuple(args,"new_PreControl",0,0,0)) SWIG_fail;
43927 {
43928 if (!wxPyCheckForApp()) SWIG_fail;
43929 PyThreadState* __tstate = wxPyBeginAllowThreads();
43930 result = (wxControl *)new wxControl();
43931 wxPyEndAllowThreads(__tstate);
43932 if (PyErr_Occurred()) SWIG_fail;
43933 }
43934 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_OWN | 0 );
43935 return resultobj;
43936 fail:
43937 return NULL;
43938 }
43939
43940
43941 SWIGINTERN PyObject *_wrap_Control_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43942 PyObject *resultobj = 0;
43943 wxControl *arg1 = (wxControl *) 0 ;
43944 wxWindow *arg2 = (wxWindow *) 0 ;
43945 int arg3 = (int) -1 ;
43946 wxPoint const &arg4_defvalue = wxDefaultPosition ;
43947 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
43948 wxSize const &arg5_defvalue = wxDefaultSize ;
43949 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
43950 long arg6 = (long) 0 ;
43951 wxValidator const &arg7_defvalue = wxDefaultValidator ;
43952 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
43953 wxString const &arg8_defvalue = wxPyControlNameStr ;
43954 wxString *arg8 = (wxString *) &arg8_defvalue ;
43955 bool result;
43956 void *argp1 = 0 ;
43957 int res1 = 0 ;
43958 void *argp2 = 0 ;
43959 int res2 = 0 ;
43960 int val3 ;
43961 int ecode3 = 0 ;
43962 wxPoint temp4 ;
43963 wxSize temp5 ;
43964 long val6 ;
43965 int ecode6 = 0 ;
43966 void *argp7 = 0 ;
43967 int res7 = 0 ;
43968 bool temp8 = false ;
43969 PyObject * obj0 = 0 ;
43970 PyObject * obj1 = 0 ;
43971 PyObject * obj2 = 0 ;
43972 PyObject * obj3 = 0 ;
43973 PyObject * obj4 = 0 ;
43974 PyObject * obj5 = 0 ;
43975 PyObject * obj6 = 0 ;
43976 PyObject * obj7 = 0 ;
43977 char * kwnames[] = {
43978 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
43979 };
43980
43981 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
43982 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
43983 if (!SWIG_IsOK(res1)) {
43984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Create" "', expected argument " "1"" of type '" "wxControl *""'");
43985 }
43986 arg1 = reinterpret_cast< wxControl * >(argp1);
43987 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
43988 if (!SWIG_IsOK(res2)) {
43989 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
43990 }
43991 arg2 = reinterpret_cast< wxWindow * >(argp2);
43992 if (obj2) {
43993 ecode3 = SWIG_AsVal_int(obj2, &val3);
43994 if (!SWIG_IsOK(ecode3)) {
43995 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Control_Create" "', expected argument " "3"" of type '" "int""'");
43996 }
43997 arg3 = static_cast< int >(val3);
43998 }
43999 if (obj3) {
44000 {
44001 arg4 = &temp4;
44002 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
44003 }
44004 }
44005 if (obj4) {
44006 {
44007 arg5 = &temp5;
44008 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
44009 }
44010 }
44011 if (obj5) {
44012 ecode6 = SWIG_AsVal_long(obj5, &val6);
44013 if (!SWIG_IsOK(ecode6)) {
44014 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Control_Create" "', expected argument " "6"" of type '" "long""'");
44015 }
44016 arg6 = static_cast< long >(val6);
44017 }
44018 if (obj6) {
44019 res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator, 0 | 0);
44020 if (!SWIG_IsOK(res7)) {
44021 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
44022 }
44023 if (!argp7) {
44024 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
44025 }
44026 arg7 = reinterpret_cast< wxValidator * >(argp7);
44027 }
44028 if (obj7) {
44029 {
44030 arg8 = wxString_in_helper(obj7);
44031 if (arg8 == NULL) SWIG_fail;
44032 temp8 = true;
44033 }
44034 }
44035 {
44036 PyThreadState* __tstate = wxPyBeginAllowThreads();
44037 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
44038 wxPyEndAllowThreads(__tstate);
44039 if (PyErr_Occurred()) SWIG_fail;
44040 }
44041 {
44042 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44043 }
44044 {
44045 if (temp8)
44046 delete arg8;
44047 }
44048 return resultobj;
44049 fail:
44050 {
44051 if (temp8)
44052 delete arg8;
44053 }
44054 return NULL;
44055 }
44056
44057
44058 SWIGINTERN PyObject *_wrap_Control_Command(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44059 PyObject *resultobj = 0;
44060 wxControl *arg1 = (wxControl *) 0 ;
44061 wxCommandEvent *arg2 = 0 ;
44062 void *argp1 = 0 ;
44063 int res1 = 0 ;
44064 void *argp2 = 0 ;
44065 int res2 = 0 ;
44066 PyObject * obj0 = 0 ;
44067 PyObject * obj1 = 0 ;
44068 char * kwnames[] = {
44069 (char *) "self",(char *) "event", NULL
44070 };
44071
44072 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) SWIG_fail;
44073 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44074 if (!SWIG_IsOK(res1)) {
44075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Command" "', expected argument " "1"" of type '" "wxControl *""'");
44076 }
44077 arg1 = reinterpret_cast< wxControl * >(argp1);
44078 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCommandEvent, 0 );
44079 if (!SWIG_IsOK(res2)) {
44080 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
44081 }
44082 if (!argp2) {
44083 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
44084 }
44085 arg2 = reinterpret_cast< wxCommandEvent * >(argp2);
44086 {
44087 PyThreadState* __tstate = wxPyBeginAllowThreads();
44088 (arg1)->Command(*arg2);
44089 wxPyEndAllowThreads(__tstate);
44090 if (PyErr_Occurred()) SWIG_fail;
44091 }
44092 resultobj = SWIG_Py_Void();
44093 return resultobj;
44094 fail:
44095 return NULL;
44096 }
44097
44098
44099 SWIGINTERN PyObject *_wrap_Control_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44100 PyObject *resultobj = 0;
44101 wxControl *arg1 = (wxControl *) 0 ;
44102 wxString result;
44103 void *argp1 = 0 ;
44104 int res1 = 0 ;
44105 PyObject *swig_obj[1] ;
44106
44107 if (!args) SWIG_fail;
44108 swig_obj[0] = args;
44109 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44110 if (!SWIG_IsOK(res1)) {
44111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabel" "', expected argument " "1"" of type '" "wxControl *""'");
44112 }
44113 arg1 = reinterpret_cast< wxControl * >(argp1);
44114 {
44115 PyThreadState* __tstate = wxPyBeginAllowThreads();
44116 result = (arg1)->GetLabel();
44117 wxPyEndAllowThreads(__tstate);
44118 if (PyErr_Occurred()) SWIG_fail;
44119 }
44120 {
44121 #if wxUSE_UNICODE
44122 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44123 #else
44124 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44125 #endif
44126 }
44127 return resultobj;
44128 fail:
44129 return NULL;
44130 }
44131
44132
44133 SWIGINTERN PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44134 PyObject *resultobj = 0;
44135 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
44136 SwigValueWrapper<wxVisualAttributes > result;
44137 int val1 ;
44138 int ecode1 = 0 ;
44139 PyObject * obj0 = 0 ;
44140 char * kwnames[] = {
44141 (char *) "variant", NULL
44142 };
44143
44144 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
44145 if (obj0) {
44146 ecode1 = SWIG_AsVal_int(obj0, &val1);
44147 if (!SWIG_IsOK(ecode1)) {
44148 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Control_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
44149 }
44150 arg1 = static_cast< wxWindowVariant >(val1);
44151 }
44152 {
44153 if (!wxPyCheckForApp()) SWIG_fail;
44154 PyThreadState* __tstate = wxPyBeginAllowThreads();
44155 result = wxControl::GetClassDefaultAttributes(arg1);
44156 wxPyEndAllowThreads(__tstate);
44157 if (PyErr_Occurred()) SWIG_fail;
44158 }
44159 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
44160 return resultobj;
44161 fail:
44162 return NULL;
44163 }
44164
44165
44166 SWIGINTERN PyObject *Control_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44167 PyObject *obj;
44168 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44169 SWIG_TypeNewClientData(SWIGTYPE_p_wxControl, SWIG_NewClientData(obj));
44170 return SWIG_Py_Void();
44171 }
44172
44173 SWIGINTERN PyObject *Control_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44174 return SWIG_Python_InitShadowInstance(args);
44175 }
44176
44177 SWIGINTERN PyObject *_wrap_ItemContainer_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44178 PyObject *resultobj = 0;
44179 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44180 wxString *arg2 = 0 ;
44181 PyObject *arg3 = (PyObject *) NULL ;
44182 int result;
44183 void *argp1 = 0 ;
44184 int res1 = 0 ;
44185 bool temp2 = false ;
44186 PyObject * obj0 = 0 ;
44187 PyObject * obj1 = 0 ;
44188 PyObject * obj2 = 0 ;
44189 char * kwnames[] = {
44190 (char *) "self",(char *) "item",(char *) "clientData", NULL
44191 };
44192
44193 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44194 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44195 if (!SWIG_IsOK(res1)) {
44196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Append" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44197 }
44198 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44199 {
44200 arg2 = wxString_in_helper(obj1);
44201 if (arg2 == NULL) SWIG_fail;
44202 temp2 = true;
44203 }
44204 if (obj2) {
44205 arg3 = obj2;
44206 }
44207 {
44208 PyThreadState* __tstate = wxPyBeginAllowThreads();
44209 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
44210 wxPyEndAllowThreads(__tstate);
44211 if (PyErr_Occurred()) SWIG_fail;
44212 }
44213 resultobj = SWIG_From_int(static_cast< int >(result));
44214 {
44215 if (temp2)
44216 delete arg2;
44217 }
44218 return resultobj;
44219 fail:
44220 {
44221 if (temp2)
44222 delete arg2;
44223 }
44224 return NULL;
44225 }
44226
44227
44228 SWIGINTERN PyObject *_wrap_ItemContainer_AppendItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44229 PyObject *resultobj = 0;
44230 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44231 wxArrayString *arg2 = 0 ;
44232 void *argp1 = 0 ;
44233 int res1 = 0 ;
44234 bool temp2 = false ;
44235 PyObject * obj0 = 0 ;
44236 PyObject * obj1 = 0 ;
44237 char * kwnames[] = {
44238 (char *) "self",(char *) "strings", NULL
44239 };
44240
44241 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) SWIG_fail;
44242 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44243 if (!SWIG_IsOK(res1)) {
44244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_AppendItems" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44245 }
44246 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44247 {
44248 if (! PySequence_Check(obj1)) {
44249 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
44250 SWIG_fail;
44251 }
44252 arg2 = new wxArrayString;
44253 temp2 = true;
44254 int i, len=PySequence_Length(obj1);
44255 for (i=0; i<len; i++) {
44256 PyObject* item = PySequence_GetItem(obj1, i);
44257 wxString* s = wxString_in_helper(item);
44258 if (PyErr_Occurred()) SWIG_fail;
44259 arg2->Add(*s);
44260 delete s;
44261 Py_DECREF(item);
44262 }
44263 }
44264 {
44265 PyThreadState* __tstate = wxPyBeginAllowThreads();
44266 (arg1)->Append((wxArrayString const &)*arg2);
44267 wxPyEndAllowThreads(__tstate);
44268 if (PyErr_Occurred()) SWIG_fail;
44269 }
44270 resultobj = SWIG_Py_Void();
44271 {
44272 if (temp2) delete arg2;
44273 }
44274 return resultobj;
44275 fail:
44276 {
44277 if (temp2) delete arg2;
44278 }
44279 return NULL;
44280 }
44281
44282
44283 SWIGINTERN PyObject *_wrap_ItemContainer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44284 PyObject *resultobj = 0;
44285 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44286 wxString *arg2 = 0 ;
44287 unsigned int arg3 ;
44288 PyObject *arg4 = (PyObject *) NULL ;
44289 int result;
44290 void *argp1 = 0 ;
44291 int res1 = 0 ;
44292 bool temp2 = false ;
44293 unsigned int val3 ;
44294 int ecode3 = 0 ;
44295 PyObject * obj0 = 0 ;
44296 PyObject * obj1 = 0 ;
44297 PyObject * obj2 = 0 ;
44298 PyObject * obj3 = 0 ;
44299 char * kwnames[] = {
44300 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
44301 };
44302
44303 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
44304 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44305 if (!SWIG_IsOK(res1)) {
44306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Insert" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44307 }
44308 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44309 {
44310 arg2 = wxString_in_helper(obj1);
44311 if (arg2 == NULL) SWIG_fail;
44312 temp2 = true;
44313 }
44314 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
44315 if (!SWIG_IsOK(ecode3)) {
44316 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ItemContainer_Insert" "', expected argument " "3"" of type '" "unsigned int""'");
44317 }
44318 arg3 = static_cast< unsigned int >(val3);
44319 if (obj3) {
44320 arg4 = obj3;
44321 }
44322 {
44323 PyThreadState* __tstate = wxPyBeginAllowThreads();
44324 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
44325 wxPyEndAllowThreads(__tstate);
44326 if (PyErr_Occurred()) SWIG_fail;
44327 }
44328 resultobj = SWIG_From_int(static_cast< int >(result));
44329 {
44330 if (temp2)
44331 delete arg2;
44332 }
44333 return resultobj;
44334 fail:
44335 {
44336 if (temp2)
44337 delete arg2;
44338 }
44339 return NULL;
44340 }
44341
44342
44343 SWIGINTERN PyObject *_wrap_ItemContainer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44344 PyObject *resultobj = 0;
44345 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44346 void *argp1 = 0 ;
44347 int res1 = 0 ;
44348 PyObject *swig_obj[1] ;
44349
44350 if (!args) SWIG_fail;
44351 swig_obj[0] = args;
44352 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44353 if (!SWIG_IsOK(res1)) {
44354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Clear" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44355 }
44356 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44357 {
44358 PyThreadState* __tstate = wxPyBeginAllowThreads();
44359 (arg1)->Clear();
44360 wxPyEndAllowThreads(__tstate);
44361 if (PyErr_Occurred()) SWIG_fail;
44362 }
44363 resultobj = SWIG_Py_Void();
44364 return resultobj;
44365 fail:
44366 return NULL;
44367 }
44368
44369
44370 SWIGINTERN PyObject *_wrap_ItemContainer_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44371 PyObject *resultobj = 0;
44372 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44373 unsigned int arg2 ;
44374 void *argp1 = 0 ;
44375 int res1 = 0 ;
44376 unsigned int val2 ;
44377 int ecode2 = 0 ;
44378 PyObject * obj0 = 0 ;
44379 PyObject * obj1 = 0 ;
44380 char * kwnames[] = {
44381 (char *) "self",(char *) "n", NULL
44382 };
44383
44384 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
44385 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44386 if (!SWIG_IsOK(res1)) {
44387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Delete" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44388 }
44389 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44390 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44391 if (!SWIG_IsOK(ecode2)) {
44392 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Delete" "', expected argument " "2"" of type '" "unsigned int""'");
44393 }
44394 arg2 = static_cast< unsigned int >(val2);
44395 {
44396 PyThreadState* __tstate = wxPyBeginAllowThreads();
44397 (arg1)->Delete(arg2);
44398 wxPyEndAllowThreads(__tstate);
44399 if (PyErr_Occurred()) SWIG_fail;
44400 }
44401 resultobj = SWIG_Py_Void();
44402 return resultobj;
44403 fail:
44404 return NULL;
44405 }
44406
44407
44408 SWIGINTERN PyObject *_wrap_ItemContainer_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44409 PyObject *resultobj = 0;
44410 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44411 unsigned int arg2 ;
44412 PyObject *result = 0 ;
44413 void *argp1 = 0 ;
44414 int res1 = 0 ;
44415 unsigned int val2 ;
44416 int ecode2 = 0 ;
44417 PyObject * obj0 = 0 ;
44418 PyObject * obj1 = 0 ;
44419 char * kwnames[] = {
44420 (char *) "self",(char *) "n", NULL
44421 };
44422
44423 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
44424 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44425 if (!SWIG_IsOK(res1)) {
44426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44427 }
44428 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44429 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44430 if (!SWIG_IsOK(ecode2)) {
44431 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
44432 }
44433 arg2 = static_cast< unsigned int >(val2);
44434 {
44435 PyThreadState* __tstate = wxPyBeginAllowThreads();
44436 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
44437 wxPyEndAllowThreads(__tstate);
44438 if (PyErr_Occurred()) SWIG_fail;
44439 }
44440 resultobj = result;
44441 return resultobj;
44442 fail:
44443 return NULL;
44444 }
44445
44446
44447 SWIGINTERN PyObject *_wrap_ItemContainer_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44448 PyObject *resultobj = 0;
44449 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44450 unsigned int arg2 ;
44451 PyObject *arg3 = (PyObject *) 0 ;
44452 void *argp1 = 0 ;
44453 int res1 = 0 ;
44454 unsigned int val2 ;
44455 int ecode2 = 0 ;
44456 PyObject * obj0 = 0 ;
44457 PyObject * obj1 = 0 ;
44458 PyObject * obj2 = 0 ;
44459 char * kwnames[] = {
44460 (char *) "self",(char *) "n",(char *) "clientData", NULL
44461 };
44462
44463 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44464 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44465 if (!SWIG_IsOK(res1)) {
44466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44467 }
44468 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44469 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44470 if (!SWIG_IsOK(ecode2)) {
44471 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
44472 }
44473 arg2 = static_cast< unsigned int >(val2);
44474 arg3 = obj2;
44475 {
44476 PyThreadState* __tstate = wxPyBeginAllowThreads();
44477 wxItemContainer_SetClientData(arg1,arg2,arg3);
44478 wxPyEndAllowThreads(__tstate);
44479 if (PyErr_Occurred()) SWIG_fail;
44480 }
44481 resultobj = SWIG_Py_Void();
44482 return resultobj;
44483 fail:
44484 return NULL;
44485 }
44486
44487
44488 SWIGINTERN PyObject *_wrap_ItemContainer_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44489 PyObject *resultobj = 0;
44490 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44491 unsigned int result;
44492 void *argp1 = 0 ;
44493 int res1 = 0 ;
44494 PyObject *swig_obj[1] ;
44495
44496 if (!args) SWIG_fail;
44497 swig_obj[0] = args;
44498 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44499 if (!SWIG_IsOK(res1)) {
44500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetCount" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44501 }
44502 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44503 {
44504 PyThreadState* __tstate = wxPyBeginAllowThreads();
44505 result = (unsigned int)((wxItemContainer const *)arg1)->GetCount();
44506 wxPyEndAllowThreads(__tstate);
44507 if (PyErr_Occurred()) SWIG_fail;
44508 }
44509 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
44510 return resultobj;
44511 fail:
44512 return NULL;
44513 }
44514
44515
44516 SWIGINTERN PyObject *_wrap_ItemContainer_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44517 PyObject *resultobj = 0;
44518 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44519 bool result;
44520 void *argp1 = 0 ;
44521 int res1 = 0 ;
44522 PyObject *swig_obj[1] ;
44523
44524 if (!args) SWIG_fail;
44525 swig_obj[0] = args;
44526 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44527 if (!SWIG_IsOK(res1)) {
44528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_IsEmpty" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44529 }
44530 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44531 {
44532 PyThreadState* __tstate = wxPyBeginAllowThreads();
44533 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
44534 wxPyEndAllowThreads(__tstate);
44535 if (PyErr_Occurred()) SWIG_fail;
44536 }
44537 {
44538 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44539 }
44540 return resultobj;
44541 fail:
44542 return NULL;
44543 }
44544
44545
44546 SWIGINTERN PyObject *_wrap_ItemContainer_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44547 PyObject *resultobj = 0;
44548 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44549 unsigned int arg2 ;
44550 wxString result;
44551 void *argp1 = 0 ;
44552 int res1 = 0 ;
44553 unsigned int val2 ;
44554 int ecode2 = 0 ;
44555 PyObject * obj0 = 0 ;
44556 PyObject * obj1 = 0 ;
44557 char * kwnames[] = {
44558 (char *) "self",(char *) "n", NULL
44559 };
44560
44561 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) SWIG_fail;
44562 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44563 if (!SWIG_IsOK(res1)) {
44564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44565 }
44566 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44567 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44568 if (!SWIG_IsOK(ecode2)) {
44569 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetString" "', expected argument " "2"" of type '" "unsigned int""'");
44570 }
44571 arg2 = static_cast< unsigned int >(val2);
44572 {
44573 PyThreadState* __tstate = wxPyBeginAllowThreads();
44574 result = ((wxItemContainer const *)arg1)->GetString(arg2);
44575 wxPyEndAllowThreads(__tstate);
44576 if (PyErr_Occurred()) SWIG_fail;
44577 }
44578 {
44579 #if wxUSE_UNICODE
44580 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44581 #else
44582 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44583 #endif
44584 }
44585 return resultobj;
44586 fail:
44587 return NULL;
44588 }
44589
44590
44591 SWIGINTERN PyObject *_wrap_ItemContainer_GetStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44592 PyObject *resultobj = 0;
44593 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44594 wxArrayString result;
44595 void *argp1 = 0 ;
44596 int res1 = 0 ;
44597 PyObject *swig_obj[1] ;
44598
44599 if (!args) SWIG_fail;
44600 swig_obj[0] = args;
44601 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44602 if (!SWIG_IsOK(res1)) {
44603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStrings" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44604 }
44605 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44606 {
44607 PyThreadState* __tstate = wxPyBeginAllowThreads();
44608 result = ((wxItemContainer const *)arg1)->GetStrings();
44609 wxPyEndAllowThreads(__tstate);
44610 if (PyErr_Occurred()) SWIG_fail;
44611 }
44612 {
44613 resultobj = wxArrayString2PyList_helper(result);
44614 }
44615 return resultobj;
44616 fail:
44617 return NULL;
44618 }
44619
44620
44621 SWIGINTERN PyObject *_wrap_ItemContainer_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44622 PyObject *resultobj = 0;
44623 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44624 unsigned int arg2 ;
44625 wxString *arg3 = 0 ;
44626 void *argp1 = 0 ;
44627 int res1 = 0 ;
44628 unsigned int val2 ;
44629 int ecode2 = 0 ;
44630 bool temp3 = false ;
44631 PyObject * obj0 = 0 ;
44632 PyObject * obj1 = 0 ;
44633 PyObject * obj2 = 0 ;
44634 char * kwnames[] = {
44635 (char *) "self",(char *) "n",(char *) "s", NULL
44636 };
44637
44638 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44639 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44640 if (!SWIG_IsOK(res1)) {
44641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetString" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44642 }
44643 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44644 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44645 if (!SWIG_IsOK(ecode2)) {
44646 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetString" "', expected argument " "2"" of type '" "unsigned int""'");
44647 }
44648 arg2 = static_cast< unsigned int >(val2);
44649 {
44650 arg3 = wxString_in_helper(obj2);
44651 if (arg3 == NULL) SWIG_fail;
44652 temp3 = true;
44653 }
44654 {
44655 PyThreadState* __tstate = wxPyBeginAllowThreads();
44656 (arg1)->SetString(arg2,(wxString const &)*arg3);
44657 wxPyEndAllowThreads(__tstate);
44658 if (PyErr_Occurred()) SWIG_fail;
44659 }
44660 resultobj = SWIG_Py_Void();
44661 {
44662 if (temp3)
44663 delete arg3;
44664 }
44665 return resultobj;
44666 fail:
44667 {
44668 if (temp3)
44669 delete arg3;
44670 }
44671 return NULL;
44672 }
44673
44674
44675 SWIGINTERN PyObject *_wrap_ItemContainer_FindString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44676 PyObject *resultobj = 0;
44677 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44678 wxString *arg2 = 0 ;
44679 int result;
44680 void *argp1 = 0 ;
44681 int res1 = 0 ;
44682 bool temp2 = false ;
44683 PyObject * obj0 = 0 ;
44684 PyObject * obj1 = 0 ;
44685 char * kwnames[] = {
44686 (char *) "self",(char *) "s", NULL
44687 };
44688
44689 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) SWIG_fail;
44690 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44691 if (!SWIG_IsOK(res1)) {
44692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_FindString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44693 }
44694 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44695 {
44696 arg2 = wxString_in_helper(obj1);
44697 if (arg2 == NULL) SWIG_fail;
44698 temp2 = true;
44699 }
44700 {
44701 PyThreadState* __tstate = wxPyBeginAllowThreads();
44702 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
44703 wxPyEndAllowThreads(__tstate);
44704 if (PyErr_Occurred()) SWIG_fail;
44705 }
44706 resultobj = SWIG_From_int(static_cast< int >(result));
44707 {
44708 if (temp2)
44709 delete arg2;
44710 }
44711 return resultobj;
44712 fail:
44713 {
44714 if (temp2)
44715 delete arg2;
44716 }
44717 return NULL;
44718 }
44719
44720
44721 SWIGINTERN PyObject *_wrap_ItemContainer_SetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44722 PyObject *resultobj = 0;
44723 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44724 int arg2 ;
44725 void *argp1 = 0 ;
44726 int res1 = 0 ;
44727 int val2 ;
44728 int ecode2 = 0 ;
44729 PyObject * obj0 = 0 ;
44730 PyObject * obj1 = 0 ;
44731 char * kwnames[] = {
44732 (char *) "self",(char *) "n", NULL
44733 };
44734
44735 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) SWIG_fail;
44736 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44737 if (!SWIG_IsOK(res1)) {
44738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44739 }
44740 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44741 ecode2 = SWIG_AsVal_int(obj1, &val2);
44742 if (!SWIG_IsOK(ecode2)) {
44743 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetSelection" "', expected argument " "2"" of type '" "int""'");
44744 }
44745 arg2 = static_cast< int >(val2);
44746 {
44747 PyThreadState* __tstate = wxPyBeginAllowThreads();
44748 (arg1)->SetSelection(arg2);
44749 wxPyEndAllowThreads(__tstate);
44750 if (PyErr_Occurred()) SWIG_fail;
44751 }
44752 resultobj = SWIG_Py_Void();
44753 return resultobj;
44754 fail:
44755 return NULL;
44756 }
44757
44758
44759 SWIGINTERN PyObject *_wrap_ItemContainer_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44760 PyObject *resultobj = 0;
44761 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44762 int result;
44763 void *argp1 = 0 ;
44764 int res1 = 0 ;
44765 PyObject *swig_obj[1] ;
44766
44767 if (!args) SWIG_fail;
44768 swig_obj[0] = args;
44769 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44770 if (!SWIG_IsOK(res1)) {
44771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44772 }
44773 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44774 {
44775 PyThreadState* __tstate = wxPyBeginAllowThreads();
44776 result = (int)((wxItemContainer const *)arg1)->GetSelection();
44777 wxPyEndAllowThreads(__tstate);
44778 if (PyErr_Occurred()) SWIG_fail;
44779 }
44780 resultobj = SWIG_From_int(static_cast< int >(result));
44781 return resultobj;
44782 fail:
44783 return NULL;
44784 }
44785
44786
44787 SWIGINTERN PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44788 PyObject *resultobj = 0;
44789 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44790 wxString *arg2 = 0 ;
44791 bool result;
44792 void *argp1 = 0 ;
44793 int res1 = 0 ;
44794 bool temp2 = false ;
44795 PyObject * obj0 = 0 ;
44796 PyObject * obj1 = 0 ;
44797 char * kwnames[] = {
44798 (char *) "self",(char *) "s", NULL
44799 };
44800
44801 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) SWIG_fail;
44802 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44803 if (!SWIG_IsOK(res1)) {
44804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44805 }
44806 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44807 {
44808 arg2 = wxString_in_helper(obj1);
44809 if (arg2 == NULL) SWIG_fail;
44810 temp2 = true;
44811 }
44812 {
44813 PyThreadState* __tstate = wxPyBeginAllowThreads();
44814 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
44815 wxPyEndAllowThreads(__tstate);
44816 if (PyErr_Occurred()) SWIG_fail;
44817 }
44818 {
44819 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44820 }
44821 {
44822 if (temp2)
44823 delete arg2;
44824 }
44825 return resultobj;
44826 fail:
44827 {
44828 if (temp2)
44829 delete arg2;
44830 }
44831 return NULL;
44832 }
44833
44834
44835 SWIGINTERN PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44836 PyObject *resultobj = 0;
44837 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44838 wxString result;
44839 void *argp1 = 0 ;
44840 int res1 = 0 ;
44841 PyObject *swig_obj[1] ;
44842
44843 if (!args) SWIG_fail;
44844 swig_obj[0] = args;
44845 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44846 if (!SWIG_IsOK(res1)) {
44847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44848 }
44849 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44850 {
44851 PyThreadState* __tstate = wxPyBeginAllowThreads();
44852 result = ((wxItemContainer const *)arg1)->GetStringSelection();
44853 wxPyEndAllowThreads(__tstate);
44854 if (PyErr_Occurred()) SWIG_fail;
44855 }
44856 {
44857 #if wxUSE_UNICODE
44858 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44859 #else
44860 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44861 #endif
44862 }
44863 return resultobj;
44864 fail:
44865 return NULL;
44866 }
44867
44868
44869 SWIGINTERN PyObject *_wrap_ItemContainer_Select(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44870 PyObject *resultobj = 0;
44871 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44872 int arg2 ;
44873 void *argp1 = 0 ;
44874 int res1 = 0 ;
44875 int val2 ;
44876 int ecode2 = 0 ;
44877 PyObject * obj0 = 0 ;
44878 PyObject * obj1 = 0 ;
44879 char * kwnames[] = {
44880 (char *) "self",(char *) "n", NULL
44881 };
44882
44883 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) SWIG_fail;
44884 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44885 if (!SWIG_IsOK(res1)) {
44886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Select" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44887 }
44888 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44889 ecode2 = SWIG_AsVal_int(obj1, &val2);
44890 if (!SWIG_IsOK(ecode2)) {
44891 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Select" "', expected argument " "2"" of type '" "int""'");
44892 }
44893 arg2 = static_cast< int >(val2);
44894 {
44895 PyThreadState* __tstate = wxPyBeginAllowThreads();
44896 (arg1)->Select(arg2);
44897 wxPyEndAllowThreads(__tstate);
44898 if (PyErr_Occurred()) SWIG_fail;
44899 }
44900 resultobj = SWIG_Py_Void();
44901 return resultobj;
44902 fail:
44903 return NULL;
44904 }
44905
44906
44907 SWIGINTERN PyObject *ItemContainer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44908 PyObject *obj;
44909 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44910 SWIG_TypeNewClientData(SWIGTYPE_p_wxItemContainer, SWIG_NewClientData(obj));
44911 return SWIG_Py_Void();
44912 }
44913
44914 SWIGINTERN PyObject *ControlWithItems_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44915 PyObject *obj;
44916 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44917 SWIG_TypeNewClientData(SWIGTYPE_p_wxControlWithItems, SWIG_NewClientData(obj));
44918 return SWIG_Py_Void();
44919 }
44920
44921 SWIGINTERN PyObject *_wrap_new_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44922 PyObject *resultobj = 0;
44923 wxSizerItem *result = 0 ;
44924
44925 if (!SWIG_Python_UnpackTuple(args,"new_SizerItem",0,0,0)) SWIG_fail;
44926 {
44927 PyThreadState* __tstate = wxPyBeginAllowThreads();
44928 result = (wxSizerItem *)new wxSizerItem();
44929 wxPyEndAllowThreads(__tstate);
44930 if (PyErr_Occurred()) SWIG_fail;
44931 }
44932 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_NEW | 0 );
44933 return resultobj;
44934 fail:
44935 return NULL;
44936 }
44937
44938
44939 SWIGINTERN PyObject *_wrap_delete_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44940 PyObject *resultobj = 0;
44941 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44942 void *argp1 = 0 ;
44943 int res1 = 0 ;
44944 PyObject *swig_obj[1] ;
44945
44946 if (!args) SWIG_fail;
44947 swig_obj[0] = args;
44948 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
44949 if (!SWIG_IsOK(res1)) {
44950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerItem" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44951 }
44952 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44953 {
44954 PyThreadState* __tstate = wxPyBeginAllowThreads();
44955 delete arg1;
44956
44957 wxPyEndAllowThreads(__tstate);
44958 if (PyErr_Occurred()) SWIG_fail;
44959 }
44960 resultobj = SWIG_Py_Void();
44961 return resultobj;
44962 fail:
44963 return NULL;
44964 }
44965
44966
44967 SWIGINTERN PyObject *_wrap_new_SizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44968 PyObject *resultobj = 0;
44969 wxWindow *arg1 = (wxWindow *) 0 ;
44970 int arg2 ;
44971 int arg3 ;
44972 int arg4 ;
44973 PyObject *arg5 = (PyObject *) NULL ;
44974 wxSizerItem *result = 0 ;
44975 void *argp1 = 0 ;
44976 int res1 = 0 ;
44977 int val2 ;
44978 int ecode2 = 0 ;
44979 int val3 ;
44980 int ecode3 = 0 ;
44981 int val4 ;
44982 int ecode4 = 0 ;
44983 PyObject * obj0 = 0 ;
44984 PyObject * obj1 = 0 ;
44985 PyObject * obj2 = 0 ;
44986 PyObject * obj3 = 0 ;
44987 PyObject * obj4 = 0 ;
44988 char * kwnames[] = {
44989 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
44990 };
44991
44992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
44993 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
44994 if (!SWIG_IsOK(res1)) {
44995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
44996 }
44997 arg1 = reinterpret_cast< wxWindow * >(argp1);
44998 ecode2 = SWIG_AsVal_int(obj1, &val2);
44999 if (!SWIG_IsOK(ecode2)) {
45000 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemWindow" "', expected argument " "2"" of type '" "int""'");
45001 }
45002 arg2 = static_cast< int >(val2);
45003 ecode3 = SWIG_AsVal_int(obj2, &val3);
45004 if (!SWIG_IsOK(ecode3)) {
45005 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemWindow" "', expected argument " "3"" of type '" "int""'");
45006 }
45007 arg3 = static_cast< int >(val3);
45008 ecode4 = SWIG_AsVal_int(obj3, &val4);
45009 if (!SWIG_IsOK(ecode4)) {
45010 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemWindow" "', expected argument " "4"" of type '" "int""'");
45011 }
45012 arg4 = static_cast< int >(val4);
45013 if (obj4) {
45014 arg5 = obj4;
45015 }
45016 {
45017 PyThreadState* __tstate = wxPyBeginAllowThreads();
45018 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
45019 wxPyEndAllowThreads(__tstate);
45020 if (PyErr_Occurred()) SWIG_fail;
45021 }
45022 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
45023 return resultobj;
45024 fail:
45025 return NULL;
45026 }
45027
45028
45029 SWIGINTERN PyObject *_wrap_new_SizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45030 PyObject *resultobj = 0;
45031 int arg1 ;
45032 int arg2 ;
45033 int arg3 ;
45034 int arg4 ;
45035 int arg5 ;
45036 PyObject *arg6 = (PyObject *) NULL ;
45037 wxSizerItem *result = 0 ;
45038 int val1 ;
45039 int ecode1 = 0 ;
45040 int val2 ;
45041 int ecode2 = 0 ;
45042 int val3 ;
45043 int ecode3 = 0 ;
45044 int val4 ;
45045 int ecode4 = 0 ;
45046 int val5 ;
45047 int ecode5 = 0 ;
45048 PyObject * obj0 = 0 ;
45049 PyObject * obj1 = 0 ;
45050 PyObject * obj2 = 0 ;
45051 PyObject * obj3 = 0 ;
45052 PyObject * obj4 = 0 ;
45053 PyObject * obj5 = 0 ;
45054 char * kwnames[] = {
45055 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45056 };
45057
45058 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
45059 ecode1 = SWIG_AsVal_int(obj0, &val1);
45060 if (!SWIG_IsOK(ecode1)) {
45061 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
45062 }
45063 arg1 = static_cast< int >(val1);
45064 ecode2 = SWIG_AsVal_int(obj1, &val2);
45065 if (!SWIG_IsOK(ecode2)) {
45066 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
45067 }
45068 arg2 = static_cast< int >(val2);
45069 ecode3 = SWIG_AsVal_int(obj2, &val3);
45070 if (!SWIG_IsOK(ecode3)) {
45071 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSpacer" "', expected argument " "3"" of type '" "int""'");
45072 }
45073 arg3 = static_cast< int >(val3);
45074 ecode4 = SWIG_AsVal_int(obj3, &val4);
45075 if (!SWIG_IsOK(ecode4)) {
45076 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSpacer" "', expected argument " "4"" of type '" "int""'");
45077 }
45078 arg4 = static_cast< int >(val4);
45079 ecode5 = SWIG_AsVal_int(obj4, &val5);
45080 if (!SWIG_IsOK(ecode5)) {
45081 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
45082 }
45083 arg5 = static_cast< int >(val5);
45084 if (obj5) {
45085 arg6 = obj5;
45086 }
45087 {
45088 PyThreadState* __tstate = wxPyBeginAllowThreads();
45089 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
45090 wxPyEndAllowThreads(__tstate);
45091 if (PyErr_Occurred()) SWIG_fail;
45092 }
45093 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
45094 return resultobj;
45095 fail:
45096 return NULL;
45097 }
45098
45099
45100 SWIGINTERN PyObject *_wrap_new_SizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45101 PyObject *resultobj = 0;
45102 wxSizer *arg1 = (wxSizer *) 0 ;
45103 int arg2 ;
45104 int arg3 ;
45105 int arg4 ;
45106 PyObject *arg5 = (PyObject *) NULL ;
45107 wxSizerItem *result = 0 ;
45108 int res1 = 0 ;
45109 int val2 ;
45110 int ecode2 = 0 ;
45111 int val3 ;
45112 int ecode3 = 0 ;
45113 int val4 ;
45114 int ecode4 = 0 ;
45115 PyObject * obj0 = 0 ;
45116 PyObject * obj1 = 0 ;
45117 PyObject * obj2 = 0 ;
45118 PyObject * obj3 = 0 ;
45119 PyObject * obj4 = 0 ;
45120 char * kwnames[] = {
45121 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45122 };
45123
45124 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
45125 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
45126 if (!SWIG_IsOK(res1)) {
45127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
45128 }
45129 ecode2 = SWIG_AsVal_int(obj1, &val2);
45130 if (!SWIG_IsOK(ecode2)) {
45131 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSizer" "', expected argument " "2"" of type '" "int""'");
45132 }
45133 arg2 = static_cast< int >(val2);
45134 ecode3 = SWIG_AsVal_int(obj2, &val3);
45135 if (!SWIG_IsOK(ecode3)) {
45136 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSizer" "', expected argument " "3"" of type '" "int""'");
45137 }
45138 arg3 = static_cast< int >(val3);
45139 ecode4 = SWIG_AsVal_int(obj3, &val4);
45140 if (!SWIG_IsOK(ecode4)) {
45141 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSizer" "', expected argument " "4"" of type '" "int""'");
45142 }
45143 arg4 = static_cast< int >(val4);
45144 if (obj4) {
45145 arg5 = obj4;
45146 }
45147 {
45148 PyThreadState* __tstate = wxPyBeginAllowThreads();
45149 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
45150 wxPyEndAllowThreads(__tstate);
45151 if (PyErr_Occurred()) SWIG_fail;
45152 }
45153 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
45154 return resultobj;
45155 fail:
45156 return NULL;
45157 }
45158
45159
45160 SWIGINTERN PyObject *_wrap_SizerItem_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45161 PyObject *resultobj = 0;
45162 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45163 void *argp1 = 0 ;
45164 int res1 = 0 ;
45165 PyObject *swig_obj[1] ;
45166
45167 if (!args) SWIG_fail;
45168 swig_obj[0] = args;
45169 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45170 if (!SWIG_IsOK(res1)) {
45171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DeleteWindows" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45172 }
45173 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45174 {
45175 PyThreadState* __tstate = wxPyBeginAllowThreads();
45176 (arg1)->DeleteWindows();
45177 wxPyEndAllowThreads(__tstate);
45178 if (PyErr_Occurred()) SWIG_fail;
45179 }
45180 resultobj = SWIG_Py_Void();
45181 return resultobj;
45182 fail:
45183 return NULL;
45184 }
45185
45186
45187 SWIGINTERN PyObject *_wrap_SizerItem_DetachSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45188 PyObject *resultobj = 0;
45189 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45190 void *argp1 = 0 ;
45191 int res1 = 0 ;
45192 PyObject *swig_obj[1] ;
45193
45194 if (!args) SWIG_fail;
45195 swig_obj[0] = args;
45196 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45197 if (!SWIG_IsOK(res1)) {
45198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DetachSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45199 }
45200 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45201 {
45202 PyThreadState* __tstate = wxPyBeginAllowThreads();
45203 (arg1)->DetachSizer();
45204 wxPyEndAllowThreads(__tstate);
45205 if (PyErr_Occurred()) SWIG_fail;
45206 }
45207 resultobj = SWIG_Py_Void();
45208 return resultobj;
45209 fail:
45210 return NULL;
45211 }
45212
45213
45214 SWIGINTERN PyObject *_wrap_SizerItem_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45215 PyObject *resultobj = 0;
45216 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45217 wxSize result;
45218 void *argp1 = 0 ;
45219 int res1 = 0 ;
45220 PyObject *swig_obj[1] ;
45221
45222 if (!args) SWIG_fail;
45223 swig_obj[0] = args;
45224 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45225 if (!SWIG_IsOK(res1)) {
45226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45227 }
45228 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45229 {
45230 PyThreadState* __tstate = wxPyBeginAllowThreads();
45231 result = (arg1)->GetSize();
45232 wxPyEndAllowThreads(__tstate);
45233 if (PyErr_Occurred()) SWIG_fail;
45234 }
45235 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45236 return resultobj;
45237 fail:
45238 return NULL;
45239 }
45240
45241
45242 SWIGINTERN PyObject *_wrap_SizerItem_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45243 PyObject *resultobj = 0;
45244 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45245 wxSize result;
45246 void *argp1 = 0 ;
45247 int res1 = 0 ;
45248 PyObject *swig_obj[1] ;
45249
45250 if (!args) SWIG_fail;
45251 swig_obj[0] = args;
45252 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45253 if (!SWIG_IsOK(res1)) {
45254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_CalcMin" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45255 }
45256 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45257 {
45258 PyThreadState* __tstate = wxPyBeginAllowThreads();
45259 result = (arg1)->CalcMin();
45260 wxPyEndAllowThreads(__tstate);
45261 if (PyErr_Occurred()) SWIG_fail;
45262 }
45263 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45264 return resultobj;
45265 fail:
45266 return NULL;
45267 }
45268
45269
45270 SWIGINTERN PyObject *_wrap_SizerItem_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45271 PyObject *resultobj = 0;
45272 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45273 wxPoint *arg2 = 0 ;
45274 wxSize *arg3 = 0 ;
45275 void *argp1 = 0 ;
45276 int res1 = 0 ;
45277 wxPoint temp2 ;
45278 wxSize temp3 ;
45279 PyObject * obj0 = 0 ;
45280 PyObject * obj1 = 0 ;
45281 PyObject * obj2 = 0 ;
45282 char * kwnames[] = {
45283 (char *) "self",(char *) "pos",(char *) "size", NULL
45284 };
45285
45286 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45287 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45288 if (!SWIG_IsOK(res1)) {
45289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetDimension" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45290 }
45291 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45292 {
45293 arg2 = &temp2;
45294 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
45295 }
45296 {
45297 arg3 = &temp3;
45298 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
45299 }
45300 {
45301 PyThreadState* __tstate = wxPyBeginAllowThreads();
45302 (arg1)->SetDimension((wxPoint const &)*arg2,(wxSize const &)*arg3);
45303 wxPyEndAllowThreads(__tstate);
45304 if (PyErr_Occurred()) SWIG_fail;
45305 }
45306 resultobj = SWIG_Py_Void();
45307 return resultobj;
45308 fail:
45309 return NULL;
45310 }
45311
45312
45313 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45314 PyObject *resultobj = 0;
45315 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45316 wxSize result;
45317 void *argp1 = 0 ;
45318 int res1 = 0 ;
45319 PyObject *swig_obj[1] ;
45320
45321 if (!args) SWIG_fail;
45322 swig_obj[0] = args;
45323 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45324 if (!SWIG_IsOK(res1)) {
45325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45326 }
45327 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45328 {
45329 PyThreadState* __tstate = wxPyBeginAllowThreads();
45330 result = (arg1)->GetMinSize();
45331 wxPyEndAllowThreads(__tstate);
45332 if (PyErr_Occurred()) SWIG_fail;
45333 }
45334 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45335 return resultobj;
45336 fail:
45337 return NULL;
45338 }
45339
45340
45341 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45342 PyObject *resultobj = 0;
45343 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45344 wxSize result;
45345 void *argp1 = 0 ;
45346 int res1 = 0 ;
45347 PyObject *swig_obj[1] ;
45348
45349 if (!args) SWIG_fail;
45350 swig_obj[0] = args;
45351 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45352 if (!SWIG_IsOK(res1)) {
45353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSizeWithBorder" "', expected argument " "1"" of type '" "wxSizerItem const *""'");
45354 }
45355 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45356 {
45357 PyThreadState* __tstate = wxPyBeginAllowThreads();
45358 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
45359 wxPyEndAllowThreads(__tstate);
45360 if (PyErr_Occurred()) SWIG_fail;
45361 }
45362 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45363 return resultobj;
45364 fail:
45365 return NULL;
45366 }
45367
45368
45369 SWIGINTERN PyObject *_wrap_SizerItem_SetInitSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45370 PyObject *resultobj = 0;
45371 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45372 int arg2 ;
45373 int arg3 ;
45374 void *argp1 = 0 ;
45375 int res1 = 0 ;
45376 int val2 ;
45377 int ecode2 = 0 ;
45378 int val3 ;
45379 int ecode3 = 0 ;
45380 PyObject * obj0 = 0 ;
45381 PyObject * obj1 = 0 ;
45382 PyObject * obj2 = 0 ;
45383 char * kwnames[] = {
45384 (char *) "self",(char *) "x",(char *) "y", NULL
45385 };
45386
45387 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45388 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45389 if (!SWIG_IsOK(res1)) {
45390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetInitSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45391 }
45392 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45393 ecode2 = SWIG_AsVal_int(obj1, &val2);
45394 if (!SWIG_IsOK(ecode2)) {
45395 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetInitSize" "', expected argument " "2"" of type '" "int""'");
45396 }
45397 arg2 = static_cast< int >(val2);
45398 ecode3 = SWIG_AsVal_int(obj2, &val3);
45399 if (!SWIG_IsOK(ecode3)) {
45400 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetInitSize" "', expected argument " "3"" of type '" "int""'");
45401 }
45402 arg3 = static_cast< int >(val3);
45403 {
45404 PyThreadState* __tstate = wxPyBeginAllowThreads();
45405 (arg1)->SetInitSize(arg2,arg3);
45406 wxPyEndAllowThreads(__tstate);
45407 if (PyErr_Occurred()) SWIG_fail;
45408 }
45409 resultobj = SWIG_Py_Void();
45410 return resultobj;
45411 fail:
45412 return NULL;
45413 }
45414
45415
45416 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45417 PyObject *resultobj = 0;
45418 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45419 int arg2 ;
45420 int arg3 ;
45421 void *argp1 = 0 ;
45422 int res1 = 0 ;
45423 int val2 ;
45424 int ecode2 = 0 ;
45425 int val3 ;
45426 int ecode3 = 0 ;
45427 PyObject * obj0 = 0 ;
45428 PyObject * obj1 = 0 ;
45429 PyObject * obj2 = 0 ;
45430 char * kwnames[] = {
45431 (char *) "self",(char *) "width",(char *) "height", NULL
45432 };
45433
45434 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45435 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45436 if (!SWIG_IsOK(res1)) {
45437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioWH" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45438 }
45439 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45440 ecode2 = SWIG_AsVal_int(obj1, &val2);
45441 if (!SWIG_IsOK(ecode2)) {
45442 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatioWH" "', expected argument " "2"" of type '" "int""'");
45443 }
45444 arg2 = static_cast< int >(val2);
45445 ecode3 = SWIG_AsVal_int(obj2, &val3);
45446 if (!SWIG_IsOK(ecode3)) {
45447 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetRatioWH" "', expected argument " "3"" of type '" "int""'");
45448 }
45449 arg3 = static_cast< int >(val3);
45450 {
45451 PyThreadState* __tstate = wxPyBeginAllowThreads();
45452 (arg1)->SetRatio(arg2,arg3);
45453 wxPyEndAllowThreads(__tstate);
45454 if (PyErr_Occurred()) SWIG_fail;
45455 }
45456 resultobj = SWIG_Py_Void();
45457 return resultobj;
45458 fail:
45459 return NULL;
45460 }
45461
45462
45463 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45464 PyObject *resultobj = 0;
45465 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45466 wxSize *arg2 = 0 ;
45467 void *argp1 = 0 ;
45468 int res1 = 0 ;
45469 wxSize temp2 ;
45470 PyObject * obj0 = 0 ;
45471 PyObject * obj1 = 0 ;
45472 char * kwnames[] = {
45473 (char *) "self",(char *) "size", NULL
45474 };
45475
45476 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) SWIG_fail;
45477 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45478 if (!SWIG_IsOK(res1)) {
45479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45480 }
45481 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45482 {
45483 arg2 = &temp2;
45484 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
45485 }
45486 {
45487 PyThreadState* __tstate = wxPyBeginAllowThreads();
45488 (arg1)->SetRatio((wxSize const &)*arg2);
45489 wxPyEndAllowThreads(__tstate);
45490 if (PyErr_Occurred()) SWIG_fail;
45491 }
45492 resultobj = SWIG_Py_Void();
45493 return resultobj;
45494 fail:
45495 return NULL;
45496 }
45497
45498
45499 SWIGINTERN PyObject *_wrap_SizerItem_SetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45500 PyObject *resultobj = 0;
45501 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45502 float arg2 ;
45503 void *argp1 = 0 ;
45504 int res1 = 0 ;
45505 float val2 ;
45506 int ecode2 = 0 ;
45507 PyObject * obj0 = 0 ;
45508 PyObject * obj1 = 0 ;
45509 char * kwnames[] = {
45510 (char *) "self",(char *) "ratio", NULL
45511 };
45512
45513 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) SWIG_fail;
45514 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45515 if (!SWIG_IsOK(res1)) {
45516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45517 }
45518 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45519 ecode2 = SWIG_AsVal_float(obj1, &val2);
45520 if (!SWIG_IsOK(ecode2)) {
45521 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatio" "', expected argument " "2"" of type '" "float""'");
45522 }
45523 arg2 = static_cast< float >(val2);
45524 {
45525 PyThreadState* __tstate = wxPyBeginAllowThreads();
45526 (arg1)->SetRatio(arg2);
45527 wxPyEndAllowThreads(__tstate);
45528 if (PyErr_Occurred()) SWIG_fail;
45529 }
45530 resultobj = SWIG_Py_Void();
45531 return resultobj;
45532 fail:
45533 return NULL;
45534 }
45535
45536
45537 SWIGINTERN PyObject *_wrap_SizerItem_GetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45538 PyObject *resultobj = 0;
45539 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45540 float result;
45541 void *argp1 = 0 ;
45542 int res1 = 0 ;
45543 PyObject *swig_obj[1] ;
45544
45545 if (!args) SWIG_fail;
45546 swig_obj[0] = args;
45547 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45548 if (!SWIG_IsOK(res1)) {
45549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45550 }
45551 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45552 {
45553 PyThreadState* __tstate = wxPyBeginAllowThreads();
45554 result = (float)(arg1)->GetRatio();
45555 wxPyEndAllowThreads(__tstate);
45556 if (PyErr_Occurred()) SWIG_fail;
45557 }
45558 resultobj = SWIG_From_float(static_cast< float >(result));
45559 return resultobj;
45560 fail:
45561 return NULL;
45562 }
45563
45564
45565 SWIGINTERN PyObject *_wrap_SizerItem_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45566 PyObject *resultobj = 0;
45567 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45568 wxRect result;
45569 void *argp1 = 0 ;
45570 int res1 = 0 ;
45571 PyObject *swig_obj[1] ;
45572
45573 if (!args) SWIG_fail;
45574 swig_obj[0] = args;
45575 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45576 if (!SWIG_IsOK(res1)) {
45577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRect" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45578 }
45579 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45580 {
45581 PyThreadState* __tstate = wxPyBeginAllowThreads();
45582 result = (arg1)->GetRect();
45583 wxPyEndAllowThreads(__tstate);
45584 if (PyErr_Occurred()) SWIG_fail;
45585 }
45586 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
45587 return resultobj;
45588 fail:
45589 return NULL;
45590 }
45591
45592
45593 SWIGINTERN PyObject *_wrap_SizerItem_IsWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45594 PyObject *resultobj = 0;
45595 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45596 bool result;
45597 void *argp1 = 0 ;
45598 int res1 = 0 ;
45599 PyObject *swig_obj[1] ;
45600
45601 if (!args) SWIG_fail;
45602 swig_obj[0] = args;
45603 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45604 if (!SWIG_IsOK(res1)) {
45605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45606 }
45607 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45608 {
45609 PyThreadState* __tstate = wxPyBeginAllowThreads();
45610 result = (bool)(arg1)->IsWindow();
45611 wxPyEndAllowThreads(__tstate);
45612 if (PyErr_Occurred()) SWIG_fail;
45613 }
45614 {
45615 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45616 }
45617 return resultobj;
45618 fail:
45619 return NULL;
45620 }
45621
45622
45623 SWIGINTERN PyObject *_wrap_SizerItem_IsSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45624 PyObject *resultobj = 0;
45625 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45626 bool result;
45627 void *argp1 = 0 ;
45628 int res1 = 0 ;
45629 PyObject *swig_obj[1] ;
45630
45631 if (!args) SWIG_fail;
45632 swig_obj[0] = args;
45633 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45634 if (!SWIG_IsOK(res1)) {
45635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45636 }
45637 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45638 {
45639 PyThreadState* __tstate = wxPyBeginAllowThreads();
45640 result = (bool)(arg1)->IsSizer();
45641 wxPyEndAllowThreads(__tstate);
45642 if (PyErr_Occurred()) SWIG_fail;
45643 }
45644 {
45645 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45646 }
45647 return resultobj;
45648 fail:
45649 return NULL;
45650 }
45651
45652
45653 SWIGINTERN PyObject *_wrap_SizerItem_IsSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45654 PyObject *resultobj = 0;
45655 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45656 bool result;
45657 void *argp1 = 0 ;
45658 int res1 = 0 ;
45659 PyObject *swig_obj[1] ;
45660
45661 if (!args) SWIG_fail;
45662 swig_obj[0] = args;
45663 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45664 if (!SWIG_IsOK(res1)) {
45665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45666 }
45667 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45668 {
45669 PyThreadState* __tstate = wxPyBeginAllowThreads();
45670 result = (bool)(arg1)->IsSpacer();
45671 wxPyEndAllowThreads(__tstate);
45672 if (PyErr_Occurred()) SWIG_fail;
45673 }
45674 {
45675 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45676 }
45677 return resultobj;
45678 fail:
45679 return NULL;
45680 }
45681
45682
45683 SWIGINTERN PyObject *_wrap_SizerItem_SetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45684 PyObject *resultobj = 0;
45685 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45686 int arg2 ;
45687 void *argp1 = 0 ;
45688 int res1 = 0 ;
45689 int val2 ;
45690 int ecode2 = 0 ;
45691 PyObject * obj0 = 0 ;
45692 PyObject * obj1 = 0 ;
45693 char * kwnames[] = {
45694 (char *) "self",(char *) "proportion", NULL
45695 };
45696
45697 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) SWIG_fail;
45698 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45699 if (!SWIG_IsOK(res1)) {
45700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45701 }
45702 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45703 ecode2 = SWIG_AsVal_int(obj1, &val2);
45704 if (!SWIG_IsOK(ecode2)) {
45705 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetProportion" "', expected argument " "2"" of type '" "int""'");
45706 }
45707 arg2 = static_cast< int >(val2);
45708 {
45709 PyThreadState* __tstate = wxPyBeginAllowThreads();
45710 (arg1)->SetProportion(arg2);
45711 wxPyEndAllowThreads(__tstate);
45712 if (PyErr_Occurred()) SWIG_fail;
45713 }
45714 resultobj = SWIG_Py_Void();
45715 return resultobj;
45716 fail:
45717 return NULL;
45718 }
45719
45720
45721 SWIGINTERN PyObject *_wrap_SizerItem_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45722 PyObject *resultobj = 0;
45723 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45724 int result;
45725 void *argp1 = 0 ;
45726 int res1 = 0 ;
45727 PyObject *swig_obj[1] ;
45728
45729 if (!args) SWIG_fail;
45730 swig_obj[0] = args;
45731 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45732 if (!SWIG_IsOK(res1)) {
45733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45734 }
45735 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45736 {
45737 PyThreadState* __tstate = wxPyBeginAllowThreads();
45738 result = (int)(arg1)->GetProportion();
45739 wxPyEndAllowThreads(__tstate);
45740 if (PyErr_Occurred()) SWIG_fail;
45741 }
45742 resultobj = SWIG_From_int(static_cast< int >(result));
45743 return resultobj;
45744 fail:
45745 return NULL;
45746 }
45747
45748
45749 SWIGINTERN PyObject *_wrap_SizerItem_SetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45750 PyObject *resultobj = 0;
45751 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45752 int arg2 ;
45753 void *argp1 = 0 ;
45754 int res1 = 0 ;
45755 int val2 ;
45756 int ecode2 = 0 ;
45757 PyObject * obj0 = 0 ;
45758 PyObject * obj1 = 0 ;
45759 char * kwnames[] = {
45760 (char *) "self",(char *) "flag", NULL
45761 };
45762
45763 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) SWIG_fail;
45764 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45765 if (!SWIG_IsOK(res1)) {
45766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45767 }
45768 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45769 ecode2 = SWIG_AsVal_int(obj1, &val2);
45770 if (!SWIG_IsOK(ecode2)) {
45771 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetFlag" "', expected argument " "2"" of type '" "int""'");
45772 }
45773 arg2 = static_cast< int >(val2);
45774 {
45775 PyThreadState* __tstate = wxPyBeginAllowThreads();
45776 (arg1)->SetFlag(arg2);
45777 wxPyEndAllowThreads(__tstate);
45778 if (PyErr_Occurred()) SWIG_fail;
45779 }
45780 resultobj = SWIG_Py_Void();
45781 return resultobj;
45782 fail:
45783 return NULL;
45784 }
45785
45786
45787 SWIGINTERN PyObject *_wrap_SizerItem_GetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45788 PyObject *resultobj = 0;
45789 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45790 int result;
45791 void *argp1 = 0 ;
45792 int res1 = 0 ;
45793 PyObject *swig_obj[1] ;
45794
45795 if (!args) SWIG_fail;
45796 swig_obj[0] = args;
45797 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45798 if (!SWIG_IsOK(res1)) {
45799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45800 }
45801 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45802 {
45803 PyThreadState* __tstate = wxPyBeginAllowThreads();
45804 result = (int)(arg1)->GetFlag();
45805 wxPyEndAllowThreads(__tstate);
45806 if (PyErr_Occurred()) SWIG_fail;
45807 }
45808 resultobj = SWIG_From_int(static_cast< int >(result));
45809 return resultobj;
45810 fail:
45811 return NULL;
45812 }
45813
45814
45815 SWIGINTERN PyObject *_wrap_SizerItem_SetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45816 PyObject *resultobj = 0;
45817 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45818 int arg2 ;
45819 void *argp1 = 0 ;
45820 int res1 = 0 ;
45821 int val2 ;
45822 int ecode2 = 0 ;
45823 PyObject * obj0 = 0 ;
45824 PyObject * obj1 = 0 ;
45825 char * kwnames[] = {
45826 (char *) "self",(char *) "border", NULL
45827 };
45828
45829 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) SWIG_fail;
45830 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45831 if (!SWIG_IsOK(res1)) {
45832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45833 }
45834 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45835 ecode2 = SWIG_AsVal_int(obj1, &val2);
45836 if (!SWIG_IsOK(ecode2)) {
45837 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetBorder" "', expected argument " "2"" of type '" "int""'");
45838 }
45839 arg2 = static_cast< int >(val2);
45840 {
45841 PyThreadState* __tstate = wxPyBeginAllowThreads();
45842 (arg1)->SetBorder(arg2);
45843 wxPyEndAllowThreads(__tstate);
45844 if (PyErr_Occurred()) SWIG_fail;
45845 }
45846 resultobj = SWIG_Py_Void();
45847 return resultobj;
45848 fail:
45849 return NULL;
45850 }
45851
45852
45853 SWIGINTERN PyObject *_wrap_SizerItem_GetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45854 PyObject *resultobj = 0;
45855 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45856 int result;
45857 void *argp1 = 0 ;
45858 int res1 = 0 ;
45859 PyObject *swig_obj[1] ;
45860
45861 if (!args) SWIG_fail;
45862 swig_obj[0] = args;
45863 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45864 if (!SWIG_IsOK(res1)) {
45865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45866 }
45867 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45868 {
45869 PyThreadState* __tstate = wxPyBeginAllowThreads();
45870 result = (int)(arg1)->GetBorder();
45871 wxPyEndAllowThreads(__tstate);
45872 if (PyErr_Occurred()) SWIG_fail;
45873 }
45874 resultobj = SWIG_From_int(static_cast< int >(result));
45875 return resultobj;
45876 fail:
45877 return NULL;
45878 }
45879
45880
45881 SWIGINTERN PyObject *_wrap_SizerItem_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45882 PyObject *resultobj = 0;
45883 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45884 wxWindow *result = 0 ;
45885 void *argp1 = 0 ;
45886 int res1 = 0 ;
45887 PyObject *swig_obj[1] ;
45888
45889 if (!args) SWIG_fail;
45890 swig_obj[0] = args;
45891 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45892 if (!SWIG_IsOK(res1)) {
45893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45894 }
45895 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45896 {
45897 PyThreadState* __tstate = wxPyBeginAllowThreads();
45898 result = (wxWindow *)(arg1)->GetWindow();
45899 wxPyEndAllowThreads(__tstate);
45900 if (PyErr_Occurred()) SWIG_fail;
45901 }
45902 {
45903 resultobj = wxPyMake_wxObject(result, 0);
45904 }
45905 return resultobj;
45906 fail:
45907 return NULL;
45908 }
45909
45910
45911 SWIGINTERN PyObject *_wrap_SizerItem_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45912 PyObject *resultobj = 0;
45913 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45914 wxWindow *arg2 = (wxWindow *) 0 ;
45915 void *argp1 = 0 ;
45916 int res1 = 0 ;
45917 void *argp2 = 0 ;
45918 int res2 = 0 ;
45919 PyObject * obj0 = 0 ;
45920 PyObject * obj1 = 0 ;
45921 char * kwnames[] = {
45922 (char *) "self",(char *) "window", NULL
45923 };
45924
45925 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
45926 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45927 if (!SWIG_IsOK(res1)) {
45928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45929 }
45930 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45931 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
45932 if (!SWIG_IsOK(res2)) {
45933 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
45934 }
45935 arg2 = reinterpret_cast< wxWindow * >(argp2);
45936 {
45937 PyThreadState* __tstate = wxPyBeginAllowThreads();
45938 (arg1)->SetWindow(arg2);
45939 wxPyEndAllowThreads(__tstate);
45940 if (PyErr_Occurred()) SWIG_fail;
45941 }
45942 resultobj = SWIG_Py_Void();
45943 return resultobj;
45944 fail:
45945 return NULL;
45946 }
45947
45948
45949 SWIGINTERN PyObject *_wrap_SizerItem_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45950 PyObject *resultobj = 0;
45951 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45952 wxSizer *result = 0 ;
45953 void *argp1 = 0 ;
45954 int res1 = 0 ;
45955 PyObject *swig_obj[1] ;
45956
45957 if (!args) SWIG_fail;
45958 swig_obj[0] = args;
45959 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45960 if (!SWIG_IsOK(res1)) {
45961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45962 }
45963 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45964 {
45965 PyThreadState* __tstate = wxPyBeginAllowThreads();
45966 result = (wxSizer *)(arg1)->GetSizer();
45967 wxPyEndAllowThreads(__tstate);
45968 if (PyErr_Occurred()) SWIG_fail;
45969 }
45970 {
45971 resultobj = wxPyMake_wxObject(result, (bool)0);
45972 }
45973 return resultobj;
45974 fail:
45975 return NULL;
45976 }
45977
45978
45979 SWIGINTERN PyObject *_wrap_SizerItem_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45980 PyObject *resultobj = 0;
45981 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45982 wxSizer *arg2 = (wxSizer *) 0 ;
45983 void *argp1 = 0 ;
45984 int res1 = 0 ;
45985 int res2 = 0 ;
45986 PyObject * obj0 = 0 ;
45987 PyObject * obj1 = 0 ;
45988 char * kwnames[] = {
45989 (char *) "self",(char *) "sizer", NULL
45990 };
45991
45992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) SWIG_fail;
45993 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45994 if (!SWIG_IsOK(res1)) {
45995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45996 }
45997 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45998 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
45999 if (!SWIG_IsOK(res2)) {
46000 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
46001 }
46002 {
46003 PyThreadState* __tstate = wxPyBeginAllowThreads();
46004 (arg1)->SetSizer(arg2);
46005 wxPyEndAllowThreads(__tstate);
46006 if (PyErr_Occurred()) SWIG_fail;
46007 }
46008 resultobj = SWIG_Py_Void();
46009 return resultobj;
46010 fail:
46011 return NULL;
46012 }
46013
46014
46015 SWIGINTERN PyObject *_wrap_SizerItem_GetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46016 PyObject *resultobj = 0;
46017 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46018 wxSize *result = 0 ;
46019 void *argp1 = 0 ;
46020 int res1 = 0 ;
46021 PyObject *swig_obj[1] ;
46022
46023 if (!args) SWIG_fail;
46024 swig_obj[0] = args;
46025 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46026 if (!SWIG_IsOK(res1)) {
46027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46028 }
46029 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46030 {
46031 PyThreadState* __tstate = wxPyBeginAllowThreads();
46032 {
46033 wxSize const &_result_ref = (arg1)->GetSpacer();
46034 result = (wxSize *) &_result_ref;
46035 }
46036 wxPyEndAllowThreads(__tstate);
46037 if (PyErr_Occurred()) SWIG_fail;
46038 }
46039 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
46040 return resultobj;
46041 fail:
46042 return NULL;
46043 }
46044
46045
46046 SWIGINTERN PyObject *_wrap_SizerItem_SetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46047 PyObject *resultobj = 0;
46048 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46049 wxSize *arg2 = 0 ;
46050 void *argp1 = 0 ;
46051 int res1 = 0 ;
46052 wxSize temp2 ;
46053 PyObject * obj0 = 0 ;
46054 PyObject * obj1 = 0 ;
46055 char * kwnames[] = {
46056 (char *) "self",(char *) "size", NULL
46057 };
46058
46059 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) SWIG_fail;
46060 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46061 if (!SWIG_IsOK(res1)) {
46062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46063 }
46064 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46065 {
46066 arg2 = &temp2;
46067 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
46068 }
46069 {
46070 PyThreadState* __tstate = wxPyBeginAllowThreads();
46071 (arg1)->SetSpacer((wxSize const &)*arg2);
46072 wxPyEndAllowThreads(__tstate);
46073 if (PyErr_Occurred()) SWIG_fail;
46074 }
46075 resultobj = SWIG_Py_Void();
46076 return resultobj;
46077 fail:
46078 return NULL;
46079 }
46080
46081
46082 SWIGINTERN PyObject *_wrap_SizerItem_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46083 PyObject *resultobj = 0;
46084 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46085 bool arg2 ;
46086 void *argp1 = 0 ;
46087 int res1 = 0 ;
46088 bool val2 ;
46089 int ecode2 = 0 ;
46090 PyObject * obj0 = 0 ;
46091 PyObject * obj1 = 0 ;
46092 char * kwnames[] = {
46093 (char *) "self",(char *) "show", NULL
46094 };
46095
46096 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) SWIG_fail;
46097 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46098 if (!SWIG_IsOK(res1)) {
46099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_Show" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46100 }
46101 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46102 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46103 if (!SWIG_IsOK(ecode2)) {
46104 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_Show" "', expected argument " "2"" of type '" "bool""'");
46105 }
46106 arg2 = static_cast< bool >(val2);
46107 {
46108 PyThreadState* __tstate = wxPyBeginAllowThreads();
46109 (arg1)->Show(arg2);
46110 wxPyEndAllowThreads(__tstate);
46111 if (PyErr_Occurred()) SWIG_fail;
46112 }
46113 resultobj = SWIG_Py_Void();
46114 return resultobj;
46115 fail:
46116 return NULL;
46117 }
46118
46119
46120 SWIGINTERN PyObject *_wrap_SizerItem_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46121 PyObject *resultobj = 0;
46122 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46123 bool result;
46124 void *argp1 = 0 ;
46125 int res1 = 0 ;
46126 PyObject *swig_obj[1] ;
46127
46128 if (!args) SWIG_fail;
46129 swig_obj[0] = args;
46130 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46131 if (!SWIG_IsOK(res1)) {
46132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsShown" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46133 }
46134 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46135 {
46136 PyThreadState* __tstate = wxPyBeginAllowThreads();
46137 result = (bool)(arg1)->IsShown();
46138 wxPyEndAllowThreads(__tstate);
46139 if (PyErr_Occurred()) SWIG_fail;
46140 }
46141 {
46142 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46143 }
46144 return resultobj;
46145 fail:
46146 return NULL;
46147 }
46148
46149
46150 SWIGINTERN PyObject *_wrap_SizerItem_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46151 PyObject *resultobj = 0;
46152 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46153 wxPoint result;
46154 void *argp1 = 0 ;
46155 int res1 = 0 ;
46156 PyObject *swig_obj[1] ;
46157
46158 if (!args) SWIG_fail;
46159 swig_obj[0] = args;
46160 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46161 if (!SWIG_IsOK(res1)) {
46162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetPosition" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46163 }
46164 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46165 {
46166 PyThreadState* __tstate = wxPyBeginAllowThreads();
46167 result = (arg1)->GetPosition();
46168 wxPyEndAllowThreads(__tstate);
46169 if (PyErr_Occurred()) SWIG_fail;
46170 }
46171 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
46172 return resultobj;
46173 fail:
46174 return NULL;
46175 }
46176
46177
46178 SWIGINTERN PyObject *_wrap_SizerItem_GetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46179 PyObject *resultobj = 0;
46180 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46181 PyObject *result = 0 ;
46182 void *argp1 = 0 ;
46183 int res1 = 0 ;
46184 PyObject *swig_obj[1] ;
46185
46186 if (!args) SWIG_fail;
46187 swig_obj[0] = args;
46188 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46189 if (!SWIG_IsOK(res1)) {
46190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46191 }
46192 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46193 {
46194 PyThreadState* __tstate = wxPyBeginAllowThreads();
46195 result = (PyObject *)wxSizerItem_GetUserData(arg1);
46196 wxPyEndAllowThreads(__tstate);
46197 if (PyErr_Occurred()) SWIG_fail;
46198 }
46199 resultobj = result;
46200 return resultobj;
46201 fail:
46202 return NULL;
46203 }
46204
46205
46206 SWIGINTERN PyObject *_wrap_SizerItem_SetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46207 PyObject *resultobj = 0;
46208 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46209 PyObject *arg2 = (PyObject *) 0 ;
46210 void *argp1 = 0 ;
46211 int res1 = 0 ;
46212 PyObject * obj0 = 0 ;
46213 PyObject * obj1 = 0 ;
46214 char * kwnames[] = {
46215 (char *) "self",(char *) "userData", NULL
46216 };
46217
46218 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetUserData",kwnames,&obj0,&obj1)) SWIG_fail;
46219 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46220 if (!SWIG_IsOK(res1)) {
46221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46222 }
46223 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46224 arg2 = obj1;
46225 {
46226 PyThreadState* __tstate = wxPyBeginAllowThreads();
46227 wxSizerItem_SetUserData(arg1,arg2);
46228 wxPyEndAllowThreads(__tstate);
46229 if (PyErr_Occurred()) SWIG_fail;
46230 }
46231 resultobj = SWIG_Py_Void();
46232 return resultobj;
46233 fail:
46234 return NULL;
46235 }
46236
46237
46238 SWIGINTERN PyObject *SizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46239 PyObject *obj;
46240 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
46241 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerItem, SWIG_NewClientData(obj));
46242 return SWIG_Py_Void();
46243 }
46244
46245 SWIGINTERN PyObject *SizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46246 return SWIG_Python_InitShadowInstance(args);
46247 }
46248
46249 SWIGINTERN PyObject *_wrap_delete_Sizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46250 PyObject *resultobj = 0;
46251 wxSizer *arg1 = (wxSizer *) 0 ;
46252 void *argp1 = 0 ;
46253 int res1 = 0 ;
46254 PyObject *swig_obj[1] ;
46255
46256 if (!args) SWIG_fail;
46257 swig_obj[0] = args;
46258 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
46259 if (!SWIG_IsOK(res1)) {
46260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sizer" "', expected argument " "1"" of type '" "wxSizer *""'");
46261 }
46262 arg1 = reinterpret_cast< wxSizer * >(argp1);
46263 {
46264 PyThreadState* __tstate = wxPyBeginAllowThreads();
46265 delete arg1;
46266
46267 wxPyEndAllowThreads(__tstate);
46268 if (PyErr_Occurred()) SWIG_fail;
46269 }
46270 resultobj = SWIG_Py_Void();
46271 return resultobj;
46272 fail:
46273 return NULL;
46274 }
46275
46276
46277 SWIGINTERN PyObject *_wrap_Sizer__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46278 PyObject *resultobj = 0;
46279 wxSizer *arg1 = (wxSizer *) 0 ;
46280 PyObject *arg2 = (PyObject *) 0 ;
46281 void *argp1 = 0 ;
46282 int res1 = 0 ;
46283 PyObject * obj0 = 0 ;
46284 PyObject * obj1 = 0 ;
46285 char * kwnames[] = {
46286 (char *) "self",(char *) "_self", NULL
46287 };
46288
46289 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
46290 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46291 if (!SWIG_IsOK(res1)) {
46292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__setOORInfo" "', expected argument " "1"" of type '" "wxSizer *""'");
46293 }
46294 arg1 = reinterpret_cast< wxSizer * >(argp1);
46295 arg2 = obj1;
46296 {
46297 PyThreadState* __tstate = wxPyBeginAllowThreads();
46298 wxSizer__setOORInfo(arg1,arg2);
46299 wxPyEndAllowThreads(__tstate);
46300 if (PyErr_Occurred()) SWIG_fail;
46301 }
46302 resultobj = SWIG_Py_Void();
46303 return resultobj;
46304 fail:
46305 return NULL;
46306 }
46307
46308
46309 SWIGINTERN PyObject *_wrap_Sizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46310 PyObject *resultobj = 0;
46311 wxSizer *arg1 = (wxSizer *) 0 ;
46312 PyObject *arg2 = (PyObject *) 0 ;
46313 int arg3 = (int) 0 ;
46314 int arg4 = (int) 0 ;
46315 int arg5 = (int) 0 ;
46316 PyObject *arg6 = (PyObject *) NULL ;
46317 wxSizerItem *result = 0 ;
46318 void *argp1 = 0 ;
46319 int res1 = 0 ;
46320 int val3 ;
46321 int ecode3 = 0 ;
46322 int val4 ;
46323 int ecode4 = 0 ;
46324 int val5 ;
46325 int ecode5 = 0 ;
46326 PyObject * obj0 = 0 ;
46327 PyObject * obj1 = 0 ;
46328 PyObject * obj2 = 0 ;
46329 PyObject * obj3 = 0 ;
46330 PyObject * obj4 = 0 ;
46331 PyObject * obj5 = 0 ;
46332 char * kwnames[] = {
46333 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46334 };
46335
46336 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
46337 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46338 if (!SWIG_IsOK(res1)) {
46339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Add" "', expected argument " "1"" of type '" "wxSizer *""'");
46340 }
46341 arg1 = reinterpret_cast< wxSizer * >(argp1);
46342 arg2 = obj1;
46343 if (obj2) {
46344 ecode3 = SWIG_AsVal_int(obj2, &val3);
46345 if (!SWIG_IsOK(ecode3)) {
46346 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Add" "', expected argument " "3"" of type '" "int""'");
46347 }
46348 arg3 = static_cast< int >(val3);
46349 }
46350 if (obj3) {
46351 ecode4 = SWIG_AsVal_int(obj3, &val4);
46352 if (!SWIG_IsOK(ecode4)) {
46353 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Add" "', expected argument " "4"" of type '" "int""'");
46354 }
46355 arg4 = static_cast< int >(val4);
46356 }
46357 if (obj4) {
46358 ecode5 = SWIG_AsVal_int(obj4, &val5);
46359 if (!SWIG_IsOK(ecode5)) {
46360 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Add" "', expected argument " "5"" of type '" "int""'");
46361 }
46362 arg5 = static_cast< int >(val5);
46363 }
46364 if (obj5) {
46365 arg6 = obj5;
46366 }
46367 {
46368 PyThreadState* __tstate = wxPyBeginAllowThreads();
46369 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
46370 wxPyEndAllowThreads(__tstate);
46371 if (PyErr_Occurred()) SWIG_fail;
46372 }
46373 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46374 return resultobj;
46375 fail:
46376 return NULL;
46377 }
46378
46379
46380 SWIGINTERN PyObject *_wrap_Sizer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46381 PyObject *resultobj = 0;
46382 wxSizer *arg1 = (wxSizer *) 0 ;
46383 int arg2 ;
46384 PyObject *arg3 = (PyObject *) 0 ;
46385 int arg4 = (int) 0 ;
46386 int arg5 = (int) 0 ;
46387 int arg6 = (int) 0 ;
46388 PyObject *arg7 = (PyObject *) NULL ;
46389 wxSizerItem *result = 0 ;
46390 void *argp1 = 0 ;
46391 int res1 = 0 ;
46392 int val2 ;
46393 int ecode2 = 0 ;
46394 int val4 ;
46395 int ecode4 = 0 ;
46396 int val5 ;
46397 int ecode5 = 0 ;
46398 int val6 ;
46399 int ecode6 = 0 ;
46400 PyObject * obj0 = 0 ;
46401 PyObject * obj1 = 0 ;
46402 PyObject * obj2 = 0 ;
46403 PyObject * obj3 = 0 ;
46404 PyObject * obj4 = 0 ;
46405 PyObject * obj5 = 0 ;
46406 PyObject * obj6 = 0 ;
46407 char * kwnames[] = {
46408 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46409 };
46410
46411 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
46412 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46413 if (!SWIG_IsOK(res1)) {
46414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Insert" "', expected argument " "1"" of type '" "wxSizer *""'");
46415 }
46416 arg1 = reinterpret_cast< wxSizer * >(argp1);
46417 ecode2 = SWIG_AsVal_int(obj1, &val2);
46418 if (!SWIG_IsOK(ecode2)) {
46419 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Insert" "', expected argument " "2"" of type '" "int""'");
46420 }
46421 arg2 = static_cast< int >(val2);
46422 arg3 = obj2;
46423 if (obj3) {
46424 ecode4 = SWIG_AsVal_int(obj3, &val4);
46425 if (!SWIG_IsOK(ecode4)) {
46426 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Insert" "', expected argument " "4"" of type '" "int""'");
46427 }
46428 arg4 = static_cast< int >(val4);
46429 }
46430 if (obj4) {
46431 ecode5 = SWIG_AsVal_int(obj4, &val5);
46432 if (!SWIG_IsOK(ecode5)) {
46433 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Insert" "', expected argument " "5"" of type '" "int""'");
46434 }
46435 arg5 = static_cast< int >(val5);
46436 }
46437 if (obj5) {
46438 ecode6 = SWIG_AsVal_int(obj5, &val6);
46439 if (!SWIG_IsOK(ecode6)) {
46440 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Sizer_Insert" "', expected argument " "6"" of type '" "int""'");
46441 }
46442 arg6 = static_cast< int >(val6);
46443 }
46444 if (obj6) {
46445 arg7 = obj6;
46446 }
46447 {
46448 PyThreadState* __tstate = wxPyBeginAllowThreads();
46449 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
46450 wxPyEndAllowThreads(__tstate);
46451 if (PyErr_Occurred()) SWIG_fail;
46452 }
46453 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46454 return resultobj;
46455 fail:
46456 return NULL;
46457 }
46458
46459
46460 SWIGINTERN PyObject *_wrap_Sizer_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46461 PyObject *resultobj = 0;
46462 wxSizer *arg1 = (wxSizer *) 0 ;
46463 PyObject *arg2 = (PyObject *) 0 ;
46464 int arg3 = (int) 0 ;
46465 int arg4 = (int) 0 ;
46466 int arg5 = (int) 0 ;
46467 PyObject *arg6 = (PyObject *) NULL ;
46468 wxSizerItem *result = 0 ;
46469 void *argp1 = 0 ;
46470 int res1 = 0 ;
46471 int val3 ;
46472 int ecode3 = 0 ;
46473 int val4 ;
46474 int ecode4 = 0 ;
46475 int val5 ;
46476 int ecode5 = 0 ;
46477 PyObject * obj0 = 0 ;
46478 PyObject * obj1 = 0 ;
46479 PyObject * obj2 = 0 ;
46480 PyObject * obj3 = 0 ;
46481 PyObject * obj4 = 0 ;
46482 PyObject * obj5 = 0 ;
46483 char * kwnames[] = {
46484 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46485 };
46486
46487 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
46488 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46489 if (!SWIG_IsOK(res1)) {
46490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Prepend" "', expected argument " "1"" of type '" "wxSizer *""'");
46491 }
46492 arg1 = reinterpret_cast< wxSizer * >(argp1);
46493 arg2 = obj1;
46494 if (obj2) {
46495 ecode3 = SWIG_AsVal_int(obj2, &val3);
46496 if (!SWIG_IsOK(ecode3)) {
46497 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Prepend" "', expected argument " "3"" of type '" "int""'");
46498 }
46499 arg3 = static_cast< int >(val3);
46500 }
46501 if (obj3) {
46502 ecode4 = SWIG_AsVal_int(obj3, &val4);
46503 if (!SWIG_IsOK(ecode4)) {
46504 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Prepend" "', expected argument " "4"" of type '" "int""'");
46505 }
46506 arg4 = static_cast< int >(val4);
46507 }
46508 if (obj4) {
46509 ecode5 = SWIG_AsVal_int(obj4, &val5);
46510 if (!SWIG_IsOK(ecode5)) {
46511 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Prepend" "', expected argument " "5"" of type '" "int""'");
46512 }
46513 arg5 = static_cast< int >(val5);
46514 }
46515 if (obj5) {
46516 arg6 = obj5;
46517 }
46518 {
46519 PyThreadState* __tstate = wxPyBeginAllowThreads();
46520 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
46521 wxPyEndAllowThreads(__tstate);
46522 if (PyErr_Occurred()) SWIG_fail;
46523 }
46524 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46525 return resultobj;
46526 fail:
46527 return NULL;
46528 }
46529
46530
46531 SWIGINTERN PyObject *_wrap_Sizer_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46532 PyObject *resultobj = 0;
46533 wxSizer *arg1 = (wxSizer *) 0 ;
46534 PyObject *arg2 = (PyObject *) 0 ;
46535 bool result;
46536 void *argp1 = 0 ;
46537 int res1 = 0 ;
46538 PyObject * obj0 = 0 ;
46539 PyObject * obj1 = 0 ;
46540 char * kwnames[] = {
46541 (char *) "self",(char *) "item", NULL
46542 };
46543
46544 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
46545 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46546 if (!SWIG_IsOK(res1)) {
46547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Remove" "', expected argument " "1"" of type '" "wxSizer *""'");
46548 }
46549 arg1 = reinterpret_cast< wxSizer * >(argp1);
46550 arg2 = obj1;
46551 {
46552 PyThreadState* __tstate = wxPyBeginAllowThreads();
46553 result = (bool)wxSizer_Remove(arg1,arg2);
46554 wxPyEndAllowThreads(__tstate);
46555 if (PyErr_Occurred()) SWIG_fail;
46556 }
46557 {
46558 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46559 }
46560 return resultobj;
46561 fail:
46562 return NULL;
46563 }
46564
46565
46566 SWIGINTERN PyObject *_wrap_Sizer_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46567 PyObject *resultobj = 0;
46568 wxSizer *arg1 = (wxSizer *) 0 ;
46569 PyObject *arg2 = (PyObject *) 0 ;
46570 bool result;
46571 void *argp1 = 0 ;
46572 int res1 = 0 ;
46573 PyObject * obj0 = 0 ;
46574 PyObject * obj1 = 0 ;
46575 char * kwnames[] = {
46576 (char *) "self",(char *) "item", NULL
46577 };
46578
46579 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) SWIG_fail;
46580 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46581 if (!SWIG_IsOK(res1)) {
46582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Detach" "', expected argument " "1"" of type '" "wxSizer *""'");
46583 }
46584 arg1 = reinterpret_cast< wxSizer * >(argp1);
46585 arg2 = obj1;
46586 {
46587 PyThreadState* __tstate = wxPyBeginAllowThreads();
46588 result = (bool)wxSizer_Detach(arg1,arg2);
46589 wxPyEndAllowThreads(__tstate);
46590 if (PyErr_Occurred()) SWIG_fail;
46591 }
46592 {
46593 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46594 }
46595 return resultobj;
46596 fail:
46597 return NULL;
46598 }
46599
46600
46601 SWIGINTERN PyObject *_wrap_Sizer_GetItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46602 PyObject *resultobj = 0;
46603 wxSizer *arg1 = (wxSizer *) 0 ;
46604 PyObject *arg2 = (PyObject *) 0 ;
46605 wxSizerItem *result = 0 ;
46606 void *argp1 = 0 ;
46607 int res1 = 0 ;
46608 PyObject * obj0 = 0 ;
46609 PyObject * obj1 = 0 ;
46610 char * kwnames[] = {
46611 (char *) "self",(char *) "item", NULL
46612 };
46613
46614 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) SWIG_fail;
46615 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46616 if (!SWIG_IsOK(res1)) {
46617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46618 }
46619 arg1 = reinterpret_cast< wxSizer * >(argp1);
46620 arg2 = obj1;
46621 {
46622 PyThreadState* __tstate = wxPyBeginAllowThreads();
46623 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
46624 wxPyEndAllowThreads(__tstate);
46625 if (PyErr_Occurred()) SWIG_fail;
46626 }
46627 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46628 return resultobj;
46629 fail:
46630 return NULL;
46631 }
46632
46633
46634 SWIGINTERN PyObject *_wrap_Sizer__SetItemMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46635 PyObject *resultobj = 0;
46636 wxSizer *arg1 = (wxSizer *) 0 ;
46637 PyObject *arg2 = (PyObject *) 0 ;
46638 wxSize *arg3 = 0 ;
46639 void *argp1 = 0 ;
46640 int res1 = 0 ;
46641 wxSize temp3 ;
46642 PyObject * obj0 = 0 ;
46643 PyObject * obj1 = 0 ;
46644 PyObject * obj2 = 0 ;
46645 char * kwnames[] = {
46646 (char *) "self",(char *) "item",(char *) "size", NULL
46647 };
46648
46649 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46650 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46651 if (!SWIG_IsOK(res1)) {
46652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__SetItemMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46653 }
46654 arg1 = reinterpret_cast< wxSizer * >(argp1);
46655 arg2 = obj1;
46656 {
46657 arg3 = &temp3;
46658 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
46659 }
46660 {
46661 PyThreadState* __tstate = wxPyBeginAllowThreads();
46662 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
46663 wxPyEndAllowThreads(__tstate);
46664 if (PyErr_Occurred()) SWIG_fail;
46665 }
46666 resultobj = SWIG_Py_Void();
46667 return resultobj;
46668 fail:
46669 return NULL;
46670 }
46671
46672
46673 SWIGINTERN PyObject *_wrap_Sizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46674 PyObject *resultobj = 0;
46675 wxSizer *arg1 = (wxSizer *) 0 ;
46676 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
46677 wxSizerItem *result = 0 ;
46678 void *argp1 = 0 ;
46679 int res1 = 0 ;
46680 int res2 = 0 ;
46681 PyObject * obj0 = 0 ;
46682 PyObject * obj1 = 0 ;
46683 char * kwnames[] = {
46684 (char *) "self",(char *) "item", NULL
46685 };
46686
46687 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
46688 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46689 if (!SWIG_IsOK(res1)) {
46690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46691 }
46692 arg1 = reinterpret_cast< wxSizer * >(argp1);
46693 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46694 if (!SWIG_IsOK(res2)) {
46695 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_AddItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
46696 }
46697 {
46698 PyThreadState* __tstate = wxPyBeginAllowThreads();
46699 result = (wxSizerItem *)(arg1)->Add(arg2);
46700 wxPyEndAllowThreads(__tstate);
46701 if (PyErr_Occurred()) SWIG_fail;
46702 }
46703 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46704 return resultobj;
46705 fail:
46706 return NULL;
46707 }
46708
46709
46710 SWIGINTERN PyObject *_wrap_Sizer_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46711 PyObject *resultobj = 0;
46712 wxSizer *arg1 = (wxSizer *) 0 ;
46713 size_t arg2 ;
46714 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
46715 wxSizerItem *result = 0 ;
46716 void *argp1 = 0 ;
46717 int res1 = 0 ;
46718 size_t val2 ;
46719 int ecode2 = 0 ;
46720 int res3 = 0 ;
46721 PyObject * obj0 = 0 ;
46722 PyObject * obj1 = 0 ;
46723 PyObject * obj2 = 0 ;
46724 char * kwnames[] = {
46725 (char *) "self",(char *) "index",(char *) "item", NULL
46726 };
46727
46728 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46729 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46730 if (!SWIG_IsOK(res1)) {
46731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_InsertItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46732 }
46733 arg1 = reinterpret_cast< wxSizer * >(argp1);
46734 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
46735 if (!SWIG_IsOK(ecode2)) {
46736 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
46737 }
46738 arg2 = static_cast< size_t >(val2);
46739 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46740 if (!SWIG_IsOK(res3)) {
46741 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_InsertItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
46742 }
46743 {
46744 PyThreadState* __tstate = wxPyBeginAllowThreads();
46745 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
46746 wxPyEndAllowThreads(__tstate);
46747 if (PyErr_Occurred()) SWIG_fail;
46748 }
46749 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46750 return resultobj;
46751 fail:
46752 return NULL;
46753 }
46754
46755
46756 SWIGINTERN PyObject *_wrap_Sizer_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46757 PyObject *resultobj = 0;
46758 wxSizer *arg1 = (wxSizer *) 0 ;
46759 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
46760 wxSizerItem *result = 0 ;
46761 void *argp1 = 0 ;
46762 int res1 = 0 ;
46763 int res2 = 0 ;
46764 PyObject * obj0 = 0 ;
46765 PyObject * obj1 = 0 ;
46766 char * kwnames[] = {
46767 (char *) "self",(char *) "item", NULL
46768 };
46769
46770 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
46771 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46772 if (!SWIG_IsOK(res1)) {
46773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_PrependItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46774 }
46775 arg1 = reinterpret_cast< wxSizer * >(argp1);
46776 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46777 if (!SWIG_IsOK(res2)) {
46778 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_PrependItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
46779 }
46780 {
46781 PyThreadState* __tstate = wxPyBeginAllowThreads();
46782 result = (wxSizerItem *)(arg1)->Prepend(arg2);
46783 wxPyEndAllowThreads(__tstate);
46784 if (PyErr_Occurred()) SWIG_fail;
46785 }
46786 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46787 return resultobj;
46788 fail:
46789 return NULL;
46790 }
46791
46792
46793 SWIGINTERN PyObject *_wrap_Sizer_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46794 PyObject *resultobj = 0;
46795 wxSizer *arg1 = (wxSizer *) 0 ;
46796 int arg2 ;
46797 int arg3 ;
46798 int arg4 ;
46799 int arg5 ;
46800 void *argp1 = 0 ;
46801 int res1 = 0 ;
46802 int val2 ;
46803 int ecode2 = 0 ;
46804 int val3 ;
46805 int ecode3 = 0 ;
46806 int val4 ;
46807 int ecode4 = 0 ;
46808 int val5 ;
46809 int ecode5 = 0 ;
46810 PyObject * obj0 = 0 ;
46811 PyObject * obj1 = 0 ;
46812 PyObject * obj2 = 0 ;
46813 PyObject * obj3 = 0 ;
46814 PyObject * obj4 = 0 ;
46815 char * kwnames[] = {
46816 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
46817 };
46818
46819 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
46820 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46821 if (!SWIG_IsOK(res1)) {
46822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetDimension" "', expected argument " "1"" of type '" "wxSizer *""'");
46823 }
46824 arg1 = reinterpret_cast< wxSizer * >(argp1);
46825 ecode2 = SWIG_AsVal_int(obj1, &val2);
46826 if (!SWIG_IsOK(ecode2)) {
46827 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_SetDimension" "', expected argument " "2"" of type '" "int""'");
46828 }
46829 arg2 = static_cast< int >(val2);
46830 ecode3 = SWIG_AsVal_int(obj2, &val3);
46831 if (!SWIG_IsOK(ecode3)) {
46832 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_SetDimension" "', expected argument " "3"" of type '" "int""'");
46833 }
46834 arg3 = static_cast< int >(val3);
46835 ecode4 = SWIG_AsVal_int(obj3, &val4);
46836 if (!SWIG_IsOK(ecode4)) {
46837 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_SetDimension" "', expected argument " "4"" of type '" "int""'");
46838 }
46839 arg4 = static_cast< int >(val4);
46840 ecode5 = SWIG_AsVal_int(obj4, &val5);
46841 if (!SWIG_IsOK(ecode5)) {
46842 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_SetDimension" "', expected argument " "5"" of type '" "int""'");
46843 }
46844 arg5 = static_cast< int >(val5);
46845 {
46846 PyThreadState* __tstate = wxPyBeginAllowThreads();
46847 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
46848 wxPyEndAllowThreads(__tstate);
46849 if (PyErr_Occurred()) SWIG_fail;
46850 }
46851 resultobj = SWIG_Py_Void();
46852 return resultobj;
46853 fail:
46854 return NULL;
46855 }
46856
46857
46858 SWIGINTERN PyObject *_wrap_Sizer_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46859 PyObject *resultobj = 0;
46860 wxSizer *arg1 = (wxSizer *) 0 ;
46861 wxSize *arg2 = 0 ;
46862 void *argp1 = 0 ;
46863 int res1 = 0 ;
46864 wxSize temp2 ;
46865 PyObject * obj0 = 0 ;
46866 PyObject * obj1 = 0 ;
46867 char * kwnames[] = {
46868 (char *) "self",(char *) "size", NULL
46869 };
46870
46871 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
46872 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46873 if (!SWIG_IsOK(res1)) {
46874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46875 }
46876 arg1 = reinterpret_cast< wxSizer * >(argp1);
46877 {
46878 arg2 = &temp2;
46879 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
46880 }
46881 {
46882 PyThreadState* __tstate = wxPyBeginAllowThreads();
46883 (arg1)->SetMinSize((wxSize const &)*arg2);
46884 wxPyEndAllowThreads(__tstate);
46885 if (PyErr_Occurred()) SWIG_fail;
46886 }
46887 resultobj = SWIG_Py_Void();
46888 return resultobj;
46889 fail:
46890 return NULL;
46891 }
46892
46893
46894 SWIGINTERN PyObject *_wrap_Sizer_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46895 PyObject *resultobj = 0;
46896 wxSizer *arg1 = (wxSizer *) 0 ;
46897 wxSize result;
46898 void *argp1 = 0 ;
46899 int res1 = 0 ;
46900 PyObject *swig_obj[1] ;
46901
46902 if (!args) SWIG_fail;
46903 swig_obj[0] = args;
46904 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46905 if (!SWIG_IsOK(res1)) {
46906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46907 }
46908 arg1 = reinterpret_cast< wxSizer * >(argp1);
46909 {
46910 PyThreadState* __tstate = wxPyBeginAllowThreads();
46911 result = (arg1)->GetSize();
46912 wxPyEndAllowThreads(__tstate);
46913 if (PyErr_Occurred()) SWIG_fail;
46914 }
46915 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46916 return resultobj;
46917 fail:
46918 return NULL;
46919 }
46920
46921
46922 SWIGINTERN PyObject *_wrap_Sizer_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46923 PyObject *resultobj = 0;
46924 wxSizer *arg1 = (wxSizer *) 0 ;
46925 wxPoint result;
46926 void *argp1 = 0 ;
46927 int res1 = 0 ;
46928 PyObject *swig_obj[1] ;
46929
46930 if (!args) SWIG_fail;
46931 swig_obj[0] = args;
46932 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46933 if (!SWIG_IsOK(res1)) {
46934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetPosition" "', expected argument " "1"" of type '" "wxSizer *""'");
46935 }
46936 arg1 = reinterpret_cast< wxSizer * >(argp1);
46937 {
46938 PyThreadState* __tstate = wxPyBeginAllowThreads();
46939 result = (arg1)->GetPosition();
46940 wxPyEndAllowThreads(__tstate);
46941 if (PyErr_Occurred()) SWIG_fail;
46942 }
46943 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
46944 return resultobj;
46945 fail:
46946 return NULL;
46947 }
46948
46949
46950 SWIGINTERN PyObject *_wrap_Sizer_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46951 PyObject *resultobj = 0;
46952 wxSizer *arg1 = (wxSizer *) 0 ;
46953 wxSize result;
46954 void *argp1 = 0 ;
46955 int res1 = 0 ;
46956 PyObject *swig_obj[1] ;
46957
46958 if (!args) SWIG_fail;
46959 swig_obj[0] = args;
46960 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46961 if (!SWIG_IsOK(res1)) {
46962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46963 }
46964 arg1 = reinterpret_cast< wxSizer * >(argp1);
46965 {
46966 PyThreadState* __tstate = wxPyBeginAllowThreads();
46967 result = (arg1)->GetMinSize();
46968 wxPyEndAllowThreads(__tstate);
46969 if (PyErr_Occurred()) SWIG_fail;
46970 }
46971 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46972 return resultobj;
46973 fail:
46974 return NULL;
46975 }
46976
46977
46978 SWIGINTERN PyObject *_wrap_Sizer_RecalcSizes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46979 PyObject *resultobj = 0;
46980 wxSizer *arg1 = (wxSizer *) 0 ;
46981 void *argp1 = 0 ;
46982 int res1 = 0 ;
46983 PyObject *swig_obj[1] ;
46984
46985 if (!args) SWIG_fail;
46986 swig_obj[0] = args;
46987 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46988 if (!SWIG_IsOK(res1)) {
46989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_RecalcSizes" "', expected argument " "1"" of type '" "wxSizer *""'");
46990 }
46991 arg1 = reinterpret_cast< wxSizer * >(argp1);
46992 {
46993 PyThreadState* __tstate = wxPyBeginAllowThreads();
46994 (arg1)->RecalcSizes();
46995 wxPyEndAllowThreads(__tstate);
46996 if (PyErr_Occurred()) SWIG_fail;
46997 }
46998 resultobj = SWIG_Py_Void();
46999 return resultobj;
47000 fail:
47001 return NULL;
47002 }
47003
47004
47005 SWIGINTERN PyObject *_wrap_Sizer_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47006 PyObject *resultobj = 0;
47007 wxSizer *arg1 = (wxSizer *) 0 ;
47008 wxSize result;
47009 void *argp1 = 0 ;
47010 int res1 = 0 ;
47011 PyObject *swig_obj[1] ;
47012
47013 if (!args) SWIG_fail;
47014 swig_obj[0] = args;
47015 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47016 if (!SWIG_IsOK(res1)) {
47017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_CalcMin" "', expected argument " "1"" of type '" "wxSizer *""'");
47018 }
47019 arg1 = reinterpret_cast< wxSizer * >(argp1);
47020 {
47021 PyThreadState* __tstate = wxPyBeginAllowThreads();
47022 result = (arg1)->CalcMin();
47023 wxPyEndAllowThreads(__tstate);
47024 if (PyErr_Occurred()) SWIG_fail;
47025 }
47026 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
47027 return resultobj;
47028 fail:
47029 return NULL;
47030 }
47031
47032
47033 SWIGINTERN PyObject *_wrap_Sizer_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47034 PyObject *resultobj = 0;
47035 wxSizer *arg1 = (wxSizer *) 0 ;
47036 void *argp1 = 0 ;
47037 int res1 = 0 ;
47038 PyObject *swig_obj[1] ;
47039
47040 if (!args) SWIG_fail;
47041 swig_obj[0] = args;
47042 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47043 if (!SWIG_IsOK(res1)) {
47044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Layout" "', expected argument " "1"" of type '" "wxSizer *""'");
47045 }
47046 arg1 = reinterpret_cast< wxSizer * >(argp1);
47047 {
47048 PyThreadState* __tstate = wxPyBeginAllowThreads();
47049 (arg1)->Layout();
47050 wxPyEndAllowThreads(__tstate);
47051 if (PyErr_Occurred()) SWIG_fail;
47052 }
47053 resultobj = SWIG_Py_Void();
47054 return resultobj;
47055 fail:
47056 return NULL;
47057 }
47058
47059
47060 SWIGINTERN PyObject *_wrap_Sizer_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47061 PyObject *resultobj = 0;
47062 wxSizer *arg1 = (wxSizer *) 0 ;
47063 wxWindow *arg2 = (wxWindow *) 0 ;
47064 wxSize result;
47065 void *argp1 = 0 ;
47066 int res1 = 0 ;
47067 void *argp2 = 0 ;
47068 int res2 = 0 ;
47069 PyObject * obj0 = 0 ;
47070 PyObject * obj1 = 0 ;
47071 char * kwnames[] = {
47072 (char *) "self",(char *) "window", NULL
47073 };
47074
47075 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) SWIG_fail;
47076 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47077 if (!SWIG_IsOK(res1)) {
47078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Fit" "', expected argument " "1"" of type '" "wxSizer *""'");
47079 }
47080 arg1 = reinterpret_cast< wxSizer * >(argp1);
47081 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47082 if (!SWIG_IsOK(res2)) {
47083 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_Fit" "', expected argument " "2"" of type '" "wxWindow *""'");
47084 }
47085 arg2 = reinterpret_cast< wxWindow * >(argp2);
47086 {
47087 PyThreadState* __tstate = wxPyBeginAllowThreads();
47088 result = (arg1)->Fit(arg2);
47089 wxPyEndAllowThreads(__tstate);
47090 if (PyErr_Occurred()) SWIG_fail;
47091 }
47092 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
47093 return resultobj;
47094 fail:
47095 return NULL;
47096 }
47097
47098
47099 SWIGINTERN PyObject *_wrap_Sizer_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47100 PyObject *resultobj = 0;
47101 wxSizer *arg1 = (wxSizer *) 0 ;
47102 wxWindow *arg2 = (wxWindow *) 0 ;
47103 void *argp1 = 0 ;
47104 int res1 = 0 ;
47105 void *argp2 = 0 ;
47106 int res2 = 0 ;
47107 PyObject * obj0 = 0 ;
47108 PyObject * obj1 = 0 ;
47109 char * kwnames[] = {
47110 (char *) "self",(char *) "window", NULL
47111 };
47112
47113 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) SWIG_fail;
47114 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47115 if (!SWIG_IsOK(res1)) {
47116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_FitInside" "', expected argument " "1"" of type '" "wxSizer *""'");
47117 }
47118 arg1 = reinterpret_cast< wxSizer * >(argp1);
47119 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47120 if (!SWIG_IsOK(res2)) {
47121 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_FitInside" "', expected argument " "2"" of type '" "wxWindow *""'");
47122 }
47123 arg2 = reinterpret_cast< wxWindow * >(argp2);
47124 {
47125 PyThreadState* __tstate = wxPyBeginAllowThreads();
47126 (arg1)->FitInside(arg2);
47127 wxPyEndAllowThreads(__tstate);
47128 if (PyErr_Occurred()) SWIG_fail;
47129 }
47130 resultobj = SWIG_Py_Void();
47131 return resultobj;
47132 fail:
47133 return NULL;
47134 }
47135
47136
47137 SWIGINTERN PyObject *_wrap_Sizer_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47138 PyObject *resultobj = 0;
47139 wxSizer *arg1 = (wxSizer *) 0 ;
47140 wxWindow *arg2 = (wxWindow *) 0 ;
47141 void *argp1 = 0 ;
47142 int res1 = 0 ;
47143 void *argp2 = 0 ;
47144 int res2 = 0 ;
47145 PyObject * obj0 = 0 ;
47146 PyObject * obj1 = 0 ;
47147 char * kwnames[] = {
47148 (char *) "self",(char *) "window", NULL
47149 };
47150
47151 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
47152 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47153 if (!SWIG_IsOK(res1)) {
47154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
47155 }
47156 arg1 = reinterpret_cast< wxSizer * >(argp1);
47157 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47158 if (!SWIG_IsOK(res2)) {
47159 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
47160 }
47161 arg2 = reinterpret_cast< wxWindow * >(argp2);
47162 {
47163 PyThreadState* __tstate = wxPyBeginAllowThreads();
47164 (arg1)->SetSizeHints(arg2);
47165 wxPyEndAllowThreads(__tstate);
47166 if (PyErr_Occurred()) SWIG_fail;
47167 }
47168 resultobj = SWIG_Py_Void();
47169 return resultobj;
47170 fail:
47171 return NULL;
47172 }
47173
47174
47175 SWIGINTERN PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47176 PyObject *resultobj = 0;
47177 wxSizer *arg1 = (wxSizer *) 0 ;
47178 wxWindow *arg2 = (wxWindow *) 0 ;
47179 void *argp1 = 0 ;
47180 int res1 = 0 ;
47181 void *argp2 = 0 ;
47182 int res2 = 0 ;
47183 PyObject * obj0 = 0 ;
47184 PyObject * obj1 = 0 ;
47185 char * kwnames[] = {
47186 (char *) "self",(char *) "window", NULL
47187 };
47188
47189 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
47190 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47191 if (!SWIG_IsOK(res1)) {
47192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
47193 }
47194 arg1 = reinterpret_cast< wxSizer * >(argp1);
47195 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47196 if (!SWIG_IsOK(res2)) {
47197 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
47198 }
47199 arg2 = reinterpret_cast< wxWindow * >(argp2);
47200 {
47201 PyThreadState* __tstate = wxPyBeginAllowThreads();
47202 (arg1)->SetVirtualSizeHints(arg2);
47203 wxPyEndAllowThreads(__tstate);
47204 if (PyErr_Occurred()) SWIG_fail;
47205 }
47206 resultobj = SWIG_Py_Void();
47207 return resultobj;
47208 fail:
47209 return NULL;
47210 }
47211
47212
47213 SWIGINTERN PyObject *_wrap_Sizer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47214 PyObject *resultobj = 0;
47215 wxSizer *arg1 = (wxSizer *) 0 ;
47216 bool arg2 = (bool) false ;
47217 void *argp1 = 0 ;
47218 int res1 = 0 ;
47219 bool val2 ;
47220 int ecode2 = 0 ;
47221 PyObject * obj0 = 0 ;
47222 PyObject * obj1 = 0 ;
47223 char * kwnames[] = {
47224 (char *) "self",(char *) "deleteWindows", NULL
47225 };
47226
47227 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) SWIG_fail;
47228 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47229 if (!SWIG_IsOK(res1)) {
47230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Clear" "', expected argument " "1"" of type '" "wxSizer *""'");
47231 }
47232 arg1 = reinterpret_cast< wxSizer * >(argp1);
47233 if (obj1) {
47234 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47235 if (!SWIG_IsOK(ecode2)) {
47236 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Clear" "', expected argument " "2"" of type '" "bool""'");
47237 }
47238 arg2 = static_cast< bool >(val2);
47239 }
47240 {
47241 PyThreadState* __tstate = wxPyBeginAllowThreads();
47242 (arg1)->Clear(arg2);
47243 wxPyEndAllowThreads(__tstate);
47244 if (PyErr_Occurred()) SWIG_fail;
47245 }
47246 resultobj = SWIG_Py_Void();
47247 return resultobj;
47248 fail:
47249 return NULL;
47250 }
47251
47252
47253 SWIGINTERN PyObject *_wrap_Sizer_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47254 PyObject *resultobj = 0;
47255 wxSizer *arg1 = (wxSizer *) 0 ;
47256 void *argp1 = 0 ;
47257 int res1 = 0 ;
47258 PyObject *swig_obj[1] ;
47259
47260 if (!args) SWIG_fail;
47261 swig_obj[0] = args;
47262 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47263 if (!SWIG_IsOK(res1)) {
47264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_DeleteWindows" "', expected argument " "1"" of type '" "wxSizer *""'");
47265 }
47266 arg1 = reinterpret_cast< wxSizer * >(argp1);
47267 {
47268 PyThreadState* __tstate = wxPyBeginAllowThreads();
47269 (arg1)->DeleteWindows();
47270 wxPyEndAllowThreads(__tstate);
47271 if (PyErr_Occurred()) SWIG_fail;
47272 }
47273 resultobj = SWIG_Py_Void();
47274 return resultobj;
47275 fail:
47276 return NULL;
47277 }
47278
47279
47280 SWIGINTERN PyObject *_wrap_Sizer_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47281 PyObject *resultobj = 0;
47282 wxSizer *arg1 = (wxSizer *) 0 ;
47283 PyObject *result = 0 ;
47284 void *argp1 = 0 ;
47285 int res1 = 0 ;
47286 PyObject *swig_obj[1] ;
47287
47288 if (!args) SWIG_fail;
47289 swig_obj[0] = args;
47290 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47291 if (!SWIG_IsOK(res1)) {
47292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetChildren" "', expected argument " "1"" of type '" "wxSizer *""'");
47293 }
47294 arg1 = reinterpret_cast< wxSizer * >(argp1);
47295 {
47296 PyThreadState* __tstate = wxPyBeginAllowThreads();
47297 result = (PyObject *)wxSizer_GetChildren(arg1);
47298 wxPyEndAllowThreads(__tstate);
47299 if (PyErr_Occurred()) SWIG_fail;
47300 }
47301 resultobj = result;
47302 return resultobj;
47303 fail:
47304 return NULL;
47305 }
47306
47307
47308 SWIGINTERN PyObject *_wrap_Sizer_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47309 PyObject *resultobj = 0;
47310 wxSizer *arg1 = (wxSizer *) 0 ;
47311 PyObject *arg2 = (PyObject *) 0 ;
47312 bool arg3 = (bool) true ;
47313 bool arg4 = (bool) false ;
47314 bool result;
47315 void *argp1 = 0 ;
47316 int res1 = 0 ;
47317 bool val3 ;
47318 int ecode3 = 0 ;
47319 bool val4 ;
47320 int ecode4 = 0 ;
47321 PyObject * obj0 = 0 ;
47322 PyObject * obj1 = 0 ;
47323 PyObject * obj2 = 0 ;
47324 PyObject * obj3 = 0 ;
47325 char * kwnames[] = {
47326 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
47327 };
47328
47329 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47330 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47331 if (!SWIG_IsOK(res1)) {
47332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Show" "', expected argument " "1"" of type '" "wxSizer *""'");
47333 }
47334 arg1 = reinterpret_cast< wxSizer * >(argp1);
47335 arg2 = obj1;
47336 if (obj2) {
47337 ecode3 = SWIG_AsVal_bool(obj2, &val3);
47338 if (!SWIG_IsOK(ecode3)) {
47339 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Show" "', expected argument " "3"" of type '" "bool""'");
47340 }
47341 arg3 = static_cast< bool >(val3);
47342 }
47343 if (obj3) {
47344 ecode4 = SWIG_AsVal_bool(obj3, &val4);
47345 if (!SWIG_IsOK(ecode4)) {
47346 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Show" "', expected argument " "4"" of type '" "bool""'");
47347 }
47348 arg4 = static_cast< bool >(val4);
47349 }
47350 {
47351 PyThreadState* __tstate = wxPyBeginAllowThreads();
47352 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
47353 wxPyEndAllowThreads(__tstate);
47354 if (PyErr_Occurred()) SWIG_fail;
47355 }
47356 {
47357 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47358 }
47359 return resultobj;
47360 fail:
47361 return NULL;
47362 }
47363
47364
47365 SWIGINTERN PyObject *_wrap_Sizer_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47366 PyObject *resultobj = 0;
47367 wxSizer *arg1 = (wxSizer *) 0 ;
47368 PyObject *arg2 = (PyObject *) 0 ;
47369 bool result;
47370 void *argp1 = 0 ;
47371 int res1 = 0 ;
47372 PyObject * obj0 = 0 ;
47373 PyObject * obj1 = 0 ;
47374 char * kwnames[] = {
47375 (char *) "self",(char *) "item", NULL
47376 };
47377
47378 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) SWIG_fail;
47379 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47380 if (!SWIG_IsOK(res1)) {
47381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_IsShown" "', expected argument " "1"" of type '" "wxSizer *""'");
47382 }
47383 arg1 = reinterpret_cast< wxSizer * >(argp1);
47384 arg2 = obj1;
47385 {
47386 PyThreadState* __tstate = wxPyBeginAllowThreads();
47387 result = (bool)wxSizer_IsShown(arg1,arg2);
47388 wxPyEndAllowThreads(__tstate);
47389 if (PyErr_Occurred()) SWIG_fail;
47390 }
47391 {
47392 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47393 }
47394 return resultobj;
47395 fail:
47396 return NULL;
47397 }
47398
47399
47400 SWIGINTERN PyObject *_wrap_Sizer_ShowItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47401 PyObject *resultobj = 0;
47402 wxSizer *arg1 = (wxSizer *) 0 ;
47403 bool arg2 ;
47404 void *argp1 = 0 ;
47405 int res1 = 0 ;
47406 bool val2 ;
47407 int ecode2 = 0 ;
47408 PyObject * obj0 = 0 ;
47409 PyObject * obj1 = 0 ;
47410 char * kwnames[] = {
47411 (char *) "self",(char *) "show", NULL
47412 };
47413
47414 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) SWIG_fail;
47415 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47416 if (!SWIG_IsOK(res1)) {
47417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_ShowItems" "', expected argument " "1"" of type '" "wxSizer *""'");
47418 }
47419 arg1 = reinterpret_cast< wxSizer * >(argp1);
47420 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47421 if (!SWIG_IsOK(ecode2)) {
47422 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_ShowItems" "', expected argument " "2"" of type '" "bool""'");
47423 }
47424 arg2 = static_cast< bool >(val2);
47425 {
47426 PyThreadState* __tstate = wxPyBeginAllowThreads();
47427 (arg1)->ShowItems(arg2);
47428 wxPyEndAllowThreads(__tstate);
47429 if (PyErr_Occurred()) SWIG_fail;
47430 }
47431 resultobj = SWIG_Py_Void();
47432 return resultobj;
47433 fail:
47434 return NULL;
47435 }
47436
47437
47438 SWIGINTERN PyObject *Sizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47439 PyObject *obj;
47440 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47441 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizer, SWIG_NewClientData(obj));
47442 return SWIG_Py_Void();
47443 }
47444
47445 SWIGINTERN PyObject *_wrap_new_PySizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47446 PyObject *resultobj = 0;
47447 wxPySizer *result = 0 ;
47448
47449 if (!SWIG_Python_UnpackTuple(args,"new_PySizer",0,0,0)) SWIG_fail;
47450 {
47451 PyThreadState* __tstate = wxPyBeginAllowThreads();
47452 result = (wxPySizer *)new wxPySizer();
47453 wxPyEndAllowThreads(__tstate);
47454 if (PyErr_Occurred()) SWIG_fail;
47455 }
47456 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPySizer, SWIG_POINTER_NEW | 0 );
47457 return resultobj;
47458 fail:
47459 return NULL;
47460 }
47461
47462
47463 SWIGINTERN PyObject *_wrap_PySizer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47464 PyObject *resultobj = 0;
47465 wxPySizer *arg1 = (wxPySizer *) 0 ;
47466 PyObject *arg2 = (PyObject *) 0 ;
47467 PyObject *arg3 = (PyObject *) 0 ;
47468 void *argp1 = 0 ;
47469 int res1 = 0 ;
47470 PyObject * obj0 = 0 ;
47471 PyObject * obj1 = 0 ;
47472 PyObject * obj2 = 0 ;
47473 char * kwnames[] = {
47474 (char *) "self",(char *) "self",(char *) "_class", NULL
47475 };
47476
47477 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47478 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPySizer, 0 | 0 );
47479 if (!SWIG_IsOK(res1)) {
47480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySizer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPySizer *""'");
47481 }
47482 arg1 = reinterpret_cast< wxPySizer * >(argp1);
47483 arg2 = obj1;
47484 arg3 = obj2;
47485 {
47486 PyThreadState* __tstate = wxPyBeginAllowThreads();
47487 (arg1)->_setCallbackInfo(arg2,arg3);
47488 wxPyEndAllowThreads(__tstate);
47489 if (PyErr_Occurred()) SWIG_fail;
47490 }
47491 resultobj = SWIG_Py_Void();
47492 return resultobj;
47493 fail:
47494 return NULL;
47495 }
47496
47497
47498 SWIGINTERN PyObject *PySizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47499 PyObject *obj;
47500 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47501 SWIG_TypeNewClientData(SWIGTYPE_p_wxPySizer, SWIG_NewClientData(obj));
47502 return SWIG_Py_Void();
47503 }
47504
47505 SWIGINTERN PyObject *PySizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47506 return SWIG_Python_InitShadowInstance(args);
47507 }
47508
47509 SWIGINTERN PyObject *_wrap_new_BoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47510 PyObject *resultobj = 0;
47511 int arg1 = (int) wxHORIZONTAL ;
47512 wxBoxSizer *result = 0 ;
47513 int val1 ;
47514 int ecode1 = 0 ;
47515 PyObject * obj0 = 0 ;
47516 char * kwnames[] = {
47517 (char *) "orient", NULL
47518 };
47519
47520 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) SWIG_fail;
47521 if (obj0) {
47522 ecode1 = SWIG_AsVal_int(obj0, &val1);
47523 if (!SWIG_IsOK(ecode1)) {
47524 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BoxSizer" "', expected argument " "1"" of type '" "int""'");
47525 }
47526 arg1 = static_cast< int >(val1);
47527 }
47528 {
47529 PyThreadState* __tstate = wxPyBeginAllowThreads();
47530 result = (wxBoxSizer *)new wxBoxSizer(arg1);
47531 wxPyEndAllowThreads(__tstate);
47532 if (PyErr_Occurred()) SWIG_fail;
47533 }
47534 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_NEW | 0 );
47535 return resultobj;
47536 fail:
47537 return NULL;
47538 }
47539
47540
47541 SWIGINTERN PyObject *_wrap_BoxSizer_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47542 PyObject *resultobj = 0;
47543 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
47544 int result;
47545 void *argp1 = 0 ;
47546 int res1 = 0 ;
47547 PyObject *swig_obj[1] ;
47548
47549 if (!args) SWIG_fail;
47550 swig_obj[0] = args;
47551 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
47552 if (!SWIG_IsOK(res1)) {
47553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_GetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
47554 }
47555 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
47556 {
47557 PyThreadState* __tstate = wxPyBeginAllowThreads();
47558 result = (int)(arg1)->GetOrientation();
47559 wxPyEndAllowThreads(__tstate);
47560 if (PyErr_Occurred()) SWIG_fail;
47561 }
47562 resultobj = SWIG_From_int(static_cast< int >(result));
47563 return resultobj;
47564 fail:
47565 return NULL;
47566 }
47567
47568
47569 SWIGINTERN PyObject *_wrap_BoxSizer_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47570 PyObject *resultobj = 0;
47571 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
47572 int arg2 ;
47573 void *argp1 = 0 ;
47574 int res1 = 0 ;
47575 int val2 ;
47576 int ecode2 = 0 ;
47577 PyObject * obj0 = 0 ;
47578 PyObject * obj1 = 0 ;
47579 char * kwnames[] = {
47580 (char *) "self",(char *) "orient", NULL
47581 };
47582
47583 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
47584 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
47585 if (!SWIG_IsOK(res1)) {
47586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_SetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
47587 }
47588 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
47589 ecode2 = SWIG_AsVal_int(obj1, &val2);
47590 if (!SWIG_IsOK(ecode2)) {
47591 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoxSizer_SetOrientation" "', expected argument " "2"" of type '" "int""'");
47592 }
47593 arg2 = static_cast< int >(val2);
47594 {
47595 PyThreadState* __tstate = wxPyBeginAllowThreads();
47596 (arg1)->SetOrientation(arg2);
47597 wxPyEndAllowThreads(__tstate);
47598 if (PyErr_Occurred()) SWIG_fail;
47599 }
47600 resultobj = SWIG_Py_Void();
47601 return resultobj;
47602 fail:
47603 return NULL;
47604 }
47605
47606
47607 SWIGINTERN PyObject *BoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47608 PyObject *obj;
47609 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47610 SWIG_TypeNewClientData(SWIGTYPE_p_wxBoxSizer, SWIG_NewClientData(obj));
47611 return SWIG_Py_Void();
47612 }
47613
47614 SWIGINTERN PyObject *BoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47615 return SWIG_Python_InitShadowInstance(args);
47616 }
47617
47618 SWIGINTERN PyObject *_wrap_new_StaticBoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47619 PyObject *resultobj = 0;
47620 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
47621 int arg2 = (int) wxHORIZONTAL ;
47622 wxStaticBoxSizer *result = 0 ;
47623 void *argp1 = 0 ;
47624 int res1 = 0 ;
47625 int val2 ;
47626 int ecode2 = 0 ;
47627 PyObject * obj0 = 0 ;
47628 PyObject * obj1 = 0 ;
47629 char * kwnames[] = {
47630 (char *) "box",(char *) "orient", NULL
47631 };
47632
47633 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) SWIG_fail;
47634 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStaticBox, 0 | 0 );
47635 if (!SWIG_IsOK(res1)) {
47636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StaticBoxSizer" "', expected argument " "1"" of type '" "wxStaticBox *""'");
47637 }
47638 arg1 = reinterpret_cast< wxStaticBox * >(argp1);
47639 if (obj1) {
47640 ecode2 = SWIG_AsVal_int(obj1, &val2);
47641 if (!SWIG_IsOK(ecode2)) {
47642 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StaticBoxSizer" "', expected argument " "2"" of type '" "int""'");
47643 }
47644 arg2 = static_cast< int >(val2);
47645 }
47646 {
47647 PyThreadState* __tstate = wxPyBeginAllowThreads();
47648 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
47649 wxPyEndAllowThreads(__tstate);
47650 if (PyErr_Occurred()) SWIG_fail;
47651 }
47652 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_NEW | 0 );
47653 return resultobj;
47654 fail:
47655 return NULL;
47656 }
47657
47658
47659 SWIGINTERN PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47660 PyObject *resultobj = 0;
47661 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
47662 wxStaticBox *result = 0 ;
47663 void *argp1 = 0 ;
47664 int res1 = 0 ;
47665 PyObject *swig_obj[1] ;
47666
47667 if (!args) SWIG_fail;
47668 swig_obj[0] = args;
47669 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStaticBoxSizer, 0 | 0 );
47670 if (!SWIG_IsOK(res1)) {
47671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StaticBoxSizer_GetStaticBox" "', expected argument " "1"" of type '" "wxStaticBoxSizer *""'");
47672 }
47673 arg1 = reinterpret_cast< wxStaticBoxSizer * >(argp1);
47674 {
47675 PyThreadState* __tstate = wxPyBeginAllowThreads();
47676 result = (wxStaticBox *)(arg1)->GetStaticBox();
47677 wxPyEndAllowThreads(__tstate);
47678 if (PyErr_Occurred()) SWIG_fail;
47679 }
47680 {
47681 resultobj = wxPyMake_wxObject(result, (bool)0);
47682 }
47683 return resultobj;
47684 fail:
47685 return NULL;
47686 }
47687
47688
47689 SWIGINTERN PyObject *StaticBoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47690 PyObject *obj;
47691 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47692 SWIG_TypeNewClientData(SWIGTYPE_p_wxStaticBoxSizer, SWIG_NewClientData(obj));
47693 return SWIG_Py_Void();
47694 }
47695
47696 SWIGINTERN PyObject *StaticBoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47697 return SWIG_Python_InitShadowInstance(args);
47698 }
47699
47700 SWIGINTERN PyObject *_wrap_new_GridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47701 PyObject *resultobj = 0;
47702 int arg1 = (int) 1 ;
47703 int arg2 = (int) 0 ;
47704 int arg3 = (int) 0 ;
47705 int arg4 = (int) 0 ;
47706 wxGridSizer *result = 0 ;
47707 int val1 ;
47708 int ecode1 = 0 ;
47709 int val2 ;
47710 int ecode2 = 0 ;
47711 int val3 ;
47712 int ecode3 = 0 ;
47713 int val4 ;
47714 int ecode4 = 0 ;
47715 PyObject * obj0 = 0 ;
47716 PyObject * obj1 = 0 ;
47717 PyObject * obj2 = 0 ;
47718 PyObject * obj3 = 0 ;
47719 char * kwnames[] = {
47720 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
47721 };
47722
47723 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47724 if (obj0) {
47725 ecode1 = SWIG_AsVal_int(obj0, &val1);
47726 if (!SWIG_IsOK(ecode1)) {
47727 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizer" "', expected argument " "1"" of type '" "int""'");
47728 }
47729 arg1 = static_cast< int >(val1);
47730 }
47731 if (obj1) {
47732 ecode2 = SWIG_AsVal_int(obj1, &val2);
47733 if (!SWIG_IsOK(ecode2)) {
47734 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizer" "', expected argument " "2"" of type '" "int""'");
47735 }
47736 arg2 = static_cast< int >(val2);
47737 }
47738 if (obj2) {
47739 ecode3 = SWIG_AsVal_int(obj2, &val3);
47740 if (!SWIG_IsOK(ecode3)) {
47741 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridSizer" "', expected argument " "3"" of type '" "int""'");
47742 }
47743 arg3 = static_cast< int >(val3);
47744 }
47745 if (obj3) {
47746 ecode4 = SWIG_AsVal_int(obj3, &val4);
47747 if (!SWIG_IsOK(ecode4)) {
47748 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizer" "', expected argument " "4"" of type '" "int""'");
47749 }
47750 arg4 = static_cast< int >(val4);
47751 }
47752 {
47753 PyThreadState* __tstate = wxPyBeginAllowThreads();
47754 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
47755 wxPyEndAllowThreads(__tstate);
47756 if (PyErr_Occurred()) SWIG_fail;
47757 }
47758 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizer, SWIG_POINTER_NEW | 0 );
47759 return resultobj;
47760 fail:
47761 return NULL;
47762 }
47763
47764
47765 SWIGINTERN PyObject *_wrap_GridSizer_SetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47766 PyObject *resultobj = 0;
47767 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47768 int arg2 ;
47769 void *argp1 = 0 ;
47770 int res1 = 0 ;
47771 int val2 ;
47772 int ecode2 = 0 ;
47773 PyObject * obj0 = 0 ;
47774 PyObject * obj1 = 0 ;
47775 char * kwnames[] = {
47776 (char *) "self",(char *) "cols", NULL
47777 };
47778
47779 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) SWIG_fail;
47780 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47781 if (!SWIG_IsOK(res1)) {
47782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47783 }
47784 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47785 ecode2 = SWIG_AsVal_int(obj1, &val2);
47786 if (!SWIG_IsOK(ecode2)) {
47787 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetCols" "', expected argument " "2"" of type '" "int""'");
47788 }
47789 arg2 = static_cast< int >(val2);
47790 {
47791 PyThreadState* __tstate = wxPyBeginAllowThreads();
47792 (arg1)->SetCols(arg2);
47793 wxPyEndAllowThreads(__tstate);
47794 if (PyErr_Occurred()) SWIG_fail;
47795 }
47796 resultobj = SWIG_Py_Void();
47797 return resultobj;
47798 fail:
47799 return NULL;
47800 }
47801
47802
47803 SWIGINTERN PyObject *_wrap_GridSizer_SetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47804 PyObject *resultobj = 0;
47805 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47806 int arg2 ;
47807 void *argp1 = 0 ;
47808 int res1 = 0 ;
47809 int val2 ;
47810 int ecode2 = 0 ;
47811 PyObject * obj0 = 0 ;
47812 PyObject * obj1 = 0 ;
47813 char * kwnames[] = {
47814 (char *) "self",(char *) "rows", NULL
47815 };
47816
47817 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) SWIG_fail;
47818 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47819 if (!SWIG_IsOK(res1)) {
47820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47821 }
47822 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47823 ecode2 = SWIG_AsVal_int(obj1, &val2);
47824 if (!SWIG_IsOK(ecode2)) {
47825 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetRows" "', expected argument " "2"" of type '" "int""'");
47826 }
47827 arg2 = static_cast< int >(val2);
47828 {
47829 PyThreadState* __tstate = wxPyBeginAllowThreads();
47830 (arg1)->SetRows(arg2);
47831 wxPyEndAllowThreads(__tstate);
47832 if (PyErr_Occurred()) SWIG_fail;
47833 }
47834 resultobj = SWIG_Py_Void();
47835 return resultobj;
47836 fail:
47837 return NULL;
47838 }
47839
47840
47841 SWIGINTERN PyObject *_wrap_GridSizer_SetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47842 PyObject *resultobj = 0;
47843 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47844 int arg2 ;
47845 void *argp1 = 0 ;
47846 int res1 = 0 ;
47847 int val2 ;
47848 int ecode2 = 0 ;
47849 PyObject * obj0 = 0 ;
47850 PyObject * obj1 = 0 ;
47851 char * kwnames[] = {
47852 (char *) "self",(char *) "gap", NULL
47853 };
47854
47855 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) SWIG_fail;
47856 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47857 if (!SWIG_IsOK(res1)) {
47858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47859 }
47860 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47861 ecode2 = SWIG_AsVal_int(obj1, &val2);
47862 if (!SWIG_IsOK(ecode2)) {
47863 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetVGap" "', expected argument " "2"" of type '" "int""'");
47864 }
47865 arg2 = static_cast< int >(val2);
47866 {
47867 PyThreadState* __tstate = wxPyBeginAllowThreads();
47868 (arg1)->SetVGap(arg2);
47869 wxPyEndAllowThreads(__tstate);
47870 if (PyErr_Occurred()) SWIG_fail;
47871 }
47872 resultobj = SWIG_Py_Void();
47873 return resultobj;
47874 fail:
47875 return NULL;
47876 }
47877
47878
47879 SWIGINTERN PyObject *_wrap_GridSizer_SetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47880 PyObject *resultobj = 0;
47881 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47882 int arg2 ;
47883 void *argp1 = 0 ;
47884 int res1 = 0 ;
47885 int val2 ;
47886 int ecode2 = 0 ;
47887 PyObject * obj0 = 0 ;
47888 PyObject * obj1 = 0 ;
47889 char * kwnames[] = {
47890 (char *) "self",(char *) "gap", NULL
47891 };
47892
47893 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) SWIG_fail;
47894 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47895 if (!SWIG_IsOK(res1)) {
47896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47897 }
47898 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47899 ecode2 = SWIG_AsVal_int(obj1, &val2);
47900 if (!SWIG_IsOK(ecode2)) {
47901 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetHGap" "', expected argument " "2"" of type '" "int""'");
47902 }
47903 arg2 = static_cast< int >(val2);
47904 {
47905 PyThreadState* __tstate = wxPyBeginAllowThreads();
47906 (arg1)->SetHGap(arg2);
47907 wxPyEndAllowThreads(__tstate);
47908 if (PyErr_Occurred()) SWIG_fail;
47909 }
47910 resultobj = SWIG_Py_Void();
47911 return resultobj;
47912 fail:
47913 return NULL;
47914 }
47915
47916
47917 SWIGINTERN PyObject *_wrap_GridSizer_GetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47918 PyObject *resultobj = 0;
47919 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47920 int result;
47921 void *argp1 = 0 ;
47922 int res1 = 0 ;
47923 PyObject *swig_obj[1] ;
47924
47925 if (!args) SWIG_fail;
47926 swig_obj[0] = args;
47927 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47928 if (!SWIG_IsOK(res1)) {
47929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47930 }
47931 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47932 {
47933 PyThreadState* __tstate = wxPyBeginAllowThreads();
47934 result = (int)(arg1)->GetCols();
47935 wxPyEndAllowThreads(__tstate);
47936 if (PyErr_Occurred()) SWIG_fail;
47937 }
47938 resultobj = SWIG_From_int(static_cast< int >(result));
47939 return resultobj;
47940 fail:
47941 return NULL;
47942 }
47943
47944
47945 SWIGINTERN PyObject *_wrap_GridSizer_GetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47946 PyObject *resultobj = 0;
47947 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47948 int result;
47949 void *argp1 = 0 ;
47950 int res1 = 0 ;
47951 PyObject *swig_obj[1] ;
47952
47953 if (!args) SWIG_fail;
47954 swig_obj[0] = args;
47955 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47956 if (!SWIG_IsOK(res1)) {
47957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47958 }
47959 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47960 {
47961 PyThreadState* __tstate = wxPyBeginAllowThreads();
47962 result = (int)(arg1)->GetRows();
47963 wxPyEndAllowThreads(__tstate);
47964 if (PyErr_Occurred()) SWIG_fail;
47965 }
47966 resultobj = SWIG_From_int(static_cast< int >(result));
47967 return resultobj;
47968 fail:
47969 return NULL;
47970 }
47971
47972
47973 SWIGINTERN PyObject *_wrap_GridSizer_GetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47974 PyObject *resultobj = 0;
47975 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47976 int result;
47977 void *argp1 = 0 ;
47978 int res1 = 0 ;
47979 PyObject *swig_obj[1] ;
47980
47981 if (!args) SWIG_fail;
47982 swig_obj[0] = args;
47983 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47984 if (!SWIG_IsOK(res1)) {
47985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47986 }
47987 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47988 {
47989 PyThreadState* __tstate = wxPyBeginAllowThreads();
47990 result = (int)(arg1)->GetVGap();
47991 wxPyEndAllowThreads(__tstate);
47992 if (PyErr_Occurred()) SWIG_fail;
47993 }
47994 resultobj = SWIG_From_int(static_cast< int >(result));
47995 return resultobj;
47996 fail:
47997 return NULL;
47998 }
47999
48000
48001 SWIGINTERN PyObject *_wrap_GridSizer_GetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48002 PyObject *resultobj = 0;
48003 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48004 int result;
48005 void *argp1 = 0 ;
48006 int res1 = 0 ;
48007 PyObject *swig_obj[1] ;
48008
48009 if (!args) SWIG_fail;
48010 swig_obj[0] = args;
48011 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48012 if (!SWIG_IsOK(res1)) {
48013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48014 }
48015 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48016 {
48017 PyThreadState* __tstate = wxPyBeginAllowThreads();
48018 result = (int)(arg1)->GetHGap();
48019 wxPyEndAllowThreads(__tstate);
48020 if (PyErr_Occurred()) SWIG_fail;
48021 }
48022 resultobj = SWIG_From_int(static_cast< int >(result));
48023 return resultobj;
48024 fail:
48025 return NULL;
48026 }
48027
48028
48029 SWIGINTERN PyObject *GridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48030 PyObject *obj;
48031 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48032 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizer, SWIG_NewClientData(obj));
48033 return SWIG_Py_Void();
48034 }
48035
48036 SWIGINTERN PyObject *GridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48037 return SWIG_Python_InitShadowInstance(args);
48038 }
48039
48040 SWIGINTERN PyObject *_wrap_new_FlexGridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48041 PyObject *resultobj = 0;
48042 int arg1 = (int) 1 ;
48043 int arg2 = (int) 0 ;
48044 int arg3 = (int) 0 ;
48045 int arg4 = (int) 0 ;
48046 wxFlexGridSizer *result = 0 ;
48047 int val1 ;
48048 int ecode1 = 0 ;
48049 int val2 ;
48050 int ecode2 = 0 ;
48051 int val3 ;
48052 int ecode3 = 0 ;
48053 int val4 ;
48054 int ecode4 = 0 ;
48055 PyObject * obj0 = 0 ;
48056 PyObject * obj1 = 0 ;
48057 PyObject * obj2 = 0 ;
48058 PyObject * obj3 = 0 ;
48059 char * kwnames[] = {
48060 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
48061 };
48062
48063 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
48064 if (obj0) {
48065 ecode1 = SWIG_AsVal_int(obj0, &val1);
48066 if (!SWIG_IsOK(ecode1)) {
48067 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlexGridSizer" "', expected argument " "1"" of type '" "int""'");
48068 }
48069 arg1 = static_cast< int >(val1);
48070 }
48071 if (obj1) {
48072 ecode2 = SWIG_AsVal_int(obj1, &val2);
48073 if (!SWIG_IsOK(ecode2)) {
48074 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlexGridSizer" "', expected argument " "2"" of type '" "int""'");
48075 }
48076 arg2 = static_cast< int >(val2);
48077 }
48078 if (obj2) {
48079 ecode3 = SWIG_AsVal_int(obj2, &val3);
48080 if (!SWIG_IsOK(ecode3)) {
48081 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FlexGridSizer" "', expected argument " "3"" of type '" "int""'");
48082 }
48083 arg3 = static_cast< int >(val3);
48084 }
48085 if (obj3) {
48086 ecode4 = SWIG_AsVal_int(obj3, &val4);
48087 if (!SWIG_IsOK(ecode4)) {
48088 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FlexGridSizer" "', expected argument " "4"" of type '" "int""'");
48089 }
48090 arg4 = static_cast< int >(val4);
48091 }
48092 {
48093 PyThreadState* __tstate = wxPyBeginAllowThreads();
48094 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
48095 wxPyEndAllowThreads(__tstate);
48096 if (PyErr_Occurred()) SWIG_fail;
48097 }
48098 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_NEW | 0 );
48099 return resultobj;
48100 fail:
48101 return NULL;
48102 }
48103
48104
48105 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48106 PyObject *resultobj = 0;
48107 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48108 size_t arg2 ;
48109 int arg3 = (int) 0 ;
48110 void *argp1 = 0 ;
48111 int res1 = 0 ;
48112 size_t val2 ;
48113 int ecode2 = 0 ;
48114 int val3 ;
48115 int ecode3 = 0 ;
48116 PyObject * obj0 = 0 ;
48117 PyObject * obj1 = 0 ;
48118 PyObject * obj2 = 0 ;
48119 char * kwnames[] = {
48120 (char *) "self",(char *) "idx",(char *) "proportion", NULL
48121 };
48122
48123 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48124 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48125 if (!SWIG_IsOK(res1)) {
48126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48127 }
48128 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48129 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48130 if (!SWIG_IsOK(ecode2)) {
48131 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
48132 }
48133 arg2 = static_cast< size_t >(val2);
48134 if (obj2) {
48135 ecode3 = SWIG_AsVal_int(obj2, &val3);
48136 if (!SWIG_IsOK(ecode3)) {
48137 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "3"" of type '" "int""'");
48138 }
48139 arg3 = static_cast< int >(val3);
48140 }
48141 {
48142 PyThreadState* __tstate = wxPyBeginAllowThreads();
48143 (arg1)->AddGrowableRow(arg2,arg3);
48144 wxPyEndAllowThreads(__tstate);
48145 if (PyErr_Occurred()) SWIG_fail;
48146 }
48147 resultobj = SWIG_Py_Void();
48148 return resultobj;
48149 fail:
48150 return NULL;
48151 }
48152
48153
48154 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48155 PyObject *resultobj = 0;
48156 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48157 size_t arg2 ;
48158 void *argp1 = 0 ;
48159 int res1 = 0 ;
48160 size_t val2 ;
48161 int ecode2 = 0 ;
48162 PyObject * obj0 = 0 ;
48163 PyObject * obj1 = 0 ;
48164 char * kwnames[] = {
48165 (char *) "self",(char *) "idx", NULL
48166 };
48167
48168 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) SWIG_fail;
48169 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48170 if (!SWIG_IsOK(res1)) {
48171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48172 }
48173 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48174 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48175 if (!SWIG_IsOK(ecode2)) {
48176 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
48177 }
48178 arg2 = static_cast< size_t >(val2);
48179 {
48180 PyThreadState* __tstate = wxPyBeginAllowThreads();
48181 (arg1)->RemoveGrowableRow(arg2);
48182 wxPyEndAllowThreads(__tstate);
48183 if (PyErr_Occurred()) SWIG_fail;
48184 }
48185 resultobj = SWIG_Py_Void();
48186 return resultobj;
48187 fail:
48188 return NULL;
48189 }
48190
48191
48192 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48193 PyObject *resultobj = 0;
48194 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48195 size_t arg2 ;
48196 int arg3 = (int) 0 ;
48197 void *argp1 = 0 ;
48198 int res1 = 0 ;
48199 size_t val2 ;
48200 int ecode2 = 0 ;
48201 int val3 ;
48202 int ecode3 = 0 ;
48203 PyObject * obj0 = 0 ;
48204 PyObject * obj1 = 0 ;
48205 PyObject * obj2 = 0 ;
48206 char * kwnames[] = {
48207 (char *) "self",(char *) "idx",(char *) "proportion", NULL
48208 };
48209
48210 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48211 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48212 if (!SWIG_IsOK(res1)) {
48213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48214 }
48215 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48216 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48217 if (!SWIG_IsOK(ecode2)) {
48218 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
48219 }
48220 arg2 = static_cast< size_t >(val2);
48221 if (obj2) {
48222 ecode3 = SWIG_AsVal_int(obj2, &val3);
48223 if (!SWIG_IsOK(ecode3)) {
48224 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "3"" of type '" "int""'");
48225 }
48226 arg3 = static_cast< int >(val3);
48227 }
48228 {
48229 PyThreadState* __tstate = wxPyBeginAllowThreads();
48230 (arg1)->AddGrowableCol(arg2,arg3);
48231 wxPyEndAllowThreads(__tstate);
48232 if (PyErr_Occurred()) SWIG_fail;
48233 }
48234 resultobj = SWIG_Py_Void();
48235 return resultobj;
48236 fail:
48237 return NULL;
48238 }
48239
48240
48241 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48242 PyObject *resultobj = 0;
48243 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48244 size_t arg2 ;
48245 void *argp1 = 0 ;
48246 int res1 = 0 ;
48247 size_t val2 ;
48248 int ecode2 = 0 ;
48249 PyObject * obj0 = 0 ;
48250 PyObject * obj1 = 0 ;
48251 char * kwnames[] = {
48252 (char *) "self",(char *) "idx", NULL
48253 };
48254
48255 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) SWIG_fail;
48256 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48257 if (!SWIG_IsOK(res1)) {
48258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48259 }
48260 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48261 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48262 if (!SWIG_IsOK(ecode2)) {
48263 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
48264 }
48265 arg2 = static_cast< size_t >(val2);
48266 {
48267 PyThreadState* __tstate = wxPyBeginAllowThreads();
48268 (arg1)->RemoveGrowableCol(arg2);
48269 wxPyEndAllowThreads(__tstate);
48270 if (PyErr_Occurred()) SWIG_fail;
48271 }
48272 resultobj = SWIG_Py_Void();
48273 return resultobj;
48274 fail:
48275 return NULL;
48276 }
48277
48278
48279 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48280 PyObject *resultobj = 0;
48281 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48282 int arg2 ;
48283 void *argp1 = 0 ;
48284 int res1 = 0 ;
48285 int val2 ;
48286 int ecode2 = 0 ;
48287 PyObject * obj0 = 0 ;
48288 PyObject * obj1 = 0 ;
48289 char * kwnames[] = {
48290 (char *) "self",(char *) "direction", NULL
48291 };
48292
48293 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) SWIG_fail;
48294 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48295 if (!SWIG_IsOK(res1)) {
48296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48297 }
48298 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48299 ecode2 = SWIG_AsVal_int(obj1, &val2);
48300 if (!SWIG_IsOK(ecode2)) {
48301 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "2"" of type '" "int""'");
48302 }
48303 arg2 = static_cast< int >(val2);
48304 {
48305 PyThreadState* __tstate = wxPyBeginAllowThreads();
48306 (arg1)->SetFlexibleDirection(arg2);
48307 wxPyEndAllowThreads(__tstate);
48308 if (PyErr_Occurred()) SWIG_fail;
48309 }
48310 resultobj = SWIG_Py_Void();
48311 return resultobj;
48312 fail:
48313 return NULL;
48314 }
48315
48316
48317 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48318 PyObject *resultobj = 0;
48319 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48320 int result;
48321 void *argp1 = 0 ;
48322 int res1 = 0 ;
48323 PyObject *swig_obj[1] ;
48324
48325 if (!args) SWIG_fail;
48326 swig_obj[0] = args;
48327 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48328 if (!SWIG_IsOK(res1)) {
48329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48330 }
48331 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48332 {
48333 PyThreadState* __tstate = wxPyBeginAllowThreads();
48334 result = (int)(arg1)->GetFlexibleDirection();
48335 wxPyEndAllowThreads(__tstate);
48336 if (PyErr_Occurred()) SWIG_fail;
48337 }
48338 resultobj = SWIG_From_int(static_cast< int >(result));
48339 return resultobj;
48340 fail:
48341 return NULL;
48342 }
48343
48344
48345 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48346 PyObject *resultobj = 0;
48347 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48348 wxFlexSizerGrowMode arg2 ;
48349 void *argp1 = 0 ;
48350 int res1 = 0 ;
48351 int val2 ;
48352 int ecode2 = 0 ;
48353 PyObject * obj0 = 0 ;
48354 PyObject * obj1 = 0 ;
48355 char * kwnames[] = {
48356 (char *) "self",(char *) "mode", NULL
48357 };
48358
48359 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) SWIG_fail;
48360 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48361 if (!SWIG_IsOK(res1)) {
48362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48363 }
48364 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48365 ecode2 = SWIG_AsVal_int(obj1, &val2);
48366 if (!SWIG_IsOK(ecode2)) {
48367 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "2"" of type '" "wxFlexSizerGrowMode""'");
48368 }
48369 arg2 = static_cast< wxFlexSizerGrowMode >(val2);
48370 {
48371 PyThreadState* __tstate = wxPyBeginAllowThreads();
48372 (arg1)->SetNonFlexibleGrowMode(arg2);
48373 wxPyEndAllowThreads(__tstate);
48374 if (PyErr_Occurred()) SWIG_fail;
48375 }
48376 resultobj = SWIG_Py_Void();
48377 return resultobj;
48378 fail:
48379 return NULL;
48380 }
48381
48382
48383 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48384 PyObject *resultobj = 0;
48385 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48386 wxFlexSizerGrowMode result;
48387 void *argp1 = 0 ;
48388 int res1 = 0 ;
48389 PyObject *swig_obj[1] ;
48390
48391 if (!args) SWIG_fail;
48392 swig_obj[0] = args;
48393 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48394 if (!SWIG_IsOK(res1)) {
48395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48396 }
48397 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48398 {
48399 PyThreadState* __tstate = wxPyBeginAllowThreads();
48400 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
48401 wxPyEndAllowThreads(__tstate);
48402 if (PyErr_Occurred()) SWIG_fail;
48403 }
48404 resultobj = SWIG_From_int(static_cast< int >(result));
48405 return resultobj;
48406 fail:
48407 return NULL;
48408 }
48409
48410
48411 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48412 PyObject *resultobj = 0;
48413 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48414 wxArrayInt *result = 0 ;
48415 void *argp1 = 0 ;
48416 int res1 = 0 ;
48417 PyObject *swig_obj[1] ;
48418
48419 if (!args) SWIG_fail;
48420 swig_obj[0] = args;
48421 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48422 if (!SWIG_IsOK(res1)) {
48423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetRowHeights" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
48424 }
48425 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48426 {
48427 PyThreadState* __tstate = wxPyBeginAllowThreads();
48428 {
48429 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
48430 result = (wxArrayInt *) &_result_ref;
48431 }
48432 wxPyEndAllowThreads(__tstate);
48433 if (PyErr_Occurred()) SWIG_fail;
48434 }
48435 {
48436 resultobj = PyList_New(0);
48437 size_t idx;
48438 for (idx = 0; idx < result->GetCount(); idx += 1) {
48439 PyObject* val = PyInt_FromLong( result->Item(idx) );
48440 PyList_Append(resultobj, val);
48441 Py_DECREF(val);
48442 }
48443 }
48444 return resultobj;
48445 fail:
48446 return NULL;
48447 }
48448
48449
48450 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48451 PyObject *resultobj = 0;
48452 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48453 wxArrayInt *result = 0 ;
48454 void *argp1 = 0 ;
48455 int res1 = 0 ;
48456 PyObject *swig_obj[1] ;
48457
48458 if (!args) SWIG_fail;
48459 swig_obj[0] = args;
48460 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48461 if (!SWIG_IsOK(res1)) {
48462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetColWidths" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
48463 }
48464 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48465 {
48466 PyThreadState* __tstate = wxPyBeginAllowThreads();
48467 {
48468 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
48469 result = (wxArrayInt *) &_result_ref;
48470 }
48471 wxPyEndAllowThreads(__tstate);
48472 if (PyErr_Occurred()) SWIG_fail;
48473 }
48474 {
48475 resultobj = PyList_New(0);
48476 size_t idx;
48477 for (idx = 0; idx < result->GetCount(); idx += 1) {
48478 PyObject* val = PyInt_FromLong( result->Item(idx) );
48479 PyList_Append(resultobj, val);
48480 Py_DECREF(val);
48481 }
48482 }
48483 return resultobj;
48484 fail:
48485 return NULL;
48486 }
48487
48488
48489 SWIGINTERN PyObject *FlexGridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48490 PyObject *obj;
48491 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48492 SWIG_TypeNewClientData(SWIGTYPE_p_wxFlexGridSizer, SWIG_NewClientData(obj));
48493 return SWIG_Py_Void();
48494 }
48495
48496 SWIGINTERN PyObject *FlexGridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48497 return SWIG_Python_InitShadowInstance(args);
48498 }
48499
48500 SWIGINTERN PyObject *_wrap_new_StdDialogButtonSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48501 PyObject *resultobj = 0;
48502 wxStdDialogButtonSizer *result = 0 ;
48503
48504 if (!SWIG_Python_UnpackTuple(args,"new_StdDialogButtonSizer",0,0,0)) SWIG_fail;
48505 {
48506 PyThreadState* __tstate = wxPyBeginAllowThreads();
48507 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
48508 wxPyEndAllowThreads(__tstate);
48509 if (PyErr_Occurred()) SWIG_fail;
48510 }
48511 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_NEW | 0 );
48512 return resultobj;
48513 fail:
48514 return NULL;
48515 }
48516
48517
48518 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48519 PyObject *resultobj = 0;
48520 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48521 wxButton *arg2 = (wxButton *) 0 ;
48522 void *argp1 = 0 ;
48523 int res1 = 0 ;
48524 void *argp2 = 0 ;
48525 int res2 = 0 ;
48526 PyObject * obj0 = 0 ;
48527 PyObject * obj1 = 0 ;
48528 char * kwnames[] = {
48529 (char *) "self",(char *) "button", NULL
48530 };
48531
48532 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) SWIG_fail;
48533 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48534 if (!SWIG_IsOK(res1)) {
48535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48536 }
48537 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48538 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48539 if (!SWIG_IsOK(res2)) {
48540 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "2"" of type '" "wxButton *""'");
48541 }
48542 arg2 = reinterpret_cast< wxButton * >(argp2);
48543 {
48544 PyThreadState* __tstate = wxPyBeginAllowThreads();
48545 (arg1)->AddButton(arg2);
48546 wxPyEndAllowThreads(__tstate);
48547 if (PyErr_Occurred()) SWIG_fail;
48548 }
48549 resultobj = SWIG_Py_Void();
48550 return resultobj;
48551 fail:
48552 return NULL;
48553 }
48554
48555
48556 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48557 PyObject *resultobj = 0;
48558 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48559 void *argp1 = 0 ;
48560 int res1 = 0 ;
48561 PyObject *swig_obj[1] ;
48562
48563 if (!args) SWIG_fail;
48564 swig_obj[0] = args;
48565 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48566 if (!SWIG_IsOK(res1)) {
48567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_Realize" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48568 }
48569 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48570 {
48571 PyThreadState* __tstate = wxPyBeginAllowThreads();
48572 (arg1)->Realize();
48573 wxPyEndAllowThreads(__tstate);
48574 if (PyErr_Occurred()) SWIG_fail;
48575 }
48576 resultobj = SWIG_Py_Void();
48577 return resultobj;
48578 fail:
48579 return NULL;
48580 }
48581
48582
48583 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48584 PyObject *resultobj = 0;
48585 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48586 wxButton *arg2 = (wxButton *) 0 ;
48587 void *argp1 = 0 ;
48588 int res1 = 0 ;
48589 void *argp2 = 0 ;
48590 int res2 = 0 ;
48591 PyObject * obj0 = 0 ;
48592 PyObject * obj1 = 0 ;
48593 char * kwnames[] = {
48594 (char *) "self",(char *) "button", NULL
48595 };
48596
48597 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
48598 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48599 if (!SWIG_IsOK(res1)) {
48600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48601 }
48602 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48603 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48604 if (!SWIG_IsOK(res2)) {
48605 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
48606 }
48607 arg2 = reinterpret_cast< wxButton * >(argp2);
48608 {
48609 PyThreadState* __tstate = wxPyBeginAllowThreads();
48610 (arg1)->SetAffirmativeButton(arg2);
48611 wxPyEndAllowThreads(__tstate);
48612 if (PyErr_Occurred()) SWIG_fail;
48613 }
48614 resultobj = SWIG_Py_Void();
48615 return resultobj;
48616 fail:
48617 return NULL;
48618 }
48619
48620
48621 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48622 PyObject *resultobj = 0;
48623 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48624 wxButton *arg2 = (wxButton *) 0 ;
48625 void *argp1 = 0 ;
48626 int res1 = 0 ;
48627 void *argp2 = 0 ;
48628 int res2 = 0 ;
48629 PyObject * obj0 = 0 ;
48630 PyObject * obj1 = 0 ;
48631 char * kwnames[] = {
48632 (char *) "self",(char *) "button", NULL
48633 };
48634
48635 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
48636 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48637 if (!SWIG_IsOK(res1)) {
48638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48639 }
48640 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48641 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48642 if (!SWIG_IsOK(res2)) {
48643 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
48644 }
48645 arg2 = reinterpret_cast< wxButton * >(argp2);
48646 {
48647 PyThreadState* __tstate = wxPyBeginAllowThreads();
48648 (arg1)->SetNegativeButton(arg2);
48649 wxPyEndAllowThreads(__tstate);
48650 if (PyErr_Occurred()) SWIG_fail;
48651 }
48652 resultobj = SWIG_Py_Void();
48653 return resultobj;
48654 fail:
48655 return NULL;
48656 }
48657
48658
48659 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48660 PyObject *resultobj = 0;
48661 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48662 wxButton *arg2 = (wxButton *) 0 ;
48663 void *argp1 = 0 ;
48664 int res1 = 0 ;
48665 void *argp2 = 0 ;
48666 int res2 = 0 ;
48667 PyObject * obj0 = 0 ;
48668 PyObject * obj1 = 0 ;
48669 char * kwnames[] = {
48670 (char *) "self",(char *) "button", NULL
48671 };
48672
48673 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) SWIG_fail;
48674 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48675 if (!SWIG_IsOK(res1)) {
48676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48677 }
48678 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48679 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48680 if (!SWIG_IsOK(res2)) {
48681 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "2"" of type '" "wxButton *""'");
48682 }
48683 arg2 = reinterpret_cast< wxButton * >(argp2);
48684 {
48685 PyThreadState* __tstate = wxPyBeginAllowThreads();
48686 (arg1)->SetCancelButton(arg2);
48687 wxPyEndAllowThreads(__tstate);
48688 if (PyErr_Occurred()) SWIG_fail;
48689 }
48690 resultobj = SWIG_Py_Void();
48691 return resultobj;
48692 fail:
48693 return NULL;
48694 }
48695
48696
48697 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48698 PyObject *resultobj = 0;
48699 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48700 wxButton *result = 0 ;
48701 void *argp1 = 0 ;
48702 int res1 = 0 ;
48703 PyObject *swig_obj[1] ;
48704
48705 if (!args) SWIG_fail;
48706 swig_obj[0] = args;
48707 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48708 if (!SWIG_IsOK(res1)) {
48709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48710 }
48711 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48712 {
48713 PyThreadState* __tstate = wxPyBeginAllowThreads();
48714 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
48715 wxPyEndAllowThreads(__tstate);
48716 if (PyErr_Occurred()) SWIG_fail;
48717 }
48718 {
48719 resultobj = wxPyMake_wxObject(result, (bool)0);
48720 }
48721 return resultobj;
48722 fail:
48723 return NULL;
48724 }
48725
48726
48727 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48728 PyObject *resultobj = 0;
48729 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48730 wxButton *result = 0 ;
48731 void *argp1 = 0 ;
48732 int res1 = 0 ;
48733 PyObject *swig_obj[1] ;
48734
48735 if (!args) SWIG_fail;
48736 swig_obj[0] = args;
48737 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48738 if (!SWIG_IsOK(res1)) {
48739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetApplyButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48740 }
48741 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48742 {
48743 PyThreadState* __tstate = wxPyBeginAllowThreads();
48744 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
48745 wxPyEndAllowThreads(__tstate);
48746 if (PyErr_Occurred()) SWIG_fail;
48747 }
48748 {
48749 resultobj = wxPyMake_wxObject(result, (bool)0);
48750 }
48751 return resultobj;
48752 fail:
48753 return NULL;
48754 }
48755
48756
48757 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48758 PyObject *resultobj = 0;
48759 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48760 wxButton *result = 0 ;
48761 void *argp1 = 0 ;
48762 int res1 = 0 ;
48763 PyObject *swig_obj[1] ;
48764
48765 if (!args) SWIG_fail;
48766 swig_obj[0] = args;
48767 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48768 if (!SWIG_IsOK(res1)) {
48769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48770 }
48771 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48772 {
48773 PyThreadState* __tstate = wxPyBeginAllowThreads();
48774 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
48775 wxPyEndAllowThreads(__tstate);
48776 if (PyErr_Occurred()) SWIG_fail;
48777 }
48778 {
48779 resultobj = wxPyMake_wxObject(result, (bool)0);
48780 }
48781 return resultobj;
48782 fail:
48783 return NULL;
48784 }
48785
48786
48787 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48788 PyObject *resultobj = 0;
48789 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48790 wxButton *result = 0 ;
48791 void *argp1 = 0 ;
48792 int res1 = 0 ;
48793 PyObject *swig_obj[1] ;
48794
48795 if (!args) SWIG_fail;
48796 swig_obj[0] = args;
48797 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48798 if (!SWIG_IsOK(res1)) {
48799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48800 }
48801 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48802 {
48803 PyThreadState* __tstate = wxPyBeginAllowThreads();
48804 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
48805 wxPyEndAllowThreads(__tstate);
48806 if (PyErr_Occurred()) SWIG_fail;
48807 }
48808 {
48809 resultobj = wxPyMake_wxObject(result, (bool)0);
48810 }
48811 return resultobj;
48812 fail:
48813 return NULL;
48814 }
48815
48816
48817 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48818 PyObject *resultobj = 0;
48819 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48820 wxButton *result = 0 ;
48821 void *argp1 = 0 ;
48822 int res1 = 0 ;
48823 PyObject *swig_obj[1] ;
48824
48825 if (!args) SWIG_fail;
48826 swig_obj[0] = args;
48827 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48828 if (!SWIG_IsOK(res1)) {
48829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetHelpButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48830 }
48831 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48832 {
48833 PyThreadState* __tstate = wxPyBeginAllowThreads();
48834 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
48835 wxPyEndAllowThreads(__tstate);
48836 if (PyErr_Occurred()) SWIG_fail;
48837 }
48838 {
48839 resultobj = wxPyMake_wxObject(result, (bool)0);
48840 }
48841 return resultobj;
48842 fail:
48843 return NULL;
48844 }
48845
48846
48847 SWIGINTERN PyObject *StdDialogButtonSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48848 PyObject *obj;
48849 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48850 SWIG_TypeNewClientData(SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_NewClientData(obj));
48851 return SWIG_Py_Void();
48852 }
48853
48854 SWIGINTERN PyObject *StdDialogButtonSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48855 return SWIG_Python_InitShadowInstance(args);
48856 }
48857
48858 SWIGINTERN PyObject *_wrap_new_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48859 PyObject *resultobj = 0;
48860 int arg1 = (int) 0 ;
48861 int arg2 = (int) 0 ;
48862 wxGBPosition *result = 0 ;
48863 int val1 ;
48864 int ecode1 = 0 ;
48865 int val2 ;
48866 int ecode2 = 0 ;
48867 PyObject * obj0 = 0 ;
48868 PyObject * obj1 = 0 ;
48869 char * kwnames[] = {
48870 (char *) "row",(char *) "col", NULL
48871 };
48872
48873 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) SWIG_fail;
48874 if (obj0) {
48875 ecode1 = SWIG_AsVal_int(obj0, &val1);
48876 if (!SWIG_IsOK(ecode1)) {
48877 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBPosition" "', expected argument " "1"" of type '" "int""'");
48878 }
48879 arg1 = static_cast< int >(val1);
48880 }
48881 if (obj1) {
48882 ecode2 = SWIG_AsVal_int(obj1, &val2);
48883 if (!SWIG_IsOK(ecode2)) {
48884 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBPosition" "', expected argument " "2"" of type '" "int""'");
48885 }
48886 arg2 = static_cast< int >(val2);
48887 }
48888 {
48889 PyThreadState* __tstate = wxPyBeginAllowThreads();
48890 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
48891 wxPyEndAllowThreads(__tstate);
48892 if (PyErr_Occurred()) SWIG_fail;
48893 }
48894 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_NEW | 0 );
48895 return resultobj;
48896 fail:
48897 return NULL;
48898 }
48899
48900
48901 SWIGINTERN PyObject *_wrap_delete_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48902 PyObject *resultobj = 0;
48903 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48904 void *argp1 = 0 ;
48905 int res1 = 0 ;
48906 PyObject *swig_obj[1] ;
48907
48908 if (!args) SWIG_fail;
48909 swig_obj[0] = args;
48910 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, SWIG_POINTER_DISOWN | 0 );
48911 if (!SWIG_IsOK(res1)) {
48912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBPosition" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48913 }
48914 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48915 {
48916 PyThreadState* __tstate = wxPyBeginAllowThreads();
48917 delete arg1;
48918
48919 wxPyEndAllowThreads(__tstate);
48920 if (PyErr_Occurred()) SWIG_fail;
48921 }
48922 resultobj = SWIG_Py_Void();
48923 return resultobj;
48924 fail:
48925 return NULL;
48926 }
48927
48928
48929 SWIGINTERN PyObject *_wrap_GBPosition_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48930 PyObject *resultobj = 0;
48931 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48932 int result;
48933 void *argp1 = 0 ;
48934 int res1 = 0 ;
48935 PyObject *swig_obj[1] ;
48936
48937 if (!args) SWIG_fail;
48938 swig_obj[0] = args;
48939 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48940 if (!SWIG_IsOK(res1)) {
48941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetRow" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
48942 }
48943 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48944 {
48945 PyThreadState* __tstate = wxPyBeginAllowThreads();
48946 result = (int)((wxGBPosition const *)arg1)->GetRow();
48947 wxPyEndAllowThreads(__tstate);
48948 if (PyErr_Occurred()) SWIG_fail;
48949 }
48950 resultobj = SWIG_From_int(static_cast< int >(result));
48951 return resultobj;
48952 fail:
48953 return NULL;
48954 }
48955
48956
48957 SWIGINTERN PyObject *_wrap_GBPosition_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48958 PyObject *resultobj = 0;
48959 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48960 int result;
48961 void *argp1 = 0 ;
48962 int res1 = 0 ;
48963 PyObject *swig_obj[1] ;
48964
48965 if (!args) SWIG_fail;
48966 swig_obj[0] = args;
48967 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48968 if (!SWIG_IsOK(res1)) {
48969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetCol" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
48970 }
48971 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48972 {
48973 PyThreadState* __tstate = wxPyBeginAllowThreads();
48974 result = (int)((wxGBPosition const *)arg1)->GetCol();
48975 wxPyEndAllowThreads(__tstate);
48976 if (PyErr_Occurred()) SWIG_fail;
48977 }
48978 resultobj = SWIG_From_int(static_cast< int >(result));
48979 return resultobj;
48980 fail:
48981 return NULL;
48982 }
48983
48984
48985 SWIGINTERN PyObject *_wrap_GBPosition_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48986 PyObject *resultobj = 0;
48987 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48988 int arg2 ;
48989 void *argp1 = 0 ;
48990 int res1 = 0 ;
48991 int val2 ;
48992 int ecode2 = 0 ;
48993 PyObject * obj0 = 0 ;
48994 PyObject * obj1 = 0 ;
48995 char * kwnames[] = {
48996 (char *) "self",(char *) "row", NULL
48997 };
48998
48999 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
49000 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49001 if (!SWIG_IsOK(res1)) {
49002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetRow" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49003 }
49004 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49005 ecode2 = SWIG_AsVal_int(obj1, &val2);
49006 if (!SWIG_IsOK(ecode2)) {
49007 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetRow" "', expected argument " "2"" of type '" "int""'");
49008 }
49009 arg2 = static_cast< int >(val2);
49010 {
49011 PyThreadState* __tstate = wxPyBeginAllowThreads();
49012 (arg1)->SetRow(arg2);
49013 wxPyEndAllowThreads(__tstate);
49014 if (PyErr_Occurred()) SWIG_fail;
49015 }
49016 resultobj = SWIG_Py_Void();
49017 return resultobj;
49018 fail:
49019 return NULL;
49020 }
49021
49022
49023 SWIGINTERN PyObject *_wrap_GBPosition_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49024 PyObject *resultobj = 0;
49025 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49026 int arg2 ;
49027 void *argp1 = 0 ;
49028 int res1 = 0 ;
49029 int val2 ;
49030 int ecode2 = 0 ;
49031 PyObject * obj0 = 0 ;
49032 PyObject * obj1 = 0 ;
49033 char * kwnames[] = {
49034 (char *) "self",(char *) "col", NULL
49035 };
49036
49037 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
49038 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49039 if (!SWIG_IsOK(res1)) {
49040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetCol" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49041 }
49042 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49043 ecode2 = SWIG_AsVal_int(obj1, &val2);
49044 if (!SWIG_IsOK(ecode2)) {
49045 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetCol" "', expected argument " "2"" of type '" "int""'");
49046 }
49047 arg2 = static_cast< int >(val2);
49048 {
49049 PyThreadState* __tstate = wxPyBeginAllowThreads();
49050 (arg1)->SetCol(arg2);
49051 wxPyEndAllowThreads(__tstate);
49052 if (PyErr_Occurred()) SWIG_fail;
49053 }
49054 resultobj = SWIG_Py_Void();
49055 return resultobj;
49056 fail:
49057 return NULL;
49058 }
49059
49060
49061 SWIGINTERN PyObject *_wrap_GBPosition___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49062 PyObject *resultobj = 0;
49063 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49064 PyObject *arg2 = (PyObject *) 0 ;
49065 bool result;
49066 void *argp1 = 0 ;
49067 int res1 = 0 ;
49068 PyObject * obj0 = 0 ;
49069 PyObject * obj1 = 0 ;
49070 char * kwnames[] = {
49071 (char *) "self",(char *) "other", NULL
49072 };
49073
49074 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
49075 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49076 if (!SWIG_IsOK(res1)) {
49077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___eq__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49078 }
49079 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49080 arg2 = obj1;
49081 {
49082 result = (bool)wxGBPosition___eq__(arg1,arg2);
49083 if (PyErr_Occurred()) SWIG_fail;
49084 }
49085 {
49086 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49087 }
49088 return resultobj;
49089 fail:
49090 return NULL;
49091 }
49092
49093
49094 SWIGINTERN PyObject *_wrap_GBPosition___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49095 PyObject *resultobj = 0;
49096 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49097 PyObject *arg2 = (PyObject *) 0 ;
49098 bool result;
49099 void *argp1 = 0 ;
49100 int res1 = 0 ;
49101 PyObject * obj0 = 0 ;
49102 PyObject * obj1 = 0 ;
49103 char * kwnames[] = {
49104 (char *) "self",(char *) "other", NULL
49105 };
49106
49107 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
49108 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49109 if (!SWIG_IsOK(res1)) {
49110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___ne__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49111 }
49112 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49113 arg2 = obj1;
49114 {
49115 result = (bool)wxGBPosition___ne__(arg1,arg2);
49116 if (PyErr_Occurred()) SWIG_fail;
49117 }
49118 {
49119 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49120 }
49121 return resultobj;
49122 fail:
49123 return NULL;
49124 }
49125
49126
49127 SWIGINTERN PyObject *_wrap_GBPosition_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49128 PyObject *resultobj = 0;
49129 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49130 int arg2 = (int) 0 ;
49131 int arg3 = (int) 0 ;
49132 void *argp1 = 0 ;
49133 int res1 = 0 ;
49134 int val2 ;
49135 int ecode2 = 0 ;
49136 int val3 ;
49137 int ecode3 = 0 ;
49138 PyObject * obj0 = 0 ;
49139 PyObject * obj1 = 0 ;
49140 PyObject * obj2 = 0 ;
49141 char * kwnames[] = {
49142 (char *) "self",(char *) "row",(char *) "col", NULL
49143 };
49144
49145 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49146 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49147 if (!SWIG_IsOK(res1)) {
49148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Set" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49149 }
49150 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49151 if (obj1) {
49152 ecode2 = SWIG_AsVal_int(obj1, &val2);
49153 if (!SWIG_IsOK(ecode2)) {
49154 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_Set" "', expected argument " "2"" of type '" "int""'");
49155 }
49156 arg2 = static_cast< int >(val2);
49157 }
49158 if (obj2) {
49159 ecode3 = SWIG_AsVal_int(obj2, &val3);
49160 if (!SWIG_IsOK(ecode3)) {
49161 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBPosition_Set" "', expected argument " "3"" of type '" "int""'");
49162 }
49163 arg3 = static_cast< int >(val3);
49164 }
49165 {
49166 PyThreadState* __tstate = wxPyBeginAllowThreads();
49167 wxGBPosition_Set(arg1,arg2,arg3);
49168 wxPyEndAllowThreads(__tstate);
49169 if (PyErr_Occurred()) SWIG_fail;
49170 }
49171 resultobj = SWIG_Py_Void();
49172 return resultobj;
49173 fail:
49174 return NULL;
49175 }
49176
49177
49178 SWIGINTERN PyObject *_wrap_GBPosition_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49179 PyObject *resultobj = 0;
49180 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49181 PyObject *result = 0 ;
49182 void *argp1 = 0 ;
49183 int res1 = 0 ;
49184 PyObject *swig_obj[1] ;
49185
49186 if (!args) SWIG_fail;
49187 swig_obj[0] = args;
49188 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49189 if (!SWIG_IsOK(res1)) {
49190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Get" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49191 }
49192 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49193 {
49194 PyThreadState* __tstate = wxPyBeginAllowThreads();
49195 result = (PyObject *)wxGBPosition_Get(arg1);
49196 wxPyEndAllowThreads(__tstate);
49197 if (PyErr_Occurred()) SWIG_fail;
49198 }
49199 resultobj = result;
49200 return resultobj;
49201 fail:
49202 return NULL;
49203 }
49204
49205
49206 SWIGINTERN PyObject *GBPosition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49207 PyObject *obj;
49208 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49209 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBPosition, SWIG_NewClientData(obj));
49210 return SWIG_Py_Void();
49211 }
49212
49213 SWIGINTERN PyObject *GBPosition_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49214 return SWIG_Python_InitShadowInstance(args);
49215 }
49216
49217 SWIGINTERN PyObject *_wrap_new_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49218 PyObject *resultobj = 0;
49219 int arg1 = (int) 1 ;
49220 int arg2 = (int) 1 ;
49221 wxGBSpan *result = 0 ;
49222 int val1 ;
49223 int ecode1 = 0 ;
49224 int val2 ;
49225 int ecode2 = 0 ;
49226 PyObject * obj0 = 0 ;
49227 PyObject * obj1 = 0 ;
49228 char * kwnames[] = {
49229 (char *) "rowspan",(char *) "colspan", NULL
49230 };
49231
49232 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) SWIG_fail;
49233 if (obj0) {
49234 ecode1 = SWIG_AsVal_int(obj0, &val1);
49235 if (!SWIG_IsOK(ecode1)) {
49236 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSpan" "', expected argument " "1"" of type '" "int""'");
49237 }
49238 arg1 = static_cast< int >(val1);
49239 }
49240 if (obj1) {
49241 ecode2 = SWIG_AsVal_int(obj1, &val2);
49242 if (!SWIG_IsOK(ecode2)) {
49243 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSpan" "', expected argument " "2"" of type '" "int""'");
49244 }
49245 arg2 = static_cast< int >(val2);
49246 }
49247 {
49248 PyThreadState* __tstate = wxPyBeginAllowThreads();
49249 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
49250 wxPyEndAllowThreads(__tstate);
49251 if (PyErr_Occurred()) SWIG_fail;
49252 }
49253 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_NEW | 0 );
49254 return resultobj;
49255 fail:
49256 return NULL;
49257 }
49258
49259
49260 SWIGINTERN PyObject *_wrap_delete_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49261 PyObject *resultobj = 0;
49262 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49263 void *argp1 = 0 ;
49264 int res1 = 0 ;
49265 PyObject *swig_obj[1] ;
49266
49267 if (!args) SWIG_fail;
49268 swig_obj[0] = args;
49269 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, SWIG_POINTER_DISOWN | 0 );
49270 if (!SWIG_IsOK(res1)) {
49271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSpan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49272 }
49273 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49274 {
49275 PyThreadState* __tstate = wxPyBeginAllowThreads();
49276 delete arg1;
49277
49278 wxPyEndAllowThreads(__tstate);
49279 if (PyErr_Occurred()) SWIG_fail;
49280 }
49281 resultobj = SWIG_Py_Void();
49282 return resultobj;
49283 fail:
49284 return NULL;
49285 }
49286
49287
49288 SWIGINTERN PyObject *_wrap_GBSpan_GetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49289 PyObject *resultobj = 0;
49290 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49291 int result;
49292 void *argp1 = 0 ;
49293 int res1 = 0 ;
49294 PyObject *swig_obj[1] ;
49295
49296 if (!args) SWIG_fail;
49297 swig_obj[0] = args;
49298 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49299 if (!SWIG_IsOK(res1)) {
49300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetRowspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
49301 }
49302 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49303 {
49304 PyThreadState* __tstate = wxPyBeginAllowThreads();
49305 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
49306 wxPyEndAllowThreads(__tstate);
49307 if (PyErr_Occurred()) SWIG_fail;
49308 }
49309 resultobj = SWIG_From_int(static_cast< int >(result));
49310 return resultobj;
49311 fail:
49312 return NULL;
49313 }
49314
49315
49316 SWIGINTERN PyObject *_wrap_GBSpan_GetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49317 PyObject *resultobj = 0;
49318 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49319 int result;
49320 void *argp1 = 0 ;
49321 int res1 = 0 ;
49322 PyObject *swig_obj[1] ;
49323
49324 if (!args) SWIG_fail;
49325 swig_obj[0] = args;
49326 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49327 if (!SWIG_IsOK(res1)) {
49328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetColspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
49329 }
49330 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49331 {
49332 PyThreadState* __tstate = wxPyBeginAllowThreads();
49333 result = (int)((wxGBSpan const *)arg1)->GetColspan();
49334 wxPyEndAllowThreads(__tstate);
49335 if (PyErr_Occurred()) SWIG_fail;
49336 }
49337 resultobj = SWIG_From_int(static_cast< int >(result));
49338 return resultobj;
49339 fail:
49340 return NULL;
49341 }
49342
49343
49344 SWIGINTERN PyObject *_wrap_GBSpan_SetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49345 PyObject *resultobj = 0;
49346 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49347 int arg2 ;
49348 void *argp1 = 0 ;
49349 int res1 = 0 ;
49350 int val2 ;
49351 int ecode2 = 0 ;
49352 PyObject * obj0 = 0 ;
49353 PyObject * obj1 = 0 ;
49354 char * kwnames[] = {
49355 (char *) "self",(char *) "rowspan", NULL
49356 };
49357
49358 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) SWIG_fail;
49359 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49360 if (!SWIG_IsOK(res1)) {
49361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetRowspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49362 }
49363 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49364 ecode2 = SWIG_AsVal_int(obj1, &val2);
49365 if (!SWIG_IsOK(ecode2)) {
49366 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetRowspan" "', expected argument " "2"" of type '" "int""'");
49367 }
49368 arg2 = static_cast< int >(val2);
49369 {
49370 PyThreadState* __tstate = wxPyBeginAllowThreads();
49371 (arg1)->SetRowspan(arg2);
49372 wxPyEndAllowThreads(__tstate);
49373 if (PyErr_Occurred()) SWIG_fail;
49374 }
49375 resultobj = SWIG_Py_Void();
49376 return resultobj;
49377 fail:
49378 return NULL;
49379 }
49380
49381
49382 SWIGINTERN PyObject *_wrap_GBSpan_SetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49383 PyObject *resultobj = 0;
49384 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49385 int arg2 ;
49386 void *argp1 = 0 ;
49387 int res1 = 0 ;
49388 int val2 ;
49389 int ecode2 = 0 ;
49390 PyObject * obj0 = 0 ;
49391 PyObject * obj1 = 0 ;
49392 char * kwnames[] = {
49393 (char *) "self",(char *) "colspan", NULL
49394 };
49395
49396 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) SWIG_fail;
49397 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49398 if (!SWIG_IsOK(res1)) {
49399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetColspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49400 }
49401 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49402 ecode2 = SWIG_AsVal_int(obj1, &val2);
49403 if (!SWIG_IsOK(ecode2)) {
49404 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetColspan" "', expected argument " "2"" of type '" "int""'");
49405 }
49406 arg2 = static_cast< int >(val2);
49407 {
49408 PyThreadState* __tstate = wxPyBeginAllowThreads();
49409 (arg1)->SetColspan(arg2);
49410 wxPyEndAllowThreads(__tstate);
49411 if (PyErr_Occurred()) SWIG_fail;
49412 }
49413 resultobj = SWIG_Py_Void();
49414 return resultobj;
49415 fail:
49416 return NULL;
49417 }
49418
49419
49420 SWIGINTERN PyObject *_wrap_GBSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49421 PyObject *resultobj = 0;
49422 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49423 PyObject *arg2 = (PyObject *) 0 ;
49424 bool result;
49425 void *argp1 = 0 ;
49426 int res1 = 0 ;
49427 PyObject * obj0 = 0 ;
49428 PyObject * obj1 = 0 ;
49429 char * kwnames[] = {
49430 (char *) "self",(char *) "other", NULL
49431 };
49432
49433 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
49434 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49435 if (!SWIG_IsOK(res1)) {
49436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___eq__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49437 }
49438 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49439 arg2 = obj1;
49440 {
49441 result = (bool)wxGBSpan___eq__(arg1,arg2);
49442 if (PyErr_Occurred()) SWIG_fail;
49443 }
49444 {
49445 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49446 }
49447 return resultobj;
49448 fail:
49449 return NULL;
49450 }
49451
49452
49453 SWIGINTERN PyObject *_wrap_GBSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49454 PyObject *resultobj = 0;
49455 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49456 PyObject *arg2 = (PyObject *) 0 ;
49457 bool result;
49458 void *argp1 = 0 ;
49459 int res1 = 0 ;
49460 PyObject * obj0 = 0 ;
49461 PyObject * obj1 = 0 ;
49462 char * kwnames[] = {
49463 (char *) "self",(char *) "other", NULL
49464 };
49465
49466 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
49467 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49468 if (!SWIG_IsOK(res1)) {
49469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___ne__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49470 }
49471 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49472 arg2 = obj1;
49473 {
49474 result = (bool)wxGBSpan___ne__(arg1,arg2);
49475 if (PyErr_Occurred()) SWIG_fail;
49476 }
49477 {
49478 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49479 }
49480 return resultobj;
49481 fail:
49482 return NULL;
49483 }
49484
49485
49486 SWIGINTERN PyObject *_wrap_GBSpan_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49487 PyObject *resultobj = 0;
49488 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49489 int arg2 = (int) 1 ;
49490 int arg3 = (int) 1 ;
49491 void *argp1 = 0 ;
49492 int res1 = 0 ;
49493 int val2 ;
49494 int ecode2 = 0 ;
49495 int val3 ;
49496 int ecode3 = 0 ;
49497 PyObject * obj0 = 0 ;
49498 PyObject * obj1 = 0 ;
49499 PyObject * obj2 = 0 ;
49500 char * kwnames[] = {
49501 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
49502 };
49503
49504 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49505 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49506 if (!SWIG_IsOK(res1)) {
49507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Set" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49508 }
49509 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49510 if (obj1) {
49511 ecode2 = SWIG_AsVal_int(obj1, &val2);
49512 if (!SWIG_IsOK(ecode2)) {
49513 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_Set" "', expected argument " "2"" of type '" "int""'");
49514 }
49515 arg2 = static_cast< int >(val2);
49516 }
49517 if (obj2) {
49518 ecode3 = SWIG_AsVal_int(obj2, &val3);
49519 if (!SWIG_IsOK(ecode3)) {
49520 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBSpan_Set" "', expected argument " "3"" of type '" "int""'");
49521 }
49522 arg3 = static_cast< int >(val3);
49523 }
49524 {
49525 PyThreadState* __tstate = wxPyBeginAllowThreads();
49526 wxGBSpan_Set(arg1,arg2,arg3);
49527 wxPyEndAllowThreads(__tstate);
49528 if (PyErr_Occurred()) SWIG_fail;
49529 }
49530 resultobj = SWIG_Py_Void();
49531 return resultobj;
49532 fail:
49533 return NULL;
49534 }
49535
49536
49537 SWIGINTERN PyObject *_wrap_GBSpan_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49538 PyObject *resultobj = 0;
49539 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49540 PyObject *result = 0 ;
49541 void *argp1 = 0 ;
49542 int res1 = 0 ;
49543 PyObject *swig_obj[1] ;
49544
49545 if (!args) SWIG_fail;
49546 swig_obj[0] = args;
49547 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49548 if (!SWIG_IsOK(res1)) {
49549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Get" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49550 }
49551 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49552 {
49553 PyThreadState* __tstate = wxPyBeginAllowThreads();
49554 result = (PyObject *)wxGBSpan_Get(arg1);
49555 wxPyEndAllowThreads(__tstate);
49556 if (PyErr_Occurred()) SWIG_fail;
49557 }
49558 resultobj = result;
49559 return resultobj;
49560 fail:
49561 return NULL;
49562 }
49563
49564
49565 SWIGINTERN PyObject *GBSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49566 PyObject *obj;
49567 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49568 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSpan, SWIG_NewClientData(obj));
49569 return SWIG_Py_Void();
49570 }
49571
49572 SWIGINTERN PyObject *GBSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49573 return SWIG_Python_InitShadowInstance(args);
49574 }
49575
49576 SWIGINTERN int DefaultSpan_set(PyObject *) {
49577 SWIG_Error(SWIG_AttributeError,"Variable DefaultSpan is read-only.");
49578 return 1;
49579 }
49580
49581
49582 SWIGINTERN PyObject *DefaultSpan_get(void) {
49583 PyObject *pyobj = 0;
49584
49585 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0 );
49586 return pyobj;
49587 }
49588
49589
49590 SWIGINTERN PyObject *_wrap_new_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49591 PyObject *resultobj = 0;
49592 wxGBSizerItem *result = 0 ;
49593
49594 if (!SWIG_Python_UnpackTuple(args,"new_GBSizerItem",0,0,0)) SWIG_fail;
49595 {
49596 PyThreadState* __tstate = wxPyBeginAllowThreads();
49597 result = (wxGBSizerItem *)new wxGBSizerItem();
49598 wxPyEndAllowThreads(__tstate);
49599 if (PyErr_Occurred()) SWIG_fail;
49600 }
49601 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_NEW | 0 );
49602 return resultobj;
49603 fail:
49604 return NULL;
49605 }
49606
49607
49608 SWIGINTERN PyObject *_wrap_delete_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49609 PyObject *resultobj = 0;
49610 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49611 void *argp1 = 0 ;
49612 int res1 = 0 ;
49613 PyObject *swig_obj[1] ;
49614
49615 if (!args) SWIG_fail;
49616 swig_obj[0] = args;
49617 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
49618 if (!SWIG_IsOK(res1)) {
49619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSizerItem" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49620 }
49621 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49622 {
49623 PyThreadState* __tstate = wxPyBeginAllowThreads();
49624 delete arg1;
49625
49626 wxPyEndAllowThreads(__tstate);
49627 if (PyErr_Occurred()) SWIG_fail;
49628 }
49629 resultobj = SWIG_Py_Void();
49630 return resultobj;
49631 fail:
49632 return NULL;
49633 }
49634
49635
49636 SWIGINTERN PyObject *_wrap_new_GBSizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49637 PyObject *resultobj = 0;
49638 wxWindow *arg1 = (wxWindow *) 0 ;
49639 wxGBPosition *arg2 = 0 ;
49640 wxGBSpan *arg3 = 0 ;
49641 int arg4 ;
49642 int arg5 ;
49643 PyObject *arg6 = (PyObject *) NULL ;
49644 wxGBSizerItem *result = 0 ;
49645 void *argp1 = 0 ;
49646 int res1 = 0 ;
49647 wxGBPosition temp2 ;
49648 wxGBSpan temp3 ;
49649 int val4 ;
49650 int ecode4 = 0 ;
49651 int val5 ;
49652 int ecode5 = 0 ;
49653 PyObject * obj0 = 0 ;
49654 PyObject * obj1 = 0 ;
49655 PyObject * obj2 = 0 ;
49656 PyObject * obj3 = 0 ;
49657 PyObject * obj4 = 0 ;
49658 PyObject * obj5 = 0 ;
49659 char * kwnames[] = {
49660 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49661 };
49662
49663 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49664 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
49665 if (!SWIG_IsOK(res1)) {
49666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
49667 }
49668 arg1 = reinterpret_cast< wxWindow * >(argp1);
49669 {
49670 arg2 = &temp2;
49671 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49672 }
49673 {
49674 arg3 = &temp3;
49675 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
49676 }
49677 ecode4 = SWIG_AsVal_int(obj3, &val4);
49678 if (!SWIG_IsOK(ecode4)) {
49679 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemWindow" "', expected argument " "4"" of type '" "int""'");
49680 }
49681 arg4 = static_cast< int >(val4);
49682 ecode5 = SWIG_AsVal_int(obj4, &val5);
49683 if (!SWIG_IsOK(ecode5)) {
49684 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemWindow" "', expected argument " "5"" of type '" "int""'");
49685 }
49686 arg5 = static_cast< int >(val5);
49687 if (obj5) {
49688 arg6 = obj5;
49689 }
49690 {
49691 PyThreadState* __tstate = wxPyBeginAllowThreads();
49692 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
49693 wxPyEndAllowThreads(__tstate);
49694 if (PyErr_Occurred()) SWIG_fail;
49695 }
49696 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49697 return resultobj;
49698 fail:
49699 return NULL;
49700 }
49701
49702
49703 SWIGINTERN PyObject *_wrap_new_GBSizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49704 PyObject *resultobj = 0;
49705 wxSizer *arg1 = (wxSizer *) 0 ;
49706 wxGBPosition *arg2 = 0 ;
49707 wxGBSpan *arg3 = 0 ;
49708 int arg4 ;
49709 int arg5 ;
49710 PyObject *arg6 = (PyObject *) NULL ;
49711 wxGBSizerItem *result = 0 ;
49712 int res1 = 0 ;
49713 wxGBPosition temp2 ;
49714 wxGBSpan temp3 ;
49715 int val4 ;
49716 int ecode4 = 0 ;
49717 int val5 ;
49718 int ecode5 = 0 ;
49719 PyObject * obj0 = 0 ;
49720 PyObject * obj1 = 0 ;
49721 PyObject * obj2 = 0 ;
49722 PyObject * obj3 = 0 ;
49723 PyObject * obj4 = 0 ;
49724 PyObject * obj5 = 0 ;
49725 char * kwnames[] = {
49726 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49727 };
49728
49729 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49730 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
49731 if (!SWIG_IsOK(res1)) {
49732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
49733 }
49734 {
49735 arg2 = &temp2;
49736 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49737 }
49738 {
49739 arg3 = &temp3;
49740 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
49741 }
49742 ecode4 = SWIG_AsVal_int(obj3, &val4);
49743 if (!SWIG_IsOK(ecode4)) {
49744 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemSizer" "', expected argument " "4"" of type '" "int""'");
49745 }
49746 arg4 = static_cast< int >(val4);
49747 ecode5 = SWIG_AsVal_int(obj4, &val5);
49748 if (!SWIG_IsOK(ecode5)) {
49749 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSizer" "', expected argument " "5"" of type '" "int""'");
49750 }
49751 arg5 = static_cast< int >(val5);
49752 if (obj5) {
49753 arg6 = obj5;
49754 }
49755 {
49756 PyThreadState* __tstate = wxPyBeginAllowThreads();
49757 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
49758 wxPyEndAllowThreads(__tstate);
49759 if (PyErr_Occurred()) SWIG_fail;
49760 }
49761 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49762 return resultobj;
49763 fail:
49764 return NULL;
49765 }
49766
49767
49768 SWIGINTERN PyObject *_wrap_new_GBSizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49769 PyObject *resultobj = 0;
49770 int arg1 ;
49771 int arg2 ;
49772 wxGBPosition *arg3 = 0 ;
49773 wxGBSpan *arg4 = 0 ;
49774 int arg5 ;
49775 int arg6 ;
49776 PyObject *arg7 = (PyObject *) NULL ;
49777 wxGBSizerItem *result = 0 ;
49778 int val1 ;
49779 int ecode1 = 0 ;
49780 int val2 ;
49781 int ecode2 = 0 ;
49782 wxGBPosition temp3 ;
49783 wxGBSpan temp4 ;
49784 int val5 ;
49785 int ecode5 = 0 ;
49786 int val6 ;
49787 int ecode6 = 0 ;
49788 PyObject * obj0 = 0 ;
49789 PyObject * obj1 = 0 ;
49790 PyObject * obj2 = 0 ;
49791 PyObject * obj3 = 0 ;
49792 PyObject * obj4 = 0 ;
49793 PyObject * obj5 = 0 ;
49794 PyObject * obj6 = 0 ;
49795 char * kwnames[] = {
49796 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49797 };
49798
49799 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
49800 ecode1 = SWIG_AsVal_int(obj0, &val1);
49801 if (!SWIG_IsOK(ecode1)) {
49802 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
49803 }
49804 arg1 = static_cast< int >(val1);
49805 ecode2 = SWIG_AsVal_int(obj1, &val2);
49806 if (!SWIG_IsOK(ecode2)) {
49807 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
49808 }
49809 arg2 = static_cast< int >(val2);
49810 {
49811 arg3 = &temp3;
49812 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
49813 }
49814 {
49815 arg4 = &temp4;
49816 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
49817 }
49818 ecode5 = SWIG_AsVal_int(obj4, &val5);
49819 if (!SWIG_IsOK(ecode5)) {
49820 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
49821 }
49822 arg5 = static_cast< int >(val5);
49823 ecode6 = SWIG_AsVal_int(obj5, &val6);
49824 if (!SWIG_IsOK(ecode6)) {
49825 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GBSizerItemSpacer" "', expected argument " "6"" of type '" "int""'");
49826 }
49827 arg6 = static_cast< int >(val6);
49828 if (obj6) {
49829 arg7 = obj6;
49830 }
49831 {
49832 PyThreadState* __tstate = wxPyBeginAllowThreads();
49833 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
49834 wxPyEndAllowThreads(__tstate);
49835 if (PyErr_Occurred()) SWIG_fail;
49836 }
49837 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49838 return resultobj;
49839 fail:
49840 return NULL;
49841 }
49842
49843
49844 SWIGINTERN PyObject *_wrap_GBSizerItem_GetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49845 PyObject *resultobj = 0;
49846 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49847 wxGBPosition result;
49848 void *argp1 = 0 ;
49849 int res1 = 0 ;
49850 PyObject *swig_obj[1] ;
49851
49852 if (!args) SWIG_fail;
49853 swig_obj[0] = args;
49854 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49855 if (!SWIG_IsOK(res1)) {
49856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetPos" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
49857 }
49858 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49859 {
49860 PyThreadState* __tstate = wxPyBeginAllowThreads();
49861 result = ((wxGBSizerItem const *)arg1)->GetPos();
49862 wxPyEndAllowThreads(__tstate);
49863 if (PyErr_Occurred()) SWIG_fail;
49864 }
49865 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
49866 return resultobj;
49867 fail:
49868 return NULL;
49869 }
49870
49871
49872 SWIGINTERN PyObject *_wrap_GBSizerItem_GetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49873 PyObject *resultobj = 0;
49874 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49875 wxGBSpan result;
49876 void *argp1 = 0 ;
49877 int res1 = 0 ;
49878 PyObject *swig_obj[1] ;
49879
49880 if (!args) SWIG_fail;
49881 swig_obj[0] = args;
49882 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49883 if (!SWIG_IsOK(res1)) {
49884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
49885 }
49886 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49887 {
49888 PyThreadState* __tstate = wxPyBeginAllowThreads();
49889 result = ((wxGBSizerItem const *)arg1)->GetSpan();
49890 wxPyEndAllowThreads(__tstate);
49891 if (PyErr_Occurred()) SWIG_fail;
49892 }
49893 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
49894 return resultobj;
49895 fail:
49896 return NULL;
49897 }
49898
49899
49900 SWIGINTERN PyObject *_wrap_GBSizerItem_SetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49901 PyObject *resultobj = 0;
49902 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49903 wxGBPosition *arg2 = 0 ;
49904 bool result;
49905 void *argp1 = 0 ;
49906 int res1 = 0 ;
49907 wxGBPosition temp2 ;
49908 PyObject * obj0 = 0 ;
49909 PyObject * obj1 = 0 ;
49910 char * kwnames[] = {
49911 (char *) "self",(char *) "pos", NULL
49912 };
49913
49914 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) SWIG_fail;
49915 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49916 if (!SWIG_IsOK(res1)) {
49917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49918 }
49919 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49920 {
49921 arg2 = &temp2;
49922 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49923 }
49924 {
49925 PyThreadState* __tstate = wxPyBeginAllowThreads();
49926 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
49927 wxPyEndAllowThreads(__tstate);
49928 if (PyErr_Occurred()) SWIG_fail;
49929 }
49930 {
49931 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49932 }
49933 return resultobj;
49934 fail:
49935 return NULL;
49936 }
49937
49938
49939 SWIGINTERN PyObject *_wrap_GBSizerItem_SetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49940 PyObject *resultobj = 0;
49941 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49942 wxGBSpan *arg2 = 0 ;
49943 bool result;
49944 void *argp1 = 0 ;
49945 int res1 = 0 ;
49946 wxGBSpan temp2 ;
49947 PyObject * obj0 = 0 ;
49948 PyObject * obj1 = 0 ;
49949 char * kwnames[] = {
49950 (char *) "self",(char *) "span", NULL
49951 };
49952
49953 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) SWIG_fail;
49954 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49955 if (!SWIG_IsOK(res1)) {
49956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49957 }
49958 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49959 {
49960 arg2 = &temp2;
49961 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
49962 }
49963 {
49964 PyThreadState* __tstate = wxPyBeginAllowThreads();
49965 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
49966 wxPyEndAllowThreads(__tstate);
49967 if (PyErr_Occurred()) SWIG_fail;
49968 }
49969 {
49970 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49971 }
49972 return resultobj;
49973 fail:
49974 return NULL;
49975 }
49976
49977
49978 SWIGINTERN PyObject *_wrap_GBSizerItem_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49979 PyObject *resultobj = 0;
49980 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49981 wxGBSizerItem *arg2 = 0 ;
49982 bool result;
49983 void *argp1 = 0 ;
49984 int res1 = 0 ;
49985 void *argp2 = 0 ;
49986 int res2 = 0 ;
49987 PyObject * obj0 = 0 ;
49988 PyObject * obj1 = 0 ;
49989 char * kwnames[] = {
49990 (char *) "self",(char *) "other", NULL
49991 };
49992
49993 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
49994 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49995 if (!SWIG_IsOK(res1)) {
49996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_Intersects" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49997 }
49998 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49999 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGBSizerItem, 0 | 0);
50000 if (!SWIG_IsOK(res2)) {
50001 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
50002 }
50003 if (!argp2) {
50004 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
50005 }
50006 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
50007 {
50008 PyThreadState* __tstate = wxPyBeginAllowThreads();
50009 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
50010 wxPyEndAllowThreads(__tstate);
50011 if (PyErr_Occurred()) SWIG_fail;
50012 }
50013 {
50014 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50015 }
50016 return resultobj;
50017 fail:
50018 return NULL;
50019 }
50020
50021
50022 SWIGINTERN PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50023 PyObject *resultobj = 0;
50024 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50025 wxGBPosition *arg2 = 0 ;
50026 wxGBSpan *arg3 = 0 ;
50027 bool result;
50028 void *argp1 = 0 ;
50029 int res1 = 0 ;
50030 wxGBPosition temp2 ;
50031 wxGBSpan temp3 ;
50032 PyObject * obj0 = 0 ;
50033 PyObject * obj1 = 0 ;
50034 PyObject * obj2 = 0 ;
50035 char * kwnames[] = {
50036 (char *) "self",(char *) "pos",(char *) "span", NULL
50037 };
50038
50039 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50040 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50041 if (!SWIG_IsOK(res1)) {
50042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_IntersectsPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50043 }
50044 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50045 {
50046 arg2 = &temp2;
50047 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50048 }
50049 {
50050 arg3 = &temp3;
50051 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
50052 }
50053 {
50054 PyThreadState* __tstate = wxPyBeginAllowThreads();
50055 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
50056 wxPyEndAllowThreads(__tstate);
50057 if (PyErr_Occurred()) SWIG_fail;
50058 }
50059 {
50060 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50061 }
50062 return resultobj;
50063 fail:
50064 return NULL;
50065 }
50066
50067
50068 SWIGINTERN PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50069 PyObject *resultobj = 0;
50070 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50071 wxGBPosition result;
50072 void *argp1 = 0 ;
50073 int res1 = 0 ;
50074 PyObject *swig_obj[1] ;
50075
50076 if (!args) SWIG_fail;
50077 swig_obj[0] = args;
50078 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50079 if (!SWIG_IsOK(res1)) {
50080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetEndPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50081 }
50082 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50083 {
50084 PyThreadState* __tstate = wxPyBeginAllowThreads();
50085 result = wxGBSizerItem_GetEndPos(arg1);
50086 wxPyEndAllowThreads(__tstate);
50087 if (PyErr_Occurred()) SWIG_fail;
50088 }
50089 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50090 return resultobj;
50091 fail:
50092 return NULL;
50093 }
50094
50095
50096 SWIGINTERN PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50097 PyObject *resultobj = 0;
50098 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50099 wxGridBagSizer *result = 0 ;
50100 void *argp1 = 0 ;
50101 int res1 = 0 ;
50102 PyObject *swig_obj[1] ;
50103
50104 if (!args) SWIG_fail;
50105 swig_obj[0] = args;
50106 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50107 if (!SWIG_IsOK(res1)) {
50108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
50109 }
50110 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50111 {
50112 PyThreadState* __tstate = wxPyBeginAllowThreads();
50113 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
50114 wxPyEndAllowThreads(__tstate);
50115 if (PyErr_Occurred()) SWIG_fail;
50116 }
50117 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50118 return resultobj;
50119 fail:
50120 return NULL;
50121 }
50122
50123
50124 SWIGINTERN PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50125 PyObject *resultobj = 0;
50126 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50127 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
50128 void *argp1 = 0 ;
50129 int res1 = 0 ;
50130 void *argp2 = 0 ;
50131 int res2 = 0 ;
50132 PyObject * obj0 = 0 ;
50133 PyObject * obj1 = 0 ;
50134 char * kwnames[] = {
50135 (char *) "self",(char *) "sizer", NULL
50136 };
50137
50138 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) SWIG_fail;
50139 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50140 if (!SWIG_IsOK(res1)) {
50141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50142 }
50143 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50144 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50145 if (!SWIG_IsOK(res2)) {
50146 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "2"" of type '" "wxGridBagSizer *""'");
50147 }
50148 arg2 = reinterpret_cast< wxGridBagSizer * >(argp2);
50149 {
50150 PyThreadState* __tstate = wxPyBeginAllowThreads();
50151 (arg1)->SetGBSizer(arg2);
50152 wxPyEndAllowThreads(__tstate);
50153 if (PyErr_Occurred()) SWIG_fail;
50154 }
50155 resultobj = SWIG_Py_Void();
50156 return resultobj;
50157 fail:
50158 return NULL;
50159 }
50160
50161
50162 SWIGINTERN PyObject *GBSizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50163 PyObject *obj;
50164 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
50165 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSizerItem, SWIG_NewClientData(obj));
50166 return SWIG_Py_Void();
50167 }
50168
50169 SWIGINTERN PyObject *GBSizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50170 return SWIG_Python_InitShadowInstance(args);
50171 }
50172
50173 SWIGINTERN PyObject *_wrap_new_GridBagSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50174 PyObject *resultobj = 0;
50175 int arg1 = (int) 0 ;
50176 int arg2 = (int) 0 ;
50177 wxGridBagSizer *result = 0 ;
50178 int val1 ;
50179 int ecode1 = 0 ;
50180 int val2 ;
50181 int ecode2 = 0 ;
50182 PyObject * obj0 = 0 ;
50183 PyObject * obj1 = 0 ;
50184 char * kwnames[] = {
50185 (char *) "vgap",(char *) "hgap", NULL
50186 };
50187
50188 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) SWIG_fail;
50189 if (obj0) {
50190 ecode1 = SWIG_AsVal_int(obj0, &val1);
50191 if (!SWIG_IsOK(ecode1)) {
50192 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridBagSizer" "', expected argument " "1"" of type '" "int""'");
50193 }
50194 arg1 = static_cast< int >(val1);
50195 }
50196 if (obj1) {
50197 ecode2 = SWIG_AsVal_int(obj1, &val2);
50198 if (!SWIG_IsOK(ecode2)) {
50199 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridBagSizer" "', expected argument " "2"" of type '" "int""'");
50200 }
50201 arg2 = static_cast< int >(val2);
50202 }
50203 {
50204 PyThreadState* __tstate = wxPyBeginAllowThreads();
50205 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
50206 wxPyEndAllowThreads(__tstate);
50207 if (PyErr_Occurred()) SWIG_fail;
50208 }
50209 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_NEW | 0 );
50210 return resultobj;
50211 fail:
50212 return NULL;
50213 }
50214
50215
50216 SWIGINTERN PyObject *_wrap_GridBagSizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50217 PyObject *resultobj = 0;
50218 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50219 PyObject *arg2 = (PyObject *) 0 ;
50220 wxGBPosition *arg3 = 0 ;
50221 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
50222 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
50223 int arg5 = (int) 0 ;
50224 int arg6 = (int) 0 ;
50225 PyObject *arg7 = (PyObject *) NULL ;
50226 wxGBSizerItem *result = 0 ;
50227 void *argp1 = 0 ;
50228 int res1 = 0 ;
50229 wxGBPosition temp3 ;
50230 wxGBSpan temp4 ;
50231 int val5 ;
50232 int ecode5 = 0 ;
50233 int val6 ;
50234 int ecode6 = 0 ;
50235 PyObject * obj0 = 0 ;
50236 PyObject * obj1 = 0 ;
50237 PyObject * obj2 = 0 ;
50238 PyObject * obj3 = 0 ;
50239 PyObject * obj4 = 0 ;
50240 PyObject * obj5 = 0 ;
50241 PyObject * obj6 = 0 ;
50242 char * kwnames[] = {
50243 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
50244 };
50245
50246 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
50247 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50248 if (!SWIG_IsOK(res1)) {
50249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_Add" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50250 }
50251 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50252 arg2 = obj1;
50253 {
50254 arg3 = &temp3;
50255 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
50256 }
50257 if (obj3) {
50258 {
50259 arg4 = &temp4;
50260 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
50261 }
50262 }
50263 if (obj4) {
50264 ecode5 = SWIG_AsVal_int(obj4, &val5);
50265 if (!SWIG_IsOK(ecode5)) {
50266 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridBagSizer_Add" "', expected argument " "5"" of type '" "int""'");
50267 }
50268 arg5 = static_cast< int >(val5);
50269 }
50270 if (obj5) {
50271 ecode6 = SWIG_AsVal_int(obj5, &val6);
50272 if (!SWIG_IsOK(ecode6)) {
50273 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridBagSizer_Add" "', expected argument " "6"" of type '" "int""'");
50274 }
50275 arg6 = static_cast< int >(val6);
50276 }
50277 if (obj6) {
50278 arg7 = obj6;
50279 }
50280 {
50281 PyThreadState* __tstate = wxPyBeginAllowThreads();
50282 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
50283 wxPyEndAllowThreads(__tstate);
50284 if (PyErr_Occurred()) SWIG_fail;
50285 }
50286 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50287 return resultobj;
50288 fail:
50289 return NULL;
50290 }
50291
50292
50293 SWIGINTERN PyObject *_wrap_GridBagSizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50294 PyObject *resultobj = 0;
50295 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50296 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
50297 wxGBSizerItem *result = 0 ;
50298 void *argp1 = 0 ;
50299 int res1 = 0 ;
50300 int res2 = 0 ;
50301 PyObject * obj0 = 0 ;
50302 PyObject * obj1 = 0 ;
50303 char * kwnames[] = {
50304 (char *) "self",(char *) "item", NULL
50305 };
50306
50307 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
50308 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50309 if (!SWIG_IsOK(res1)) {
50310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_AddItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50311 }
50312 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50313 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
50314 if (!SWIG_IsOK(res2)) {
50315 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_AddItem" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
50316 }
50317 {
50318 PyThreadState* __tstate = wxPyBeginAllowThreads();
50319 result = (wxGBSizerItem *)(arg1)->Add(arg2);
50320 wxPyEndAllowThreads(__tstate);
50321 if (PyErr_Occurred()) SWIG_fail;
50322 }
50323 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50324 return resultobj;
50325 fail:
50326 return NULL;
50327 }
50328
50329
50330 SWIGINTERN PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50331 PyObject *resultobj = 0;
50332 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50333 int arg2 ;
50334 int arg3 ;
50335 wxSize result;
50336 void *argp1 = 0 ;
50337 int res1 = 0 ;
50338 int val2 ;
50339 int ecode2 = 0 ;
50340 int val3 ;
50341 int ecode3 = 0 ;
50342 PyObject * obj0 = 0 ;
50343 PyObject * obj1 = 0 ;
50344 PyObject * obj2 = 0 ;
50345 char * kwnames[] = {
50346 (char *) "self",(char *) "row",(char *) "col", NULL
50347 };
50348
50349 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50350 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50351 if (!SWIG_IsOK(res1)) {
50352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
50353 }
50354 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50355 ecode2 = SWIG_AsVal_int(obj1, &val2);
50356 if (!SWIG_IsOK(ecode2)) {
50357 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "2"" of type '" "int""'");
50358 }
50359 arg2 = static_cast< int >(val2);
50360 ecode3 = SWIG_AsVal_int(obj2, &val3);
50361 if (!SWIG_IsOK(ecode3)) {
50362 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "3"" of type '" "int""'");
50363 }
50364 arg3 = static_cast< int >(val3);
50365 {
50366 PyThreadState* __tstate = wxPyBeginAllowThreads();
50367 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
50368 wxPyEndAllowThreads(__tstate);
50369 if (PyErr_Occurred()) SWIG_fail;
50370 }
50371 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50372 return resultobj;
50373 fail:
50374 return NULL;
50375 }
50376
50377
50378 SWIGINTERN PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50379 PyObject *resultobj = 0;
50380 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50381 wxSize result;
50382 void *argp1 = 0 ;
50383 int res1 = 0 ;
50384 PyObject *swig_obj[1] ;
50385
50386 if (!args) SWIG_fail;
50387 swig_obj[0] = args;
50388 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50389 if (!SWIG_IsOK(res1)) {
50390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
50391 }
50392 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50393 {
50394 PyThreadState* __tstate = wxPyBeginAllowThreads();
50395 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
50396 wxPyEndAllowThreads(__tstate);
50397 if (PyErr_Occurred()) SWIG_fail;
50398 }
50399 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50400 return resultobj;
50401 fail:
50402 return NULL;
50403 }
50404
50405
50406 SWIGINTERN PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50407 PyObject *resultobj = 0;
50408 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50409 wxSize *arg2 = 0 ;
50410 void *argp1 = 0 ;
50411 int res1 = 0 ;
50412 wxSize temp2 ;
50413 PyObject * obj0 = 0 ;
50414 PyObject * obj1 = 0 ;
50415 char * kwnames[] = {
50416 (char *) "self",(char *) "sz", NULL
50417 };
50418
50419 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) SWIG_fail;
50420 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50421 if (!SWIG_IsOK(res1)) {
50422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50423 }
50424 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50425 {
50426 arg2 = &temp2;
50427 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
50428 }
50429 {
50430 PyThreadState* __tstate = wxPyBeginAllowThreads();
50431 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
50432 wxPyEndAllowThreads(__tstate);
50433 if (PyErr_Occurred()) SWIG_fail;
50434 }
50435 resultobj = SWIG_Py_Void();
50436 return resultobj;
50437 fail:
50438 return NULL;
50439 }
50440
50441
50442 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50443 PyObject *resultobj = 0;
50444 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50445 wxWindow *arg2 = (wxWindow *) 0 ;
50446 wxGBPosition result;
50447 void *argp1 = 0 ;
50448 int res1 = 0 ;
50449 void *argp2 = 0 ;
50450 int res2 = 0 ;
50451
50452 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50453 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50454 if (!SWIG_IsOK(res1)) {
50455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50456 }
50457 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50458 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50459 if (!SWIG_IsOK(res2)) {
50460 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
50461 }
50462 arg2 = reinterpret_cast< wxWindow * >(argp2);
50463 {
50464 PyThreadState* __tstate = wxPyBeginAllowThreads();
50465 result = (arg1)->GetItemPosition(arg2);
50466 wxPyEndAllowThreads(__tstate);
50467 if (PyErr_Occurred()) SWIG_fail;
50468 }
50469 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50470 return resultobj;
50471 fail:
50472 return NULL;
50473 }
50474
50475
50476 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50477 PyObject *resultobj = 0;
50478 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50479 wxSizer *arg2 = (wxSizer *) 0 ;
50480 wxGBPosition result;
50481 void *argp1 = 0 ;
50482 int res1 = 0 ;
50483 void *argp2 = 0 ;
50484 int res2 = 0 ;
50485
50486 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50487 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50488 if (!SWIG_IsOK(res1)) {
50489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50490 }
50491 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50492 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50493 if (!SWIG_IsOK(res2)) {
50494 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
50495 }
50496 arg2 = reinterpret_cast< wxSizer * >(argp2);
50497 {
50498 PyThreadState* __tstate = wxPyBeginAllowThreads();
50499 result = (arg1)->GetItemPosition(arg2);
50500 wxPyEndAllowThreads(__tstate);
50501 if (PyErr_Occurred()) SWIG_fail;
50502 }
50503 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50504 return resultobj;
50505 fail:
50506 return NULL;
50507 }
50508
50509
50510 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50511 PyObject *resultobj = 0;
50512 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50513 size_t arg2 ;
50514 wxGBPosition result;
50515 void *argp1 = 0 ;
50516 int res1 = 0 ;
50517 size_t val2 ;
50518 int ecode2 = 0 ;
50519
50520 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50521 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50522 if (!SWIG_IsOK(res1)) {
50523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50524 }
50525 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50526 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50527 if (!SWIG_IsOK(ecode2)) {
50528 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
50529 }
50530 arg2 = static_cast< size_t >(val2);
50531 {
50532 PyThreadState* __tstate = wxPyBeginAllowThreads();
50533 result = (arg1)->GetItemPosition(arg2);
50534 wxPyEndAllowThreads(__tstate);
50535 if (PyErr_Occurred()) SWIG_fail;
50536 }
50537 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50538 return resultobj;
50539 fail:
50540 return NULL;
50541 }
50542
50543
50544 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
50545 int argc;
50546 PyObject *argv[3];
50547
50548 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemPosition",0,2,argv))) SWIG_fail;
50549 --argc;
50550 if (argc == 2) {
50551 int _v = 0;
50552 {
50553 void *vptr = 0;
50554 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50555 _v = SWIG_CheckState(res);
50556 }
50557 if (!_v) goto check_1;
50558 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self, argc, argv);
50559 }
50560 check_1:
50561
50562 if (argc == 2) {
50563 int _v = 0;
50564 {
50565 void *vptr = 0;
50566 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50567 _v = SWIG_CheckState(res);
50568 }
50569 if (!_v) goto check_2;
50570 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self, argc, argv);
50571 }
50572 check_2:
50573
50574 if (argc == 2) {
50575 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self, argc, argv);
50576 }
50577
50578 fail:
50579 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
50580 return NULL;
50581 }
50582
50583
50584 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50585 PyObject *resultobj = 0;
50586 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50587 wxWindow *arg2 = (wxWindow *) 0 ;
50588 wxGBPosition *arg3 = 0 ;
50589 bool result;
50590 void *argp1 = 0 ;
50591 int res1 = 0 ;
50592 void *argp2 = 0 ;
50593 int res2 = 0 ;
50594 wxGBPosition temp3 ;
50595
50596 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50597 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50598 if (!SWIG_IsOK(res1)) {
50599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50600 }
50601 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50602 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50603 if (!SWIG_IsOK(res2)) {
50604 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
50605 }
50606 arg2 = reinterpret_cast< wxWindow * >(argp2);
50607 {
50608 arg3 = &temp3;
50609 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50610 }
50611 {
50612 PyThreadState* __tstate = wxPyBeginAllowThreads();
50613 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50614 wxPyEndAllowThreads(__tstate);
50615 if (PyErr_Occurred()) SWIG_fail;
50616 }
50617 {
50618 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50619 }
50620 return resultobj;
50621 fail:
50622 return NULL;
50623 }
50624
50625
50626 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50627 PyObject *resultobj = 0;
50628 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50629 wxSizer *arg2 = (wxSizer *) 0 ;
50630 wxGBPosition *arg3 = 0 ;
50631 bool result;
50632 void *argp1 = 0 ;
50633 int res1 = 0 ;
50634 void *argp2 = 0 ;
50635 int res2 = 0 ;
50636 wxGBPosition temp3 ;
50637
50638 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50639 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50640 if (!SWIG_IsOK(res1)) {
50641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50642 }
50643 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50644 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50645 if (!SWIG_IsOK(res2)) {
50646 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
50647 }
50648 arg2 = reinterpret_cast< wxSizer * >(argp2);
50649 {
50650 arg3 = &temp3;
50651 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50652 }
50653 {
50654 PyThreadState* __tstate = wxPyBeginAllowThreads();
50655 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50656 wxPyEndAllowThreads(__tstate);
50657 if (PyErr_Occurred()) SWIG_fail;
50658 }
50659 {
50660 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50661 }
50662 return resultobj;
50663 fail:
50664 return NULL;
50665 }
50666
50667
50668 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50669 PyObject *resultobj = 0;
50670 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50671 size_t arg2 ;
50672 wxGBPosition *arg3 = 0 ;
50673 bool result;
50674 void *argp1 = 0 ;
50675 int res1 = 0 ;
50676 size_t val2 ;
50677 int ecode2 = 0 ;
50678 wxGBPosition temp3 ;
50679
50680 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50681 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50682 if (!SWIG_IsOK(res1)) {
50683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50684 }
50685 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50686 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50687 if (!SWIG_IsOK(ecode2)) {
50688 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
50689 }
50690 arg2 = static_cast< size_t >(val2);
50691 {
50692 arg3 = &temp3;
50693 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50694 }
50695 {
50696 PyThreadState* __tstate = wxPyBeginAllowThreads();
50697 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50698 wxPyEndAllowThreads(__tstate);
50699 if (PyErr_Occurred()) SWIG_fail;
50700 }
50701 {
50702 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50703 }
50704 return resultobj;
50705 fail:
50706 return NULL;
50707 }
50708
50709
50710 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
50711 int argc;
50712 PyObject *argv[4];
50713
50714 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemPosition",0,3,argv))) SWIG_fail;
50715 --argc;
50716 if (argc == 3) {
50717 int _v = 0;
50718 {
50719 void *vptr = 0;
50720 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50721 _v = SWIG_CheckState(res);
50722 }
50723 if (!_v) goto check_1;
50724 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self, argc, argv);
50725 }
50726 check_1:
50727
50728 if (argc == 3) {
50729 int _v = 0;
50730 {
50731 void *vptr = 0;
50732 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50733 _v = SWIG_CheckState(res);
50734 }
50735 if (!_v) goto check_2;
50736 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self, argc, argv);
50737 }
50738 check_2:
50739
50740 if (argc == 3) {
50741 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self, argc, argv);
50742 }
50743
50744 fail:
50745 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
50746 return NULL;
50747 }
50748
50749
50750 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50751 PyObject *resultobj = 0;
50752 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50753 wxWindow *arg2 = (wxWindow *) 0 ;
50754 wxGBSpan result;
50755 void *argp1 = 0 ;
50756 int res1 = 0 ;
50757 void *argp2 = 0 ;
50758 int res2 = 0 ;
50759
50760 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50761 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50762 if (!SWIG_IsOK(res1)) {
50763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50764 }
50765 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50766 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50767 if (!SWIG_IsOK(res2)) {
50768 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
50769 }
50770 arg2 = reinterpret_cast< wxWindow * >(argp2);
50771 {
50772 PyThreadState* __tstate = wxPyBeginAllowThreads();
50773 result = (arg1)->GetItemSpan(arg2);
50774 wxPyEndAllowThreads(__tstate);
50775 if (PyErr_Occurred()) SWIG_fail;
50776 }
50777 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50778 return resultobj;
50779 fail:
50780 return NULL;
50781 }
50782
50783
50784 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50785 PyObject *resultobj = 0;
50786 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50787 wxSizer *arg2 = (wxSizer *) 0 ;
50788 wxGBSpan result;
50789 void *argp1 = 0 ;
50790 int res1 = 0 ;
50791 void *argp2 = 0 ;
50792 int res2 = 0 ;
50793
50794 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50795 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50796 if (!SWIG_IsOK(res1)) {
50797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50798 }
50799 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50800 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50801 if (!SWIG_IsOK(res2)) {
50802 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
50803 }
50804 arg2 = reinterpret_cast< wxSizer * >(argp2);
50805 {
50806 PyThreadState* __tstate = wxPyBeginAllowThreads();
50807 result = (arg1)->GetItemSpan(arg2);
50808 wxPyEndAllowThreads(__tstate);
50809 if (PyErr_Occurred()) SWIG_fail;
50810 }
50811 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50812 return resultobj;
50813 fail:
50814 return NULL;
50815 }
50816
50817
50818 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50819 PyObject *resultobj = 0;
50820 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50821 size_t arg2 ;
50822 wxGBSpan result;
50823 void *argp1 = 0 ;
50824 int res1 = 0 ;
50825 size_t val2 ;
50826 int ecode2 = 0 ;
50827
50828 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50829 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50830 if (!SWIG_IsOK(res1)) {
50831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50832 }
50833 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50834 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50835 if (!SWIG_IsOK(ecode2)) {
50836 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
50837 }
50838 arg2 = static_cast< size_t >(val2);
50839 {
50840 PyThreadState* __tstate = wxPyBeginAllowThreads();
50841 result = (arg1)->GetItemSpan(arg2);
50842 wxPyEndAllowThreads(__tstate);
50843 if (PyErr_Occurred()) SWIG_fail;
50844 }
50845 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50846 return resultobj;
50847 fail:
50848 return NULL;
50849 }
50850
50851
50852 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
50853 int argc;
50854 PyObject *argv[3];
50855
50856 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemSpan",0,2,argv))) SWIG_fail;
50857 --argc;
50858 if (argc == 2) {
50859 int _v = 0;
50860 {
50861 void *vptr = 0;
50862 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50863 _v = SWIG_CheckState(res);
50864 }
50865 if (!_v) goto check_1;
50866 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self, argc, argv);
50867 }
50868 check_1:
50869
50870 if (argc == 2) {
50871 int _v = 0;
50872 {
50873 void *vptr = 0;
50874 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50875 _v = SWIG_CheckState(res);
50876 }
50877 if (!_v) goto check_2;
50878 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self, argc, argv);
50879 }
50880 check_2:
50881
50882 if (argc == 2) {
50883 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self, argc, argv);
50884 }
50885
50886 fail:
50887 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
50888 return NULL;
50889 }
50890
50891
50892 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50893 PyObject *resultobj = 0;
50894 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50895 wxWindow *arg2 = (wxWindow *) 0 ;
50896 wxGBSpan *arg3 = 0 ;
50897 bool result;
50898 void *argp1 = 0 ;
50899 int res1 = 0 ;
50900 void *argp2 = 0 ;
50901 int res2 = 0 ;
50902 wxGBSpan temp3 ;
50903
50904 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50905 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50906 if (!SWIG_IsOK(res1)) {
50907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50908 }
50909 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50910 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50911 if (!SWIG_IsOK(res2)) {
50912 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
50913 }
50914 arg2 = reinterpret_cast< wxWindow * >(argp2);
50915 {
50916 arg3 = &temp3;
50917 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
50918 }
50919 {
50920 PyThreadState* __tstate = wxPyBeginAllowThreads();
50921 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
50922 wxPyEndAllowThreads(__tstate);
50923 if (PyErr_Occurred()) SWIG_fail;
50924 }
50925 {
50926 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50927 }
50928 return resultobj;
50929 fail:
50930 return NULL;
50931 }
50932
50933
50934 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50935 PyObject *resultobj = 0;
50936 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50937 wxSizer *arg2 = (wxSizer *) 0 ;
50938 wxGBSpan *arg3 = 0 ;
50939 bool result;
50940 void *argp1 = 0 ;
50941 int res1 = 0 ;
50942 void *argp2 = 0 ;
50943 int res2 = 0 ;
50944 wxGBSpan temp3 ;
50945
50946 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50947 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50948 if (!SWIG_IsOK(res1)) {
50949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50950 }
50951 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50952 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50953 if (!SWIG_IsOK(res2)) {
50954 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
50955 }
50956 arg2 = reinterpret_cast< wxSizer * >(argp2);
50957 {
50958 arg3 = &temp3;
50959 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
50960 }
50961 {
50962 PyThreadState* __tstate = wxPyBeginAllowThreads();
50963 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
50964 wxPyEndAllowThreads(__tstate);
50965 if (PyErr_Occurred()) SWIG_fail;
50966 }
50967 {
50968 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50969 }
50970 return resultobj;
50971 fail:
50972 return NULL;
50973 }
50974
50975
50976 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50977 PyObject *resultobj = 0;
50978 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50979 size_t arg2 ;
50980 wxGBSpan *arg3 = 0 ;
50981 bool result;
50982 void *argp1 = 0 ;
50983 int res1 = 0 ;
50984 size_t val2 ;
50985 int ecode2 = 0 ;
50986 wxGBSpan temp3 ;
50987
50988 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50989 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50990 if (!SWIG_IsOK(res1)) {
50991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50992 }
50993 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50994 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50995 if (!SWIG_IsOK(ecode2)) {
50996 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
50997 }
50998 arg2 = static_cast< size_t >(val2);
50999 {
51000 arg3 = &temp3;
51001 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
51002 }
51003 {
51004 PyThreadState* __tstate = wxPyBeginAllowThreads();
51005 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
51006 wxPyEndAllowThreads(__tstate);
51007 if (PyErr_Occurred()) SWIG_fail;
51008 }
51009 {
51010 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51011 }
51012 return resultobj;
51013 fail:
51014 return NULL;
51015 }
51016
51017
51018 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
51019 int argc;
51020 PyObject *argv[4];
51021
51022 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemSpan",0,3,argv))) SWIG_fail;
51023 --argc;
51024 if (argc == 3) {
51025 int _v = 0;
51026 {
51027 void *vptr = 0;
51028 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
51029 _v = SWIG_CheckState(res);
51030 }
51031 if (!_v) goto check_1;
51032 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self, argc, argv);
51033 }
51034 check_1:
51035
51036 if (argc == 3) {
51037 int _v = 0;
51038 {
51039 void *vptr = 0;
51040 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
51041 _v = SWIG_CheckState(res);
51042 }
51043 if (!_v) goto check_2;
51044 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self, argc, argv);
51045 }
51046 check_2:
51047
51048 if (argc == 3) {
51049 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self, argc, argv);
51050 }
51051
51052 fail:
51053 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
51054 return NULL;
51055 }
51056
51057
51058 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51059 PyObject *resultobj = 0;
51060 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51061 wxWindow *arg2 = (wxWindow *) 0 ;
51062 wxGBSizerItem *result = 0 ;
51063 void *argp1 = 0 ;
51064 int res1 = 0 ;
51065 void *argp2 = 0 ;
51066 int res2 = 0 ;
51067
51068 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51069 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51070 if (!SWIG_IsOK(res1)) {
51071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51072 }
51073 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51074 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51075 if (!SWIG_IsOK(res2)) {
51076 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxWindow *""'");
51077 }
51078 arg2 = reinterpret_cast< wxWindow * >(argp2);
51079 {
51080 PyThreadState* __tstate = wxPyBeginAllowThreads();
51081 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
51082 wxPyEndAllowThreads(__tstate);
51083 if (PyErr_Occurred()) SWIG_fail;
51084 }
51085 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51086 return resultobj;
51087 fail:
51088 return NULL;
51089 }
51090
51091
51092 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51093 PyObject *resultobj = 0;
51094 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51095 wxSizer *arg2 = (wxSizer *) 0 ;
51096 wxGBSizerItem *result = 0 ;
51097 void *argp1 = 0 ;
51098 int res1 = 0 ;
51099 void *argp2 = 0 ;
51100 int res2 = 0 ;
51101
51102 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51103 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51104 if (!SWIG_IsOK(res1)) {
51105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51106 }
51107 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51108 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
51109 if (!SWIG_IsOK(res2)) {
51110 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxSizer *""'");
51111 }
51112 arg2 = reinterpret_cast< wxSizer * >(argp2);
51113 {
51114 PyThreadState* __tstate = wxPyBeginAllowThreads();
51115 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
51116 wxPyEndAllowThreads(__tstate);
51117 if (PyErr_Occurred()) SWIG_fail;
51118 }
51119 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51120 return resultobj;
51121 fail:
51122 return NULL;
51123 }
51124
51125
51126 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
51127 int argc;
51128 PyObject *argv[3];
51129
51130 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_FindItem",0,2,argv))) SWIG_fail;
51131 --argc;
51132 if (argc == 2) {
51133 int _v = 0;
51134 {
51135 void *vptr = 0;
51136 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
51137 _v = SWIG_CheckState(res);
51138 }
51139 if (!_v) goto check_1;
51140 return _wrap_GridBagSizer_FindItem__SWIG_0(self, argc, argv);
51141 }
51142 check_1:
51143
51144 if (argc == 2) {
51145 return _wrap_GridBagSizer_FindItem__SWIG_1(self, argc, argv);
51146 }
51147
51148 fail:
51149 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
51150 return NULL;
51151 }
51152
51153
51154 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51155 PyObject *resultobj = 0;
51156 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51157 wxGBPosition *arg2 = 0 ;
51158 wxGBSizerItem *result = 0 ;
51159 void *argp1 = 0 ;
51160 int res1 = 0 ;
51161 wxGBPosition temp2 ;
51162 PyObject * obj0 = 0 ;
51163 PyObject * obj1 = 0 ;
51164 char * kwnames[] = {
51165 (char *) "self",(char *) "pos", NULL
51166 };
51167
51168 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) SWIG_fail;
51169 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51170 if (!SWIG_IsOK(res1)) {
51171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51172 }
51173 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51174 {
51175 arg2 = &temp2;
51176 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51177 }
51178 {
51179 PyThreadState* __tstate = wxPyBeginAllowThreads();
51180 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
51181 wxPyEndAllowThreads(__tstate);
51182 if (PyErr_Occurred()) SWIG_fail;
51183 }
51184 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51185 return resultobj;
51186 fail:
51187 return NULL;
51188 }
51189
51190
51191 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51192 PyObject *resultobj = 0;
51193 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51194 wxPoint *arg2 = 0 ;
51195 wxGBSizerItem *result = 0 ;
51196 void *argp1 = 0 ;
51197 int res1 = 0 ;
51198 wxPoint temp2 ;
51199 PyObject * obj0 = 0 ;
51200 PyObject * obj1 = 0 ;
51201 char * kwnames[] = {
51202 (char *) "self",(char *) "pt", NULL
51203 };
51204
51205 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) SWIG_fail;
51206 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51207 if (!SWIG_IsOK(res1)) {
51208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPoint" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51209 }
51210 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51211 {
51212 arg2 = &temp2;
51213 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
51214 }
51215 {
51216 PyThreadState* __tstate = wxPyBeginAllowThreads();
51217 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
51218 wxPyEndAllowThreads(__tstate);
51219 if (PyErr_Occurred()) SWIG_fail;
51220 }
51221 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51222 return resultobj;
51223 fail:
51224 return NULL;
51225 }
51226
51227
51228 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51229 PyObject *resultobj = 0;
51230 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51231 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
51232 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
51233 bool result;
51234 void *argp1 = 0 ;
51235 int res1 = 0 ;
51236 void *argp2 = 0 ;
51237 int res2 = 0 ;
51238 void *argp3 = 0 ;
51239 int res3 = 0 ;
51240 PyObject * obj0 = 0 ;
51241 PyObject * obj1 = 0 ;
51242 PyObject * obj2 = 0 ;
51243 char * kwnames[] = {
51244 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
51245 };
51246
51247 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51248 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51249 if (!SWIG_IsOK(res1)) {
51250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51251 }
51252 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51253 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51254 if (!SWIG_IsOK(res2)) {
51255 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
51256 }
51257 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
51258 if (obj2) {
51259 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51260 if (!SWIG_IsOK(res3)) {
51261 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "3"" of type '" "wxGBSizerItem *""'");
51262 }
51263 arg3 = reinterpret_cast< wxGBSizerItem * >(argp3);
51264 }
51265 {
51266 PyThreadState* __tstate = wxPyBeginAllowThreads();
51267 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
51268 wxPyEndAllowThreads(__tstate);
51269 if (PyErr_Occurred()) SWIG_fail;
51270 }
51271 {
51272 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51273 }
51274 return resultobj;
51275 fail:
51276 return NULL;
51277 }
51278
51279
51280 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51281 PyObject *resultobj = 0;
51282 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51283 wxGBPosition *arg2 = 0 ;
51284 wxGBSpan *arg3 = 0 ;
51285 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
51286 bool result;
51287 void *argp1 = 0 ;
51288 int res1 = 0 ;
51289 wxGBPosition temp2 ;
51290 wxGBSpan temp3 ;
51291 void *argp4 = 0 ;
51292 int res4 = 0 ;
51293 PyObject * obj0 = 0 ;
51294 PyObject * obj1 = 0 ;
51295 PyObject * obj2 = 0 ;
51296 PyObject * obj3 = 0 ;
51297 char * kwnames[] = {
51298 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
51299 };
51300
51301 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51302 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51303 if (!SWIG_IsOK(res1)) {
51304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51305 }
51306 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51307 {
51308 arg2 = &temp2;
51309 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51310 }
51311 {
51312 arg3 = &temp3;
51313 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
51314 }
51315 if (obj3) {
51316 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51317 if (!SWIG_IsOK(res4)) {
51318 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "4"" of type '" "wxGBSizerItem *""'");
51319 }
51320 arg4 = reinterpret_cast< wxGBSizerItem * >(argp4);
51321 }
51322 {
51323 PyThreadState* __tstate = wxPyBeginAllowThreads();
51324 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
51325 wxPyEndAllowThreads(__tstate);
51326 if (PyErr_Occurred()) SWIG_fail;
51327 }
51328 {
51329 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51330 }
51331 return resultobj;
51332 fail:
51333 return NULL;
51334 }
51335
51336
51337 SWIGINTERN PyObject *GridBagSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51338 PyObject *obj;
51339 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51340 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridBagSizer, SWIG_NewClientData(obj));
51341 return SWIG_Py_Void();
51342 }
51343
51344 SWIGINTERN PyObject *GridBagSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51345 return SWIG_Python_InitShadowInstance(args);
51346 }
51347
51348 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51349 PyObject *resultobj = 0;
51350 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51351 wxRelationship arg2 ;
51352 wxWindow *arg3 = (wxWindow *) 0 ;
51353 wxEdge arg4 ;
51354 int arg5 = (int) 0 ;
51355 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
51356 void *argp1 = 0 ;
51357 int res1 = 0 ;
51358 int val2 ;
51359 int ecode2 = 0 ;
51360 void *argp3 = 0 ;
51361 int res3 = 0 ;
51362 int val4 ;
51363 int ecode4 = 0 ;
51364 int val5 ;
51365 int ecode5 = 0 ;
51366 int val6 ;
51367 int ecode6 = 0 ;
51368 PyObject * obj0 = 0 ;
51369 PyObject * obj1 = 0 ;
51370 PyObject * obj2 = 0 ;
51371 PyObject * obj3 = 0 ;
51372 PyObject * obj4 = 0 ;
51373 PyObject * obj5 = 0 ;
51374 char * kwnames[] = {
51375 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
51376 };
51377
51378 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
51379 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51380 if (!SWIG_IsOK(res1)) {
51381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51382 }
51383 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51384 ecode2 = SWIG_AsVal_int(obj1, &val2);
51385 if (!SWIG_IsOK(ecode2)) {
51386 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "2"" of type '" "wxRelationship""'");
51387 }
51388 arg2 = static_cast< wxRelationship >(val2);
51389 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
51390 if (!SWIG_IsOK(res3)) {
51391 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "3"" of type '" "wxWindow *""'");
51392 }
51393 arg3 = reinterpret_cast< wxWindow * >(argp3);
51394 ecode4 = SWIG_AsVal_int(obj3, &val4);
51395 if (!SWIG_IsOK(ecode4)) {
51396 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "4"" of type '" "wxEdge""'");
51397 }
51398 arg4 = static_cast< wxEdge >(val4);
51399 if (obj4) {
51400 ecode5 = SWIG_AsVal_int(obj4, &val5);
51401 if (!SWIG_IsOK(ecode5)) {
51402 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "5"" of type '" "int""'");
51403 }
51404 arg5 = static_cast< int >(val5);
51405 }
51406 if (obj5) {
51407 ecode6 = SWIG_AsVal_int(obj5, &val6);
51408 if (!SWIG_IsOK(ecode6)) {
51409 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "6"" of type '" "int""'");
51410 }
51411 arg6 = static_cast< int >(val6);
51412 }
51413 {
51414 PyThreadState* __tstate = wxPyBeginAllowThreads();
51415 (arg1)->Set(arg2,arg3,arg4,arg5,arg6);
51416 wxPyEndAllowThreads(__tstate);
51417 if (PyErr_Occurred()) SWIG_fail;
51418 }
51419 resultobj = SWIG_Py_Void();
51420 return resultobj;
51421 fail:
51422 return NULL;
51423 }
51424
51425
51426 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51427 PyObject *resultobj = 0;
51428 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51429 wxWindow *arg2 = (wxWindow *) 0 ;
51430 int arg3 = (int) 0 ;
51431 void *argp1 = 0 ;
51432 int res1 = 0 ;
51433 void *argp2 = 0 ;
51434 int res2 = 0 ;
51435 int val3 ;
51436 int ecode3 = 0 ;
51437 PyObject * obj0 = 0 ;
51438 PyObject * obj1 = 0 ;
51439 PyObject * obj2 = 0 ;
51440 char * kwnames[] = {
51441 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51442 };
51443
51444 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51445 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51446 if (!SWIG_IsOK(res1)) {
51447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51448 }
51449 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51450 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51451 if (!SWIG_IsOK(res2)) {
51452 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51453 }
51454 arg2 = reinterpret_cast< wxWindow * >(argp2);
51455 if (obj2) {
51456 ecode3 = SWIG_AsVal_int(obj2, &val3);
51457 if (!SWIG_IsOK(ecode3)) {
51458 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "3"" of type '" "int""'");
51459 }
51460 arg3 = static_cast< int >(val3);
51461 }
51462 {
51463 PyThreadState* __tstate = wxPyBeginAllowThreads();
51464 (arg1)->LeftOf(arg2,arg3);
51465 wxPyEndAllowThreads(__tstate);
51466 if (PyErr_Occurred()) SWIG_fail;
51467 }
51468 resultobj = SWIG_Py_Void();
51469 return resultobj;
51470 fail:
51471 return NULL;
51472 }
51473
51474
51475 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51476 PyObject *resultobj = 0;
51477 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51478 wxWindow *arg2 = (wxWindow *) 0 ;
51479 int arg3 = (int) 0 ;
51480 void *argp1 = 0 ;
51481 int res1 = 0 ;
51482 void *argp2 = 0 ;
51483 int res2 = 0 ;
51484 int val3 ;
51485 int ecode3 = 0 ;
51486 PyObject * obj0 = 0 ;
51487 PyObject * obj1 = 0 ;
51488 PyObject * obj2 = 0 ;
51489 char * kwnames[] = {
51490 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51491 };
51492
51493 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51494 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51495 if (!SWIG_IsOK(res1)) {
51496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51497 }
51498 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51499 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51500 if (!SWIG_IsOK(res2)) {
51501 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51502 }
51503 arg2 = reinterpret_cast< wxWindow * >(argp2);
51504 if (obj2) {
51505 ecode3 = SWIG_AsVal_int(obj2, &val3);
51506 if (!SWIG_IsOK(ecode3)) {
51507 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "3"" of type '" "int""'");
51508 }
51509 arg3 = static_cast< int >(val3);
51510 }
51511 {
51512 PyThreadState* __tstate = wxPyBeginAllowThreads();
51513 (arg1)->RightOf(arg2,arg3);
51514 wxPyEndAllowThreads(__tstate);
51515 if (PyErr_Occurred()) SWIG_fail;
51516 }
51517 resultobj = SWIG_Py_Void();
51518 return resultobj;
51519 fail:
51520 return NULL;
51521 }
51522
51523
51524 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51525 PyObject *resultobj = 0;
51526 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51527 wxWindow *arg2 = (wxWindow *) 0 ;
51528 int arg3 = (int) 0 ;
51529 void *argp1 = 0 ;
51530 int res1 = 0 ;
51531 void *argp2 = 0 ;
51532 int res2 = 0 ;
51533 int val3 ;
51534 int ecode3 = 0 ;
51535 PyObject * obj0 = 0 ;
51536 PyObject * obj1 = 0 ;
51537 PyObject * obj2 = 0 ;
51538 char * kwnames[] = {
51539 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51540 };
51541
51542 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51543 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51544 if (!SWIG_IsOK(res1)) {
51545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51546 }
51547 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51548 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51549 if (!SWIG_IsOK(res2)) {
51550 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "2"" of type '" "wxWindow *""'");
51551 }
51552 arg2 = reinterpret_cast< wxWindow * >(argp2);
51553 if (obj2) {
51554 ecode3 = SWIG_AsVal_int(obj2, &val3);
51555 if (!SWIG_IsOK(ecode3)) {
51556 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "3"" of type '" "int""'");
51557 }
51558 arg3 = static_cast< int >(val3);
51559 }
51560 {
51561 PyThreadState* __tstate = wxPyBeginAllowThreads();
51562 (arg1)->Above(arg2,arg3);
51563 wxPyEndAllowThreads(__tstate);
51564 if (PyErr_Occurred()) SWIG_fail;
51565 }
51566 resultobj = SWIG_Py_Void();
51567 return resultobj;
51568 fail:
51569 return NULL;
51570 }
51571
51572
51573 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51574 PyObject *resultobj = 0;
51575 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51576 wxWindow *arg2 = (wxWindow *) 0 ;
51577 int arg3 = (int) 0 ;
51578 void *argp1 = 0 ;
51579 int res1 = 0 ;
51580 void *argp2 = 0 ;
51581 int res2 = 0 ;
51582 int val3 ;
51583 int ecode3 = 0 ;
51584 PyObject * obj0 = 0 ;
51585 PyObject * obj1 = 0 ;
51586 PyObject * obj2 = 0 ;
51587 char * kwnames[] = {
51588 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51589 };
51590
51591 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51592 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51593 if (!SWIG_IsOK(res1)) {
51594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51595 }
51596 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51597 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51598 if (!SWIG_IsOK(res2)) {
51599 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "2"" of type '" "wxWindow *""'");
51600 }
51601 arg2 = reinterpret_cast< wxWindow * >(argp2);
51602 if (obj2) {
51603 ecode3 = SWIG_AsVal_int(obj2, &val3);
51604 if (!SWIG_IsOK(ecode3)) {
51605 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "3"" of type '" "int""'");
51606 }
51607 arg3 = static_cast< int >(val3);
51608 }
51609 {
51610 PyThreadState* __tstate = wxPyBeginAllowThreads();
51611 (arg1)->Below(arg2,arg3);
51612 wxPyEndAllowThreads(__tstate);
51613 if (PyErr_Occurred()) SWIG_fail;
51614 }
51615 resultobj = SWIG_Py_Void();
51616 return resultobj;
51617 fail:
51618 return NULL;
51619 }
51620
51621
51622 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51623 PyObject *resultobj = 0;
51624 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51625 wxWindow *arg2 = (wxWindow *) 0 ;
51626 wxEdge arg3 ;
51627 int arg4 = (int) 0 ;
51628 void *argp1 = 0 ;
51629 int res1 = 0 ;
51630 void *argp2 = 0 ;
51631 int res2 = 0 ;
51632 int val3 ;
51633 int ecode3 = 0 ;
51634 int val4 ;
51635 int ecode4 = 0 ;
51636 PyObject * obj0 = 0 ;
51637 PyObject * obj1 = 0 ;
51638 PyObject * obj2 = 0 ;
51639 PyObject * obj3 = 0 ;
51640 char * kwnames[] = {
51641 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
51642 };
51643
51644 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51645 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51646 if (!SWIG_IsOK(res1)) {
51647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51648 }
51649 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51650 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51651 if (!SWIG_IsOK(res2)) {
51652 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "2"" of type '" "wxWindow *""'");
51653 }
51654 arg2 = reinterpret_cast< wxWindow * >(argp2);
51655 ecode3 = SWIG_AsVal_int(obj2, &val3);
51656 if (!SWIG_IsOK(ecode3)) {
51657 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "3"" of type '" "wxEdge""'");
51658 }
51659 arg3 = static_cast< wxEdge >(val3);
51660 if (obj3) {
51661 ecode4 = SWIG_AsVal_int(obj3, &val4);
51662 if (!SWIG_IsOK(ecode4)) {
51663 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "4"" of type '" "int""'");
51664 }
51665 arg4 = static_cast< int >(val4);
51666 }
51667 {
51668 PyThreadState* __tstate = wxPyBeginAllowThreads();
51669 (arg1)->SameAs(arg2,arg3,arg4);
51670 wxPyEndAllowThreads(__tstate);
51671 if (PyErr_Occurred()) SWIG_fail;
51672 }
51673 resultobj = SWIG_Py_Void();
51674 return resultobj;
51675 fail:
51676 return NULL;
51677 }
51678
51679
51680 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51681 PyObject *resultobj = 0;
51682 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51683 wxWindow *arg2 = (wxWindow *) 0 ;
51684 wxEdge arg3 ;
51685 int arg4 ;
51686 void *argp1 = 0 ;
51687 int res1 = 0 ;
51688 void *argp2 = 0 ;
51689 int res2 = 0 ;
51690 int val3 ;
51691 int ecode3 = 0 ;
51692 int val4 ;
51693 int ecode4 = 0 ;
51694 PyObject * obj0 = 0 ;
51695 PyObject * obj1 = 0 ;
51696 PyObject * obj2 = 0 ;
51697 PyObject * obj3 = 0 ;
51698 char * kwnames[] = {
51699 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
51700 };
51701
51702 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51703 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51704 if (!SWIG_IsOK(res1)) {
51705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51706 }
51707 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51708 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51709 if (!SWIG_IsOK(res2)) {
51710 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51711 }
51712 arg2 = reinterpret_cast< wxWindow * >(argp2);
51713 ecode3 = SWIG_AsVal_int(obj2, &val3);
51714 if (!SWIG_IsOK(ecode3)) {
51715 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "3"" of type '" "wxEdge""'");
51716 }
51717 arg3 = static_cast< wxEdge >(val3);
51718 ecode4 = SWIG_AsVal_int(obj3, &val4);
51719 if (!SWIG_IsOK(ecode4)) {
51720 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "4"" of type '" "int""'");
51721 }
51722 arg4 = static_cast< int >(val4);
51723 {
51724 PyThreadState* __tstate = wxPyBeginAllowThreads();
51725 (arg1)->PercentOf(arg2,arg3,arg4);
51726 wxPyEndAllowThreads(__tstate);
51727 if (PyErr_Occurred()) SWIG_fail;
51728 }
51729 resultobj = SWIG_Py_Void();
51730 return resultobj;
51731 fail:
51732 return NULL;
51733 }
51734
51735
51736 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51737 PyObject *resultobj = 0;
51738 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51739 int arg2 ;
51740 void *argp1 = 0 ;
51741 int res1 = 0 ;
51742 int val2 ;
51743 int ecode2 = 0 ;
51744 PyObject * obj0 = 0 ;
51745 PyObject * obj1 = 0 ;
51746 char * kwnames[] = {
51747 (char *) "self",(char *) "val", NULL
51748 };
51749
51750 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) SWIG_fail;
51751 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51752 if (!SWIG_IsOK(res1)) {
51753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51754 }
51755 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51756 ecode2 = SWIG_AsVal_int(obj1, &val2);
51757 if (!SWIG_IsOK(ecode2)) {
51758 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "2"" of type '" "int""'");
51759 }
51760 arg2 = static_cast< int >(val2);
51761 {
51762 PyThreadState* __tstate = wxPyBeginAllowThreads();
51763 (arg1)->Absolute(arg2);
51764 wxPyEndAllowThreads(__tstate);
51765 if (PyErr_Occurred()) SWIG_fail;
51766 }
51767 resultobj = SWIG_Py_Void();
51768 return resultobj;
51769 fail:
51770 return NULL;
51771 }
51772
51773
51774 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51775 PyObject *resultobj = 0;
51776 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51777 void *argp1 = 0 ;
51778 int res1 = 0 ;
51779 PyObject *swig_obj[1] ;
51780
51781 if (!args) SWIG_fail;
51782 swig_obj[0] = args;
51783 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51784 if (!SWIG_IsOK(res1)) {
51785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Unconstrained" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51786 }
51787 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51788 {
51789 PyThreadState* __tstate = wxPyBeginAllowThreads();
51790 (arg1)->Unconstrained();
51791 wxPyEndAllowThreads(__tstate);
51792 if (PyErr_Occurred()) SWIG_fail;
51793 }
51794 resultobj = SWIG_Py_Void();
51795 return resultobj;
51796 fail:
51797 return NULL;
51798 }
51799
51800
51801 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51802 PyObject *resultobj = 0;
51803 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51804 void *argp1 = 0 ;
51805 int res1 = 0 ;
51806 PyObject *swig_obj[1] ;
51807
51808 if (!args) SWIG_fail;
51809 swig_obj[0] = args;
51810 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51811 if (!SWIG_IsOK(res1)) {
51812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_AsIs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51813 }
51814 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51815 {
51816 PyThreadState* __tstate = wxPyBeginAllowThreads();
51817 (arg1)->AsIs();
51818 wxPyEndAllowThreads(__tstate);
51819 if (PyErr_Occurred()) SWIG_fail;
51820 }
51821 resultobj = SWIG_Py_Void();
51822 return resultobj;
51823 fail:
51824 return NULL;
51825 }
51826
51827
51828 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51829 PyObject *resultobj = 0;
51830 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51831 wxWindow *result = 0 ;
51832 void *argp1 = 0 ;
51833 int res1 = 0 ;
51834 PyObject *swig_obj[1] ;
51835
51836 if (!args) SWIG_fail;
51837 swig_obj[0] = args;
51838 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51839 if (!SWIG_IsOK(res1)) {
51840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherWindow" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51841 }
51842 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51843 {
51844 PyThreadState* __tstate = wxPyBeginAllowThreads();
51845 result = (wxWindow *)(arg1)->GetOtherWindow();
51846 wxPyEndAllowThreads(__tstate);
51847 if (PyErr_Occurred()) SWIG_fail;
51848 }
51849 {
51850 resultobj = wxPyMake_wxObject(result, 0);
51851 }
51852 return resultobj;
51853 fail:
51854 return NULL;
51855 }
51856
51857
51858 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51859 PyObject *resultobj = 0;
51860 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51861 wxEdge result;
51862 void *argp1 = 0 ;
51863 int res1 = 0 ;
51864 PyObject *swig_obj[1] ;
51865
51866 if (!args) SWIG_fail;
51867 swig_obj[0] = args;
51868 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51869 if (!SWIG_IsOK(res1)) {
51870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMyEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51871 }
51872 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51873 {
51874 PyThreadState* __tstate = wxPyBeginAllowThreads();
51875 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
51876 wxPyEndAllowThreads(__tstate);
51877 if (PyErr_Occurred()) SWIG_fail;
51878 }
51879 resultobj = SWIG_From_int(static_cast< int >(result));
51880 return resultobj;
51881 fail:
51882 return NULL;
51883 }
51884
51885
51886 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51887 PyObject *resultobj = 0;
51888 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51889 wxEdge arg2 ;
51890 void *argp1 = 0 ;
51891 int res1 = 0 ;
51892 int val2 ;
51893 int ecode2 = 0 ;
51894 PyObject * obj0 = 0 ;
51895 PyObject * obj1 = 0 ;
51896 char * kwnames[] = {
51897 (char *) "self",(char *) "which", NULL
51898 };
51899
51900 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) SWIG_fail;
51901 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51902 if (!SWIG_IsOK(res1)) {
51903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51904 }
51905 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51906 ecode2 = SWIG_AsVal_int(obj1, &val2);
51907 if (!SWIG_IsOK(ecode2)) {
51908 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
51909 }
51910 arg2 = static_cast< wxEdge >(val2);
51911 {
51912 PyThreadState* __tstate = wxPyBeginAllowThreads();
51913 (arg1)->SetEdge(arg2);
51914 wxPyEndAllowThreads(__tstate);
51915 if (PyErr_Occurred()) SWIG_fail;
51916 }
51917 resultobj = SWIG_Py_Void();
51918 return resultobj;
51919 fail:
51920 return NULL;
51921 }
51922
51923
51924 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51925 PyObject *resultobj = 0;
51926 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51927 int arg2 ;
51928 void *argp1 = 0 ;
51929 int res1 = 0 ;
51930 int val2 ;
51931 int ecode2 = 0 ;
51932 PyObject * obj0 = 0 ;
51933 PyObject * obj1 = 0 ;
51934 char * kwnames[] = {
51935 (char *) "self",(char *) "v", NULL
51936 };
51937
51938 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
51939 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51940 if (!SWIG_IsOK(res1)) {
51941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51942 }
51943 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51944 ecode2 = SWIG_AsVal_int(obj1, &val2);
51945 if (!SWIG_IsOK(ecode2)) {
51946 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "2"" of type '" "int""'");
51947 }
51948 arg2 = static_cast< int >(val2);
51949 {
51950 PyThreadState* __tstate = wxPyBeginAllowThreads();
51951 (arg1)->SetValue(arg2);
51952 wxPyEndAllowThreads(__tstate);
51953 if (PyErr_Occurred()) SWIG_fail;
51954 }
51955 resultobj = SWIG_Py_Void();
51956 return resultobj;
51957 fail:
51958 return NULL;
51959 }
51960
51961
51962 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51963 PyObject *resultobj = 0;
51964 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51965 int result;
51966 void *argp1 = 0 ;
51967 int res1 = 0 ;
51968 PyObject *swig_obj[1] ;
51969
51970 if (!args) SWIG_fail;
51971 swig_obj[0] = args;
51972 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51973 if (!SWIG_IsOK(res1)) {
51974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51975 }
51976 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51977 {
51978 PyThreadState* __tstate = wxPyBeginAllowThreads();
51979 result = (int)(arg1)->GetMargin();
51980 wxPyEndAllowThreads(__tstate);
51981 if (PyErr_Occurred()) SWIG_fail;
51982 }
51983 resultobj = SWIG_From_int(static_cast< int >(result));
51984 return resultobj;
51985 fail:
51986 return NULL;
51987 }
51988
51989
51990 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51991 PyObject *resultobj = 0;
51992 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51993 int arg2 ;
51994 void *argp1 = 0 ;
51995 int res1 = 0 ;
51996 int val2 ;
51997 int ecode2 = 0 ;
51998 PyObject * obj0 = 0 ;
51999 PyObject * obj1 = 0 ;
52000 char * kwnames[] = {
52001 (char *) "self",(char *) "m", NULL
52002 };
52003
52004 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) SWIG_fail;
52005 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52006 if (!SWIG_IsOK(res1)) {
52007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52008 }
52009 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52010 ecode2 = SWIG_AsVal_int(obj1, &val2);
52011 if (!SWIG_IsOK(ecode2)) {
52012 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "2"" of type '" "int""'");
52013 }
52014 arg2 = static_cast< int >(val2);
52015 {
52016 PyThreadState* __tstate = wxPyBeginAllowThreads();
52017 (arg1)->SetMargin(arg2);
52018 wxPyEndAllowThreads(__tstate);
52019 if (PyErr_Occurred()) SWIG_fail;
52020 }
52021 resultobj = SWIG_Py_Void();
52022 return resultobj;
52023 fail:
52024 return NULL;
52025 }
52026
52027
52028 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52029 PyObject *resultobj = 0;
52030 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52031 int result;
52032 void *argp1 = 0 ;
52033 int res1 = 0 ;
52034 PyObject *swig_obj[1] ;
52035
52036 if (!args) SWIG_fail;
52037 swig_obj[0] = args;
52038 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52039 if (!SWIG_IsOK(res1)) {
52040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52041 }
52042 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52043 {
52044 PyThreadState* __tstate = wxPyBeginAllowThreads();
52045 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
52046 wxPyEndAllowThreads(__tstate);
52047 if (PyErr_Occurred()) SWIG_fail;
52048 }
52049 resultobj = SWIG_From_int(static_cast< int >(result));
52050 return resultobj;
52051 fail:
52052 return NULL;
52053 }
52054
52055
52056 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52057 PyObject *resultobj = 0;
52058 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52059 int result;
52060 void *argp1 = 0 ;
52061 int res1 = 0 ;
52062 PyObject *swig_obj[1] ;
52063
52064 if (!args) SWIG_fail;
52065 swig_obj[0] = args;
52066 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52067 if (!SWIG_IsOK(res1)) {
52068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetPercent" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52069 }
52070 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52071 {
52072 PyThreadState* __tstate = wxPyBeginAllowThreads();
52073 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
52074 wxPyEndAllowThreads(__tstate);
52075 if (PyErr_Occurred()) SWIG_fail;
52076 }
52077 resultobj = SWIG_From_int(static_cast< int >(result));
52078 return resultobj;
52079 fail:
52080 return NULL;
52081 }
52082
52083
52084 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52085 PyObject *resultobj = 0;
52086 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52087 int result;
52088 void *argp1 = 0 ;
52089 int res1 = 0 ;
52090 PyObject *swig_obj[1] ;
52091
52092 if (!args) SWIG_fail;
52093 swig_obj[0] = args;
52094 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52095 if (!SWIG_IsOK(res1)) {
52096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52097 }
52098 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52099 {
52100 PyThreadState* __tstate = wxPyBeginAllowThreads();
52101 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
52102 wxPyEndAllowThreads(__tstate);
52103 if (PyErr_Occurred()) SWIG_fail;
52104 }
52105 resultobj = SWIG_From_int(static_cast< int >(result));
52106 return resultobj;
52107 fail:
52108 return NULL;
52109 }
52110
52111
52112 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52113 PyObject *resultobj = 0;
52114 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52115 bool result;
52116 void *argp1 = 0 ;
52117 int res1 = 0 ;
52118 PyObject *swig_obj[1] ;
52119
52120 if (!args) SWIG_fail;
52121 swig_obj[0] = args;
52122 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52123 if (!SWIG_IsOK(res1)) {
52124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52125 }
52126 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52127 {
52128 PyThreadState* __tstate = wxPyBeginAllowThreads();
52129 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
52130 wxPyEndAllowThreads(__tstate);
52131 if (PyErr_Occurred()) SWIG_fail;
52132 }
52133 {
52134 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52135 }
52136 return resultobj;
52137 fail:
52138 return NULL;
52139 }
52140
52141
52142 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52143 PyObject *resultobj = 0;
52144 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52145 bool arg2 ;
52146 void *argp1 = 0 ;
52147 int res1 = 0 ;
52148 bool val2 ;
52149 int ecode2 = 0 ;
52150 PyObject * obj0 = 0 ;
52151 PyObject * obj1 = 0 ;
52152 char * kwnames[] = {
52153 (char *) "self",(char *) "d", NULL
52154 };
52155
52156 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) SWIG_fail;
52157 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52158 if (!SWIG_IsOK(res1)) {
52159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52160 }
52161 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52162 ecode2 = SWIG_AsVal_bool(obj1, &val2);
52163 if (!SWIG_IsOK(ecode2)) {
52164 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "2"" of type '" "bool""'");
52165 }
52166 arg2 = static_cast< bool >(val2);
52167 {
52168 PyThreadState* __tstate = wxPyBeginAllowThreads();
52169 (arg1)->SetDone(arg2);
52170 wxPyEndAllowThreads(__tstate);
52171 if (PyErr_Occurred()) SWIG_fail;
52172 }
52173 resultobj = SWIG_Py_Void();
52174 return resultobj;
52175 fail:
52176 return NULL;
52177 }
52178
52179
52180 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52181 PyObject *resultobj = 0;
52182 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52183 wxRelationship result;
52184 void *argp1 = 0 ;
52185 int res1 = 0 ;
52186 PyObject *swig_obj[1] ;
52187
52188 if (!args) SWIG_fail;
52189 swig_obj[0] = args;
52190 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52191 if (!SWIG_IsOK(res1)) {
52192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52193 }
52194 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52195 {
52196 PyThreadState* __tstate = wxPyBeginAllowThreads();
52197 result = (wxRelationship)(arg1)->GetRelationship();
52198 wxPyEndAllowThreads(__tstate);
52199 if (PyErr_Occurred()) SWIG_fail;
52200 }
52201 resultobj = SWIG_From_int(static_cast< int >(result));
52202 return resultobj;
52203 fail:
52204 return NULL;
52205 }
52206
52207
52208 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52209 PyObject *resultobj = 0;
52210 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52211 wxRelationship arg2 ;
52212 void *argp1 = 0 ;
52213 int res1 = 0 ;
52214 int val2 ;
52215 int ecode2 = 0 ;
52216 PyObject * obj0 = 0 ;
52217 PyObject * obj1 = 0 ;
52218 char * kwnames[] = {
52219 (char *) "self",(char *) "r", NULL
52220 };
52221
52222 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) SWIG_fail;
52223 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52224 if (!SWIG_IsOK(res1)) {
52225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52226 }
52227 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52228 ecode2 = SWIG_AsVal_int(obj1, &val2);
52229 if (!SWIG_IsOK(ecode2)) {
52230 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "2"" of type '" "wxRelationship""'");
52231 }
52232 arg2 = static_cast< wxRelationship >(val2);
52233 {
52234 PyThreadState* __tstate = wxPyBeginAllowThreads();
52235 (arg1)->SetRelationship(arg2);
52236 wxPyEndAllowThreads(__tstate);
52237 if (PyErr_Occurred()) SWIG_fail;
52238 }
52239 resultobj = SWIG_Py_Void();
52240 return resultobj;
52241 fail:
52242 return NULL;
52243 }
52244
52245
52246 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52247 PyObject *resultobj = 0;
52248 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52249 wxWindow *arg2 = (wxWindow *) 0 ;
52250 bool result;
52251 void *argp1 = 0 ;
52252 int res1 = 0 ;
52253 void *argp2 = 0 ;
52254 int res2 = 0 ;
52255 PyObject * obj0 = 0 ;
52256 PyObject * obj1 = 0 ;
52257 char * kwnames[] = {
52258 (char *) "self",(char *) "otherW", NULL
52259 };
52260
52261 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) SWIG_fail;
52262 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52263 if (!SWIG_IsOK(res1)) {
52264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52265 }
52266 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52267 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52268 if (!SWIG_IsOK(res2)) {
52269 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "2"" of type '" "wxWindow *""'");
52270 }
52271 arg2 = reinterpret_cast< wxWindow * >(argp2);
52272 {
52273 PyThreadState* __tstate = wxPyBeginAllowThreads();
52274 result = (bool)(arg1)->ResetIfWin(arg2);
52275 wxPyEndAllowThreads(__tstate);
52276 if (PyErr_Occurred()) SWIG_fail;
52277 }
52278 {
52279 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52280 }
52281 return resultobj;
52282 fail:
52283 return NULL;
52284 }
52285
52286
52287 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52288 PyObject *resultobj = 0;
52289 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52290 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
52291 wxWindow *arg3 = (wxWindow *) 0 ;
52292 bool result;
52293 void *argp1 = 0 ;
52294 int res1 = 0 ;
52295 void *argp2 = 0 ;
52296 int res2 = 0 ;
52297 void *argp3 = 0 ;
52298 int res3 = 0 ;
52299 PyObject * obj0 = 0 ;
52300 PyObject * obj1 = 0 ;
52301 PyObject * obj2 = 0 ;
52302 char * kwnames[] = {
52303 (char *) "self",(char *) "constraints",(char *) "win", NULL
52304 };
52305
52306 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52307 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52308 if (!SWIG_IsOK(res1)) {
52309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52310 }
52311 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52312 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52313 if (!SWIG_IsOK(res2)) {
52314 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
52315 }
52316 arg2 = reinterpret_cast< wxLayoutConstraints * >(argp2);
52317 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
52318 if (!SWIG_IsOK(res3)) {
52319 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "3"" of type '" "wxWindow *""'");
52320 }
52321 arg3 = reinterpret_cast< wxWindow * >(argp3);
52322 {
52323 PyThreadState* __tstate = wxPyBeginAllowThreads();
52324 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
52325 wxPyEndAllowThreads(__tstate);
52326 if (PyErr_Occurred()) SWIG_fail;
52327 }
52328 {
52329 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52330 }
52331 return resultobj;
52332 fail:
52333 return NULL;
52334 }
52335
52336
52337 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52338 PyObject *resultobj = 0;
52339 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52340 wxEdge arg2 ;
52341 wxWindow *arg3 = (wxWindow *) 0 ;
52342 wxWindow *arg4 = (wxWindow *) 0 ;
52343 int result;
52344 void *argp1 = 0 ;
52345 int res1 = 0 ;
52346 int val2 ;
52347 int ecode2 = 0 ;
52348 void *argp3 = 0 ;
52349 int res3 = 0 ;
52350 void *argp4 = 0 ;
52351 int res4 = 0 ;
52352 PyObject * obj0 = 0 ;
52353 PyObject * obj1 = 0 ;
52354 PyObject * obj2 = 0 ;
52355 PyObject * obj3 = 0 ;
52356 char * kwnames[] = {
52357 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
52358 };
52359
52360 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52361 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52362 if (!SWIG_IsOK(res1)) {
52363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52364 }
52365 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52366 ecode2 = SWIG_AsVal_int(obj1, &val2);
52367 if (!SWIG_IsOK(ecode2)) {
52368 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
52369 }
52370 arg2 = static_cast< wxEdge >(val2);
52371 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
52372 if (!SWIG_IsOK(res3)) {
52373 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "3"" of type '" "wxWindow *""'");
52374 }
52375 arg3 = reinterpret_cast< wxWindow * >(argp3);
52376 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
52377 if (!SWIG_IsOK(res4)) {
52378 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "4"" of type '" "wxWindow *""'");
52379 }
52380 arg4 = reinterpret_cast< wxWindow * >(argp4);
52381 {
52382 PyThreadState* __tstate = wxPyBeginAllowThreads();
52383 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge(arg2,arg3,arg4);
52384 wxPyEndAllowThreads(__tstate);
52385 if (PyErr_Occurred()) SWIG_fail;
52386 }
52387 resultobj = SWIG_From_int(static_cast< int >(result));
52388 return resultobj;
52389 fail:
52390 return NULL;
52391 }
52392
52393
52394 SWIGINTERN PyObject *IndividualLayoutConstraint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52395 PyObject *obj;
52396 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52397 SWIG_TypeNewClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_NewClientData(obj));
52398 return SWIG_Py_Void();
52399 }
52400
52401 SWIGINTERN PyObject *_wrap_LayoutConstraints_left_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52402 PyObject *resultobj = 0;
52403 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52404 wxIndividualLayoutConstraint *result = 0 ;
52405 void *argp1 = 0 ;
52406 int res1 = 0 ;
52407 PyObject *swig_obj[1] ;
52408
52409 if (!args) SWIG_fail;
52410 swig_obj[0] = args;
52411 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52412 if (!SWIG_IsOK(res1)) {
52413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_left_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52414 }
52415 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52416 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
52417 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52418 return resultobj;
52419 fail:
52420 return NULL;
52421 }
52422
52423
52424 SWIGINTERN PyObject *_wrap_LayoutConstraints_top_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52425 PyObject *resultobj = 0;
52426 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52427 wxIndividualLayoutConstraint *result = 0 ;
52428 void *argp1 = 0 ;
52429 int res1 = 0 ;
52430 PyObject *swig_obj[1] ;
52431
52432 if (!args) SWIG_fail;
52433 swig_obj[0] = args;
52434 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52435 if (!SWIG_IsOK(res1)) {
52436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_top_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52437 }
52438 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52439 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
52440 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52441 return resultobj;
52442 fail:
52443 return NULL;
52444 }
52445
52446
52447 SWIGINTERN PyObject *_wrap_LayoutConstraints_right_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52448 PyObject *resultobj = 0;
52449 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52450 wxIndividualLayoutConstraint *result = 0 ;
52451 void *argp1 = 0 ;
52452 int res1 = 0 ;
52453 PyObject *swig_obj[1] ;
52454
52455 if (!args) SWIG_fail;
52456 swig_obj[0] = args;
52457 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52458 if (!SWIG_IsOK(res1)) {
52459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_right_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52460 }
52461 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52462 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
52463 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52464 return resultobj;
52465 fail:
52466 return NULL;
52467 }
52468
52469
52470 SWIGINTERN PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52471 PyObject *resultobj = 0;
52472 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52473 wxIndividualLayoutConstraint *result = 0 ;
52474 void *argp1 = 0 ;
52475 int res1 = 0 ;
52476 PyObject *swig_obj[1] ;
52477
52478 if (!args) SWIG_fail;
52479 swig_obj[0] = args;
52480 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52481 if (!SWIG_IsOK(res1)) {
52482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_bottom_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52483 }
52484 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52485 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
52486 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52487 return resultobj;
52488 fail:
52489 return NULL;
52490 }
52491
52492
52493 SWIGINTERN PyObject *_wrap_LayoutConstraints_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52494 PyObject *resultobj = 0;
52495 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52496 wxIndividualLayoutConstraint *result = 0 ;
52497 void *argp1 = 0 ;
52498 int res1 = 0 ;
52499 PyObject *swig_obj[1] ;
52500
52501 if (!args) SWIG_fail;
52502 swig_obj[0] = args;
52503 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52504 if (!SWIG_IsOK(res1)) {
52505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_width_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52506 }
52507 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52508 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
52509 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52510 return resultobj;
52511 fail:
52512 return NULL;
52513 }
52514
52515
52516 SWIGINTERN PyObject *_wrap_LayoutConstraints_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52517 PyObject *resultobj = 0;
52518 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52519 wxIndividualLayoutConstraint *result = 0 ;
52520 void *argp1 = 0 ;
52521 int res1 = 0 ;
52522 PyObject *swig_obj[1] ;
52523
52524 if (!args) SWIG_fail;
52525 swig_obj[0] = args;
52526 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52527 if (!SWIG_IsOK(res1)) {
52528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_height_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52529 }
52530 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52531 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
52532 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52533 return resultobj;
52534 fail:
52535 return NULL;
52536 }
52537
52538
52539 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52540 PyObject *resultobj = 0;
52541 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52542 wxIndividualLayoutConstraint *result = 0 ;
52543 void *argp1 = 0 ;
52544 int res1 = 0 ;
52545 PyObject *swig_obj[1] ;
52546
52547 if (!args) SWIG_fail;
52548 swig_obj[0] = args;
52549 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52550 if (!SWIG_IsOK(res1)) {
52551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreX_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52552 }
52553 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52554 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
52555 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52556 return resultobj;
52557 fail:
52558 return NULL;
52559 }
52560
52561
52562 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52563 PyObject *resultobj = 0;
52564 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52565 wxIndividualLayoutConstraint *result = 0 ;
52566 void *argp1 = 0 ;
52567 int res1 = 0 ;
52568 PyObject *swig_obj[1] ;
52569
52570 if (!args) SWIG_fail;
52571 swig_obj[0] = args;
52572 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52573 if (!SWIG_IsOK(res1)) {
52574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreY_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52575 }
52576 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52577 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
52578 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52579 return resultobj;
52580 fail:
52581 return NULL;
52582 }
52583
52584
52585 SWIGINTERN PyObject *_wrap_new_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52586 PyObject *resultobj = 0;
52587 wxLayoutConstraints *result = 0 ;
52588
52589 if (!SWIG_Python_UnpackTuple(args,"new_LayoutConstraints",0,0,0)) SWIG_fail;
52590 {
52591 PyThreadState* __tstate = wxPyBeginAllowThreads();
52592 result = (wxLayoutConstraints *)new wxLayoutConstraints();
52593 wxPyEndAllowThreads(__tstate);
52594 if (PyErr_Occurred()) SWIG_fail;
52595 }
52596 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_NEW | 0 );
52597 return resultobj;
52598 fail:
52599 return NULL;
52600 }
52601
52602
52603 SWIGINTERN PyObject *_wrap_delete_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52604 PyObject *resultobj = 0;
52605 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52606 void *argp1 = 0 ;
52607 int res1 = 0 ;
52608 PyObject *swig_obj[1] ;
52609
52610 if (!args) SWIG_fail;
52611 swig_obj[0] = args;
52612 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
52613 if (!SWIG_IsOK(res1)) {
52614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LayoutConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52615 }
52616 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52617 {
52618 PyThreadState* __tstate = wxPyBeginAllowThreads();
52619 delete arg1;
52620
52621 wxPyEndAllowThreads(__tstate);
52622 if (PyErr_Occurred()) SWIG_fail;
52623 }
52624 resultobj = SWIG_Py_Void();
52625 return resultobj;
52626 fail:
52627 return NULL;
52628 }
52629
52630
52631 SWIGINTERN PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52632 PyObject *resultobj = 0;
52633 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52634 wxWindow *arg2 = (wxWindow *) 0 ;
52635 int *arg3 = (int *) 0 ;
52636 bool result;
52637 void *argp1 = 0 ;
52638 int res1 = 0 ;
52639 void *argp2 = 0 ;
52640 int res2 = 0 ;
52641 int temp3 ;
52642 int res3 = SWIG_TMPOBJ ;
52643 PyObject * obj0 = 0 ;
52644 PyObject * obj1 = 0 ;
52645 char * kwnames[] = {
52646 (char *) "self",(char *) "win", NULL
52647 };
52648
52649 arg3 = &temp3;
52650 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
52651 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52652 if (!SWIG_IsOK(res1)) {
52653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52654 }
52655 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52656 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52657 if (!SWIG_IsOK(res2)) {
52658 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "2"" of type '" "wxWindow *""'");
52659 }
52660 arg2 = reinterpret_cast< wxWindow * >(argp2);
52661 {
52662 PyThreadState* __tstate = wxPyBeginAllowThreads();
52663 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
52664 wxPyEndAllowThreads(__tstate);
52665 if (PyErr_Occurred()) SWIG_fail;
52666 }
52667 {
52668 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52669 }
52670 if (SWIG_IsTmpObj(res3)) {
52671 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
52672 } else {
52673 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
52674 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
52675 }
52676 return resultobj;
52677 fail:
52678 return NULL;
52679 }
52680
52681
52682 SWIGINTERN PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52683 PyObject *resultobj = 0;
52684 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52685 bool result;
52686 void *argp1 = 0 ;
52687 int res1 = 0 ;
52688 PyObject *swig_obj[1] ;
52689
52690 if (!args) SWIG_fail;
52691 swig_obj[0] = args;
52692 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52693 if (!SWIG_IsOK(res1)) {
52694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_AreSatisfied" "', expected argument " "1"" of type '" "wxLayoutConstraints const *""'");
52695 }
52696 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52697 {
52698 PyThreadState* __tstate = wxPyBeginAllowThreads();
52699 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
52700 wxPyEndAllowThreads(__tstate);
52701 if (PyErr_Occurred()) SWIG_fail;
52702 }
52703 {
52704 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52705 }
52706 return resultobj;
52707 fail:
52708 return NULL;
52709 }
52710
52711
52712 SWIGINTERN PyObject *LayoutConstraints_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52713 PyObject *obj;
52714 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52715 SWIG_TypeNewClientData(SWIGTYPE_p_wxLayoutConstraints, SWIG_NewClientData(obj));
52716 return SWIG_Py_Void();
52717 }
52718
52719 SWIGINTERN PyObject *LayoutConstraints_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52720 return SWIG_Python_InitShadowInstance(args);
52721 }
52722
52723 static PyMethodDef SwigMethods[] = {
52724 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
52725 { (char *)"Object_GetClassName", (PyCFunction)_wrap_Object_GetClassName, METH_O, NULL},
52726 { (char *)"Object_Destroy", (PyCFunction)_wrap_Object_Destroy, METH_O, NULL},
52727 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
52728 { (char *)"Size_width_set", _wrap_Size_width_set, METH_VARARGS, NULL},
52729 { (char *)"Size_width_get", (PyCFunction)_wrap_Size_width_get, METH_O, NULL},
52730 { (char *)"Size_height_set", _wrap_Size_height_set, METH_VARARGS, NULL},
52731 { (char *)"Size_height_get", (PyCFunction)_wrap_Size_height_get, METH_O, NULL},
52732 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
52733 { (char *)"delete_Size", (PyCFunction)_wrap_delete_Size, METH_O, NULL},
52734 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52735 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52736 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52737 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52738 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
52739 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
52740 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52741 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
52742 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
52743 { (char *)"Size_GetWidth", (PyCFunction)_wrap_Size_GetWidth, METH_O, NULL},
52744 { (char *)"Size_GetHeight", (PyCFunction)_wrap_Size_GetHeight, METH_O, NULL},
52745 { (char *)"Size_IsFullySpecified", (PyCFunction)_wrap_Size_IsFullySpecified, METH_O, NULL},
52746 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
52747 { (char *)"Size_Get", (PyCFunction)_wrap_Size_Get, METH_O, NULL},
52748 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
52749 { (char *)"Size_swiginit", Size_swiginit, METH_VARARGS, NULL},
52750 { (char *)"RealPoint_x_set", _wrap_RealPoint_x_set, METH_VARARGS, NULL},
52751 { (char *)"RealPoint_x_get", (PyCFunction)_wrap_RealPoint_x_get, METH_O, NULL},
52752 { (char *)"RealPoint_y_set", _wrap_RealPoint_y_set, METH_VARARGS, NULL},
52753 { (char *)"RealPoint_y_get", (PyCFunction)_wrap_RealPoint_y_get, METH_O, NULL},
52754 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
52755 { (char *)"delete_RealPoint", (PyCFunction)_wrap_delete_RealPoint, METH_O, NULL},
52756 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52757 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52758 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52759 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52760 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52761 { (char *)"RealPoint_Get", (PyCFunction)_wrap_RealPoint_Get, METH_O, NULL},
52762 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
52763 { (char *)"RealPoint_swiginit", RealPoint_swiginit, METH_VARARGS, NULL},
52764 { (char *)"Point_x_set", _wrap_Point_x_set, METH_VARARGS, NULL},
52765 { (char *)"Point_x_get", (PyCFunction)_wrap_Point_x_get, METH_O, NULL},
52766 { (char *)"Point_y_set", _wrap_Point_y_set, METH_VARARGS, NULL},
52767 { (char *)"Point_y_get", (PyCFunction)_wrap_Point_y_get, METH_O, NULL},
52768 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
52769 { (char *)"delete_Point", (PyCFunction)_wrap_delete_Point, METH_O, NULL},
52770 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52771 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52772 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52773 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52774 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52775 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
52776 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52777 { (char *)"Point_Get", (PyCFunction)_wrap_Point_Get, METH_O, NULL},
52778 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
52779 { (char *)"Point_swiginit", Point_swiginit, METH_VARARGS, NULL},
52780 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
52781 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
52782 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
52783 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
52784 { (char *)"delete_Rect", (PyCFunction)_wrap_delete_Rect, METH_O, NULL},
52785 { (char *)"Rect_GetX", (PyCFunction)_wrap_Rect_GetX, METH_O, NULL},
52786 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
52787 { (char *)"Rect_GetY", (PyCFunction)_wrap_Rect_GetY, METH_O, NULL},
52788 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
52789 { (char *)"Rect_GetWidth", (PyCFunction)_wrap_Rect_GetWidth, METH_O, NULL},
52790 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
52791 { (char *)"Rect_GetHeight", (PyCFunction)_wrap_Rect_GetHeight, METH_O, NULL},
52792 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
52793 { (char *)"Rect_GetPosition", (PyCFunction)_wrap_Rect_GetPosition, METH_O, NULL},
52794 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
52795 { (char *)"Rect_GetSize", (PyCFunction)_wrap_Rect_GetSize, METH_O, NULL},
52796 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
52797 { (char *)"Rect_IsEmpty", (PyCFunction)_wrap_Rect_IsEmpty, METH_O, NULL},
52798 { (char *)"Rect_GetTopLeft", (PyCFunction)_wrap_Rect_GetTopLeft, METH_O, NULL},
52799 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
52800 { (char *)"Rect_GetBottomRight", (PyCFunction)_wrap_Rect_GetBottomRight, METH_O, NULL},
52801 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
52802 { (char *)"Rect_GetLeft", (PyCFunction)_wrap_Rect_GetLeft, METH_O, NULL},
52803 { (char *)"Rect_GetTop", (PyCFunction)_wrap_Rect_GetTop, METH_O, NULL},
52804 { (char *)"Rect_GetBottom", (PyCFunction)_wrap_Rect_GetBottom, METH_O, NULL},
52805 { (char *)"Rect_GetRight", (PyCFunction)_wrap_Rect_GetRight, METH_O, NULL},
52806 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
52807 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
52808 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
52809 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
52810 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
52811 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
52812 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
52813 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
52814 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
52815 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
52816 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52817 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52818 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52819 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52820 { (char *)"Rect_InsideXY", (PyCFunction) _wrap_Rect_InsideXY, METH_VARARGS | METH_KEYWORDS, NULL},
52821 { (char *)"Rect_Inside", (PyCFunction) _wrap_Rect_Inside, METH_VARARGS | METH_KEYWORDS, NULL},
52822 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
52823 { (char *)"Rect_CenterIn", (PyCFunction) _wrap_Rect_CenterIn, METH_VARARGS | METH_KEYWORDS, NULL},
52824 { (char *)"Rect_x_set", _wrap_Rect_x_set, METH_VARARGS, NULL},
52825 { (char *)"Rect_x_get", (PyCFunction)_wrap_Rect_x_get, METH_O, NULL},
52826 { (char *)"Rect_y_set", _wrap_Rect_y_set, METH_VARARGS, NULL},
52827 { (char *)"Rect_y_get", (PyCFunction)_wrap_Rect_y_get, METH_O, NULL},
52828 { (char *)"Rect_width_set", _wrap_Rect_width_set, METH_VARARGS, NULL},
52829 { (char *)"Rect_width_get", (PyCFunction)_wrap_Rect_width_get, METH_O, NULL},
52830 { (char *)"Rect_height_set", _wrap_Rect_height_set, METH_VARARGS, NULL},
52831 { (char *)"Rect_height_get", (PyCFunction)_wrap_Rect_height_get, METH_O, NULL},
52832 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52833 { (char *)"Rect_Get", (PyCFunction)_wrap_Rect_Get, METH_O, NULL},
52834 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
52835 { (char *)"Rect_swiginit", Rect_swiginit, METH_VARARGS, NULL},
52836 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
52837 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
52838 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
52839 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
52840 { (char *)"Point2D_GetFloor", (PyCFunction)_wrap_Point2D_GetFloor, METH_O, NULL},
52841 { (char *)"Point2D_GetRounded", (PyCFunction)_wrap_Point2D_GetRounded, METH_O, NULL},
52842 { (char *)"Point2D_GetVectorLength", (PyCFunction)_wrap_Point2D_GetVectorLength, METH_O, NULL},
52843 { (char *)"Point2D_GetVectorAngle", (PyCFunction)_wrap_Point2D_GetVectorAngle, METH_O, NULL},
52844 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
52845 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
52846 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
52847 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
52848 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
52849 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
52850 { (char *)"Point2D___neg__", (PyCFunction)_wrap_Point2D___neg__, METH_O, NULL},
52851 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52852 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
52853 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
52854 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
52855 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52856 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52857 { (char *)"Point2D_x_set", _wrap_Point2D_x_set, METH_VARARGS, NULL},
52858 { (char *)"Point2D_x_get", (PyCFunction)_wrap_Point2D_x_get, METH_O, NULL},
52859 { (char *)"Point2D_y_set", _wrap_Point2D_y_set, METH_VARARGS, NULL},
52860 { (char *)"Point2D_y_get", (PyCFunction)_wrap_Point2D_y_get, METH_O, NULL},
52861 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52862 { (char *)"Point2D_Get", (PyCFunction)_wrap_Point2D_Get, METH_O, NULL},
52863 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
52864 { (char *)"Point2D_swiginit", Point2D_swiginit, METH_VARARGS, NULL},
52865 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
52866 { (char *)"delete_InputStream", (PyCFunction)_wrap_delete_InputStream, METH_O, NULL},
52867 { (char *)"InputStream_close", (PyCFunction)_wrap_InputStream_close, METH_O, NULL},
52868 { (char *)"InputStream_flush", (PyCFunction)_wrap_InputStream_flush, METH_O, NULL},
52869 { (char *)"InputStream_eof", (PyCFunction)_wrap_InputStream_eof, METH_O, NULL},
52870 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
52871 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
52872 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
52873 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
52874 { (char *)"InputStream_tell", (PyCFunction)_wrap_InputStream_tell, METH_O, NULL},
52875 { (char *)"InputStream_Peek", (PyCFunction)_wrap_InputStream_Peek, METH_O, NULL},
52876 { (char *)"InputStream_GetC", (PyCFunction)_wrap_InputStream_GetC, METH_O, NULL},
52877 { (char *)"InputStream_LastRead", (PyCFunction)_wrap_InputStream_LastRead, METH_O, NULL},
52878 { (char *)"InputStream_CanRead", (PyCFunction)_wrap_InputStream_CanRead, METH_O, NULL},
52879 { (char *)"InputStream_Eof", (PyCFunction)_wrap_InputStream_Eof, METH_O, NULL},
52880 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
52881 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
52882 { (char *)"InputStream_TellI", (PyCFunction)_wrap_InputStream_TellI, METH_O, NULL},
52883 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
52884 { (char *)"InputStream_swiginit", InputStream_swiginit, METH_VARARGS, NULL},
52885 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
52886 { (char *)"OutputStream_LastWrite", (PyCFunction)_wrap_OutputStream_LastWrite, METH_O, NULL},
52887 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
52888 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
52889 { (char *)"delete_FSFile", (PyCFunction)_wrap_delete_FSFile, METH_O, NULL},
52890 { (char *)"FSFile_GetStream", (PyCFunction)_wrap_FSFile_GetStream, METH_O, NULL},
52891 { (char *)"FSFile_GetMimeType", (PyCFunction)_wrap_FSFile_GetMimeType, METH_O, NULL},
52892 { (char *)"FSFile_GetLocation", (PyCFunction)_wrap_FSFile_GetLocation, METH_O, NULL},
52893 { (char *)"FSFile_GetAnchor", (PyCFunction)_wrap_FSFile_GetAnchor, METH_O, NULL},
52894 { (char *)"FSFile_GetModificationTime", (PyCFunction)_wrap_FSFile_GetModificationTime, METH_O, NULL},
52895 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
52896 { (char *)"FSFile_swiginit", FSFile_swiginit, METH_VARARGS, NULL},
52897 { (char *)"delete_CPPFileSystemHandler", (PyCFunction)_wrap_delete_CPPFileSystemHandler, METH_O, NULL},
52898 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
52899 { (char *)"new_FileSystemHandler", (PyCFunction)_wrap_new_FileSystemHandler, METH_NOARGS, NULL},
52900 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
52901 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52902 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52903 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52904 { (char *)"FileSystemHandler_FindNext", (PyCFunction)_wrap_FileSystemHandler_FindNext, METH_O, NULL},
52905 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
52906 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
52907 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
52908 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
52909 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
52910 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
52911 { (char *)"FileSystemHandler_swiginit", FileSystemHandler_swiginit, METH_VARARGS, NULL},
52912 { (char *)"new_FileSystem", (PyCFunction)_wrap_new_FileSystem, METH_NOARGS, NULL},
52913 { (char *)"delete_FileSystem", (PyCFunction)_wrap_delete_FileSystem, METH_O, NULL},
52914 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
52915 { (char *)"FileSystem_GetPath", (PyCFunction)_wrap_FileSystem_GetPath, METH_O, NULL},
52916 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52917 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52918 { (char *)"FileSystem_FindNext", (PyCFunction)_wrap_FileSystem_FindNext, METH_O, NULL},
52919 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52920 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction)_wrap_FileSystem_CleanUpHandlers, METH_NOARGS, NULL},
52921 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
52922 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
52923 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
52924 { (char *)"FileSystem_swiginit", FileSystem_swiginit, METH_VARARGS, NULL},
52925 { (char *)"new_InternetFSHandler", (PyCFunction)_wrap_new_InternetFSHandler, METH_NOARGS, NULL},
52926 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52927 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52928 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
52929 { (char *)"InternetFSHandler_swiginit", InternetFSHandler_swiginit, METH_VARARGS, NULL},
52930 { (char *)"new_ZipFSHandler", (PyCFunction)_wrap_new_ZipFSHandler, METH_NOARGS, NULL},
52931 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52932 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52933 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52934 { (char *)"ZipFSHandler_FindNext", (PyCFunction)_wrap_ZipFSHandler_FindNext, METH_O, NULL},
52935 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
52936 { (char *)"ZipFSHandler_swiginit", ZipFSHandler_swiginit, METH_VARARGS, NULL},
52937 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
52938 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
52939 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
52940 { (char *)"new_MemoryFSHandler", (PyCFunction)_wrap_new_MemoryFSHandler, METH_NOARGS, NULL},
52941 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
52942 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52943 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52944 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52945 { (char *)"MemoryFSHandler_FindNext", (PyCFunction)_wrap_MemoryFSHandler_FindNext, METH_O, NULL},
52946 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
52947 { (char *)"MemoryFSHandler_swiginit", MemoryFSHandler_swiginit, METH_VARARGS, NULL},
52948 { (char *)"ImageHandler_GetName", (PyCFunction)_wrap_ImageHandler_GetName, METH_O, NULL},
52949 { (char *)"ImageHandler_GetExtension", (PyCFunction)_wrap_ImageHandler_GetExtension, METH_O, NULL},
52950 { (char *)"ImageHandler_GetType", (PyCFunction)_wrap_ImageHandler_GetType, METH_O, NULL},
52951 { (char *)"ImageHandler_GetMimeType", (PyCFunction)_wrap_ImageHandler_GetMimeType, METH_O, NULL},
52952 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
52953 { (char *)"ImageHandler_CanReadStream", (PyCFunction) _wrap_ImageHandler_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
52954 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
52955 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
52956 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
52957 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
52958 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
52959 { (char *)"new_PyImageHandler", (PyCFunction)_wrap_new_PyImageHandler, METH_NOARGS, NULL},
52960 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
52961 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
52962 { (char *)"PyImageHandler_swiginit", PyImageHandler_swiginit, METH_VARARGS, NULL},
52963 { (char *)"new_ImageHistogram", (PyCFunction)_wrap_new_ImageHistogram, METH_NOARGS, NULL},
52964 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
52965 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
52966 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
52967 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
52968 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
52969 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
52970 { (char *)"ImageHistogram_swiginit", ImageHistogram_swiginit, METH_VARARGS, NULL},
52971 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
52972 { (char *)"Image_RGBValue_red_set", _wrap_Image_RGBValue_red_set, METH_VARARGS, NULL},
52973 { (char *)"Image_RGBValue_red_get", (PyCFunction)_wrap_Image_RGBValue_red_get, METH_O, NULL},
52974 { (char *)"Image_RGBValue_green_set", _wrap_Image_RGBValue_green_set, METH_VARARGS, NULL},
52975 { (char *)"Image_RGBValue_green_get", (PyCFunction)_wrap_Image_RGBValue_green_get, METH_O, NULL},
52976 { (char *)"Image_RGBValue_blue_set", _wrap_Image_RGBValue_blue_set, METH_VARARGS, NULL},
52977 { (char *)"Image_RGBValue_blue_get", (PyCFunction)_wrap_Image_RGBValue_blue_get, METH_O, NULL},
52978 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
52979 { (char *)"Image_RGBValue_swiginit", Image_RGBValue_swiginit, METH_VARARGS, NULL},
52980 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
52981 { (char *)"Image_HSVValue_hue_set", _wrap_Image_HSVValue_hue_set, METH_VARARGS, NULL},
52982 { (char *)"Image_HSVValue_hue_get", (PyCFunction)_wrap_Image_HSVValue_hue_get, METH_O, NULL},
52983 { (char *)"Image_HSVValue_saturation_set", _wrap_Image_HSVValue_saturation_set, METH_VARARGS, NULL},
52984 { (char *)"Image_HSVValue_saturation_get", (PyCFunction)_wrap_Image_HSVValue_saturation_get, METH_O, NULL},
52985 { (char *)"Image_HSVValue_value_set", _wrap_Image_HSVValue_value_set, METH_VARARGS, NULL},
52986 { (char *)"Image_HSVValue_value_get", (PyCFunction)_wrap_Image_HSVValue_value_get, METH_O, NULL},
52987 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
52988 { (char *)"Image_HSVValue_swiginit", Image_HSVValue_swiginit, METH_VARARGS, NULL},
52989 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
52990 { (char *)"delete_Image", (PyCFunction)_wrap_delete_Image, METH_O, NULL},
52991 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
52992 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
52993 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
52994 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
52995 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
52996 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
52997 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
52998 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
52999 { (char *)"Image_Destroy", (PyCFunction)_wrap_Image_Destroy, METH_O, NULL},
53000 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
53001 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
53002 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
53003 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
53004 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
53005 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
53006 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
53007 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
53008 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
53009 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
53010 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
53011 { (char *)"Image_HasAlpha", (PyCFunction)_wrap_Image_HasAlpha, METH_O, NULL},
53012 { (char *)"Image_InitAlpha", (PyCFunction)_wrap_Image_InitAlpha, METH_O, NULL},
53013 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
53014 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
53015 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
53016 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
53017 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
53018 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
53019 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
53020 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
53021 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
53022 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
53023 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
53024 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
53025 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
53026 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
53027 { (char *)"Image_Ok", (PyCFunction)_wrap_Image_Ok, METH_O, NULL},
53028 { (char *)"Image_GetWidth", (PyCFunction)_wrap_Image_GetWidth, METH_O, NULL},
53029 { (char *)"Image_GetHeight", (PyCFunction)_wrap_Image_GetHeight, METH_O, NULL},
53030 { (char *)"Image_GetSize", (PyCFunction)_wrap_Image_GetSize, METH_O, NULL},
53031 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
53032 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
53033 { (char *)"Image_Copy", (PyCFunction)_wrap_Image_Copy, METH_O, NULL},
53034 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
53035 { (char *)"Image_GetData", (PyCFunction)_wrap_Image_GetData, METH_O, NULL},
53036 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
53037 { (char *)"Image_GetDataBuffer", (PyCFunction)_wrap_Image_GetDataBuffer, METH_O, NULL},
53038 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
53039 { (char *)"Image_GetAlphaData", (PyCFunction)_wrap_Image_GetAlphaData, METH_O, NULL},
53040 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
53041 { (char *)"Image_GetAlphaBuffer", (PyCFunction)_wrap_Image_GetAlphaBuffer, METH_O, NULL},
53042 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
53043 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
53044 { (char *)"Image_GetOrFindMaskColour", (PyCFunction)_wrap_Image_GetOrFindMaskColour, METH_O, NULL},
53045 { (char *)"Image_GetMaskRed", (PyCFunction)_wrap_Image_GetMaskRed, METH_O, NULL},
53046 { (char *)"Image_GetMaskGreen", (PyCFunction)_wrap_Image_GetMaskGreen, METH_O, NULL},
53047 { (char *)"Image_GetMaskBlue", (PyCFunction)_wrap_Image_GetMaskBlue, METH_O, NULL},
53048 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
53049 { (char *)"Image_HasMask", (PyCFunction)_wrap_Image_HasMask, METH_O, NULL},
53050 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
53051 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
53052 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
53053 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
53054 { (char *)"Image_ConvertToGreyscale", (PyCFunction) _wrap_Image_ConvertToGreyscale, METH_VARARGS | METH_KEYWORDS, NULL},
53055 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
53056 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
53057 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
53058 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
53059 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
53060 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
53061 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
53062 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
53063 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53064 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53065 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53066 { (char *)"Image_GetHandlers", (PyCFunction)_wrap_Image_GetHandlers, METH_NOARGS, NULL},
53067 { (char *)"Image_GetImageExtWildcard", (PyCFunction)_wrap_Image_GetImageExtWildcard, METH_NOARGS, NULL},
53068 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53069 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53070 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
53071 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
53072 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
53073 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
53074 { (char *)"Image_swiginit", Image_swiginit, METH_VARARGS, NULL},
53075 { (char *)"new_BMPHandler", (PyCFunction)_wrap_new_BMPHandler, METH_NOARGS, NULL},
53076 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
53077 { (char *)"BMPHandler_swiginit", BMPHandler_swiginit, METH_VARARGS, NULL},
53078 { (char *)"new_ICOHandler", (PyCFunction)_wrap_new_ICOHandler, METH_NOARGS, NULL},
53079 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
53080 { (char *)"ICOHandler_swiginit", ICOHandler_swiginit, METH_VARARGS, NULL},
53081 { (char *)"new_CURHandler", (PyCFunction)_wrap_new_CURHandler, METH_NOARGS, NULL},
53082 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
53083 { (char *)"CURHandler_swiginit", CURHandler_swiginit, METH_VARARGS, NULL},
53084 { (char *)"new_ANIHandler", (PyCFunction)_wrap_new_ANIHandler, METH_NOARGS, NULL},
53085 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
53086 { (char *)"ANIHandler_swiginit", ANIHandler_swiginit, METH_VARARGS, NULL},
53087 { (char *)"new_PNGHandler", (PyCFunction)_wrap_new_PNGHandler, METH_NOARGS, NULL},
53088 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
53089 { (char *)"PNGHandler_swiginit", PNGHandler_swiginit, METH_VARARGS, NULL},
53090 { (char *)"new_GIFHandler", (PyCFunction)_wrap_new_GIFHandler, METH_NOARGS, NULL},
53091 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
53092 { (char *)"GIFHandler_swiginit", GIFHandler_swiginit, METH_VARARGS, NULL},
53093 { (char *)"new_PCXHandler", (PyCFunction)_wrap_new_PCXHandler, METH_NOARGS, NULL},
53094 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
53095 { (char *)"PCXHandler_swiginit", PCXHandler_swiginit, METH_VARARGS, NULL},
53096 { (char *)"new_JPEGHandler", (PyCFunction)_wrap_new_JPEGHandler, METH_NOARGS, NULL},
53097 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
53098 { (char *)"JPEGHandler_swiginit", JPEGHandler_swiginit, METH_VARARGS, NULL},
53099 { (char *)"new_PNMHandler", (PyCFunction)_wrap_new_PNMHandler, METH_NOARGS, NULL},
53100 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
53101 { (char *)"PNMHandler_swiginit", PNMHandler_swiginit, METH_VARARGS, NULL},
53102 { (char *)"new_XPMHandler", (PyCFunction)_wrap_new_XPMHandler, METH_NOARGS, NULL},
53103 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
53104 { (char *)"XPMHandler_swiginit", XPMHandler_swiginit, METH_VARARGS, NULL},
53105 { (char *)"new_TIFFHandler", (PyCFunction)_wrap_new_TIFFHandler, METH_NOARGS, NULL},
53106 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
53107 { (char *)"TIFFHandler_swiginit", TIFFHandler_swiginit, METH_VARARGS, NULL},
53108 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
53109 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
53110 { (char *)"new_EvtHandler", (PyCFunction)_wrap_new_EvtHandler, METH_NOARGS, NULL},
53111 { (char *)"EvtHandler_GetNextHandler", (PyCFunction)_wrap_EvtHandler_GetNextHandler, METH_O, NULL},
53112 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction)_wrap_EvtHandler_GetPreviousHandler, METH_O, NULL},
53113 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53114 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53115 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction)_wrap_EvtHandler_GetEvtHandlerEnabled, METH_O, NULL},
53116 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53117 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53118 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53119 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction)_wrap_EvtHandler_ProcessPendingEvents, METH_O, NULL},
53120 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
53121 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
53122 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53123 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
53124 { (char *)"EvtHandler_swiginit", EvtHandler_swiginit, METH_VARARGS, NULL},
53125 { (char *)"NewEventType", (PyCFunction)_wrap_NewEventType, METH_NOARGS, NULL},
53126 { (char *)"delete_Event", (PyCFunction)_wrap_delete_Event, METH_O, NULL},
53127 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
53128 { (char *)"Event_GetEventType", (PyCFunction)_wrap_Event_GetEventType, METH_O, NULL},
53129 { (char *)"Event_GetEventObject", (PyCFunction)_wrap_Event_GetEventObject, METH_O, NULL},
53130 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
53131 { (char *)"Event_GetTimestamp", (PyCFunction)_wrap_Event_GetTimestamp, METH_O, NULL},
53132 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
53133 { (char *)"Event_GetId", (PyCFunction)_wrap_Event_GetId, METH_O, NULL},
53134 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53135 { (char *)"Event_IsCommandEvent", (PyCFunction)_wrap_Event_IsCommandEvent, METH_O, NULL},
53136 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
53137 { (char *)"Event_GetSkipped", (PyCFunction)_wrap_Event_GetSkipped, METH_O, NULL},
53138 { (char *)"Event_ShouldPropagate", (PyCFunction)_wrap_Event_ShouldPropagate, METH_O, NULL},
53139 { (char *)"Event_StopPropagation", (PyCFunction)_wrap_Event_StopPropagation, METH_O, NULL},
53140 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
53141 { (char *)"Event_Clone", (PyCFunction)_wrap_Event_Clone, METH_O, NULL},
53142 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
53143 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
53144 { (char *)"delete_PropagationDisabler", (PyCFunction)_wrap_delete_PropagationDisabler, METH_O, NULL},
53145 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
53146 { (char *)"PropagationDisabler_swiginit", PropagationDisabler_swiginit, METH_VARARGS, NULL},
53147 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
53148 { (char *)"delete_PropagateOnce", (PyCFunction)_wrap_delete_PropagateOnce, METH_O, NULL},
53149 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
53150 { (char *)"PropagateOnce_swiginit", PropagateOnce_swiginit, METH_VARARGS, NULL},
53151 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53152 { (char *)"CommandEvent_GetSelection", (PyCFunction)_wrap_CommandEvent_GetSelection, METH_O, NULL},
53153 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
53154 { (char *)"CommandEvent_GetString", (PyCFunction)_wrap_CommandEvent_GetString, METH_O, NULL},
53155 { (char *)"CommandEvent_IsChecked", (PyCFunction)_wrap_CommandEvent_IsChecked, METH_O, NULL},
53156 { (char *)"CommandEvent_IsSelection", (PyCFunction)_wrap_CommandEvent_IsSelection, METH_O, NULL},
53157 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
53158 { (char *)"CommandEvent_GetExtraLong", (PyCFunction)_wrap_CommandEvent_GetExtraLong, METH_O, NULL},
53159 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
53160 { (char *)"CommandEvent_GetInt", (PyCFunction)_wrap_CommandEvent_GetInt, METH_O, NULL},
53161 { (char *)"CommandEvent_GetClientData", (PyCFunction)_wrap_CommandEvent_GetClientData, METH_O, NULL},
53162 { (char *)"CommandEvent_SetClientData", (PyCFunction) _wrap_CommandEvent_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
53163 { (char *)"CommandEvent_Clone", (PyCFunction)_wrap_CommandEvent_Clone, METH_O, NULL},
53164 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
53165 { (char *)"CommandEvent_swiginit", CommandEvent_swiginit, METH_VARARGS, NULL},
53166 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53167 { (char *)"NotifyEvent_Veto", (PyCFunction)_wrap_NotifyEvent_Veto, METH_O, NULL},
53168 { (char *)"NotifyEvent_Allow", (PyCFunction)_wrap_NotifyEvent_Allow, METH_O, NULL},
53169 { (char *)"NotifyEvent_IsAllowed", (PyCFunction)_wrap_NotifyEvent_IsAllowed, METH_O, NULL},
53170 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
53171 { (char *)"NotifyEvent_swiginit", NotifyEvent_swiginit, METH_VARARGS, NULL},
53172 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53173 { (char *)"ScrollEvent_GetOrientation", (PyCFunction)_wrap_ScrollEvent_GetOrientation, METH_O, NULL},
53174 { (char *)"ScrollEvent_GetPosition", (PyCFunction)_wrap_ScrollEvent_GetPosition, METH_O, NULL},
53175 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
53176 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53177 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
53178 { (char *)"ScrollEvent_swiginit", ScrollEvent_swiginit, METH_VARARGS, NULL},
53179 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53180 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction)_wrap_ScrollWinEvent_GetOrientation, METH_O, NULL},
53181 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction)_wrap_ScrollWinEvent_GetPosition, METH_O, NULL},
53182 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
53183 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53184 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
53185 { (char *)"ScrollWinEvent_swiginit", ScrollWinEvent_swiginit, METH_VARARGS, NULL},
53186 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53187 { (char *)"MouseEvent_IsButton", (PyCFunction)_wrap_MouseEvent_IsButton, METH_O, NULL},
53188 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
53189 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
53190 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
53191 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
53192 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
53193 { (char *)"MouseEvent_GetButton", (PyCFunction)_wrap_MouseEvent_GetButton, METH_O, NULL},
53194 { (char *)"MouseEvent_ControlDown", (PyCFunction)_wrap_MouseEvent_ControlDown, METH_O, NULL},
53195 { (char *)"MouseEvent_MetaDown", (PyCFunction)_wrap_MouseEvent_MetaDown, METH_O, NULL},
53196 { (char *)"MouseEvent_AltDown", (PyCFunction)_wrap_MouseEvent_AltDown, METH_O, NULL},
53197 { (char *)"MouseEvent_ShiftDown", (PyCFunction)_wrap_MouseEvent_ShiftDown, METH_O, NULL},
53198 { (char *)"MouseEvent_CmdDown", (PyCFunction)_wrap_MouseEvent_CmdDown, METH_O, NULL},
53199 { (char *)"MouseEvent_LeftDown", (PyCFunction)_wrap_MouseEvent_LeftDown, METH_O, NULL},
53200 { (char *)"MouseEvent_MiddleDown", (PyCFunction)_wrap_MouseEvent_MiddleDown, METH_O, NULL},
53201 { (char *)"MouseEvent_RightDown", (PyCFunction)_wrap_MouseEvent_RightDown, METH_O, NULL},
53202 { (char *)"MouseEvent_LeftUp", (PyCFunction)_wrap_MouseEvent_LeftUp, METH_O, NULL},
53203 { (char *)"MouseEvent_MiddleUp", (PyCFunction)_wrap_MouseEvent_MiddleUp, METH_O, NULL},
53204 { (char *)"MouseEvent_RightUp", (PyCFunction)_wrap_MouseEvent_RightUp, METH_O, NULL},
53205 { (char *)"MouseEvent_LeftDClick", (PyCFunction)_wrap_MouseEvent_LeftDClick, METH_O, NULL},
53206 { (char *)"MouseEvent_MiddleDClick", (PyCFunction)_wrap_MouseEvent_MiddleDClick, METH_O, NULL},
53207 { (char *)"MouseEvent_RightDClick", (PyCFunction)_wrap_MouseEvent_RightDClick, METH_O, NULL},
53208 { (char *)"MouseEvent_LeftIsDown", (PyCFunction)_wrap_MouseEvent_LeftIsDown, METH_O, NULL},
53209 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction)_wrap_MouseEvent_MiddleIsDown, METH_O, NULL},
53210 { (char *)"MouseEvent_RightIsDown", (PyCFunction)_wrap_MouseEvent_RightIsDown, METH_O, NULL},
53211 { (char *)"MouseEvent_Dragging", (PyCFunction)_wrap_MouseEvent_Dragging, METH_O, NULL},
53212 { (char *)"MouseEvent_Moving", (PyCFunction)_wrap_MouseEvent_Moving, METH_O, NULL},
53213 { (char *)"MouseEvent_Entering", (PyCFunction)_wrap_MouseEvent_Entering, METH_O, NULL},
53214 { (char *)"MouseEvent_Leaving", (PyCFunction)_wrap_MouseEvent_Leaving, METH_O, NULL},
53215 { (char *)"MouseEvent_GetPosition", (PyCFunction)_wrap_MouseEvent_GetPosition, METH_O, NULL},
53216 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction)_wrap_MouseEvent_GetPositionTuple, METH_O, NULL},
53217 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53218 { (char *)"MouseEvent_GetX", (PyCFunction)_wrap_MouseEvent_GetX, METH_O, NULL},
53219 { (char *)"MouseEvent_GetY", (PyCFunction)_wrap_MouseEvent_GetY, METH_O, NULL},
53220 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction)_wrap_MouseEvent_GetWheelRotation, METH_O, NULL},
53221 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction)_wrap_MouseEvent_GetWheelDelta, METH_O, NULL},
53222 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction)_wrap_MouseEvent_GetLinesPerAction, METH_O, NULL},
53223 { (char *)"MouseEvent_IsPageScroll", (PyCFunction)_wrap_MouseEvent_IsPageScroll, METH_O, NULL},
53224 { (char *)"MouseEvent_m_x_set", _wrap_MouseEvent_m_x_set, METH_VARARGS, NULL},
53225 { (char *)"MouseEvent_m_x_get", (PyCFunction)_wrap_MouseEvent_m_x_get, METH_O, NULL},
53226 { (char *)"MouseEvent_m_y_set", _wrap_MouseEvent_m_y_set, METH_VARARGS, NULL},
53227 { (char *)"MouseEvent_m_y_get", (PyCFunction)_wrap_MouseEvent_m_y_get, METH_O, NULL},
53228 { (char *)"MouseEvent_m_leftDown_set", _wrap_MouseEvent_m_leftDown_set, METH_VARARGS, NULL},
53229 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction)_wrap_MouseEvent_m_leftDown_get, METH_O, NULL},
53230 { (char *)"MouseEvent_m_middleDown_set", _wrap_MouseEvent_m_middleDown_set, METH_VARARGS, NULL},
53231 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction)_wrap_MouseEvent_m_middleDown_get, METH_O, NULL},
53232 { (char *)"MouseEvent_m_rightDown_set", _wrap_MouseEvent_m_rightDown_set, METH_VARARGS, NULL},
53233 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction)_wrap_MouseEvent_m_rightDown_get, METH_O, NULL},
53234 { (char *)"MouseEvent_m_controlDown_set", _wrap_MouseEvent_m_controlDown_set, METH_VARARGS, NULL},
53235 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction)_wrap_MouseEvent_m_controlDown_get, METH_O, NULL},
53236 { (char *)"MouseEvent_m_shiftDown_set", _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS, NULL},
53237 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction)_wrap_MouseEvent_m_shiftDown_get, METH_O, NULL},
53238 { (char *)"MouseEvent_m_altDown_set", _wrap_MouseEvent_m_altDown_set, METH_VARARGS, NULL},
53239 { (char *)"MouseEvent_m_altDown_get", (PyCFunction)_wrap_MouseEvent_m_altDown_get, METH_O, NULL},
53240 { (char *)"MouseEvent_m_metaDown_set", _wrap_MouseEvent_m_metaDown_set, METH_VARARGS, NULL},
53241 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction)_wrap_MouseEvent_m_metaDown_get, METH_O, NULL},
53242 { (char *)"MouseEvent_m_wheelRotation_set", _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS, NULL},
53243 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction)_wrap_MouseEvent_m_wheelRotation_get, METH_O, NULL},
53244 { (char *)"MouseEvent_m_wheelDelta_set", _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS, NULL},
53245 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction)_wrap_MouseEvent_m_wheelDelta_get, METH_O, NULL},
53246 { (char *)"MouseEvent_m_linesPerAction_set", _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS, NULL},
53247 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction)_wrap_MouseEvent_m_linesPerAction_get, METH_O, NULL},
53248 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
53249 { (char *)"MouseEvent_swiginit", MouseEvent_swiginit, METH_VARARGS, NULL},
53250 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53251 { (char *)"SetCursorEvent_GetX", (PyCFunction)_wrap_SetCursorEvent_GetX, METH_O, NULL},
53252 { (char *)"SetCursorEvent_GetY", (PyCFunction)_wrap_SetCursorEvent_GetY, METH_O, NULL},
53253 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
53254 { (char *)"SetCursorEvent_GetCursor", (PyCFunction)_wrap_SetCursorEvent_GetCursor, METH_O, NULL},
53255 { (char *)"SetCursorEvent_HasCursor", (PyCFunction)_wrap_SetCursorEvent_HasCursor, METH_O, NULL},
53256 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
53257 { (char *)"SetCursorEvent_swiginit", SetCursorEvent_swiginit, METH_VARARGS, NULL},
53258 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53259 { (char *)"KeyEvent_GetModifiers", (PyCFunction)_wrap_KeyEvent_GetModifiers, METH_O, NULL},
53260 { (char *)"KeyEvent_ControlDown", (PyCFunction)_wrap_KeyEvent_ControlDown, METH_O, NULL},
53261 { (char *)"KeyEvent_MetaDown", (PyCFunction)_wrap_KeyEvent_MetaDown, METH_O, NULL},
53262 { (char *)"KeyEvent_AltDown", (PyCFunction)_wrap_KeyEvent_AltDown, METH_O, NULL},
53263 { (char *)"KeyEvent_ShiftDown", (PyCFunction)_wrap_KeyEvent_ShiftDown, METH_O, NULL},
53264 { (char *)"KeyEvent_CmdDown", (PyCFunction)_wrap_KeyEvent_CmdDown, METH_O, NULL},
53265 { (char *)"KeyEvent_HasModifiers", (PyCFunction)_wrap_KeyEvent_HasModifiers, METH_O, NULL},
53266 { (char *)"KeyEvent_GetKeyCode", (PyCFunction)_wrap_KeyEvent_GetKeyCode, METH_O, NULL},
53267 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction)_wrap_KeyEvent_GetUnicodeKey, METH_O, NULL},
53268 { (char *)"KeyEvent_SetUnicodeKey", (PyCFunction) _wrap_KeyEvent_SetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
53269 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction)_wrap_KeyEvent_GetRawKeyCode, METH_O, NULL},
53270 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction)_wrap_KeyEvent_GetRawKeyFlags, METH_O, NULL},
53271 { (char *)"KeyEvent_GetPosition", (PyCFunction)_wrap_KeyEvent_GetPosition, METH_O, NULL},
53272 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction)_wrap_KeyEvent_GetPositionTuple, METH_O, NULL},
53273 { (char *)"KeyEvent_GetX", (PyCFunction)_wrap_KeyEvent_GetX, METH_O, NULL},
53274 { (char *)"KeyEvent_GetY", (PyCFunction)_wrap_KeyEvent_GetY, METH_O, NULL},
53275 { (char *)"KeyEvent_m_x_set", _wrap_KeyEvent_m_x_set, METH_VARARGS, NULL},
53276 { (char *)"KeyEvent_m_x_get", (PyCFunction)_wrap_KeyEvent_m_x_get, METH_O, NULL},
53277 { (char *)"KeyEvent_m_y_set", _wrap_KeyEvent_m_y_set, METH_VARARGS, NULL},
53278 { (char *)"KeyEvent_m_y_get", (PyCFunction)_wrap_KeyEvent_m_y_get, METH_O, NULL},
53279 { (char *)"KeyEvent_m_keyCode_set", _wrap_KeyEvent_m_keyCode_set, METH_VARARGS, NULL},
53280 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction)_wrap_KeyEvent_m_keyCode_get, METH_O, NULL},
53281 { (char *)"KeyEvent_m_controlDown_set", _wrap_KeyEvent_m_controlDown_set, METH_VARARGS, NULL},
53282 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction)_wrap_KeyEvent_m_controlDown_get, METH_O, NULL},
53283 { (char *)"KeyEvent_m_shiftDown_set", _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS, NULL},
53284 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction)_wrap_KeyEvent_m_shiftDown_get, METH_O, NULL},
53285 { (char *)"KeyEvent_m_altDown_set", _wrap_KeyEvent_m_altDown_set, METH_VARARGS, NULL},
53286 { (char *)"KeyEvent_m_altDown_get", (PyCFunction)_wrap_KeyEvent_m_altDown_get, METH_O, NULL},
53287 { (char *)"KeyEvent_m_metaDown_set", _wrap_KeyEvent_m_metaDown_set, METH_VARARGS, NULL},
53288 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction)_wrap_KeyEvent_m_metaDown_get, METH_O, NULL},
53289 { (char *)"KeyEvent_m_scanCode_set", _wrap_KeyEvent_m_scanCode_set, METH_VARARGS, NULL},
53290 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction)_wrap_KeyEvent_m_scanCode_get, METH_O, NULL},
53291 { (char *)"KeyEvent_m_rawCode_set", _wrap_KeyEvent_m_rawCode_set, METH_VARARGS, NULL},
53292 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction)_wrap_KeyEvent_m_rawCode_get, METH_O, NULL},
53293 { (char *)"KeyEvent_m_rawFlags_set", _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS, NULL},
53294 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction)_wrap_KeyEvent_m_rawFlags_get, METH_O, NULL},
53295 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
53296 { (char *)"KeyEvent_swiginit", KeyEvent_swiginit, METH_VARARGS, NULL},
53297 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53298 { (char *)"SizeEvent_GetSize", (PyCFunction)_wrap_SizeEvent_GetSize, METH_O, NULL},
53299 { (char *)"SizeEvent_GetRect", (PyCFunction)_wrap_SizeEvent_GetRect, METH_O, NULL},
53300 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53301 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
53302 { (char *)"SizeEvent_m_size_set", _wrap_SizeEvent_m_size_set, METH_VARARGS, NULL},
53303 { (char *)"SizeEvent_m_size_get", (PyCFunction)_wrap_SizeEvent_m_size_get, METH_O, NULL},
53304 { (char *)"SizeEvent_m_rect_set", _wrap_SizeEvent_m_rect_set, METH_VARARGS, NULL},
53305 { (char *)"SizeEvent_m_rect_get", (PyCFunction)_wrap_SizeEvent_m_rect_get, METH_O, NULL},
53306 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
53307 { (char *)"SizeEvent_swiginit", SizeEvent_swiginit, METH_VARARGS, NULL},
53308 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53309 { (char *)"MoveEvent_GetPosition", (PyCFunction)_wrap_MoveEvent_GetPosition, METH_O, NULL},
53310 { (char *)"MoveEvent_GetRect", (PyCFunction)_wrap_MoveEvent_GetRect, METH_O, NULL},
53311 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53312 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53313 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
53314 { (char *)"MoveEvent_swiginit", MoveEvent_swiginit, METH_VARARGS, NULL},
53315 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53316 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
53317 { (char *)"PaintEvent_swiginit", PaintEvent_swiginit, METH_VARARGS, NULL},
53318 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53319 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
53320 { (char *)"NcPaintEvent_swiginit", NcPaintEvent_swiginit, METH_VARARGS, NULL},
53321 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53322 { (char *)"EraseEvent_GetDC", (PyCFunction)_wrap_EraseEvent_GetDC, METH_O, NULL},
53323 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
53324 { (char *)"EraseEvent_swiginit", EraseEvent_swiginit, METH_VARARGS, NULL},
53325 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53326 { (char *)"FocusEvent_GetWindow", (PyCFunction)_wrap_FocusEvent_GetWindow, METH_O, NULL},
53327 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53328 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
53329 { (char *)"FocusEvent_swiginit", FocusEvent_swiginit, METH_VARARGS, NULL},
53330 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53331 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction)_wrap_ChildFocusEvent_GetWindow, METH_O, NULL},
53332 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
53333 { (char *)"ChildFocusEvent_swiginit", ChildFocusEvent_swiginit, METH_VARARGS, NULL},
53334 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53335 { (char *)"ActivateEvent_GetActive", (PyCFunction)_wrap_ActivateEvent_GetActive, METH_O, NULL},
53336 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
53337 { (char *)"ActivateEvent_swiginit", ActivateEvent_swiginit, METH_VARARGS, NULL},
53338 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53339 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
53340 { (char *)"InitDialogEvent_swiginit", InitDialogEvent_swiginit, METH_VARARGS, NULL},
53341 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53342 { (char *)"MenuEvent_GetMenuId", (PyCFunction)_wrap_MenuEvent_GetMenuId, METH_O, NULL},
53343 { (char *)"MenuEvent_IsPopup", (PyCFunction)_wrap_MenuEvent_IsPopup, METH_O, NULL},
53344 { (char *)"MenuEvent_GetMenu", (PyCFunction)_wrap_MenuEvent_GetMenu, METH_O, NULL},
53345 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
53346 { (char *)"MenuEvent_swiginit", MenuEvent_swiginit, METH_VARARGS, NULL},
53347 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53348 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
53349 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction)_wrap_CloseEvent_GetLoggingOff, METH_O, NULL},
53350 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
53351 { (char *)"CloseEvent_GetVeto", (PyCFunction)_wrap_CloseEvent_GetVeto, METH_O, NULL},
53352 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
53353 { (char *)"CloseEvent_CanVeto", (PyCFunction)_wrap_CloseEvent_CanVeto, METH_O, NULL},
53354 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
53355 { (char *)"CloseEvent_swiginit", CloseEvent_swiginit, METH_VARARGS, NULL},
53356 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53357 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
53358 { (char *)"ShowEvent_GetShow", (PyCFunction)_wrap_ShowEvent_GetShow, METH_O, NULL},
53359 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
53360 { (char *)"ShowEvent_swiginit", ShowEvent_swiginit, METH_VARARGS, NULL},
53361 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53362 { (char *)"IconizeEvent_Iconized", (PyCFunction)_wrap_IconizeEvent_Iconized, METH_O, NULL},
53363 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
53364 { (char *)"IconizeEvent_swiginit", IconizeEvent_swiginit, METH_VARARGS, NULL},
53365 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53366 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
53367 { (char *)"MaximizeEvent_swiginit", MaximizeEvent_swiginit, METH_VARARGS, NULL},
53368 { (char *)"DropFilesEvent_GetPosition", (PyCFunction)_wrap_DropFilesEvent_GetPosition, METH_O, NULL},
53369 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction)_wrap_DropFilesEvent_GetNumberOfFiles, METH_O, NULL},
53370 { (char *)"DropFilesEvent_GetFiles", (PyCFunction)_wrap_DropFilesEvent_GetFiles, METH_O, NULL},
53371 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
53372 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53373 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetChecked, METH_O, NULL},
53374 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetEnabled, METH_O, NULL},
53375 { (char *)"UpdateUIEvent_GetShown", (PyCFunction)_wrap_UpdateUIEvent_GetShown, METH_O, NULL},
53376 { (char *)"UpdateUIEvent_GetText", (PyCFunction)_wrap_UpdateUIEvent_GetText, METH_O, NULL},
53377 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction)_wrap_UpdateUIEvent_GetSetText, METH_O, NULL},
53378 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetSetChecked, METH_O, NULL},
53379 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetSetEnabled, METH_O, NULL},
53380 { (char *)"UpdateUIEvent_GetSetShown", (PyCFunction)_wrap_UpdateUIEvent_GetSetShown, METH_O, NULL},
53381 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53382 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53383 { (char *)"UpdateUIEvent_Show", (PyCFunction) _wrap_UpdateUIEvent_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53384 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
53385 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
53386 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction)_wrap_UpdateUIEvent_GetUpdateInterval, METH_NOARGS, NULL},
53387 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
53388 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction)_wrap_UpdateUIEvent_ResetUpdateTime, METH_NOARGS, NULL},
53389 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
53390 { (char *)"UpdateUIEvent_GetMode", (PyCFunction)_wrap_UpdateUIEvent_GetMode, METH_NOARGS, NULL},
53391 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
53392 { (char *)"UpdateUIEvent_swiginit", UpdateUIEvent_swiginit, METH_VARARGS, NULL},
53393 { (char *)"new_SysColourChangedEvent", (PyCFunction)_wrap_new_SysColourChangedEvent, METH_NOARGS, NULL},
53394 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
53395 { (char *)"SysColourChangedEvent_swiginit", SysColourChangedEvent_swiginit, METH_VARARGS, NULL},
53396 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53397 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction)_wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_O, NULL},
53398 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
53399 { (char *)"MouseCaptureChangedEvent_swiginit", MouseCaptureChangedEvent_swiginit, METH_VARARGS, NULL},
53400 { (char *)"new_DisplayChangedEvent", (PyCFunction)_wrap_new_DisplayChangedEvent, METH_NOARGS, NULL},
53401 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
53402 { (char *)"DisplayChangedEvent_swiginit", DisplayChangedEvent_swiginit, METH_VARARGS, NULL},
53403 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53404 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53405 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction)_wrap_PaletteChangedEvent_GetChangedWindow, METH_O, NULL},
53406 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
53407 { (char *)"PaletteChangedEvent_swiginit", PaletteChangedEvent_swiginit, METH_VARARGS, NULL},
53408 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53409 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
53410 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction)_wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_O, NULL},
53411 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
53412 { (char *)"QueryNewPaletteEvent_swiginit", QueryNewPaletteEvent_swiginit, METH_VARARGS, NULL},
53413 { (char *)"new_NavigationKeyEvent", (PyCFunction)_wrap_new_NavigationKeyEvent, METH_NOARGS, NULL},
53414 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction)_wrap_NavigationKeyEvent_GetDirection, METH_O, NULL},
53415 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
53416 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction)_wrap_NavigationKeyEvent_IsWindowChange, METH_O, NULL},
53417 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
53418 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction)_wrap_NavigationKeyEvent_IsFromTab, METH_O, NULL},
53419 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
53420 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
53421 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction)_wrap_NavigationKeyEvent_GetCurrentFocus, METH_O, NULL},
53422 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
53423 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
53424 { (char *)"NavigationKeyEvent_swiginit", NavigationKeyEvent_swiginit, METH_VARARGS, NULL},
53425 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53426 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction)_wrap_WindowCreateEvent_GetWindow, METH_O, NULL},
53427 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
53428 { (char *)"WindowCreateEvent_swiginit", WindowCreateEvent_swiginit, METH_VARARGS, NULL},
53429 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53430 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction)_wrap_WindowDestroyEvent_GetWindow, METH_O, NULL},
53431 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
53432 { (char *)"WindowDestroyEvent_swiginit", WindowDestroyEvent_swiginit, METH_VARARGS, NULL},
53433 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53434 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction)_wrap_ContextMenuEvent_GetPosition, METH_O, NULL},
53435 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53436 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
53437 { (char *)"ContextMenuEvent_swiginit", ContextMenuEvent_swiginit, METH_VARARGS, NULL},
53438 { (char *)"new_IdleEvent", (PyCFunction)_wrap_new_IdleEvent, METH_NOARGS, NULL},
53439 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
53440 { (char *)"IdleEvent_MoreRequested", (PyCFunction)_wrap_IdleEvent_MoreRequested, METH_O, NULL},
53441 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
53442 { (char *)"IdleEvent_GetMode", (PyCFunction)_wrap_IdleEvent_GetMode, METH_NOARGS, NULL},
53443 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
53444 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
53445 { (char *)"IdleEvent_swiginit", IdleEvent_swiginit, METH_VARARGS, NULL},
53446 { (char *)"new_ClipboardTextEvent", (PyCFunction) _wrap_new_ClipboardTextEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53447 { (char *)"ClipboardTextEvent_swigregister", ClipboardTextEvent_swigregister, METH_VARARGS, NULL},
53448 { (char *)"ClipboardTextEvent_swiginit", ClipboardTextEvent_swiginit, METH_VARARGS, NULL},
53449 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53450 { (char *)"delete_PyEvent", (PyCFunction)_wrap_delete_PyEvent, METH_O, NULL},
53451 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53452 { (char *)"PyEvent__GetSelf", (PyCFunction)_wrap_PyEvent__GetSelf, METH_O, NULL},
53453 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
53454 { (char *)"PyEvent_swiginit", PyEvent_swiginit, METH_VARARGS, NULL},
53455 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53456 { (char *)"delete_PyCommandEvent", (PyCFunction)_wrap_delete_PyCommandEvent, METH_O, NULL},
53457 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53458 { (char *)"PyCommandEvent__GetSelf", (PyCFunction)_wrap_PyCommandEvent__GetSelf, METH_O, NULL},
53459 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
53460 { (char *)"PyCommandEvent_swiginit", PyCommandEvent_swiginit, METH_VARARGS, NULL},
53461 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53462 { (char *)"DateEvent_GetDate", (PyCFunction)_wrap_DateEvent_GetDate, METH_O, NULL},
53463 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
53464 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
53465 { (char *)"DateEvent_swiginit", DateEvent_swiginit, METH_VARARGS, NULL},
53466 { (char *)"new_PyApp", (PyCFunction)_wrap_new_PyApp, METH_NOARGS, NULL},
53467 { (char *)"delete_PyApp", (PyCFunction)_wrap_delete_PyApp, METH_O, NULL},
53468 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53469 { (char *)"PyApp_GetAppName", (PyCFunction)_wrap_PyApp_GetAppName, METH_O, NULL},
53470 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
53471 { (char *)"PyApp_GetClassName", (PyCFunction)_wrap_PyApp_GetClassName, METH_O, NULL},
53472 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
53473 { (char *)"PyApp_GetVendorName", (PyCFunction)_wrap_PyApp_GetVendorName, METH_O, NULL},
53474 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
53475 { (char *)"PyApp_GetTraits", (PyCFunction)_wrap_PyApp_GetTraits, METH_O, NULL},
53476 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction)_wrap_PyApp_ProcessPendingEvents, METH_O, NULL},
53477 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
53478 { (char *)"PyApp_WakeUpIdle", (PyCFunction)_wrap_PyApp_WakeUpIdle, METH_O, NULL},
53479 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction)_wrap_PyApp_IsMainLoopRunning, METH_NOARGS, NULL},
53480 { (char *)"PyApp_MainLoop", (PyCFunction)_wrap_PyApp_MainLoop, METH_O, NULL},
53481 { (char *)"PyApp_Exit", (PyCFunction)_wrap_PyApp_Exit, METH_O, NULL},
53482 { (char *)"PyApp_ExitMainLoop", (PyCFunction)_wrap_PyApp_ExitMainLoop, METH_O, NULL},
53483 { (char *)"PyApp_Pending", (PyCFunction)_wrap_PyApp_Pending, METH_O, NULL},
53484 { (char *)"PyApp_Dispatch", (PyCFunction)_wrap_PyApp_Dispatch, METH_O, NULL},
53485 { (char *)"PyApp_ProcessIdle", (PyCFunction)_wrap_PyApp_ProcessIdle, METH_O, NULL},
53486 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
53487 { (char *)"PyApp_IsActive", (PyCFunction)_wrap_PyApp_IsActive, METH_O, NULL},
53488 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53489 { (char *)"PyApp_GetTopWindow", (PyCFunction)_wrap_PyApp_GetTopWindow, METH_O, NULL},
53490 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
53491 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction)_wrap_PyApp_GetExitOnFrameDelete, METH_O, NULL},
53492 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
53493 { (char *)"PyApp_GetUseBestVisual", (PyCFunction)_wrap_PyApp_GetUseBestVisual, METH_O, NULL},
53494 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
53495 { (char *)"PyApp_GetPrintMode", (PyCFunction)_wrap_PyApp_GetPrintMode, METH_O, NULL},
53496 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
53497 { (char *)"PyApp_GetAssertMode", (PyCFunction)_wrap_PyApp_GetAssertMode, METH_O, NULL},
53498 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction)_wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_NOARGS, NULL},
53499 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction)_wrap_PyApp_GetMacAboutMenuItemId, METH_NOARGS, NULL},
53500 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction)_wrap_PyApp_GetMacPreferencesMenuItemId, METH_NOARGS, NULL},
53501 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction)_wrap_PyApp_GetMacExitMenuItemId, METH_NOARGS, NULL},
53502 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction)_wrap_PyApp_GetMacHelpMenuTitleName, METH_NOARGS, NULL},
53503 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
53504 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53505 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53506 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53507 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
53508 { (char *)"PyApp__BootstrapApp", (PyCFunction)_wrap_PyApp__BootstrapApp, METH_O, NULL},
53509 { (char *)"PyApp_GetComCtl32Version", (PyCFunction)_wrap_PyApp_GetComCtl32Version, METH_NOARGS, NULL},
53510 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
53511 { (char *)"PyApp_swiginit", PyApp_swiginit, METH_VARARGS, NULL},
53512 { (char *)"Exit", (PyCFunction)_wrap_Exit, METH_NOARGS, NULL},
53513 { (char *)"Yield", (PyCFunction)_wrap_Yield, METH_NOARGS, NULL},
53514 { (char *)"YieldIfNeeded", (PyCFunction)_wrap_YieldIfNeeded, METH_NOARGS, NULL},
53515 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
53516 { (char *)"WakeUpIdle", (PyCFunction)_wrap_WakeUpIdle, METH_NOARGS, NULL},
53517 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53518 { (char *)"App_CleanUp", (PyCFunction)_wrap_App_CleanUp, METH_NOARGS, NULL},
53519 { (char *)"GetApp", (PyCFunction)_wrap_GetApp, METH_NOARGS, NULL},
53520 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
53521 { (char *)"GetDefaultPyEncoding", (PyCFunction)_wrap_GetDefaultPyEncoding, METH_NOARGS, NULL},
53522 { (char *)"new_EventLoop", (PyCFunction)_wrap_new_EventLoop, METH_NOARGS, NULL},
53523 { (char *)"delete_EventLoop", (PyCFunction)_wrap_delete_EventLoop, METH_O, NULL},
53524 { (char *)"EventLoop_Run", (PyCFunction)_wrap_EventLoop_Run, METH_O, NULL},
53525 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
53526 { (char *)"EventLoop_Pending", (PyCFunction)_wrap_EventLoop_Pending, METH_O, NULL},
53527 { (char *)"EventLoop_Dispatch", (PyCFunction)_wrap_EventLoop_Dispatch, METH_O, NULL},
53528 { (char *)"EventLoop_IsRunning", (PyCFunction)_wrap_EventLoop_IsRunning, METH_O, NULL},
53529 { (char *)"EventLoop_GetActive", (PyCFunction)_wrap_EventLoop_GetActive, METH_NOARGS, NULL},
53530 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
53531 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
53532 { (char *)"EventLoop_swiginit", EventLoop_swiginit, METH_VARARGS, NULL},
53533 { (char *)"new_EventLoopActivator", (PyCFunction) _wrap_new_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
53534 { (char *)"delete_EventLoopActivator", (PyCFunction)_wrap_delete_EventLoopActivator, METH_O, NULL},
53535 { (char *)"EventLoopActivator_swigregister", EventLoopActivator_swigregister, METH_VARARGS, NULL},
53536 { (char *)"EventLoopActivator_swiginit", EventLoopActivator_swiginit, METH_VARARGS, NULL},
53537 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
53538 { (char *)"delete_AcceleratorEntry", (PyCFunction)_wrap_delete_AcceleratorEntry, METH_O, NULL},
53539 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53540 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction)_wrap_AcceleratorEntry_GetFlags, METH_O, NULL},
53541 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction)_wrap_AcceleratorEntry_GetKeyCode, METH_O, NULL},
53542 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction)_wrap_AcceleratorEntry_GetCommand, METH_O, NULL},
53543 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
53544 { (char *)"AcceleratorEntry_swiginit", AcceleratorEntry_swiginit, METH_VARARGS, NULL},
53545 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
53546 { (char *)"delete_AcceleratorTable", (PyCFunction)_wrap_delete_AcceleratorTable, METH_O, NULL},
53547 { (char *)"AcceleratorTable_Ok", (PyCFunction)_wrap_AcceleratorTable_Ok, METH_O, NULL},
53548 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
53549 { (char *)"AcceleratorTable_swiginit", AcceleratorTable_swiginit, METH_VARARGS, NULL},
53550 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
53551 { (char *)"new_VisualAttributes", (PyCFunction)_wrap_new_VisualAttributes, METH_NOARGS, NULL},
53552 { (char *)"delete_VisualAttributes", (PyCFunction)_wrap_delete_VisualAttributes, METH_O, NULL},
53553 { (char *)"VisualAttributes_font_set", _wrap_VisualAttributes_font_set, METH_VARARGS, NULL},
53554 { (char *)"VisualAttributes_font_get", (PyCFunction)_wrap_VisualAttributes_font_get, METH_O, NULL},
53555 { (char *)"VisualAttributes_colFg_set", _wrap_VisualAttributes_colFg_set, METH_VARARGS, NULL},
53556 { (char *)"VisualAttributes_colFg_get", (PyCFunction)_wrap_VisualAttributes_colFg_get, METH_O, NULL},
53557 { (char *)"VisualAttributes_colBg_set", _wrap_VisualAttributes_colBg_set, METH_VARARGS, NULL},
53558 { (char *)"VisualAttributes_colBg_get", (PyCFunction)_wrap_VisualAttributes_colBg_get, METH_O, NULL},
53559 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
53560 { (char *)"VisualAttributes_swiginit", VisualAttributes_swiginit, METH_VARARGS, NULL},
53561 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
53562 { (char *)"new_PreWindow", (PyCFunction)_wrap_new_PreWindow, METH_NOARGS, NULL},
53563 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
53564 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
53565 { (char *)"Window_Destroy", (PyCFunction)_wrap_Window_Destroy, METH_O, NULL},
53566 { (char *)"Window_DestroyChildren", (PyCFunction)_wrap_Window_DestroyChildren, METH_O, NULL},
53567 { (char *)"Window_IsBeingDeleted", (PyCFunction)_wrap_Window_IsBeingDeleted, METH_O, NULL},
53568 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53569 { (char *)"Window_GetLabel", (PyCFunction)_wrap_Window_GetLabel, METH_O, NULL},
53570 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
53571 { (char *)"Window_GetName", (PyCFunction)_wrap_Window_GetName, METH_O, NULL},
53572 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
53573 { (char *)"Window_GetWindowVariant", (PyCFunction)_wrap_Window_GetWindowVariant, METH_O, NULL},
53574 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53575 { (char *)"Window_GetId", (PyCFunction)_wrap_Window_GetId, METH_O, NULL},
53576 { (char *)"Window_NewControlId", (PyCFunction)_wrap_Window_NewControlId, METH_NOARGS, NULL},
53577 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
53578 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
53579 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
53580 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
53581 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53582 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53583 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
53584 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
53585 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
53586 { (char *)"Window_Raise", (PyCFunction)_wrap_Window_Raise, METH_O, NULL},
53587 { (char *)"Window_Lower", (PyCFunction)_wrap_Window_Lower, METH_O, NULL},
53588 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
53589 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53590 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
53591 { (char *)"Window_GetPosition", (PyCFunction)_wrap_Window_GetPosition, METH_O, NULL},
53592 { (char *)"Window_GetPositionTuple", (PyCFunction)_wrap_Window_GetPositionTuple, METH_O, NULL},
53593 { (char *)"Window_GetScreenPosition", (PyCFunction)_wrap_Window_GetScreenPosition, METH_O, NULL},
53594 { (char *)"Window_GetScreenPositionTuple", (PyCFunction)_wrap_Window_GetScreenPositionTuple, METH_O, NULL},
53595 { (char *)"Window_GetScreenRect", (PyCFunction)_wrap_Window_GetScreenRect, METH_O, NULL},
53596 { (char *)"Window_GetSize", (PyCFunction)_wrap_Window_GetSize, METH_O, NULL},
53597 { (char *)"Window_GetSizeTuple", (PyCFunction)_wrap_Window_GetSizeTuple, METH_O, NULL},
53598 { (char *)"Window_GetRect", (PyCFunction)_wrap_Window_GetRect, METH_O, NULL},
53599 { (char *)"Window_GetClientSize", (PyCFunction)_wrap_Window_GetClientSize, METH_O, NULL},
53600 { (char *)"Window_GetClientSizeTuple", (PyCFunction)_wrap_Window_GetClientSizeTuple, METH_O, NULL},
53601 { (char *)"Window_GetClientAreaOrigin", (PyCFunction)_wrap_Window_GetClientAreaOrigin, METH_O, NULL},
53602 { (char *)"Window_GetClientRect", (PyCFunction)_wrap_Window_GetClientRect, METH_O, NULL},
53603 { (char *)"Window_GetBestSize", (PyCFunction)_wrap_Window_GetBestSize, METH_O, NULL},
53604 { (char *)"Window_GetBestSizeTuple", (PyCFunction)_wrap_Window_GetBestSizeTuple, METH_O, NULL},
53605 { (char *)"Window_InvalidateBestSize", (PyCFunction)_wrap_Window_InvalidateBestSize, METH_O, NULL},
53606 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
53607 { (char *)"Window_GetBestFittingSize", (PyCFunction)_wrap_Window_GetBestFittingSize, METH_O, NULL},
53608 { (char *)"Window_GetAdjustedBestSize", (PyCFunction)_wrap_Window_GetAdjustedBestSize, METH_O, NULL},
53609 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
53610 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
53611 { (char *)"Window_Fit", (PyCFunction)_wrap_Window_Fit, METH_O, NULL},
53612 { (char *)"Window_FitInside", (PyCFunction)_wrap_Window_FitInside, METH_O, NULL},
53613 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53614 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
53615 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53616 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
53617 { (char *)"Window_GetMaxSize", (PyCFunction)_wrap_Window_GetMaxSize, METH_O, NULL},
53618 { (char *)"Window_GetMinSize", (PyCFunction)_wrap_Window_GetMinSize, METH_O, NULL},
53619 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
53620 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
53621 { (char *)"Window_GetMinWidth", (PyCFunction)_wrap_Window_GetMinWidth, METH_O, NULL},
53622 { (char *)"Window_GetMinHeight", (PyCFunction)_wrap_Window_GetMinHeight, METH_O, NULL},
53623 { (char *)"Window_GetMaxWidth", (PyCFunction)_wrap_Window_GetMaxWidth, METH_O, NULL},
53624 { (char *)"Window_GetMaxHeight", (PyCFunction)_wrap_Window_GetMaxHeight, METH_O, NULL},
53625 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
53626 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53627 { (char *)"Window_GetVirtualSize", (PyCFunction)_wrap_Window_GetVirtualSize, METH_O, NULL},
53628 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction)_wrap_Window_GetVirtualSizeTuple, METH_O, NULL},
53629 { (char *)"Window_GetBestVirtualSize", (PyCFunction)_wrap_Window_GetBestVirtualSize, METH_O, NULL},
53630 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53631 { (char *)"Window_Hide", (PyCFunction)_wrap_Window_Hide, METH_O, NULL},
53632 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53633 { (char *)"Window_Disable", (PyCFunction)_wrap_Window_Disable, METH_O, NULL},
53634 { (char *)"Window_IsShown", (PyCFunction)_wrap_Window_IsShown, METH_O, NULL},
53635 { (char *)"Window_IsEnabled", (PyCFunction)_wrap_Window_IsEnabled, METH_O, NULL},
53636 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53637 { (char *)"Window_GetWindowStyleFlag", (PyCFunction)_wrap_Window_GetWindowStyleFlag, METH_O, NULL},
53638 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53639 { (char *)"Window_IsRetained", (PyCFunction)_wrap_Window_IsRetained, METH_O, NULL},
53640 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
53641 { (char *)"Window_GetExtraStyle", (PyCFunction)_wrap_Window_GetExtraStyle, METH_O, NULL},
53642 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
53643 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53644 { (char *)"Window_GetThemeEnabled", (PyCFunction)_wrap_Window_GetThemeEnabled, METH_O, NULL},
53645 { (char *)"Window_SetFocus", (PyCFunction)_wrap_Window_SetFocus, METH_O, NULL},
53646 { (char *)"Window_SetFocusFromKbd", (PyCFunction)_wrap_Window_SetFocusFromKbd, METH_O, NULL},
53647 { (char *)"Window_FindFocus", (PyCFunction)_wrap_Window_FindFocus, METH_NOARGS, NULL},
53648 { (char *)"Window_AcceptsFocus", (PyCFunction)_wrap_Window_AcceptsFocus, METH_O, NULL},
53649 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction)_wrap_Window_AcceptsFocusFromKeyboard, METH_O, NULL},
53650 { (char *)"Window_GetDefaultItem", (PyCFunction)_wrap_Window_GetDefaultItem, METH_O, NULL},
53651 { (char *)"Window_SetDefaultItem", (PyCFunction) _wrap_Window_SetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
53652 { (char *)"Window_SetTmpDefaultItem", (PyCFunction) _wrap_Window_SetTmpDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
53653 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
53654 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
53655 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
53656 { (char *)"Window_GetChildren", (PyCFunction)_wrap_Window_GetChildren, METH_O, NULL},
53657 { (char *)"Window_GetParent", (PyCFunction)_wrap_Window_GetParent, METH_O, NULL},
53658 { (char *)"Window_GetGrandParent", (PyCFunction)_wrap_Window_GetGrandParent, METH_O, NULL},
53659 { (char *)"Window_IsTopLevel", (PyCFunction)_wrap_Window_IsTopLevel, METH_O, NULL},
53660 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
53661 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
53662 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
53663 { (char *)"Window_SetDoubleBuffered", (PyCFunction) _wrap_Window_SetDoubleBuffered, METH_VARARGS | METH_KEYWORDS, NULL},
53664 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
53665 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
53666 { (char *)"Window_GetEventHandler", (PyCFunction)_wrap_Window_GetEventHandler, METH_O, NULL},
53667 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53668 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53669 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53670 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53671 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
53672 { (char *)"Window_GetValidator", (PyCFunction)_wrap_Window_GetValidator, METH_O, NULL},
53673 { (char *)"Window_Validate", (PyCFunction)_wrap_Window_Validate, METH_O, NULL},
53674 { (char *)"Window_TransferDataToWindow", (PyCFunction)_wrap_Window_TransferDataToWindow, METH_O, NULL},
53675 { (char *)"Window_TransferDataFromWindow", (PyCFunction)_wrap_Window_TransferDataFromWindow, METH_O, NULL},
53676 { (char *)"Window_InitDialog", (PyCFunction)_wrap_Window_InitDialog, METH_O, NULL},
53677 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
53678 { (char *)"Window_GetAcceleratorTable", (PyCFunction)_wrap_Window_GetAcceleratorTable, METH_O, NULL},
53679 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
53680 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
53681 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
53682 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
53683 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
53684 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
53685 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
53686 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
53687 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
53688 { (char *)"Window_CaptureMouse", (PyCFunction)_wrap_Window_CaptureMouse, METH_O, NULL},
53689 { (char *)"Window_ReleaseMouse", (PyCFunction)_wrap_Window_ReleaseMouse, METH_O, NULL},
53690 { (char *)"Window_GetCapture", (PyCFunction)_wrap_Window_GetCapture, METH_NOARGS, NULL},
53691 { (char *)"Window_HasCapture", (PyCFunction)_wrap_Window_HasCapture, METH_O, NULL},
53692 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
53693 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
53694 { (char *)"Window_Update", (PyCFunction)_wrap_Window_Update, METH_O, NULL},
53695 { (char *)"Window_ClearBackground", (PyCFunction)_wrap_Window_ClearBackground, METH_O, NULL},
53696 { (char *)"Window_Freeze", (PyCFunction)_wrap_Window_Freeze, METH_O, NULL},
53697 { (char *)"Window_Thaw", (PyCFunction)_wrap_Window_Thaw, METH_O, NULL},
53698 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
53699 { (char *)"Window_GetUpdateRegion", (PyCFunction)_wrap_Window_GetUpdateRegion, METH_O, NULL},
53700 { (char *)"Window_GetUpdateClientRect", (PyCFunction)_wrap_Window_GetUpdateClientRect, METH_O, NULL},
53701 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
53702 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53703 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
53704 { (char *)"Window_GetDefaultAttributes", (PyCFunction)_wrap_Window_GetDefaultAttributes, METH_O, NULL},
53705 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
53706 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53707 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53708 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53709 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53710 { (char *)"Window_GetBackgroundColour", (PyCFunction)_wrap_Window_GetBackgroundColour, METH_O, NULL},
53711 { (char *)"Window_GetForegroundColour", (PyCFunction)_wrap_Window_GetForegroundColour, METH_O, NULL},
53712 { (char *)"Window_InheritsBackgroundColour", (PyCFunction)_wrap_Window_InheritsBackgroundColour, METH_O, NULL},
53713 { (char *)"Window_UseBgCol", (PyCFunction)_wrap_Window_UseBgCol, METH_O, NULL},
53714 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
53715 { (char *)"Window_GetBackgroundStyle", (PyCFunction)_wrap_Window_GetBackgroundStyle, METH_O, NULL},
53716 { (char *)"Window_HasTransparentBackground", (PyCFunction)_wrap_Window_HasTransparentBackground, METH_O, NULL},
53717 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
53718 { (char *)"Window_GetCursor", (PyCFunction)_wrap_Window_GetCursor, METH_O, NULL},
53719 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
53720 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
53721 { (char *)"Window_GetFont", (PyCFunction)_wrap_Window_GetFont, METH_O, NULL},
53722 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
53723 { (char *)"Window_GetCaret", (PyCFunction)_wrap_Window_GetCaret, METH_O, NULL},
53724 { (char *)"Window_GetCharHeight", (PyCFunction)_wrap_Window_GetCharHeight, METH_O, NULL},
53725 { (char *)"Window_GetCharWidth", (PyCFunction)_wrap_Window_GetCharWidth, METH_O, NULL},
53726 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
53727 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
53728 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
53729 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
53730 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
53731 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
53732 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
53733 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
53734 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
53735 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
53736 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
53737 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53738 { (char *)"Window_GetHandle", (PyCFunction)_wrap_Window_GetHandle, METH_O, NULL},
53739 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
53740 { (char *)"Window_DissociateHandle", (PyCFunction)_wrap_Window_DissociateHandle, METH_O, NULL},
53741 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
53742 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
53743 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
53744 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
53745 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
53746 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
53747 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53748 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
53749 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
53750 { (char *)"Window_LineUp", (PyCFunction)_wrap_Window_LineUp, METH_O, NULL},
53751 { (char *)"Window_LineDown", (PyCFunction)_wrap_Window_LineDown, METH_O, NULL},
53752 { (char *)"Window_PageUp", (PyCFunction)_wrap_Window_PageUp, METH_O, NULL},
53753 { (char *)"Window_PageDown", (PyCFunction)_wrap_Window_PageDown, METH_O, NULL},
53754 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
53755 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
53756 { (char *)"Window_GetHelpTextAtPoint", (PyCFunction) _wrap_Window_GetHelpTextAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53757 { (char *)"Window_GetHelpText", (PyCFunction)_wrap_Window_GetHelpText, METH_O, NULL},
53758 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
53759 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
53760 { (char *)"Window_GetToolTip", (PyCFunction)_wrap_Window_GetToolTip, METH_O, NULL},
53761 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
53762 { (char *)"Window_GetDropTarget", (PyCFunction)_wrap_Window_GetDropTarget, METH_O, NULL},
53763 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
53764 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
53765 { (char *)"Window_GetConstraints", (PyCFunction)_wrap_Window_GetConstraints, METH_O, NULL},
53766 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
53767 { (char *)"Window_GetAutoLayout", (PyCFunction)_wrap_Window_GetAutoLayout, METH_O, NULL},
53768 { (char *)"Window_Layout", (PyCFunction)_wrap_Window_Layout, METH_O, NULL},
53769 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53770 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
53771 { (char *)"Window_GetSizer", (PyCFunction)_wrap_Window_GetSizer, METH_O, NULL},
53772 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53773 { (char *)"Window_GetContainingSizer", (PyCFunction)_wrap_Window_GetContainingSizer, METH_O, NULL},
53774 { (char *)"Window_InheritAttributes", (PyCFunction)_wrap_Window_InheritAttributes, METH_O, NULL},
53775 { (char *)"Window_ShouldInheritColours", (PyCFunction)_wrap_Window_ShouldInheritColours, METH_O, NULL},
53776 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
53777 { (char *)"Window_swiginit", Window_swiginit, METH_VARARGS, NULL},
53778 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
53779 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
53780 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53781 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
53782 { (char *)"GetTopLevelWindows", (PyCFunction)_wrap_GetTopLevelWindows, METH_NOARGS, NULL},
53783 { (char *)"new_Validator", (PyCFunction)_wrap_new_Validator, METH_NOARGS, NULL},
53784 { (char *)"Validator_Clone", (PyCFunction)_wrap_Validator_Clone, METH_O, NULL},
53785 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
53786 { (char *)"Validator_TransferToWindow", (PyCFunction)_wrap_Validator_TransferToWindow, METH_O, NULL},
53787 { (char *)"Validator_TransferFromWindow", (PyCFunction)_wrap_Validator_TransferFromWindow, METH_O, NULL},
53788 { (char *)"Validator_GetWindow", (PyCFunction)_wrap_Validator_GetWindow, METH_O, NULL},
53789 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53790 { (char *)"Validator_IsSilent", (PyCFunction)_wrap_Validator_IsSilent, METH_NOARGS, NULL},
53791 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
53792 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
53793 { (char *)"Validator_swiginit", Validator_swiginit, METH_VARARGS, NULL},
53794 { (char *)"new_PyValidator", (PyCFunction)_wrap_new_PyValidator, METH_NOARGS, NULL},
53795 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53796 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
53797 { (char *)"PyValidator_swiginit", PyValidator_swiginit, METH_VARARGS, NULL},
53798 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
53799 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
53800 { (char *)"Menu_AppendSeparator", (PyCFunction)_wrap_Menu_AppendSeparator, METH_O, NULL},
53801 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53802 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53803 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53804 { (char *)"Menu_AppendSubMenu", (PyCFunction) _wrap_Menu_AppendSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53805 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
53806 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
53807 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
53808 { (char *)"Menu_Break", (PyCFunction)_wrap_Menu_Break, METH_O, NULL},
53809 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53810 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
53811 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53812 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53813 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53814 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
53815 { (char *)"Menu_PrependSeparator", (PyCFunction)_wrap_Menu_PrependSeparator, METH_O, NULL},
53816 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53817 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53818 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53819 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
53820 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
53821 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
53822 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
53823 { (char *)"Menu_Destroy", (PyCFunction)_wrap_Menu_Destroy, METH_O, NULL},
53824 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
53825 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
53826 { (char *)"Menu_GetMenuItemCount", (PyCFunction)_wrap_Menu_GetMenuItemCount, METH_O, NULL},
53827 { (char *)"Menu_GetMenuItems", (PyCFunction)_wrap_Menu_GetMenuItems, METH_O, NULL},
53828 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
53829 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
53830 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53831 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53832 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53833 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53834 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
53835 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53836 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53837 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53838 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53839 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
53840 { (char *)"Menu_GetTitle", (PyCFunction)_wrap_Menu_GetTitle, METH_O, NULL},
53841 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53842 { (char *)"Menu_GetEventHandler", (PyCFunction)_wrap_Menu_GetEventHandler, METH_O, NULL},
53843 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53844 { (char *)"Menu_GetInvokingWindow", (PyCFunction)_wrap_Menu_GetInvokingWindow, METH_O, NULL},
53845 { (char *)"Menu_GetStyle", (PyCFunction)_wrap_Menu_GetStyle, METH_O, NULL},
53846 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
53847 { (char *)"Menu_GetMenuBar", (PyCFunction)_wrap_Menu_GetMenuBar, METH_O, NULL},
53848 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
53849 { (char *)"Menu_Detach", (PyCFunction)_wrap_Menu_Detach, METH_O, NULL},
53850 { (char *)"Menu_IsAttached", (PyCFunction)_wrap_Menu_IsAttached, METH_O, NULL},
53851 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
53852 { (char *)"Menu_GetParent", (PyCFunction)_wrap_Menu_GetParent, METH_O, NULL},
53853 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
53854 { (char *)"Menu_swiginit", Menu_swiginit, METH_VARARGS, NULL},
53855 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
53856 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
53857 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53858 { (char *)"MenuBar_GetMenuCount", (PyCFunction)_wrap_MenuBar_GetMenuCount, METH_O, NULL},
53859 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53860 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
53861 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
53862 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
53863 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
53864 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
53865 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
53866 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
53867 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
53868 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53869 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53870 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53871 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
53872 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53873 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53874 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53875 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53876 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53877 { (char *)"MenuBar_GetFrame", (PyCFunction)_wrap_MenuBar_GetFrame, METH_O, NULL},
53878 { (char *)"MenuBar_IsAttached", (PyCFunction)_wrap_MenuBar_IsAttached, METH_O, NULL},
53879 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
53880 { (char *)"MenuBar_Detach", (PyCFunction)_wrap_MenuBar_Detach, METH_O, NULL},
53881 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53882 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction)_wrap_MenuBar_GetAutoWindowMenu, METH_NOARGS, NULL},
53883 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
53884 { (char *)"MenuBar_swiginit", MenuBar_swiginit, METH_VARARGS, NULL},
53885 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
53886 { (char *)"delete_MenuItem", (PyCFunction)_wrap_delete_MenuItem, METH_O, NULL},
53887 { (char *)"MenuItem_GetMenu", (PyCFunction)_wrap_MenuItem_GetMenu, METH_O, NULL},
53888 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53889 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53890 { (char *)"MenuItem_GetId", (PyCFunction)_wrap_MenuItem_GetId, METH_O, NULL},
53891 { (char *)"MenuItem_IsSeparator", (PyCFunction)_wrap_MenuItem_IsSeparator, METH_O, NULL},
53892 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
53893 { (char *)"MenuItem_GetLabel", (PyCFunction)_wrap_MenuItem_GetLabel, METH_O, NULL},
53894 { (char *)"MenuItem_GetText", (PyCFunction)_wrap_MenuItem_GetText, METH_O, NULL},
53895 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
53896 { (char *)"MenuItem_GetKind", (PyCFunction)_wrap_MenuItem_GetKind, METH_O, NULL},
53897 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
53898 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
53899 { (char *)"MenuItem_IsCheckable", (PyCFunction)_wrap_MenuItem_IsCheckable, METH_O, NULL},
53900 { (char *)"MenuItem_IsSubMenu", (PyCFunction)_wrap_MenuItem_IsSubMenu, METH_O, NULL},
53901 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53902 { (char *)"MenuItem_GetSubMenu", (PyCFunction)_wrap_MenuItem_GetSubMenu, METH_O, NULL},
53903 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53904 { (char *)"MenuItem_IsEnabled", (PyCFunction)_wrap_MenuItem_IsEnabled, METH_O, NULL},
53905 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53906 { (char *)"MenuItem_IsChecked", (PyCFunction)_wrap_MenuItem_IsChecked, METH_O, NULL},
53907 { (char *)"MenuItem_Toggle", (PyCFunction)_wrap_MenuItem_Toggle, METH_O, NULL},
53908 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
53909 { (char *)"MenuItem_GetHelp", (PyCFunction)_wrap_MenuItem_GetHelp, METH_O, NULL},
53910 { (char *)"MenuItem_GetAccel", (PyCFunction)_wrap_MenuItem_GetAccel, METH_O, NULL},
53911 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
53912 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53913 { (char *)"MenuItem_GetBitmap", (PyCFunction)_wrap_MenuItem_GetBitmap, METH_O, NULL},
53914 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
53915 { (char *)"MenuItem_GetFont", (PyCFunction)_wrap_MenuItem_GetFont, METH_O, NULL},
53916 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
53917 { (char *)"MenuItem_GetTextColour", (PyCFunction)_wrap_MenuItem_GetTextColour, METH_O, NULL},
53918 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53919 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction)_wrap_MenuItem_GetBackgroundColour, METH_O, NULL},
53920 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
53921 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53922 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction)_wrap_MenuItem_GetDisabledBitmap, METH_O, NULL},
53923 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
53924 { (char *)"MenuItem_GetMarginWidth", (PyCFunction)_wrap_MenuItem_GetMarginWidth, METH_O, NULL},
53925 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction)_wrap_MenuItem_GetDefaultMarginWidth, METH_NOARGS, NULL},
53926 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction)_wrap_MenuItem_IsOwnerDrawn, METH_O, NULL},
53927 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
53928 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction)_wrap_MenuItem_ResetOwnerDrawn, METH_O, NULL},
53929 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
53930 { (char *)"MenuItem_swiginit", MenuItem_swiginit, METH_VARARGS, NULL},
53931 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
53932 { (char *)"new_PreControl", (PyCFunction)_wrap_new_PreControl, METH_NOARGS, NULL},
53933 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
53934 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
53935 { (char *)"Control_GetLabel", (PyCFunction)_wrap_Control_GetLabel, METH_O, NULL},
53936 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
53937 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
53938 { (char *)"Control_swiginit", Control_swiginit, METH_VARARGS, NULL},
53939 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
53940 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
53941 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53942 { (char *)"ItemContainer_Clear", (PyCFunction)_wrap_ItemContainer_Clear, METH_O, NULL},
53943 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
53944 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
53945 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
53946 { (char *)"ItemContainer_GetCount", (PyCFunction)_wrap_ItemContainer_GetCount, METH_O, NULL},
53947 { (char *)"ItemContainer_IsEmpty", (PyCFunction)_wrap_ItemContainer_IsEmpty, METH_O, NULL},
53948 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
53949 { (char *)"ItemContainer_GetStrings", (PyCFunction)_wrap_ItemContainer_GetStrings, METH_O, NULL},
53950 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
53951 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
53952 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
53953 { (char *)"ItemContainer_GetSelection", (PyCFunction)_wrap_ItemContainer_GetSelection, METH_O, NULL},
53954 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
53955 { (char *)"ItemContainer_GetStringSelection", (PyCFunction)_wrap_ItemContainer_GetStringSelection, METH_O, NULL},
53956 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
53957 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
53958 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
53959 { (char *)"new_SizerItem", (PyCFunction)_wrap_new_SizerItem, METH_NOARGS, NULL},
53960 { (char *)"delete_SizerItem", (PyCFunction)_wrap_delete_SizerItem, METH_O, NULL},
53961 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53962 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
53963 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53964 { (char *)"SizerItem_DeleteWindows", (PyCFunction)_wrap_SizerItem_DeleteWindows, METH_O, NULL},
53965 { (char *)"SizerItem_DetachSizer", (PyCFunction)_wrap_SizerItem_DetachSizer, METH_O, NULL},
53966 { (char *)"SizerItem_GetSize", (PyCFunction)_wrap_SizerItem_GetSize, METH_O, NULL},
53967 { (char *)"SizerItem_CalcMin", (PyCFunction)_wrap_SizerItem_CalcMin, METH_O, NULL},
53968 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
53969 { (char *)"SizerItem_GetMinSize", (PyCFunction)_wrap_SizerItem_GetMinSize, METH_O, NULL},
53970 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction)_wrap_SizerItem_GetMinSizeWithBorder, METH_O, NULL},
53971 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
53972 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
53973 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
53974 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
53975 { (char *)"SizerItem_GetRatio", (PyCFunction)_wrap_SizerItem_GetRatio, METH_O, NULL},
53976 { (char *)"SizerItem_GetRect", (PyCFunction)_wrap_SizerItem_GetRect, METH_O, NULL},
53977 { (char *)"SizerItem_IsWindow", (PyCFunction)_wrap_SizerItem_IsWindow, METH_O, NULL},
53978 { (char *)"SizerItem_IsSizer", (PyCFunction)_wrap_SizerItem_IsSizer, METH_O, NULL},
53979 { (char *)"SizerItem_IsSpacer", (PyCFunction)_wrap_SizerItem_IsSpacer, METH_O, NULL},
53980 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
53981 { (char *)"SizerItem_GetProportion", (PyCFunction)_wrap_SizerItem_GetProportion, METH_O, NULL},
53982 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53983 { (char *)"SizerItem_GetFlag", (PyCFunction)_wrap_SizerItem_GetFlag, METH_O, NULL},
53984 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
53985 { (char *)"SizerItem_GetBorder", (PyCFunction)_wrap_SizerItem_GetBorder, METH_O, NULL},
53986 { (char *)"SizerItem_GetWindow", (PyCFunction)_wrap_SizerItem_GetWindow, METH_O, NULL},
53987 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53988 { (char *)"SizerItem_GetSizer", (PyCFunction)_wrap_SizerItem_GetSizer, METH_O, NULL},
53989 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53990 { (char *)"SizerItem_GetSpacer", (PyCFunction)_wrap_SizerItem_GetSpacer, METH_O, NULL},
53991 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
53992 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53993 { (char *)"SizerItem_IsShown", (PyCFunction)_wrap_SizerItem_IsShown, METH_O, NULL},
53994 { (char *)"SizerItem_GetPosition", (PyCFunction)_wrap_SizerItem_GetPosition, METH_O, NULL},
53995 { (char *)"SizerItem_GetUserData", (PyCFunction)_wrap_SizerItem_GetUserData, METH_O, NULL},
53996 { (char *)"SizerItem_SetUserData", (PyCFunction) _wrap_SizerItem_SetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
53997 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
53998 { (char *)"SizerItem_swiginit", SizerItem_swiginit, METH_VARARGS, NULL},
53999 { (char *)"delete_Sizer", (PyCFunction)_wrap_delete_Sizer, METH_O, NULL},
54000 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54001 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
54002 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
54003 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
54004 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
54005 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
54006 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
54007 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
54008 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
54009 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
54010 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
54011 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
54012 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
54013 { (char *)"Sizer_GetSize", (PyCFunction)_wrap_Sizer_GetSize, METH_O, NULL},
54014 { (char *)"Sizer_GetPosition", (PyCFunction)_wrap_Sizer_GetPosition, METH_O, NULL},
54015 { (char *)"Sizer_GetMinSize", (PyCFunction)_wrap_Sizer_GetMinSize, METH_O, NULL},
54016 { (char *)"Sizer_RecalcSizes", (PyCFunction)_wrap_Sizer_RecalcSizes, METH_O, NULL},
54017 { (char *)"Sizer_CalcMin", (PyCFunction)_wrap_Sizer_CalcMin, METH_O, NULL},
54018 { (char *)"Sizer_Layout", (PyCFunction)_wrap_Sizer_Layout, METH_O, NULL},
54019 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
54020 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
54021 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
54022 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
54023 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
54024 { (char *)"Sizer_DeleteWindows", (PyCFunction)_wrap_Sizer_DeleteWindows, METH_O, NULL},
54025 { (char *)"Sizer_GetChildren", (PyCFunction)_wrap_Sizer_GetChildren, METH_O, NULL},
54026 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
54027 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
54028 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
54029 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
54030 { (char *)"new_PySizer", (PyCFunction)_wrap_new_PySizer, METH_NOARGS, NULL},
54031 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54032 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
54033 { (char *)"PySizer_swiginit", PySizer_swiginit, METH_VARARGS, NULL},
54034 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54035 { (char *)"BoxSizer_GetOrientation", (PyCFunction)_wrap_BoxSizer_GetOrientation, METH_O, NULL},
54036 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
54037 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
54038 { (char *)"BoxSizer_swiginit", BoxSizer_swiginit, METH_VARARGS, NULL},
54039 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54040 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction)_wrap_StaticBoxSizer_GetStaticBox, METH_O, NULL},
54041 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
54042 { (char *)"StaticBoxSizer_swiginit", StaticBoxSizer_swiginit, METH_VARARGS, NULL},
54043 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54044 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
54045 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
54046 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
54047 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
54048 { (char *)"GridSizer_GetCols", (PyCFunction)_wrap_GridSizer_GetCols, METH_O, NULL},
54049 { (char *)"GridSizer_GetRows", (PyCFunction)_wrap_GridSizer_GetRows, METH_O, NULL},
54050 { (char *)"GridSizer_GetVGap", (PyCFunction)_wrap_GridSizer_GetVGap, METH_O, NULL},
54051 { (char *)"GridSizer_GetHGap", (PyCFunction)_wrap_GridSizer_GetHGap, METH_O, NULL},
54052 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
54053 { (char *)"GridSizer_swiginit", GridSizer_swiginit, METH_VARARGS, NULL},
54054 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54055 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
54056 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
54057 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
54058 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
54059 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
54060 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction)_wrap_FlexGridSizer_GetFlexibleDirection, METH_O, NULL},
54061 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
54062 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction)_wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_O, NULL},
54063 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction)_wrap_FlexGridSizer_GetRowHeights, METH_O, NULL},
54064 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction)_wrap_FlexGridSizer_GetColWidths, METH_O, NULL},
54065 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
54066 { (char *)"FlexGridSizer_swiginit", FlexGridSizer_swiginit, METH_VARARGS, NULL},
54067 { (char *)"new_StdDialogButtonSizer", (PyCFunction)_wrap_new_StdDialogButtonSizer, METH_NOARGS, NULL},
54068 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
54069 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction)_wrap_StdDialogButtonSizer_Realize, METH_O, NULL},
54070 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
54071 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
54072 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
54073 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_O, NULL},
54074 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetApplyButton, METH_O, NULL},
54075 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetNegativeButton, METH_O, NULL},
54076 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetCancelButton, METH_O, NULL},
54077 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetHelpButton, METH_O, NULL},
54078 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
54079 { (char *)"StdDialogButtonSizer_swiginit", StdDialogButtonSizer_swiginit, METH_VARARGS, NULL},
54080 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54081 { (char *)"delete_GBPosition", (PyCFunction)_wrap_delete_GBPosition, METH_O, NULL},
54082 { (char *)"GBPosition_GetRow", (PyCFunction)_wrap_GBPosition_GetRow, METH_O, NULL},
54083 { (char *)"GBPosition_GetCol", (PyCFunction)_wrap_GBPosition_GetCol, METH_O, NULL},
54084 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
54085 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
54086 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
54087 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
54088 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54089 { (char *)"GBPosition_Get", (PyCFunction)_wrap_GBPosition_Get, METH_O, NULL},
54090 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
54091 { (char *)"GBPosition_swiginit", GBPosition_swiginit, METH_VARARGS, NULL},
54092 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
54093 { (char *)"delete_GBSpan", (PyCFunction)_wrap_delete_GBSpan, METH_O, NULL},
54094 { (char *)"GBSpan_GetRowspan", (PyCFunction)_wrap_GBSpan_GetRowspan, METH_O, NULL},
54095 { (char *)"GBSpan_GetColspan", (PyCFunction)_wrap_GBSpan_GetColspan, METH_O, NULL},
54096 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
54097 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
54098 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
54099 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
54100 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54101 { (char *)"GBSpan_Get", (PyCFunction)_wrap_GBSpan_Get, METH_O, NULL},
54102 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
54103 { (char *)"GBSpan_swiginit", GBSpan_swiginit, METH_VARARGS, NULL},
54104 { (char *)"new_GBSizerItem", (PyCFunction)_wrap_new_GBSizerItem, METH_NOARGS, NULL},
54105 { (char *)"delete_GBSizerItem", (PyCFunction)_wrap_delete_GBSizerItem, METH_O, NULL},
54106 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54107 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54108 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
54109 { (char *)"GBSizerItem_GetPos", (PyCFunction)_wrap_GBSizerItem_GetPos, METH_O, NULL},
54110 { (char *)"GBSizerItem_GetSpan", (PyCFunction)_wrap_GBSizerItem_GetSpan, METH_O, NULL},
54111 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
54112 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
54113 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
54114 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
54115 { (char *)"GBSizerItem_GetEndPos", (PyCFunction)_wrap_GBSizerItem_GetEndPos, METH_O, NULL},
54116 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction)_wrap_GBSizerItem_GetGBSizer, METH_O, NULL},
54117 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54118 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
54119 { (char *)"GBSizerItem_swiginit", GBSizerItem_swiginit, METH_VARARGS, NULL},
54120 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54121 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
54122 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
54123 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
54124 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction)_wrap_GridBagSizer_GetEmptyCellSize, METH_O, NULL},
54125 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
54126 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
54127 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
54128 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
54129 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
54130 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
54131 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54132 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
54133 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
54134 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
54135 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
54136 { (char *)"GridBagSizer_swiginit", GridBagSizer_swiginit, METH_VARARGS, NULL},
54137 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54138 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
54139 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
54140 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
54141 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
54142 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
54143 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
54144 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
54145 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction)_wrap_IndividualLayoutConstraint_Unconstrained, METH_O, NULL},
54146 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction)_wrap_IndividualLayoutConstraint_AsIs, METH_O, NULL},
54147 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherWindow, METH_O, NULL},
54148 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMyEdge, METH_O, NULL},
54149 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
54150 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
54151 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMargin, METH_O, NULL},
54152 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
54153 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction)_wrap_IndividualLayoutConstraint_GetValue, METH_O, NULL},
54154 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction)_wrap_IndividualLayoutConstraint_GetPercent, METH_O, NULL},
54155 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherEdge, METH_O, NULL},
54156 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction)_wrap_IndividualLayoutConstraint_GetDone, METH_O, NULL},
54157 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
54158 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction)_wrap_IndividualLayoutConstraint_GetRelationship, METH_O, NULL},
54159 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
54160 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
54161 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
54162 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
54163 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
54164 { (char *)"LayoutConstraints_left_get", (PyCFunction)_wrap_LayoutConstraints_left_get, METH_O, NULL},
54165 { (char *)"LayoutConstraints_top_get", (PyCFunction)_wrap_LayoutConstraints_top_get, METH_O, NULL},
54166 { (char *)"LayoutConstraints_right_get", (PyCFunction)_wrap_LayoutConstraints_right_get, METH_O, NULL},
54167 { (char *)"LayoutConstraints_bottom_get", (PyCFunction)_wrap_LayoutConstraints_bottom_get, METH_O, NULL},
54168 { (char *)"LayoutConstraints_width_get", (PyCFunction)_wrap_LayoutConstraints_width_get, METH_O, NULL},
54169 { (char *)"LayoutConstraints_height_get", (PyCFunction)_wrap_LayoutConstraints_height_get, METH_O, NULL},
54170 { (char *)"LayoutConstraints_centreX_get", (PyCFunction)_wrap_LayoutConstraints_centreX_get, METH_O, NULL},
54171 { (char *)"LayoutConstraints_centreY_get", (PyCFunction)_wrap_LayoutConstraints_centreY_get, METH_O, NULL},
54172 { (char *)"new_LayoutConstraints", (PyCFunction)_wrap_new_LayoutConstraints, METH_NOARGS, NULL},
54173 { (char *)"delete_LayoutConstraints", (PyCFunction)_wrap_delete_LayoutConstraints, METH_O, NULL},
54174 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
54175 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction)_wrap_LayoutConstraints_AreSatisfied, METH_O, NULL},
54176 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
54177 { (char *)"LayoutConstraints_swiginit", LayoutConstraints_swiginit, METH_VARARGS, NULL},
54178 { NULL, NULL, 0, NULL }
54179 };
54180
54181
54182 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
54183
54184 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
54185 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
54186 }
54187 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
54188 return (void *)((wxSizer *) ((wxBoxSizer *) x));
54189 }
54190 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
54191 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
54192 }
54193 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
54194 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54195 }
54196 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
54197 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
54198 }
54199 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
54200 return (void *)((wxSizer *) ((wxGridSizer *) x));
54201 }
54202 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
54203 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
54204 }
54205 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
54206 return (void *)((wxSizer *) ((wxPySizer *) x));
54207 }
54208 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
54209 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
54210 }
54211 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
54212 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54213 }
54214 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
54215 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
54216 }
54217 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
54218 return (void *)((wxEvent *) ((wxMenuEvent *) x));
54219 }
54220 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
54221 return (void *)((wxEvent *) ((wxCloseEvent *) x));
54222 }
54223 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
54224 return (void *)((wxEvent *) ((wxMouseEvent *) x));
54225 }
54226 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
54227 return (void *)((wxEvent *) ((wxEraseEvent *) x));
54228 }
54229 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
54230 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
54231 }
54232 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
54233 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
54234 }
54235 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
54236 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
54237 }
54238 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
54239 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
54240 }
54241 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
54242 return (void *)((wxEvent *) ((wxPyEvent *) x));
54243 }
54244 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
54245 return (void *)((wxEvent *) ((wxIdleEvent *) x));
54246 }
54247 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
54248 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
54249 }
54250 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
54251 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
54252 }
54253 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
54254 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
54255 }
54256 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
54257 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
54258 }
54259 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
54260 return (void *)((wxEvent *) ((wxActivateEvent *) x));
54261 }
54262 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
54263 return (void *)((wxEvent *) ((wxSizeEvent *) x));
54264 }
54265 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
54266 return (void *)((wxEvent *) ((wxMoveEvent *) x));
54267 }
54268 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
54269 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
54270 }
54271 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
54272 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
54273 }
54274 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
54275 return (void *)((wxEvent *) ((wxPaintEvent *) x));
54276 }
54277 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
54278 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
54279 }
54280 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
54281 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
54282 }
54283 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
54284 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
54285 }
54286 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
54287 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
54288 }
54289 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
54290 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
54291 }
54292 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
54293 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
54294 }
54295 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
54296 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
54297 }
54298 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
54299 return (void *)((wxEvent *) ((wxFocusEvent *) x));
54300 }
54301 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
54302 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
54303 }
54304 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
54305 return (void *)((wxEvent *) ((wxShowEvent *) x));
54306 }
54307 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
54308 return (void *)((wxEvent *) ((wxCommandEvent *) x));
54309 }
54310 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
54311 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
54312 }
54313 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
54314 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54315 }
54316 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
54317 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
54318 }
54319 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
54320 return (void *)((wxEvent *) ((wxKeyEvent *) x));
54321 }
54322 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
54323 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
54324 }
54325 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
54326 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
54327 }
54328 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
54329 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
54330 }
54331 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
54332 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
54333 }
54334 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
54335 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
54336 }
54337 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
54338 return (void *)((wxControl *) ((wxControlWithItems *) x));
54339 }
54340 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
54341 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
54342 }
54343 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
54344 return (void *)((wxEvtHandler *) ((wxWindow *) x));
54345 }
54346 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
54347 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
54348 }
54349 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
54350 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
54351 }
54352 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
54353 return (void *)((wxEvtHandler *) ((wxValidator *) x));
54354 }
54355 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
54356 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
54357 }
54358 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
54359 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
54360 }
54361 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
54362 return (void *)((wxEvtHandler *) ((wxMenu *) x));
54363 }
54364 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
54365 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
54366 }
54367 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
54368 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
54369 }
54370 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
54371 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
54372 }
54373 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
54374 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
54375 }
54376 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
54377 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
54378 }
54379 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
54380 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54381 }
54382 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
54383 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
54384 }
54385 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
54386 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
54387 }
54388 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
54389 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
54390 }
54391 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
54392 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
54393 }
54394 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
54395 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54396 }
54397 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
54398 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
54399 }
54400 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
54401 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
54402 }
54403 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
54404 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
54405 }
54406 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
54407 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
54408 }
54409 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
54410 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
54411 }
54412 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
54413 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
54414 }
54415 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
54416 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
54417 }
54418 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
54419 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
54420 }
54421 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
54422 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
54423 }
54424 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
54425 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
54426 }
54427 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
54428 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
54429 }
54430 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
54431 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
54432 }
54433 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
54434 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
54435 }
54436 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
54437 return (void *)((wxObject *) ((wxSizerItem *) x));
54438 }
54439 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
54440 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
54441 }
54442 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
54443 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
54444 }
54445 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
54446 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
54447 }
54448 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
54449 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
54450 }
54451 static void *_p_wxSizerTo_p_wxObject(void *x) {
54452 return (void *)((wxObject *) ((wxSizer *) x));
54453 }
54454 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
54455 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
54456 }
54457 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
54458 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
54459 }
54460 static void *_p_wxEventTo_p_wxObject(void *x) {
54461 return (void *)((wxObject *) ((wxEvent *) x));
54462 }
54463 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
54464 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
54465 }
54466 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
54467 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
54468 }
54469 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
54470 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
54471 }
54472 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
54473 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
54474 }
54475 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
54476 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
54477 }
54478 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
54479 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
54480 }
54481 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
54482 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
54483 }
54484 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
54485 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
54486 }
54487 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
54488 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
54489 }
54490 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
54491 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
54492 }
54493 static void *_p_wxControlTo_p_wxObject(void *x) {
54494 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
54495 }
54496 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
54497 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
54498 }
54499 static void *_p_wxFSFileTo_p_wxObject(void *x) {
54500 return (void *)((wxObject *) ((wxFSFile *) x));
54501 }
54502 static void *_p_wxPySizerTo_p_wxObject(void *x) {
54503 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
54504 }
54505 static void *_p_wxPyEventTo_p_wxObject(void *x) {
54506 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
54507 }
54508 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
54509 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
54510 }
54511 static void *_p_wxShowEventTo_p_wxObject(void *x) {
54512 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
54513 }
54514 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
54515 return (void *)((wxObject *) ((wxMenuItem *) x));
54516 }
54517 static void *_p_wxDateEventTo_p_wxObject(void *x) {
54518 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
54519 }
54520 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
54521 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
54522 }
54523 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
54524 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
54525 }
54526 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
54527 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
54528 }
54529 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
54530 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
54531 }
54532 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
54533 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
54534 }
54535 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
54536 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
54537 }
54538 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
54539 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
54540 }
54541 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
54542 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
54543 }
54544 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
54545 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
54546 }
54547 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
54548 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
54549 }
54550 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
54551 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
54552 }
54553 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
54554 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
54555 }
54556 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
54557 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
54558 }
54559 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
54560 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54561 }
54562 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
54563 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
54564 }
54565 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
54566 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
54567 }
54568 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
54569 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
54570 }
54571 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
54572 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
54573 }
54574 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
54575 return (void *)((wxObject *) ((wxImageHandler *) x));
54576 }
54577 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
54578 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
54579 }
54580 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
54581 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
54582 }
54583 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
54584 return (void *)((wxObject *) ((wxEvtHandler *) x));
54585 }
54586 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
54587 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54588 }
54589 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
54590 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
54591 }
54592 static void *_p_wxImageTo_p_wxObject(void *x) {
54593 return (void *)((wxObject *) ((wxImage *) x));
54594 }
54595 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
54596 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
54597 }
54598 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
54599 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54600 }
54601 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
54602 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
54603 }
54604 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
54605 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
54606 }
54607 static void *_p_wxWindowTo_p_wxObject(void *x) {
54608 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
54609 }
54610 static void *_p_wxMenuTo_p_wxObject(void *x) {
54611 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
54612 }
54613 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
54614 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
54615 }
54616 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
54617 return (void *)((wxObject *) ((wxFileSystem *) x));
54618 }
54619 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
54620 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
54621 }
54622 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
54623 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
54624 }
54625 static void *_p_wxPyAppTo_p_wxObject(void *x) {
54626 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
54627 }
54628 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
54629 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
54630 }
54631 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
54632 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
54633 }
54634 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
54635 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
54636 }
54637 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
54638 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
54639 }
54640 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
54641 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
54642 }
54643 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
54644 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
54645 }
54646 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
54647 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
54648 }
54649 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
54650 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
54651 }
54652 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
54653 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
54654 }
54655 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
54656 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
54657 }
54658 static void *_p_wxValidatorTo_p_wxObject(void *x) {
54659 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
54660 }
54661 static void *_p_wxControlTo_p_wxWindow(void *x) {
54662 return (void *)((wxWindow *) ((wxControl *) x));
54663 }
54664 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
54665 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
54666 }
54667 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
54668 return (void *)((wxWindow *) ((wxMenuBar *) x));
54669 }
54670 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
54671 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
54672 }
54673 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
54674 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
54675 }
54676 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
54677 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
54678 }
54679 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
54680 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
54681 }
54682 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
54683 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
54684 }
54685 static void *_p_wxClipboardTextEventTo_p_wxCommandEvent(void *x) {
54686 return (void *)((wxCommandEvent *) ((wxClipboardTextEvent *) x));
54687 }
54688 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
54689 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54690 }
54691 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
54692 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
54693 }
54694 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
54695 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
54696 }
54697 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
54698 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
54699 }
54700 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
54701 return (void *)((wxValidator *) ((wxPyValidator *) x));
54702 }
54703 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, (void*)0, 0};
54704 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
54705 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};
54706 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
54707 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
54708 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
54709 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
54710 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
54711 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", "wxANIHandler *", 0, 0, (void*)0, 0};
54712 static swig_type_info _swigt__p_wxAcceleratorEntry = {"_p_wxAcceleratorEntry", "wxAcceleratorEntry *", 0, 0, (void*)0, 0};
54713 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", "wxAcceleratorTable *", 0, 0, (void*)0, 0};
54714 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", "wxActivateEvent *", 0, 0, (void*)0, 0};
54715 static swig_type_info _swigt__p_wxAppTraits = {"_p_wxAppTraits", "wxAppTraits *", 0, 0, (void*)0, 0};
54716 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
54717 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", "wxBMPHandler *", 0, 0, (void*)0, 0};
54718 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
54719 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", "wxBoxSizer *", 0, 0, (void*)0, 0};
54720 static swig_type_info _swigt__p_wxButton = {"_p_wxButton", "wxButton *", 0, 0, (void*)0, 0};
54721 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", "wxCURHandler *", 0, 0, (void*)0, 0};
54722 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
54723 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", "wxChildFocusEvent *", 0, 0, (void*)0, 0};
54724 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", "wxClipboardTextEvent *", 0, 0, (void*)0, 0};
54725 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", "wxCloseEvent *", 0, 0, (void*)0, 0};
54726 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
54727 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
54728 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", "wxContextMenuEvent *", 0, 0, (void*)0, 0};
54729 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
54730 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", "wxControlWithItems *", 0, 0, (void*)0, 0};
54731 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
54732 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
54733 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", "wxDateEvent *", 0, 0, (void*)0, 0};
54734 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
54735 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", "wxDisplayChangedEvent *", 0, 0, (void*)0, 0};
54736 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", "wxDropFilesEvent *", 0, 0, (void*)0, 0};
54737 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
54738 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", "wxEraseEvent *", 0, 0, (void*)0, 0};
54739 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
54740 static swig_type_info _swigt__p_wxEventLoop = {"_p_wxEventLoop", "wxEventLoop *", 0, 0, (void*)0, 0};
54741 static swig_type_info _swigt__p_wxEventLoopActivator = {"_p_wxEventLoopActivator", "wxEventLoopActivator *", 0, 0, (void*)0, 0};
54742 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
54743 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", "wxFSFile *", 0, 0, (void*)0, 0};
54744 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, (void*)0, 0};
54745 static swig_type_info _swigt__p_wxFileSystemHandler = {"_p_wxFileSystemHandler", "wxFileSystemHandler *", 0, 0, (void*)0, 0};
54746 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", "wxFlexGridSizer *", 0, 0, (void*)0, 0};
54747 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", "wxFocusEvent *", 0, 0, (void*)0, 0};
54748 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
54749 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
54750 static swig_type_info _swigt__p_wxGBPosition = {"_p_wxGBPosition", "wxGBPosition *", 0, 0, (void*)0, 0};
54751 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", "wxGBSizerItem *", 0, 0, (void*)0, 0};
54752 static swig_type_info _swigt__p_wxGBSpan = {"_p_wxGBSpan", "wxGBSpan *", 0, 0, (void*)0, 0};
54753 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", "wxGIFHandler *", 0, 0, (void*)0, 0};
54754 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", "wxGridBagSizer *", 0, 0, (void*)0, 0};
54755 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", "wxGridSizer *", 0, 0, (void*)0, 0};
54756 static swig_type_info _swigt__p_wxHelpEvent__Origin = {"_p_wxHelpEvent__Origin", "wxHelpEvent::Origin *", 0, 0, (void*)0, 0};
54757 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", "wxICOHandler *", 0, 0, (void*)0, 0};
54758 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", "wxIconizeEvent *", 0, 0, (void*)0, 0};
54759 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", "wxIdleEvent *", 0, 0, (void*)0, 0};
54760 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, (void*)0, 0};
54761 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", "wxImageHandler *", 0, 0, (void*)0, 0};
54762 static swig_type_info _swigt__p_wxImageHistogram = {"_p_wxImageHistogram", "wxImageHistogram *", 0, 0, (void*)0, 0};
54763 static swig_type_info _swigt__p_wxImage_HSVValue = {"_p_wxImage_HSVValue", "wxImage_HSVValue *", 0, 0, (void*)0, 0};
54764 static swig_type_info _swigt__p_wxImage_RGBValue = {"_p_wxImage_RGBValue", "wxImage_RGBValue *", 0, 0, (void*)0, 0};
54765 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", "wxIndividualLayoutConstraint *", 0, 0, (void*)0, 0};
54766 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", "wxInitDialogEvent *", 0, 0, (void*)0, 0};
54767 static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, (void*)0, 0};
54768 static swig_type_info _swigt__p_wxInternetFSHandler = {"_p_wxInternetFSHandler", "wxInternetFSHandler *", 0, 0, (void*)0, 0};
54769 static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, (void*)0, 0};
54770 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", "wxJPEGHandler *", 0, 0, (void*)0, 0};
54771 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
54772 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", "wxLayoutConstraints *", 0, 0, (void*)0, 0};
54773 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", "wxMaximizeEvent *", 0, 0, (void*)0, 0};
54774 static swig_type_info _swigt__p_wxMemoryFSHandler = {"_p_wxMemoryFSHandler", "wxMemoryFSHandler *", 0, 0, (void*)0, 0};
54775 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
54776 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", "wxMenuBar *", 0, 0, (void*)0, 0};
54777 static swig_type_info _swigt__p_wxMenuBarBase = {"_p_wxMenuBarBase", "wxMenuBarBase *", 0, 0, (void*)0, 0};
54778 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", "wxMenuEvent *", 0, 0, (void*)0, 0};
54779 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", "wxMenuItem *", 0, 0, (void*)0, 0};
54780 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", "wxMouseCaptureChangedEvent *", 0, 0, (void*)0, 0};
54781 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", "wxMouseEvent *", 0, 0, (void*)0, 0};
54782 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", "wxMoveEvent *", 0, 0, (void*)0, 0};
54783 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", "wxNavigationKeyEvent *", 0, 0, (void*)0, 0};
54784 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", "wxNcPaintEvent *", 0, 0, (void*)0, 0};
54785 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
54786 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
54787 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
54788 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", "wxPCXHandler *", 0, 0, (void*)0, 0};
54789 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", "wxPNGHandler *", 0, 0, (void*)0, 0};
54790 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", "wxPNMHandler *", 0, 0, (void*)0, 0};
54791 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", "wxPaintEvent *", 0, 0, (void*)0, 0};
54792 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", "wxPaletteChangedEvent *", 0, 0, (void*)0, 0};
54793 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
54794 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
54795 static swig_type_info _swigt__p_wxPoint2D = {"_p_wxPoint2D", "wxPoint2D *", 0, 0, (void*)0, 0};
54796 static swig_type_info _swigt__p_wxPropagateOnce = {"_p_wxPropagateOnce", "wxPropagateOnce *", 0, 0, (void*)0, 0};
54797 static swig_type_info _swigt__p_wxPropagationDisabler = {"_p_wxPropagationDisabler", "wxPropagationDisabler *", 0, 0, (void*)0, 0};
54798 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", "wxPyApp *", 0, 0, (void*)0, 0};
54799 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", "wxPyCommandEvent *", 0, 0, (void*)0, 0};
54800 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
54801 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", "wxPyEvent *", 0, 0, (void*)0, 0};
54802 static swig_type_info _swigt__p_wxPyFileSystemHandler = {"_p_wxPyFileSystemHandler", "wxPyFileSystemHandler *", 0, 0, (void*)0, 0};
54803 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", "wxPyImageHandler *", 0, 0, (void*)0, 0};
54804 static swig_type_info _swigt__p_wxPyInputStream = {"_p_wxPyInputStream", "wxPyInputStream *", 0, 0, (void*)0, 0};
54805 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", "wxPySizer *", 0, 0, (void*)0, 0};
54806 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", "wxPyValidator *", 0, 0, (void*)0, 0};
54807 static swig_type_info _swigt__p_wxQuantize = {"_p_wxQuantize", "wxQuantize *", 0, 0, (void*)0, 0};
54808 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", "wxQueryNewPaletteEvent *", 0, 0, (void*)0, 0};
54809 static swig_type_info _swigt__p_wxRealPoint = {"_p_wxRealPoint", "wxRealPoint *", 0, 0, (void*)0, 0};
54810 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
54811 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, (void*)0, 0};
54812 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", "wxScrollEvent *", 0, 0, (void*)0, 0};
54813 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", "wxScrollWinEvent *", 0, 0, (void*)0, 0};
54814 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", "wxSetCursorEvent *", 0, 0, (void*)0, 0};
54815 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", "wxShowEvent *", 0, 0, (void*)0, 0};
54816 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
54817 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", "wxSizeEvent *", 0, 0, (void*)0, 0};
54818 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", "wxSizer *", 0, 0, (void*)0, 0};
54819 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", "wxSizerItem *", 0, 0, (void*)0, 0};
54820 static swig_type_info _swigt__p_wxStaticBox = {"_p_wxStaticBox", "wxStaticBox *", 0, 0, (void*)0, 0};
54821 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", "wxStaticBoxSizer *", 0, 0, (void*)0, 0};
54822 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", "wxStdDialogButtonSizer *", 0, 0, (void*)0, 0};
54823 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", "wxSysColourChangedEvent *", 0, 0, (void*)0, 0};
54824 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", "wxTIFFHandler *", 0, 0, (void*)0, 0};
54825 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
54826 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", "wxUpdateUIEvent *", 0, 0, (void*)0, 0};
54827 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, (void*)0, 0};
54828 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
54829 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
54830 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", "wxWindowCreateEvent *", 0, 0, (void*)0, 0};
54831 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", "wxWindowDestroyEvent *", 0, 0, (void*)0, 0};
54832 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", "wxXPMHandler *", 0, 0, (void*)0, 0};
54833 static swig_type_info _swigt__p_wxZipFSHandler = {"_p_wxZipFSHandler", "wxZipFSHandler *", 0, 0, (void*)0, 0};
54834
54835 static swig_type_info *swig_type_initial[] = {
54836 &_swigt__p_buffer,
54837 &_swigt__p_char,
54838 &_swigt__p_form_ops_t,
54839 &_swigt__p_int,
54840 &_swigt__p_long,
54841 &_swigt__p_unsigned_char,
54842 &_swigt__p_unsigned_int,
54843 &_swigt__p_unsigned_long,
54844 &_swigt__p_wxANIHandler,
54845 &_swigt__p_wxAcceleratorEntry,
54846 &_swigt__p_wxAcceleratorTable,
54847 &_swigt__p_wxActivateEvent,
54848 &_swigt__p_wxAppTraits,
54849 &_swigt__p_wxArrayString,
54850 &_swigt__p_wxBMPHandler,
54851 &_swigt__p_wxBitmap,
54852 &_swigt__p_wxBoxSizer,
54853 &_swigt__p_wxButton,
54854 &_swigt__p_wxCURHandler,
54855 &_swigt__p_wxCaret,
54856 &_swigt__p_wxChildFocusEvent,
54857 &_swigt__p_wxClipboardTextEvent,
54858 &_swigt__p_wxCloseEvent,
54859 &_swigt__p_wxColour,
54860 &_swigt__p_wxCommandEvent,
54861 &_swigt__p_wxContextMenuEvent,
54862 &_swigt__p_wxControl,
54863 &_swigt__p_wxControlWithItems,
54864 &_swigt__p_wxCursor,
54865 &_swigt__p_wxDC,
54866 &_swigt__p_wxDateEvent,
54867 &_swigt__p_wxDateTime,
54868 &_swigt__p_wxDisplayChangedEvent,
54869 &_swigt__p_wxDropFilesEvent,
54870 &_swigt__p_wxDuplexMode,
54871 &_swigt__p_wxEraseEvent,
54872 &_swigt__p_wxEvent,
54873 &_swigt__p_wxEventLoop,
54874 &_swigt__p_wxEventLoopActivator,
54875 &_swigt__p_wxEvtHandler,
54876 &_swigt__p_wxFSFile,
54877 &_swigt__p_wxFileSystem,
54878 &_swigt__p_wxFileSystemHandler,
54879 &_swigt__p_wxFlexGridSizer,
54880 &_swigt__p_wxFocusEvent,
54881 &_swigt__p_wxFont,
54882 &_swigt__p_wxFrame,
54883 &_swigt__p_wxGBPosition,
54884 &_swigt__p_wxGBSizerItem,
54885 &_swigt__p_wxGBSpan,
54886 &_swigt__p_wxGIFHandler,
54887 &_swigt__p_wxGridBagSizer,
54888 &_swigt__p_wxGridSizer,
54889 &_swigt__p_wxHelpEvent__Origin,
54890 &_swigt__p_wxICOHandler,
54891 &_swigt__p_wxIconizeEvent,
54892 &_swigt__p_wxIdleEvent,
54893 &_swigt__p_wxImage,
54894 &_swigt__p_wxImageHandler,
54895 &_swigt__p_wxImageHistogram,
54896 &_swigt__p_wxImage_HSVValue,
54897 &_swigt__p_wxImage_RGBValue,
54898 &_swigt__p_wxIndividualLayoutConstraint,
54899 &_swigt__p_wxInitDialogEvent,
54900 &_swigt__p_wxInputStream,
54901 &_swigt__p_wxInternetFSHandler,
54902 &_swigt__p_wxItemContainer,
54903 &_swigt__p_wxJPEGHandler,
54904 &_swigt__p_wxKeyEvent,
54905 &_swigt__p_wxLayoutConstraints,
54906 &_swigt__p_wxMaximizeEvent,
54907 &_swigt__p_wxMemoryFSHandler,
54908 &_swigt__p_wxMenu,
54909 &_swigt__p_wxMenuBar,
54910 &_swigt__p_wxMenuBarBase,
54911 &_swigt__p_wxMenuEvent,
54912 &_swigt__p_wxMenuItem,
54913 &_swigt__p_wxMouseCaptureChangedEvent,
54914 &_swigt__p_wxMouseEvent,
54915 &_swigt__p_wxMoveEvent,
54916 &_swigt__p_wxNavigationKeyEvent,
54917 &_swigt__p_wxNcPaintEvent,
54918 &_swigt__p_wxNotifyEvent,
54919 &_swigt__p_wxObject,
54920 &_swigt__p_wxOutputStream,
54921 &_swigt__p_wxPCXHandler,
54922 &_swigt__p_wxPNGHandler,
54923 &_swigt__p_wxPNMHandler,
54924 &_swigt__p_wxPaintEvent,
54925 &_swigt__p_wxPaletteChangedEvent,
54926 &_swigt__p_wxPaperSize,
54927 &_swigt__p_wxPoint,
54928 &_swigt__p_wxPoint2D,
54929 &_swigt__p_wxPropagateOnce,
54930 &_swigt__p_wxPropagationDisabler,
54931 &_swigt__p_wxPyApp,
54932 &_swigt__p_wxPyCommandEvent,
54933 &_swigt__p_wxPyDropTarget,
54934 &_swigt__p_wxPyEvent,
54935 &_swigt__p_wxPyFileSystemHandler,
54936 &_swigt__p_wxPyImageHandler,
54937 &_swigt__p_wxPyInputStream,
54938 &_swigt__p_wxPySizer,
54939 &_swigt__p_wxPyValidator,
54940 &_swigt__p_wxQuantize,
54941 &_swigt__p_wxQueryNewPaletteEvent,
54942 &_swigt__p_wxRealPoint,
54943 &_swigt__p_wxRect,
54944 &_swigt__p_wxRegion,
54945 &_swigt__p_wxScrollEvent,
54946 &_swigt__p_wxScrollWinEvent,
54947 &_swigt__p_wxSetCursorEvent,
54948 &_swigt__p_wxShowEvent,
54949 &_swigt__p_wxSize,
54950 &_swigt__p_wxSizeEvent,
54951 &_swigt__p_wxSizer,
54952 &_swigt__p_wxSizerItem,
54953 &_swigt__p_wxStaticBox,
54954 &_swigt__p_wxStaticBoxSizer,
54955 &_swigt__p_wxStdDialogButtonSizer,
54956 &_swigt__p_wxSysColourChangedEvent,
54957 &_swigt__p_wxTIFFHandler,
54958 &_swigt__p_wxToolTip,
54959 &_swigt__p_wxUpdateUIEvent,
54960 &_swigt__p_wxValidator,
54961 &_swigt__p_wxVisualAttributes,
54962 &_swigt__p_wxWindow,
54963 &_swigt__p_wxWindowCreateEvent,
54964 &_swigt__p_wxWindowDestroyEvent,
54965 &_swigt__p_wxXPMHandler,
54966 &_swigt__p_wxZipFSHandler,
54967 };
54968
54969 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
54970 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
54971 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
54972 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
54973 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
54974 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
54975 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
54976 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
54977 static swig_cast_info _swigc__p_wxANIHandler[] = { {&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
54978 static swig_cast_info _swigc__p_wxAcceleratorEntry[] = { {&_swigt__p_wxAcceleratorEntry, 0, 0, 0},{0, 0, 0, 0}};
54979 static swig_cast_info _swigc__p_wxAcceleratorTable[] = { {&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
54980 static swig_cast_info _swigc__p_wxActivateEvent[] = { {&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
54981 static swig_cast_info _swigc__p_wxAppTraits[] = { {&_swigt__p_wxAppTraits, 0, 0, 0},{0, 0, 0, 0}};
54982 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
54983 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}};
54984 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
54985 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}};
54986 static swig_cast_info _swigc__p_wxButton[] = { {&_swigt__p_wxButton, 0, 0, 0},{0, 0, 0, 0}};
54987 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}};
54988 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
54989 static swig_cast_info _swigc__p_wxChildFocusEvent[] = { {&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
54990 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = { {&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
54991 static swig_cast_info _swigc__p_wxCloseEvent[] = { {&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
54992 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
54993 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}};
54994 static swig_cast_info _swigc__p_wxContextMenuEvent[] = { {&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
54995 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}};
54996 static swig_cast_info _swigc__p_wxControlWithItems[] = { {&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
54997 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
54998 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
54999 static swig_cast_info _swigc__p_wxDateEvent[] = { {&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
55000 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
55001 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = { {&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
55002 static swig_cast_info _swigc__p_wxDropFilesEvent[] = { {&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
55003 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
55004 static swig_cast_info _swigc__p_wxEraseEvent[] = { {&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
55005 static swig_cast_info _swigc__p_wxEvent[] = { {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEvent, 0, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxEvent, 0, 0},{0, 0, 0, 0}};
55006 static swig_cast_info _swigc__p_wxEventLoop[] = { {&_swigt__p_wxEventLoop, 0, 0, 0},{0, 0, 0, 0}};
55007 static swig_cast_info _swigc__p_wxEventLoopActivator[] = { {&_swigt__p_wxEventLoopActivator, 0, 0, 0},{0, 0, 0, 0}};
55008 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}};
55009 static swig_cast_info _swigc__p_wxFSFile[] = { {&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
55010 static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
55011 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}};
55012 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}};
55013 static swig_cast_info _swigc__p_wxFocusEvent[] = { {&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
55014 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
55015 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
55016 static swig_cast_info _swigc__p_wxGBPosition[] = { {&_swigt__p_wxGBPosition, 0, 0, 0},{0, 0, 0, 0}};
55017 static swig_cast_info _swigc__p_wxGBSizerItem[] = { {&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
55018 static swig_cast_info _swigc__p_wxGBSpan[] = { {&_swigt__p_wxGBSpan, 0, 0, 0},{0, 0, 0, 0}};
55019 static swig_cast_info _swigc__p_wxGIFHandler[] = { {&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
55020 static swig_cast_info _swigc__p_wxGridBagSizer[] = { {&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
55021 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}};
55022 static swig_cast_info _swigc__p_wxHelpEvent__Origin[] = { {&_swigt__p_wxHelpEvent__Origin, 0, 0, 0},{0, 0, 0, 0}};
55023 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}};
55024 static swig_cast_info _swigc__p_wxIconizeEvent[] = { {&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
55025 static swig_cast_info _swigc__p_wxIdleEvent[] = { {&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
55026 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
55027 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}};
55028 static swig_cast_info _swigc__p_wxImageHistogram[] = { {&_swigt__p_wxImageHistogram, 0, 0, 0},{0, 0, 0, 0}};
55029 static swig_cast_info _swigc__p_wxImage_HSVValue[] = { {&_swigt__p_wxImage_HSVValue, 0, 0, 0},{0, 0, 0, 0}};
55030 static swig_cast_info _swigc__p_wxImage_RGBValue[] = { {&_swigt__p_wxImage_RGBValue, 0, 0, 0},{0, 0, 0, 0}};
55031 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = { {&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
55032 static swig_cast_info _swigc__p_wxInitDialogEvent[] = { {&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
55033 static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
55034 static swig_cast_info _swigc__p_wxInternetFSHandler[] = { {&_swigt__p_wxInternetFSHandler, 0, 0, 0},{0, 0, 0, 0}};
55035 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}};
55036 static swig_cast_info _swigc__p_wxJPEGHandler[] = { {&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
55037 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
55038 static swig_cast_info _swigc__p_wxLayoutConstraints[] = { {&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
55039 static swig_cast_info _swigc__p_wxMaximizeEvent[] = { {&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
55040 static swig_cast_info _swigc__p_wxMemoryFSHandler[] = { {&_swigt__p_wxMemoryFSHandler, 0, 0, 0},{0, 0, 0, 0}};
55041 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
55042 static swig_cast_info _swigc__p_wxMenuBar[] = { {&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
55043 static swig_cast_info _swigc__p_wxMenuBarBase[] = { {&_swigt__p_wxMenuBarBase, 0, 0, 0},{0, 0, 0, 0}};
55044 static swig_cast_info _swigc__p_wxMenuEvent[] = { {&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
55045 static swig_cast_info _swigc__p_wxMenuItem[] = { {&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
55046 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = { {&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
55047 static swig_cast_info _swigc__p_wxMouseEvent[] = { {&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
55048 static swig_cast_info _swigc__p_wxMoveEvent[] = { {&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
55049 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = { {&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
55050 static swig_cast_info _swigc__p_wxNcPaintEvent[] = { {&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
55051 static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
55052 static swig_cast_info _swigc__p_wxObject[] = { {&_swigt__p_wxLayoutConstraints, _p_wxLayoutConstraintsTo_p_wxObject, 0, 0}, {&_swigt__p_wxGBSizerItem, _p_wxGBSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizerItem, _p_wxSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIndividualLayoutConstraint, _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0}, {&_swigt__p_wxStaticBoxSizer, _p_wxStaticBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBoxSizer, _p_wxBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizer, _p_wxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridBagSizer, _p_wxGridBagSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvent, _p_wxEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFlexGridSizer, _p_wxFlexGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridSizer, _p_wxGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControl, _p_wxControlTo_p_wxObject, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFSFile, _p_wxFSFileTo_p_wxObject, 0, 0}, {&_swigt__p_wxPySizer, _p_wxPySizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuItem, _p_wxMenuItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPCXHandler, _p_wxPCXHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGIFHandler, _p_wxGIFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNGHandler, _p_wxPNGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxCURHandler, _p_wxCURHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxICOHandler, _p_wxICOHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBMPHandler, _p_wxBMPHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyImageHandler, _p_wxPyImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxImageHandler, _p_wxImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxXPMHandler, _p_wxXPMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxTIFFHandler, _p_wxTIFFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvtHandler, _p_wxEvtHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNMHandler, _p_wxPNMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxStdDialogButtonSizer, _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxAcceleratorTable, _p_wxAcceleratorTableTo_p_wxObject, 0, 0}, {&_swigt__p_wxImage, _p_wxImageTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxObject, 0, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileSystem, _p_wxFileSystemTo_p_wxObject, 0, 0}, {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxObject, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxObject, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxObject, 0, 0},{0, 0, 0, 0}};
55053 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
55054 static swig_cast_info _swigc__p_wxPCXHandler[] = { {&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
55055 static swig_cast_info _swigc__p_wxPNGHandler[] = { {&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
55056 static swig_cast_info _swigc__p_wxPNMHandler[] = { {&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
55057 static swig_cast_info _swigc__p_wxPaintEvent[] = { {&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
55058 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = { {&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
55059 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
55060 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
55061 static swig_cast_info _swigc__p_wxPoint2D[] = { {&_swigt__p_wxPoint2D, 0, 0, 0},{0, 0, 0, 0}};
55062 static swig_cast_info _swigc__p_wxPropagateOnce[] = { {&_swigt__p_wxPropagateOnce, 0, 0, 0},{0, 0, 0, 0}};
55063 static swig_cast_info _swigc__p_wxPropagationDisabler[] = { {&_swigt__p_wxPropagationDisabler, 0, 0, 0},{0, 0, 0, 0}};
55064 static swig_cast_info _swigc__p_wxPyApp[] = { {&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
55065 static swig_cast_info _swigc__p_wxPyCommandEvent[] = { {&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
55066 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0},{0, 0, 0, 0}};
55067 static swig_cast_info _swigc__p_wxPyEvent[] = { {&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
55068 static swig_cast_info _swigc__p_wxPyFileSystemHandler[] = { {&_swigt__p_wxPyFileSystemHandler, 0, 0, 0},{0, 0, 0, 0}};
55069 static swig_cast_info _swigc__p_wxPyImageHandler[] = { {&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
55070 static swig_cast_info _swigc__p_wxPyInputStream[] = { {&_swigt__p_wxPyInputStream, 0, 0, 0},{0, 0, 0, 0}};
55071 static swig_cast_info _swigc__p_wxPySizer[] = { {&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
55072 static swig_cast_info _swigc__p_wxPyValidator[] = { {&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
55073 static swig_cast_info _swigc__p_wxQuantize[] = { {&_swigt__p_wxQuantize, 0, 0, 0},{0, 0, 0, 0}};
55074 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = { {&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
55075 static swig_cast_info _swigc__p_wxRealPoint[] = { {&_swigt__p_wxRealPoint, 0, 0, 0},{0, 0, 0, 0}};
55076 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
55077 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
55078 static swig_cast_info _swigc__p_wxScrollEvent[] = { {&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
55079 static swig_cast_info _swigc__p_wxScrollWinEvent[] = { {&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
55080 static swig_cast_info _swigc__p_wxSetCursorEvent[] = { {&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
55081 static swig_cast_info _swigc__p_wxShowEvent[] = { {&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
55082 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
55083 static swig_cast_info _swigc__p_wxSizeEvent[] = { {&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
55084 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}};
55085 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}};
55086 static swig_cast_info _swigc__p_wxStaticBox[] = { {&_swigt__p_wxStaticBox, 0, 0, 0},{0, 0, 0, 0}};
55087 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = { {&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
55088 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = { {&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
55089 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = { {&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
55090 static swig_cast_info _swigc__p_wxTIFFHandler[] = { {&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
55091 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
55092 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = { {&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
55093 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}};
55094 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
55095 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}};
55096 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = { {&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
55097 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = { {&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
55098 static swig_cast_info _swigc__p_wxXPMHandler[] = { {&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
55099 static swig_cast_info _swigc__p_wxZipFSHandler[] = { {&_swigt__p_wxZipFSHandler, 0, 0, 0},{0, 0, 0, 0}};
55100
55101 static swig_cast_info *swig_cast_initial[] = {
55102 _swigc__p_buffer,
55103 _swigc__p_char,
55104 _swigc__p_form_ops_t,
55105 _swigc__p_int,
55106 _swigc__p_long,
55107 _swigc__p_unsigned_char,
55108 _swigc__p_unsigned_int,
55109 _swigc__p_unsigned_long,
55110 _swigc__p_wxANIHandler,
55111 _swigc__p_wxAcceleratorEntry,
55112 _swigc__p_wxAcceleratorTable,
55113 _swigc__p_wxActivateEvent,
55114 _swigc__p_wxAppTraits,
55115 _swigc__p_wxArrayString,
55116 _swigc__p_wxBMPHandler,
55117 _swigc__p_wxBitmap,
55118 _swigc__p_wxBoxSizer,
55119 _swigc__p_wxButton,
55120 _swigc__p_wxCURHandler,
55121 _swigc__p_wxCaret,
55122 _swigc__p_wxChildFocusEvent,
55123 _swigc__p_wxClipboardTextEvent,
55124 _swigc__p_wxCloseEvent,
55125 _swigc__p_wxColour,
55126 _swigc__p_wxCommandEvent,
55127 _swigc__p_wxContextMenuEvent,
55128 _swigc__p_wxControl,
55129 _swigc__p_wxControlWithItems,
55130 _swigc__p_wxCursor,
55131 _swigc__p_wxDC,
55132 _swigc__p_wxDateEvent,
55133 _swigc__p_wxDateTime,
55134 _swigc__p_wxDisplayChangedEvent,
55135 _swigc__p_wxDropFilesEvent,
55136 _swigc__p_wxDuplexMode,
55137 _swigc__p_wxEraseEvent,
55138 _swigc__p_wxEvent,
55139 _swigc__p_wxEventLoop,
55140 _swigc__p_wxEventLoopActivator,
55141 _swigc__p_wxEvtHandler,
55142 _swigc__p_wxFSFile,
55143 _swigc__p_wxFileSystem,
55144 _swigc__p_wxFileSystemHandler,
55145 _swigc__p_wxFlexGridSizer,
55146 _swigc__p_wxFocusEvent,
55147 _swigc__p_wxFont,
55148 _swigc__p_wxFrame,
55149 _swigc__p_wxGBPosition,
55150 _swigc__p_wxGBSizerItem,
55151 _swigc__p_wxGBSpan,
55152 _swigc__p_wxGIFHandler,
55153 _swigc__p_wxGridBagSizer,
55154 _swigc__p_wxGridSizer,
55155 _swigc__p_wxHelpEvent__Origin,
55156 _swigc__p_wxICOHandler,
55157 _swigc__p_wxIconizeEvent,
55158 _swigc__p_wxIdleEvent,
55159 _swigc__p_wxImage,
55160 _swigc__p_wxImageHandler,
55161 _swigc__p_wxImageHistogram,
55162 _swigc__p_wxImage_HSVValue,
55163 _swigc__p_wxImage_RGBValue,
55164 _swigc__p_wxIndividualLayoutConstraint,
55165 _swigc__p_wxInitDialogEvent,
55166 _swigc__p_wxInputStream,
55167 _swigc__p_wxInternetFSHandler,
55168 _swigc__p_wxItemContainer,
55169 _swigc__p_wxJPEGHandler,
55170 _swigc__p_wxKeyEvent,
55171 _swigc__p_wxLayoutConstraints,
55172 _swigc__p_wxMaximizeEvent,
55173 _swigc__p_wxMemoryFSHandler,
55174 _swigc__p_wxMenu,
55175 _swigc__p_wxMenuBar,
55176 _swigc__p_wxMenuBarBase,
55177 _swigc__p_wxMenuEvent,
55178 _swigc__p_wxMenuItem,
55179 _swigc__p_wxMouseCaptureChangedEvent,
55180 _swigc__p_wxMouseEvent,
55181 _swigc__p_wxMoveEvent,
55182 _swigc__p_wxNavigationKeyEvent,
55183 _swigc__p_wxNcPaintEvent,
55184 _swigc__p_wxNotifyEvent,
55185 _swigc__p_wxObject,
55186 _swigc__p_wxOutputStream,
55187 _swigc__p_wxPCXHandler,
55188 _swigc__p_wxPNGHandler,
55189 _swigc__p_wxPNMHandler,
55190 _swigc__p_wxPaintEvent,
55191 _swigc__p_wxPaletteChangedEvent,
55192 _swigc__p_wxPaperSize,
55193 _swigc__p_wxPoint,
55194 _swigc__p_wxPoint2D,
55195 _swigc__p_wxPropagateOnce,
55196 _swigc__p_wxPropagationDisabler,
55197 _swigc__p_wxPyApp,
55198 _swigc__p_wxPyCommandEvent,
55199 _swigc__p_wxPyDropTarget,
55200 _swigc__p_wxPyEvent,
55201 _swigc__p_wxPyFileSystemHandler,
55202 _swigc__p_wxPyImageHandler,
55203 _swigc__p_wxPyInputStream,
55204 _swigc__p_wxPySizer,
55205 _swigc__p_wxPyValidator,
55206 _swigc__p_wxQuantize,
55207 _swigc__p_wxQueryNewPaletteEvent,
55208 _swigc__p_wxRealPoint,
55209 _swigc__p_wxRect,
55210 _swigc__p_wxRegion,
55211 _swigc__p_wxScrollEvent,
55212 _swigc__p_wxScrollWinEvent,
55213 _swigc__p_wxSetCursorEvent,
55214 _swigc__p_wxShowEvent,
55215 _swigc__p_wxSize,
55216 _swigc__p_wxSizeEvent,
55217 _swigc__p_wxSizer,
55218 _swigc__p_wxSizerItem,
55219 _swigc__p_wxStaticBox,
55220 _swigc__p_wxStaticBoxSizer,
55221 _swigc__p_wxStdDialogButtonSizer,
55222 _swigc__p_wxSysColourChangedEvent,
55223 _swigc__p_wxTIFFHandler,
55224 _swigc__p_wxToolTip,
55225 _swigc__p_wxUpdateUIEvent,
55226 _swigc__p_wxValidator,
55227 _swigc__p_wxVisualAttributes,
55228 _swigc__p_wxWindow,
55229 _swigc__p_wxWindowCreateEvent,
55230 _swigc__p_wxWindowDestroyEvent,
55231 _swigc__p_wxXPMHandler,
55232 _swigc__p_wxZipFSHandler,
55233 };
55234
55235
55236 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
55237
55238 static swig_const_info swig_const_table[] = {
55239 {0, 0, 0, 0.0, 0, 0}};
55240
55241 #ifdef __cplusplus
55242 }
55243 #endif
55244 /* -----------------------------------------------------------------------------
55245 * Type initialization:
55246 * This problem is tough by the requirement that no dynamic
55247 * memory is used. Also, since swig_type_info structures store pointers to
55248 * swig_cast_info structures and swig_cast_info structures store pointers back
55249 * to swig_type_info structures, we need some lookup code at initialization.
55250 * The idea is that swig generates all the structures that are needed.
55251 * The runtime then collects these partially filled structures.
55252 * The SWIG_InitializeModule function takes these initial arrays out of
55253 * swig_module, and does all the lookup, filling in the swig_module.types
55254 * array with the correct data and linking the correct swig_cast_info
55255 * structures together.
55256 *
55257 * The generated swig_type_info structures are assigned staticly to an initial
55258 * array. We just loop though that array, and handle each type individually.
55259 * First we lookup if this type has been already loaded, and if so, use the
55260 * loaded structure instead of the generated one. Then we have to fill in the
55261 * cast linked list. The cast data is initially stored in something like a
55262 * two-dimensional array. Each row corresponds to a type (there are the same
55263 * number of rows as there are in the swig_type_initial array). Each entry in
55264 * a column is one of the swig_cast_info structures for that type.
55265 * The cast_initial array is actually an array of arrays, because each row has
55266 * a variable number of columns. So to actually build the cast linked list,
55267 * we find the array of casts associated with the type, and loop through it
55268 * adding the casts to the list. The one last trick we need to do is making
55269 * sure the type pointer in the swig_cast_info struct is correct.
55270 *
55271 * First off, we lookup the cast->type name to see if it is already loaded.
55272 * There are three cases to handle:
55273 * 1) If the cast->type has already been loaded AND the type we are adding
55274 * casting info to has not been loaded (it is in this module), THEN we
55275 * replace the cast->type pointer with the type pointer that has already
55276 * been loaded.
55277 * 2) If BOTH types (the one we are adding casting info to, and the
55278 * cast->type) are loaded, THEN the cast info has already been loaded by
55279 * the previous module so we just ignore it.
55280 * 3) Finally, if cast->type has not already been loaded, then we add that
55281 * swig_cast_info to the linked list (because the cast->type) pointer will
55282 * be correct.
55283 * ----------------------------------------------------------------------------- */
55284
55285 #ifdef __cplusplus
55286 extern "C" {
55287 #if 0
55288 } /* c-mode */
55289 #endif
55290 #endif
55291
55292 #if 0
55293 #define SWIGRUNTIME_DEBUG
55294 #endif
55295
55296 SWIGRUNTIME void
55297 SWIG_InitializeModule(void *clientdata) {
55298 size_t i;
55299 swig_module_info *module_head;
55300 static int init_run = 0;
55301
55302 clientdata = clientdata;
55303
55304 if (init_run) return;
55305 init_run = 1;
55306
55307 /* Initialize the swig_module */
55308 swig_module.type_initial = swig_type_initial;
55309 swig_module.cast_initial = swig_cast_initial;
55310
55311 /* Try and load any already created modules */
55312 module_head = SWIG_GetModule(clientdata);
55313 if (module_head) {
55314 swig_module.next = module_head->next;
55315 module_head->next = &swig_module;
55316 } else {
55317 /* This is the first module loaded */
55318 swig_module.next = &swig_module;
55319 SWIG_SetModule(clientdata, &swig_module);
55320 }
55321
55322 /* Now work on filling in swig_module.types */
55323 #ifdef SWIGRUNTIME_DEBUG
55324 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
55325 #endif
55326 for (i = 0; i < swig_module.size; ++i) {
55327 swig_type_info *type = 0;
55328 swig_type_info *ret;
55329 swig_cast_info *cast;
55330
55331 #ifdef SWIGRUNTIME_DEBUG
55332 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
55333 #endif
55334
55335 /* if there is another module already loaded */
55336 if (swig_module.next != &swig_module) {
55337 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
55338 }
55339 if (type) {
55340 /* Overwrite clientdata field */
55341 #ifdef SWIGRUNTIME_DEBUG
55342 printf("SWIG_InitializeModule: found type %s\n", type->name);
55343 #endif
55344 if (swig_module.type_initial[i]->clientdata) {
55345 type->clientdata = swig_module.type_initial[i]->clientdata;
55346 #ifdef SWIGRUNTIME_DEBUG
55347 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
55348 #endif
55349 }
55350 } else {
55351 type = swig_module.type_initial[i];
55352 }
55353
55354 /* Insert casting types */
55355 cast = swig_module.cast_initial[i];
55356 while (cast->type) {
55357 /* Don't need to add information already in the list */
55358 ret = 0;
55359 #ifdef SWIGRUNTIME_DEBUG
55360 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
55361 #endif
55362 if (swig_module.next != &swig_module) {
55363 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
55364 #ifdef SWIGRUNTIME_DEBUG
55365 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
55366 #endif
55367 }
55368 if (ret) {
55369 if (type == swig_module.type_initial[i]) {
55370 #ifdef SWIGRUNTIME_DEBUG
55371 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
55372 #endif
55373 cast->type = ret;
55374 ret = 0;
55375 } else {
55376 /* Check for casting already in the list */
55377 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
55378 #ifdef SWIGRUNTIME_DEBUG
55379 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
55380 #endif
55381 if (!ocast) ret = 0;
55382 }
55383 }
55384
55385 if (!ret) {
55386 #ifdef SWIGRUNTIME_DEBUG
55387 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
55388 #endif
55389 if (type->cast) {
55390 type->cast->prev = cast;
55391 cast->next = type->cast;
55392 }
55393 type->cast = cast;
55394 }
55395 cast++;
55396 }
55397 /* Set entry in modules->types array equal to the type */
55398 swig_module.types[i] = type;
55399 }
55400 swig_module.types[i] = 0;
55401
55402 #ifdef SWIGRUNTIME_DEBUG
55403 printf("**** SWIG_InitializeModule: Cast List ******\n");
55404 for (i = 0; i < swig_module.size; ++i) {
55405 int j = 0;
55406 swig_cast_info *cast = swig_module.cast_initial[i];
55407 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
55408 while (cast->type) {
55409 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
55410 cast++;
55411 ++j;
55412 }
55413 printf("---- Total casts: %d\n",j);
55414 }
55415 printf("**** SWIG_InitializeModule: Cast List ******\n");
55416 #endif
55417 }
55418
55419 /* This function will propagate the clientdata field of type to
55420 * any new swig_type_info structures that have been added into the list
55421 * of equivalent types. It is like calling
55422 * SWIG_TypeClientData(type, clientdata) a second time.
55423 */
55424 SWIGRUNTIME void
55425 SWIG_PropagateClientData(void) {
55426 size_t i;
55427 swig_cast_info *equiv;
55428 static int init_run = 0;
55429
55430 if (init_run) return;
55431 init_run = 1;
55432
55433 for (i = 0; i < swig_module.size; i++) {
55434 if (swig_module.types[i]->clientdata) {
55435 equiv = swig_module.types[i]->cast;
55436 while (equiv) {
55437 if (!equiv->converter) {
55438 if (equiv->type && !equiv->type->clientdata)
55439 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
55440 }
55441 equiv = equiv->next;
55442 }
55443 }
55444 }
55445 }
55446
55447 #ifdef __cplusplus
55448 #if 0
55449 {
55450 /* c-mode */
55451 #endif
55452 }
55453 #endif
55454
55455
55456
55457 #ifdef __cplusplus
55458 extern "C" {
55459 #endif
55460
55461 /* Python-specific SWIG API */
55462 #define SWIG_newvarlink() SWIG_Python_newvarlink()
55463 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
55464 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
55465
55466 /* -----------------------------------------------------------------------------
55467 * global variable support code.
55468 * ----------------------------------------------------------------------------- */
55469
55470 typedef struct swig_globalvar {
55471 char *name; /* Name of global variable */
55472 PyObject *(*get_attr)(void); /* Return the current value */
55473 int (*set_attr)(PyObject *); /* Set the value */
55474 struct swig_globalvar *next;
55475 } swig_globalvar;
55476
55477 typedef struct swig_varlinkobject {
55478 PyObject_HEAD
55479 swig_globalvar *vars;
55480 } swig_varlinkobject;
55481
55482 SWIGINTERN PyObject *
55483 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
55484 return PyString_FromString("<Swig global variables>");
55485 }
55486
55487 SWIGINTERN PyObject *
55488 swig_varlink_str(swig_varlinkobject *v) {
55489 PyObject *str = PyString_FromString("(");
55490 swig_globalvar *var;
55491 for (var = v->vars; var; var=var->next) {
55492 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
55493 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
55494 }
55495 PyString_ConcatAndDel(&str,PyString_FromString(")"));
55496 return str;
55497 }
55498
55499 SWIGINTERN int
55500 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
55501 PyObject *str = swig_varlink_str(v);
55502 fprintf(fp,"Swig global variables ");
55503 fprintf(fp,"%s\n", PyString_AsString(str));
55504 Py_DECREF(str);
55505 return 0;
55506 }
55507
55508 SWIGINTERN void
55509 swig_varlink_dealloc(swig_varlinkobject *v) {
55510 swig_globalvar *var = v->vars;
55511 while (var) {
55512 swig_globalvar *n = var->next;
55513 free(var->name);
55514 free(var);
55515 var = n;
55516 }
55517 }
55518
55519 SWIGINTERN PyObject *
55520 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
55521 PyObject *res = NULL;
55522 swig_globalvar *var = v->vars;
55523 while (var) {
55524 if (strcmp(var->name,n) == 0) {
55525 res = (*var->get_attr)();
55526 break;
55527 }
55528 var = var->next;
55529 }
55530 if (res == NULL && !PyErr_Occurred()) {
55531 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
55532 }
55533 return res;
55534 }
55535
55536 SWIGINTERN int
55537 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
55538 int res = 1;
55539 swig_globalvar *var = v->vars;
55540 while (var) {
55541 if (strcmp(var->name,n) == 0) {
55542 res = (*var->set_attr)(p);
55543 break;
55544 }
55545 var = var->next;
55546 }
55547 if (res == 1 && !PyErr_Occurred()) {
55548 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
55549 }
55550 return res;
55551 }
55552
55553 SWIGINTERN PyTypeObject*
55554 swig_varlink_type(void) {
55555 static char varlink__doc__[] = "Swig var link object";
55556 static PyTypeObject varlink_type;
55557 static int type_init = 0;
55558 if (!type_init) {
55559 const PyTypeObject tmp
55560 = {
55561 PyObject_HEAD_INIT(NULL)
55562 0, /* Number of items in variable part (ob_size) */
55563 (char *)"swigvarlink", /* Type name (tp_name) */
55564 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
55565 0, /* Itemsize (tp_itemsize) */
55566 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
55567 (printfunc) swig_varlink_print, /* Print (tp_print) */
55568 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
55569 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
55570 0, /* tp_compare */
55571 (reprfunc) swig_varlink_repr, /* tp_repr */
55572 0, /* tp_as_number */
55573 0, /* tp_as_sequence */
55574 0, /* tp_as_mapping */
55575 0, /* tp_hash */
55576 0, /* tp_call */
55577 (reprfunc)swig_varlink_str, /* tp_str */
55578 0, /* tp_getattro */
55579 0, /* tp_setattro */
55580 0, /* tp_as_buffer */
55581 0, /* tp_flags */
55582 varlink__doc__, /* tp_doc */
55583 0, /* tp_traverse */
55584 0, /* tp_clear */
55585 0, /* tp_richcompare */
55586 0, /* tp_weaklistoffset */
55587 #if PY_VERSION_HEX >= 0x02020000
55588 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
55589 #endif
55590 #if PY_VERSION_HEX >= 0x02030000
55591 0, /* tp_del */
55592 #endif
55593 #ifdef COUNT_ALLOCS
55594 0,0,0,0 /* tp_alloc -> tp_next */
55595 #endif
55596 };
55597 varlink_type = tmp;
55598 varlink_type.ob_type = &PyType_Type;
55599 type_init = 1;
55600 }
55601 return &varlink_type;
55602 }
55603
55604 /* Create a variable linking object for use later */
55605 SWIGINTERN PyObject *
55606 SWIG_Python_newvarlink(void) {
55607 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
55608 if (result) {
55609 result->vars = 0;
55610 }
55611 return ((PyObject*) result);
55612 }
55613
55614 SWIGINTERN void
55615 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
55616 swig_varlinkobject *v = (swig_varlinkobject *) p;
55617 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
55618 if (gv) {
55619 size_t size = strlen(name)+1;
55620 gv->name = (char *)malloc(size);
55621 if (gv->name) {
55622 strncpy(gv->name,name,size);
55623 gv->get_attr = get_attr;
55624 gv->set_attr = set_attr;
55625 gv->next = v->vars;
55626 }
55627 }
55628 v->vars = gv;
55629 }
55630
55631 SWIGINTERN PyObject *
55632 SWIG_globals() {
55633 static PyObject *_SWIG_globals = 0;
55634 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
55635 return _SWIG_globals;
55636 }
55637
55638 /* -----------------------------------------------------------------------------
55639 * constants/methods manipulation
55640 * ----------------------------------------------------------------------------- */
55641
55642 /* Install Constants */
55643 SWIGINTERN void
55644 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
55645 PyObject *obj = 0;
55646 size_t i;
55647 for (i = 0; constants[i].type; ++i) {
55648 switch(constants[i].type) {
55649 case SWIG_PY_POINTER:
55650 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
55651 break;
55652 case SWIG_PY_BINARY:
55653 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
55654 break;
55655 default:
55656 obj = 0;
55657 break;
55658 }
55659 if (obj) {
55660 PyDict_SetItemString(d, constants[i].name, obj);
55661 Py_DECREF(obj);
55662 }
55663 }
55664 }
55665
55666 /* -----------------------------------------------------------------------------*/
55667 /* Fix SwigMethods to carry the callback ptrs when needed */
55668 /* -----------------------------------------------------------------------------*/
55669
55670 SWIGINTERN void
55671 SWIG_Python_FixMethods(PyMethodDef *methods,
55672 swig_const_info *const_table,
55673 swig_type_info **types,
55674 swig_type_info **types_initial) {
55675 size_t i;
55676 for (i = 0; methods[i].ml_name; ++i) {
55677 char *c = methods[i].ml_doc;
55678 if (c && (c = strstr(c, "swig_ptr: "))) {
55679 int j;
55680 swig_const_info *ci = 0;
55681 char *name = c + 10;
55682 for (j = 0; const_table[j].type; ++j) {
55683 if (strncmp(const_table[j].name, name,
55684 strlen(const_table[j].name)) == 0) {
55685 ci = &(const_table[j]);
55686 break;
55687 }
55688 }
55689 if (ci) {
55690 size_t shift = (ci->ptype) - types;
55691 swig_type_info *ty = types_initial[shift];
55692 size_t ldoc = (c - methods[i].ml_doc);
55693 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
55694 char *ndoc = (char*)malloc(ldoc + lptr + 10);
55695 if (ndoc) {
55696 char *buff = ndoc;
55697 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
55698 if (ptr) {
55699 strncpy(buff, methods[i].ml_doc, ldoc);
55700 buff += ldoc;
55701 strncpy(buff, "swig_ptr: ", 10);
55702 buff += 10;
55703 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
55704 methods[i].ml_doc = ndoc;
55705 }
55706 }
55707 }
55708 }
55709 }
55710 }
55711
55712 #ifdef __cplusplus
55713 }
55714 #endif
55715
55716 /* -----------------------------------------------------------------------------*
55717 * Partial Init method
55718 * -----------------------------------------------------------------------------*/
55719
55720 #ifdef __cplusplus
55721 extern "C"
55722 #endif
55723 SWIGEXPORT void SWIG_init(void) {
55724 PyObject *m, *d;
55725
55726 /* Fix SwigMethods to carry the callback ptrs when needed */
55727 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
55728
55729 m = Py_InitModule((char *) SWIG_name, SwigMethods);
55730 d = PyModule_GetDict(m);
55731
55732 SWIG_InitializeModule(0);
55733 SWIG_InstallConstants(d,swig_const_table);
55734
55735
55736
55737 #ifndef wxPyUSE_EXPORT
55738 // Make our API structure a CObject so other modules can import it
55739 // from this module.
55740 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
55741 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
55742 Py_XDECREF(cobj);
55743 #endif
55744
55745 SWIG_Python_SetConstant(d, "NOT_FOUND",SWIG_From_int(static_cast< int >(wxNOT_FOUND)));
55746 SWIG_Python_SetConstant(d, "VSCROLL",SWIG_From_int(static_cast< int >(wxVSCROLL)));
55747 SWIG_Python_SetConstant(d, "HSCROLL",SWIG_From_int(static_cast< int >(wxHSCROLL)));
55748 SWIG_Python_SetConstant(d, "CAPTION",SWIG_From_int(static_cast< int >(wxCAPTION)));
55749 SWIG_Python_SetConstant(d, "DOUBLE_BORDER",SWIG_From_int(static_cast< int >(wxDOUBLE_BORDER)));
55750 SWIG_Python_SetConstant(d, "SUNKEN_BORDER",SWIG_From_int(static_cast< int >(wxSUNKEN_BORDER)));
55751 SWIG_Python_SetConstant(d, "RAISED_BORDER",SWIG_From_int(static_cast< int >(wxRAISED_BORDER)));
55752 SWIG_Python_SetConstant(d, "BORDER",SWIG_From_int(static_cast< int >(wxBORDER)));
55753 SWIG_Python_SetConstant(d, "SIMPLE_BORDER",SWIG_From_int(static_cast< int >(wxSIMPLE_BORDER)));
55754 SWIG_Python_SetConstant(d, "STATIC_BORDER",SWIG_From_int(static_cast< int >(wxSTATIC_BORDER)));
55755 SWIG_Python_SetConstant(d, "TRANSPARENT_WINDOW",SWIG_From_int(static_cast< int >(wxTRANSPARENT_WINDOW)));
55756 SWIG_Python_SetConstant(d, "NO_BORDER",SWIG_From_int(static_cast< int >(wxNO_BORDER)));
55757 SWIG_Python_SetConstant(d, "DEFAULT_CONTROL_BORDER",SWIG_From_int(static_cast< int >(wxDEFAULT_CONTROL_BORDER)));
55758 SWIG_Python_SetConstant(d, "DEFAULT_STATUSBAR_STYLE",SWIG_From_int(static_cast< int >(wxDEFAULT_STATUSBAR_STYLE)));
55759 SWIG_Python_SetConstant(d, "TAB_TRAVERSAL",SWIG_From_int(static_cast< int >(wxTAB_TRAVERSAL)));
55760 SWIG_Python_SetConstant(d, "WANTS_CHARS",SWIG_From_int(static_cast< int >(wxWANTS_CHARS)));
55761 SWIG_Python_SetConstant(d, "POPUP_WINDOW",SWIG_From_int(static_cast< int >(wxPOPUP_WINDOW)));
55762 SWIG_Python_SetConstant(d, "CENTER_FRAME",SWIG_From_int(static_cast< int >(wxCENTER_FRAME)));
55763 SWIG_Python_SetConstant(d, "CENTRE_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTRE_ON_SCREEN)));
55764 SWIG_Python_SetConstant(d, "CENTER_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTER_ON_SCREEN)));
55765 SWIG_Python_SetConstant(d, "CLIP_CHILDREN",SWIG_From_int(static_cast< int >(wxCLIP_CHILDREN)));
55766 SWIG_Python_SetConstant(d, "CLIP_SIBLINGS",SWIG_From_int(static_cast< int >(wxCLIP_SIBLINGS)));
55767 SWIG_Python_SetConstant(d, "WINDOW_STYLE_MASK",SWIG_From_int(static_cast< int >(wxWINDOW_STYLE_MASK)));
55768 SWIG_Python_SetConstant(d, "ALWAYS_SHOW_SB",SWIG_From_int(static_cast< int >(wxALWAYS_SHOW_SB)));
55769 SWIG_Python_SetConstant(d, "RETAINED",SWIG_From_int(static_cast< int >(wxRETAINED)));
55770 SWIG_Python_SetConstant(d, "BACKINGSTORE",SWIG_From_int(static_cast< int >(wxBACKINGSTORE)));
55771 SWIG_Python_SetConstant(d, "COLOURED",SWIG_From_int(static_cast< int >(wxCOLOURED)));
55772 SWIG_Python_SetConstant(d, "FIXED_LENGTH",SWIG_From_int(static_cast< int >(wxFIXED_LENGTH)));
55773 SWIG_Python_SetConstant(d, "LB_NEEDED_SB",SWIG_From_int(static_cast< int >(wxLB_NEEDED_SB)));
55774 SWIG_Python_SetConstant(d, "LB_ALWAYS_SB",SWIG_From_int(static_cast< int >(wxLB_ALWAYS_SB)));
55775 SWIG_Python_SetConstant(d, "LB_SORT",SWIG_From_int(static_cast< int >(wxLB_SORT)));
55776 SWIG_Python_SetConstant(d, "LB_SINGLE",SWIG_From_int(static_cast< int >(wxLB_SINGLE)));
55777 SWIG_Python_SetConstant(d, "LB_MULTIPLE",SWIG_From_int(static_cast< int >(wxLB_MULTIPLE)));
55778 SWIG_Python_SetConstant(d, "LB_EXTENDED",SWIG_From_int(static_cast< int >(wxLB_EXTENDED)));
55779 SWIG_Python_SetConstant(d, "LB_OWNERDRAW",SWIG_From_int(static_cast< int >(wxLB_OWNERDRAW)));
55780 SWIG_Python_SetConstant(d, "LB_HSCROLL",SWIG_From_int(static_cast< int >(wxLB_HSCROLL)));
55781 SWIG_Python_SetConstant(d, "PROCESS_ENTER",SWIG_From_int(static_cast< int >(wxPROCESS_ENTER)));
55782 SWIG_Python_SetConstant(d, "PASSWORD",SWIG_From_int(static_cast< int >(wxPASSWORD)));
55783 SWIG_Python_SetConstant(d, "CB_SIMPLE",SWIG_From_int(static_cast< int >(wxCB_SIMPLE)));
55784 SWIG_Python_SetConstant(d, "CB_DROPDOWN",SWIG_From_int(static_cast< int >(wxCB_DROPDOWN)));
55785 SWIG_Python_SetConstant(d, "CB_SORT",SWIG_From_int(static_cast< int >(wxCB_SORT)));
55786 SWIG_Python_SetConstant(d, "CB_READONLY",SWIG_From_int(static_cast< int >(wxCB_READONLY)));
55787 SWIG_Python_SetConstant(d, "RA_HORIZONTAL",SWIG_From_int(static_cast< int >(wxRA_HORIZONTAL)));
55788 SWIG_Python_SetConstant(d, "RA_VERTICAL",SWIG_From_int(static_cast< int >(wxRA_VERTICAL)));
55789 SWIG_Python_SetConstant(d, "RA_SPECIFY_ROWS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_ROWS)));
55790 SWIG_Python_SetConstant(d, "RA_SPECIFY_COLS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_COLS)));
55791 SWIG_Python_SetConstant(d, "RA_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRA_USE_CHECKBOX)));
55792 SWIG_Python_SetConstant(d, "RB_GROUP",SWIG_From_int(static_cast< int >(wxRB_GROUP)));
55793 SWIG_Python_SetConstant(d, "RB_SINGLE",SWIG_From_int(static_cast< int >(wxRB_SINGLE)));
55794 SWIG_Python_SetConstant(d, "SB_HORIZONTAL",SWIG_From_int(static_cast< int >(wxSB_HORIZONTAL)));
55795 SWIG_Python_SetConstant(d, "SB_VERTICAL",SWIG_From_int(static_cast< int >(wxSB_VERTICAL)));
55796 SWIG_Python_SetConstant(d, "RB_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRB_USE_CHECKBOX)));
55797 SWIG_Python_SetConstant(d, "ST_SIZEGRIP",SWIG_From_int(static_cast< int >(wxST_SIZEGRIP)));
55798 SWIG_Python_SetConstant(d, "ST_NO_AUTORESIZE",SWIG_From_int(static_cast< int >(wxST_NO_AUTORESIZE)));
55799 SWIG_Python_SetConstant(d, "ST_DOTS_MIDDLE",SWIG_From_int(static_cast< int >(wxST_DOTS_MIDDLE)));
55800 SWIG_Python_SetConstant(d, "ST_DOTS_END",SWIG_From_int(static_cast< int >(wxST_DOTS_END)));
55801 SWIG_Python_SetConstant(d, "FLOOD_SURFACE",SWIG_From_int(static_cast< int >(wxFLOOD_SURFACE)));
55802 SWIG_Python_SetConstant(d, "FLOOD_BORDER",SWIG_From_int(static_cast< int >(wxFLOOD_BORDER)));
55803 SWIG_Python_SetConstant(d, "ODDEVEN_RULE",SWIG_From_int(static_cast< int >(wxODDEVEN_RULE)));
55804 SWIG_Python_SetConstant(d, "WINDING_RULE",SWIG_From_int(static_cast< int >(wxWINDING_RULE)));
55805 SWIG_Python_SetConstant(d, "TOOL_TOP",SWIG_From_int(static_cast< int >(wxTOOL_TOP)));
55806 SWIG_Python_SetConstant(d, "TOOL_BOTTOM",SWIG_From_int(static_cast< int >(wxTOOL_BOTTOM)));
55807 SWIG_Python_SetConstant(d, "TOOL_LEFT",SWIG_From_int(static_cast< int >(wxTOOL_LEFT)));
55808 SWIG_Python_SetConstant(d, "TOOL_RIGHT",SWIG_From_int(static_cast< int >(wxTOOL_RIGHT)));
55809 SWIG_Python_SetConstant(d, "OK",SWIG_From_int(static_cast< int >(wxOK)));
55810 SWIG_Python_SetConstant(d, "YES_NO",SWIG_From_int(static_cast< int >(wxYES_NO)));
55811 SWIG_Python_SetConstant(d, "CANCEL",SWIG_From_int(static_cast< int >(wxCANCEL)));
55812 SWIG_Python_SetConstant(d, "YES",SWIG_From_int(static_cast< int >(wxYES)));
55813 SWIG_Python_SetConstant(d, "NO",SWIG_From_int(static_cast< int >(wxNO)));
55814 SWIG_Python_SetConstant(d, "NO_DEFAULT",SWIG_From_int(static_cast< int >(wxNO_DEFAULT)));
55815 SWIG_Python_SetConstant(d, "YES_DEFAULT",SWIG_From_int(static_cast< int >(wxYES_DEFAULT)));
55816 SWIG_Python_SetConstant(d, "ICON_EXCLAMATION",SWIG_From_int(static_cast< int >(wxICON_EXCLAMATION)));
55817 SWIG_Python_SetConstant(d, "ICON_HAND",SWIG_From_int(static_cast< int >(wxICON_HAND)));
55818 SWIG_Python_SetConstant(d, "ICON_QUESTION",SWIG_From_int(static_cast< int >(wxICON_QUESTION)));
55819 SWIG_Python_SetConstant(d, "ICON_INFORMATION",SWIG_From_int(static_cast< int >(wxICON_INFORMATION)));
55820 SWIG_Python_SetConstant(d, "ICON_STOP",SWIG_From_int(static_cast< int >(wxICON_STOP)));
55821 SWIG_Python_SetConstant(d, "ICON_ASTERISK",SWIG_From_int(static_cast< int >(wxICON_ASTERISK)));
55822 SWIG_Python_SetConstant(d, "ICON_MASK",SWIG_From_int(static_cast< int >(wxICON_MASK)));
55823 SWIG_Python_SetConstant(d, "ICON_WARNING",SWIG_From_int(static_cast< int >(wxICON_WARNING)));
55824 SWIG_Python_SetConstant(d, "ICON_ERROR",SWIG_From_int(static_cast< int >(wxICON_ERROR)));
55825 SWIG_Python_SetConstant(d, "FORWARD",SWIG_From_int(static_cast< int >(wxFORWARD)));
55826 SWIG_Python_SetConstant(d, "BACKWARD",SWIG_From_int(static_cast< int >(wxBACKWARD)));
55827 SWIG_Python_SetConstant(d, "RESET",SWIG_From_int(static_cast< int >(wxRESET)));
55828 SWIG_Python_SetConstant(d, "HELP",SWIG_From_int(static_cast< int >(wxHELP)));
55829 SWIG_Python_SetConstant(d, "MORE",SWIG_From_int(static_cast< int >(wxMORE)));
55830 SWIG_Python_SetConstant(d, "SETUP",SWIG_From_int(static_cast< int >(wxSETUP)));
55831 SWIG_Python_SetConstant(d, "SIZE_AUTO_WIDTH",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_WIDTH)));
55832 SWIG_Python_SetConstant(d, "SIZE_AUTO_HEIGHT",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_HEIGHT)));
55833 SWIG_Python_SetConstant(d, "SIZE_AUTO",SWIG_From_int(static_cast< int >(wxSIZE_AUTO)));
55834 SWIG_Python_SetConstant(d, "SIZE_USE_EXISTING",SWIG_From_int(static_cast< int >(wxSIZE_USE_EXISTING)));
55835 SWIG_Python_SetConstant(d, "SIZE_ALLOW_MINUS_ONE",SWIG_From_int(static_cast< int >(wxSIZE_ALLOW_MINUS_ONE)));
55836 SWIG_Python_SetConstant(d, "SIZE_FORCE",SWIG_From_int(static_cast< int >(wxSIZE_FORCE)));
55837 SWIG_Python_SetConstant(d, "PORTRAIT",SWIG_From_int(static_cast< int >(wxPORTRAIT)));
55838 SWIG_Python_SetConstant(d, "LANDSCAPE",SWIG_From_int(static_cast< int >(wxLANDSCAPE)));
55839 SWIG_Python_SetConstant(d, "PRINT_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_HIGH)));
55840 SWIG_Python_SetConstant(d, "PRINT_QUALITY_MEDIUM",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_MEDIUM)));
55841 SWIG_Python_SetConstant(d, "PRINT_QUALITY_LOW",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_LOW)));
55842 SWIG_Python_SetConstant(d, "PRINT_QUALITY_DRAFT",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_DRAFT)));
55843 SWIG_Python_SetConstant(d, "ID_ANY",SWIG_From_int(static_cast< int >(wxID_ANY)));
55844 SWIG_Python_SetConstant(d, "ID_SEPARATOR",SWIG_From_int(static_cast< int >(wxID_SEPARATOR)));
55845 SWIG_Python_SetConstant(d, "ID_NONE",SWIG_From_int(static_cast< int >(wxID_NONE)));
55846 SWIG_Python_SetConstant(d, "ID_LOWEST",SWIG_From_int(static_cast< int >(wxID_LOWEST)));
55847 SWIG_Python_SetConstant(d, "ID_OPEN",SWIG_From_int(static_cast< int >(wxID_OPEN)));
55848 SWIG_Python_SetConstant(d, "ID_CLOSE",SWIG_From_int(static_cast< int >(wxID_CLOSE)));
55849 SWIG_Python_SetConstant(d, "ID_NEW",SWIG_From_int(static_cast< int >(wxID_NEW)));
55850 SWIG_Python_SetConstant(d, "ID_SAVE",SWIG_From_int(static_cast< int >(wxID_SAVE)));
55851 SWIG_Python_SetConstant(d, "ID_SAVEAS",SWIG_From_int(static_cast< int >(wxID_SAVEAS)));
55852 SWIG_Python_SetConstant(d, "ID_REVERT",SWIG_From_int(static_cast< int >(wxID_REVERT)));
55853 SWIG_Python_SetConstant(d, "ID_EXIT",SWIG_From_int(static_cast< int >(wxID_EXIT)));
55854 SWIG_Python_SetConstant(d, "ID_UNDO",SWIG_From_int(static_cast< int >(wxID_UNDO)));
55855 SWIG_Python_SetConstant(d, "ID_REDO",SWIG_From_int(static_cast< int >(wxID_REDO)));
55856 SWIG_Python_SetConstant(d, "ID_HELP",SWIG_From_int(static_cast< int >(wxID_HELP)));
55857 SWIG_Python_SetConstant(d, "ID_PRINT",SWIG_From_int(static_cast< int >(wxID_PRINT)));
55858 SWIG_Python_SetConstant(d, "ID_PRINT_SETUP",SWIG_From_int(static_cast< int >(wxID_PRINT_SETUP)));
55859 SWIG_Python_SetConstant(d, "ID_PREVIEW",SWIG_From_int(static_cast< int >(wxID_PREVIEW)));
55860 SWIG_Python_SetConstant(d, "ID_ABOUT",SWIG_From_int(static_cast< int >(wxID_ABOUT)));
55861 SWIG_Python_SetConstant(d, "ID_HELP_CONTENTS",SWIG_From_int(static_cast< int >(wxID_HELP_CONTENTS)));
55862 SWIG_Python_SetConstant(d, "ID_HELP_COMMANDS",SWIG_From_int(static_cast< int >(wxID_HELP_COMMANDS)));
55863 SWIG_Python_SetConstant(d, "ID_HELP_PROCEDURES",SWIG_From_int(static_cast< int >(wxID_HELP_PROCEDURES)));
55864 SWIG_Python_SetConstant(d, "ID_HELP_CONTEXT",SWIG_From_int(static_cast< int >(wxID_HELP_CONTEXT)));
55865 SWIG_Python_SetConstant(d, "ID_CLOSE_ALL",SWIG_From_int(static_cast< int >(wxID_CLOSE_ALL)));
55866 SWIG_Python_SetConstant(d, "ID_PREFERENCES",SWIG_From_int(static_cast< int >(wxID_PREFERENCES)));
55867 SWIG_Python_SetConstant(d, "ID_CUT",SWIG_From_int(static_cast< int >(wxID_CUT)));
55868 SWIG_Python_SetConstant(d, "ID_COPY",SWIG_From_int(static_cast< int >(wxID_COPY)));
55869 SWIG_Python_SetConstant(d, "ID_PASTE",SWIG_From_int(static_cast< int >(wxID_PASTE)));
55870 SWIG_Python_SetConstant(d, "ID_CLEAR",SWIG_From_int(static_cast< int >(wxID_CLEAR)));
55871 SWIG_Python_SetConstant(d, "ID_FIND",SWIG_From_int(static_cast< int >(wxID_FIND)));
55872 SWIG_Python_SetConstant(d, "ID_DUPLICATE",SWIG_From_int(static_cast< int >(wxID_DUPLICATE)));
55873 SWIG_Python_SetConstant(d, "ID_SELECTALL",SWIG_From_int(static_cast< int >(wxID_SELECTALL)));
55874 SWIG_Python_SetConstant(d, "ID_DELETE",SWIG_From_int(static_cast< int >(wxID_DELETE)));
55875 SWIG_Python_SetConstant(d, "ID_REPLACE",SWIG_From_int(static_cast< int >(wxID_REPLACE)));
55876 SWIG_Python_SetConstant(d, "ID_REPLACE_ALL",SWIG_From_int(static_cast< int >(wxID_REPLACE_ALL)));
55877 SWIG_Python_SetConstant(d, "ID_PROPERTIES",SWIG_From_int(static_cast< int >(wxID_PROPERTIES)));
55878 SWIG_Python_SetConstant(d, "ID_VIEW_DETAILS",SWIG_From_int(static_cast< int >(wxID_VIEW_DETAILS)));
55879 SWIG_Python_SetConstant(d, "ID_VIEW_LARGEICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_LARGEICONS)));
55880 SWIG_Python_SetConstant(d, "ID_VIEW_SMALLICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_SMALLICONS)));
55881 SWIG_Python_SetConstant(d, "ID_VIEW_LIST",SWIG_From_int(static_cast< int >(wxID_VIEW_LIST)));
55882 SWIG_Python_SetConstant(d, "ID_VIEW_SORTDATE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTDATE)));
55883 SWIG_Python_SetConstant(d, "ID_VIEW_SORTNAME",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTNAME)));
55884 SWIG_Python_SetConstant(d, "ID_VIEW_SORTSIZE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTSIZE)));
55885 SWIG_Python_SetConstant(d, "ID_VIEW_SORTTYPE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTTYPE)));
55886 SWIG_Python_SetConstant(d, "ID_FILE1",SWIG_From_int(static_cast< int >(wxID_FILE1)));
55887 SWIG_Python_SetConstant(d, "ID_FILE2",SWIG_From_int(static_cast< int >(wxID_FILE2)));
55888 SWIG_Python_SetConstant(d, "ID_FILE3",SWIG_From_int(static_cast< int >(wxID_FILE3)));
55889 SWIG_Python_SetConstant(d, "ID_FILE4",SWIG_From_int(static_cast< int >(wxID_FILE4)));
55890 SWIG_Python_SetConstant(d, "ID_FILE5",SWIG_From_int(static_cast< int >(wxID_FILE5)));
55891 SWIG_Python_SetConstant(d, "ID_FILE6",SWIG_From_int(static_cast< int >(wxID_FILE6)));
55892 SWIG_Python_SetConstant(d, "ID_FILE7",SWIG_From_int(static_cast< int >(wxID_FILE7)));
55893 SWIG_Python_SetConstant(d, "ID_FILE8",SWIG_From_int(static_cast< int >(wxID_FILE8)));
55894 SWIG_Python_SetConstant(d, "ID_FILE9",SWIG_From_int(static_cast< int >(wxID_FILE9)));
55895 SWIG_Python_SetConstant(d, "ID_OK",SWIG_From_int(static_cast< int >(wxID_OK)));
55896 SWIG_Python_SetConstant(d, "ID_CANCEL",SWIG_From_int(static_cast< int >(wxID_CANCEL)));
55897 SWIG_Python_SetConstant(d, "ID_APPLY",SWIG_From_int(static_cast< int >(wxID_APPLY)));
55898 SWIG_Python_SetConstant(d, "ID_YES",SWIG_From_int(static_cast< int >(wxID_YES)));
55899 SWIG_Python_SetConstant(d, "ID_NO",SWIG_From_int(static_cast< int >(wxID_NO)));
55900 SWIG_Python_SetConstant(d, "ID_STATIC",SWIG_From_int(static_cast< int >(wxID_STATIC)));
55901 SWIG_Python_SetConstant(d, "ID_FORWARD",SWIG_From_int(static_cast< int >(wxID_FORWARD)));
55902 SWIG_Python_SetConstant(d, "ID_BACKWARD",SWIG_From_int(static_cast< int >(wxID_BACKWARD)));
55903 SWIG_Python_SetConstant(d, "ID_DEFAULT",SWIG_From_int(static_cast< int >(wxID_DEFAULT)));
55904 SWIG_Python_SetConstant(d, "ID_MORE",SWIG_From_int(static_cast< int >(wxID_MORE)));
55905 SWIG_Python_SetConstant(d, "ID_SETUP",SWIG_From_int(static_cast< int >(wxID_SETUP)));
55906 SWIG_Python_SetConstant(d, "ID_RESET",SWIG_From_int(static_cast< int >(wxID_RESET)));
55907 SWIG_Python_SetConstant(d, "ID_CONTEXT_HELP",SWIG_From_int(static_cast< int >(wxID_CONTEXT_HELP)));
55908 SWIG_Python_SetConstant(d, "ID_YESTOALL",SWIG_From_int(static_cast< int >(wxID_YESTOALL)));
55909 SWIG_Python_SetConstant(d, "ID_NOTOALL",SWIG_From_int(static_cast< int >(wxID_NOTOALL)));
55910 SWIG_Python_SetConstant(d, "ID_ABORT",SWIG_From_int(static_cast< int >(wxID_ABORT)));
55911 SWIG_Python_SetConstant(d, "ID_RETRY",SWIG_From_int(static_cast< int >(wxID_RETRY)));
55912 SWIG_Python_SetConstant(d, "ID_IGNORE",SWIG_From_int(static_cast< int >(wxID_IGNORE)));
55913 SWIG_Python_SetConstant(d, "ID_ADD",SWIG_From_int(static_cast< int >(wxID_ADD)));
55914 SWIG_Python_SetConstant(d, "ID_REMOVE",SWIG_From_int(static_cast< int >(wxID_REMOVE)));
55915 SWIG_Python_SetConstant(d, "ID_UP",SWIG_From_int(static_cast< int >(wxID_UP)));
55916 SWIG_Python_SetConstant(d, "ID_DOWN",SWIG_From_int(static_cast< int >(wxID_DOWN)));
55917 SWIG_Python_SetConstant(d, "ID_HOME",SWIG_From_int(static_cast< int >(wxID_HOME)));
55918 SWIG_Python_SetConstant(d, "ID_REFRESH",SWIG_From_int(static_cast< int >(wxID_REFRESH)));
55919 SWIG_Python_SetConstant(d, "ID_STOP",SWIG_From_int(static_cast< int >(wxID_STOP)));
55920 SWIG_Python_SetConstant(d, "ID_INDEX",SWIG_From_int(static_cast< int >(wxID_INDEX)));
55921 SWIG_Python_SetConstant(d, "ID_BOLD",SWIG_From_int(static_cast< int >(wxID_BOLD)));
55922 SWIG_Python_SetConstant(d, "ID_ITALIC",SWIG_From_int(static_cast< int >(wxID_ITALIC)));
55923 SWIG_Python_SetConstant(d, "ID_JUSTIFY_CENTER",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_CENTER)));
55924 SWIG_Python_SetConstant(d, "ID_JUSTIFY_FILL",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_FILL)));
55925 SWIG_Python_SetConstant(d, "ID_JUSTIFY_RIGHT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_RIGHT)));
55926 SWIG_Python_SetConstant(d, "ID_JUSTIFY_LEFT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_LEFT)));
55927 SWIG_Python_SetConstant(d, "ID_UNDERLINE",SWIG_From_int(static_cast< int >(wxID_UNDERLINE)));
55928 SWIG_Python_SetConstant(d, "ID_INDENT",SWIG_From_int(static_cast< int >(wxID_INDENT)));
55929 SWIG_Python_SetConstant(d, "ID_UNINDENT",SWIG_From_int(static_cast< int >(wxID_UNINDENT)));
55930 SWIG_Python_SetConstant(d, "ID_ZOOM_100",SWIG_From_int(static_cast< int >(wxID_ZOOM_100)));
55931 SWIG_Python_SetConstant(d, "ID_ZOOM_FIT",SWIG_From_int(static_cast< int >(wxID_ZOOM_FIT)));
55932 SWIG_Python_SetConstant(d, "ID_ZOOM_IN",SWIG_From_int(static_cast< int >(wxID_ZOOM_IN)));
55933 SWIG_Python_SetConstant(d, "ID_ZOOM_OUT",SWIG_From_int(static_cast< int >(wxID_ZOOM_OUT)));
55934 SWIG_Python_SetConstant(d, "ID_UNDELETE",SWIG_From_int(static_cast< int >(wxID_UNDELETE)));
55935 SWIG_Python_SetConstant(d, "ID_REVERT_TO_SAVED",SWIG_From_int(static_cast< int >(wxID_REVERT_TO_SAVED)));
55936 SWIG_Python_SetConstant(d, "ID_HIGHEST",SWIG_From_int(static_cast< int >(wxID_HIGHEST)));
55937 SWIG_Python_SetConstant(d, "ACCEL_ALT",SWIG_From_int(static_cast< int >(wxACCEL_ALT)));
55938 SWIG_Python_SetConstant(d, "ACCEL_CTRL",SWIG_From_int(static_cast< int >(wxACCEL_CTRL)));
55939 SWIG_Python_SetConstant(d, "ACCEL_SHIFT",SWIG_From_int(static_cast< int >(wxACCEL_SHIFT)));
55940 SWIG_Python_SetConstant(d, "ACCEL_NORMAL",SWIG_From_int(static_cast< int >(wxACCEL_NORMAL)));
55941 SWIG_Python_SetConstant(d, "PD_AUTO_HIDE",SWIG_From_int(static_cast< int >(wxPD_AUTO_HIDE)));
55942 SWIG_Python_SetConstant(d, "PD_APP_MODAL",SWIG_From_int(static_cast< int >(wxPD_APP_MODAL)));
55943 SWIG_Python_SetConstant(d, "PD_CAN_ABORT",SWIG_From_int(static_cast< int >(wxPD_CAN_ABORT)));
55944 SWIG_Python_SetConstant(d, "PD_ELAPSED_TIME",SWIG_From_int(static_cast< int >(wxPD_ELAPSED_TIME)));
55945 SWIG_Python_SetConstant(d, "PD_ESTIMATED_TIME",SWIG_From_int(static_cast< int >(wxPD_ESTIMATED_TIME)));
55946 SWIG_Python_SetConstant(d, "PD_REMAINING_TIME",SWIG_From_int(static_cast< int >(wxPD_REMAINING_TIME)));
55947 SWIG_Python_SetConstant(d, "PD_SMOOTH",SWIG_From_int(static_cast< int >(wxPD_SMOOTH)));
55948 SWIG_Python_SetConstant(d, "PD_CAN_SKIP",SWIG_From_int(static_cast< int >(wxPD_CAN_SKIP)));
55949 SWIG_Python_SetConstant(d, "MENU_TEAROFF",SWIG_From_int(static_cast< int >(wxMENU_TEAROFF)));
55950 SWIG_Python_SetConstant(d, "MB_DOCKABLE",SWIG_From_int(static_cast< int >(wxMB_DOCKABLE)));
55951 SWIG_Python_SetConstant(d, "NO_FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxNO_FULL_REPAINT_ON_RESIZE)));
55952 SWIG_Python_SetConstant(d, "FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxFULL_REPAINT_ON_RESIZE)));
55953 SWIG_Python_SetConstant(d, "LI_HORIZONTAL",SWIG_From_int(static_cast< int >(wxLI_HORIZONTAL)));
55954 SWIG_Python_SetConstant(d, "LI_VERTICAL",SWIG_From_int(static_cast< int >(wxLI_VERTICAL)));
55955 SWIG_Python_SetConstant(d, "WS_EX_VALIDATE_RECURSIVELY",SWIG_From_int(static_cast< int >(wxWS_EX_VALIDATE_RECURSIVELY)));
55956 SWIG_Python_SetConstant(d, "WS_EX_BLOCK_EVENTS",SWIG_From_int(static_cast< int >(wxWS_EX_BLOCK_EVENTS)));
55957 SWIG_Python_SetConstant(d, "WS_EX_TRANSIENT",SWIG_From_int(static_cast< int >(wxWS_EX_TRANSIENT)));
55958 SWIG_Python_SetConstant(d, "WS_EX_THEMED_BACKGROUND",SWIG_From_int(static_cast< int >(wxWS_EX_THEMED_BACKGROUND)));
55959 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_IDLE",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_IDLE)));
55960 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_UI_UPDATES",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_UI_UPDATES)));
55961 SWIG_Python_SetConstant(d, "MM_TEXT",SWIG_From_int(static_cast< int >(wxMM_TEXT)));
55962 SWIG_Python_SetConstant(d, "MM_LOMETRIC",SWIG_From_int(static_cast< int >(wxMM_LOMETRIC)));
55963 SWIG_Python_SetConstant(d, "MM_HIMETRIC",SWIG_From_int(static_cast< int >(wxMM_HIMETRIC)));
55964 SWIG_Python_SetConstant(d, "MM_LOENGLISH",SWIG_From_int(static_cast< int >(wxMM_LOENGLISH)));
55965 SWIG_Python_SetConstant(d, "MM_HIENGLISH",SWIG_From_int(static_cast< int >(wxMM_HIENGLISH)));
55966 SWIG_Python_SetConstant(d, "MM_TWIPS",SWIG_From_int(static_cast< int >(wxMM_TWIPS)));
55967 SWIG_Python_SetConstant(d, "MM_ISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ISOTROPIC)));
55968 SWIG_Python_SetConstant(d, "MM_ANISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ANISOTROPIC)));
55969 SWIG_Python_SetConstant(d, "MM_POINTS",SWIG_From_int(static_cast< int >(wxMM_POINTS)));
55970 SWIG_Python_SetConstant(d, "MM_METRIC",SWIG_From_int(static_cast< int >(wxMM_METRIC)));
55971 SWIG_Python_SetConstant(d, "CENTRE",SWIG_From_int(static_cast< int >(wxCENTRE)));
55972 SWIG_Python_SetConstant(d, "CENTER",SWIG_From_int(static_cast< int >(wxCENTER)));
55973 SWIG_Python_SetConstant(d, "HORIZONTAL",SWIG_From_int(static_cast< int >(wxHORIZONTAL)));
55974 SWIG_Python_SetConstant(d, "VERTICAL",SWIG_From_int(static_cast< int >(wxVERTICAL)));
55975 SWIG_Python_SetConstant(d, "BOTH",SWIG_From_int(static_cast< int >(wxBOTH)));
55976 SWIG_Python_SetConstant(d, "LEFT",SWIG_From_int(static_cast< int >(wxLEFT)));
55977 SWIG_Python_SetConstant(d, "RIGHT",SWIG_From_int(static_cast< int >(wxRIGHT)));
55978 SWIG_Python_SetConstant(d, "UP",SWIG_From_int(static_cast< int >(wxUP)));
55979 SWIG_Python_SetConstant(d, "DOWN",SWIG_From_int(static_cast< int >(wxDOWN)));
55980 SWIG_Python_SetConstant(d, "TOP",SWIG_From_int(static_cast< int >(wxTOP)));
55981 SWIG_Python_SetConstant(d, "BOTTOM",SWIG_From_int(static_cast< int >(wxBOTTOM)));
55982 SWIG_Python_SetConstant(d, "NORTH",SWIG_From_int(static_cast< int >(wxNORTH)));
55983 SWIG_Python_SetConstant(d, "SOUTH",SWIG_From_int(static_cast< int >(wxSOUTH)));
55984 SWIG_Python_SetConstant(d, "WEST",SWIG_From_int(static_cast< int >(wxWEST)));
55985 SWIG_Python_SetConstant(d, "EAST",SWIG_From_int(static_cast< int >(wxEAST)));
55986 SWIG_Python_SetConstant(d, "ALL",SWIG_From_int(static_cast< int >(wxALL)));
55987 SWIG_Python_SetConstant(d, "ALIGN_NOT",SWIG_From_int(static_cast< int >(wxALIGN_NOT)));
55988 SWIG_Python_SetConstant(d, "ALIGN_CENTER_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_HORIZONTAL)));
55989 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_HORIZONTAL)));
55990 SWIG_Python_SetConstant(d, "ALIGN_LEFT",SWIG_From_int(static_cast< int >(wxALIGN_LEFT)));
55991 SWIG_Python_SetConstant(d, "ALIGN_TOP",SWIG_From_int(static_cast< int >(wxALIGN_TOP)));
55992 SWIG_Python_SetConstant(d, "ALIGN_RIGHT",SWIG_From_int(static_cast< int >(wxALIGN_RIGHT)));
55993 SWIG_Python_SetConstant(d, "ALIGN_BOTTOM",SWIG_From_int(static_cast< int >(wxALIGN_BOTTOM)));
55994 SWIG_Python_SetConstant(d, "ALIGN_CENTER_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_VERTICAL)));
55995 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_VERTICAL)));
55996 SWIG_Python_SetConstant(d, "ALIGN_CENTER",SWIG_From_int(static_cast< int >(wxALIGN_CENTER)));
55997 SWIG_Python_SetConstant(d, "ALIGN_CENTRE",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE)));
55998 SWIG_Python_SetConstant(d, "ALIGN_MASK",SWIG_From_int(static_cast< int >(wxALIGN_MASK)));
55999 SWIG_Python_SetConstant(d, "STRETCH_NOT",SWIG_From_int(static_cast< int >(wxSTRETCH_NOT)));
56000 SWIG_Python_SetConstant(d, "SHRINK",SWIG_From_int(static_cast< int >(wxSHRINK)));
56001 SWIG_Python_SetConstant(d, "GROW",SWIG_From_int(static_cast< int >(wxGROW)));
56002 SWIG_Python_SetConstant(d, "EXPAND",SWIG_From_int(static_cast< int >(wxEXPAND)));
56003 SWIG_Python_SetConstant(d, "SHAPED",SWIG_From_int(static_cast< int >(wxSHAPED)));
56004 SWIG_Python_SetConstant(d, "FIXED_MINSIZE",SWIG_From_int(static_cast< int >(wxFIXED_MINSIZE)));
56005 SWIG_Python_SetConstant(d, "TILE",SWIG_From_int(static_cast< int >(wxTILE)));
56006 SWIG_Python_SetConstant(d, "ADJUST_MINSIZE",SWIG_From_int(static_cast< int >(wxADJUST_MINSIZE)));
56007 SWIG_Python_SetConstant(d, "BORDER_DEFAULT",SWIG_From_int(static_cast< int >(wxBORDER_DEFAULT)));
56008 SWIG_Python_SetConstant(d, "BORDER_NONE",SWIG_From_int(static_cast< int >(wxBORDER_NONE)));
56009 SWIG_Python_SetConstant(d, "BORDER_STATIC",SWIG_From_int(static_cast< int >(wxBORDER_STATIC)));
56010 SWIG_Python_SetConstant(d, "BORDER_SIMPLE",SWIG_From_int(static_cast< int >(wxBORDER_SIMPLE)));
56011 SWIG_Python_SetConstant(d, "BORDER_RAISED",SWIG_From_int(static_cast< int >(wxBORDER_RAISED)));
56012 SWIG_Python_SetConstant(d, "BORDER_SUNKEN",SWIG_From_int(static_cast< int >(wxBORDER_SUNKEN)));
56013 SWIG_Python_SetConstant(d, "BORDER_DOUBLE",SWIG_From_int(static_cast< int >(wxBORDER_DOUBLE)));
56014 SWIG_Python_SetConstant(d, "BORDER_MASK",SWIG_From_int(static_cast< int >(wxBORDER_MASK)));
56015 SWIG_Python_SetConstant(d, "BG_STYLE_SYSTEM",SWIG_From_int(static_cast< int >(wxBG_STYLE_SYSTEM)));
56016 SWIG_Python_SetConstant(d, "BG_STYLE_COLOUR",SWIG_From_int(static_cast< int >(wxBG_STYLE_COLOUR)));
56017 SWIG_Python_SetConstant(d, "BG_STYLE_CUSTOM",SWIG_From_int(static_cast< int >(wxBG_STYLE_CUSTOM)));
56018 SWIG_Python_SetConstant(d, "DEFAULT",SWIG_From_int(static_cast< int >(wxDEFAULT)));
56019 SWIG_Python_SetConstant(d, "DECORATIVE",SWIG_From_int(static_cast< int >(wxDECORATIVE)));
56020 SWIG_Python_SetConstant(d, "ROMAN",SWIG_From_int(static_cast< int >(wxROMAN)));
56021 SWIG_Python_SetConstant(d, "SCRIPT",SWIG_From_int(static_cast< int >(wxSCRIPT)));
56022 SWIG_Python_SetConstant(d, "SWISS",SWIG_From_int(static_cast< int >(wxSWISS)));
56023 SWIG_Python_SetConstant(d, "MODERN",SWIG_From_int(static_cast< int >(wxMODERN)));
56024 SWIG_Python_SetConstant(d, "TELETYPE",SWIG_From_int(static_cast< int >(wxTELETYPE)));
56025 SWIG_Python_SetConstant(d, "VARIABLE",SWIG_From_int(static_cast< int >(wxVARIABLE)));
56026 SWIG_Python_SetConstant(d, "FIXED",SWIG_From_int(static_cast< int >(wxFIXED)));
56027 SWIG_Python_SetConstant(d, "NORMAL",SWIG_From_int(static_cast< int >(wxNORMAL)));
56028 SWIG_Python_SetConstant(d, "LIGHT",SWIG_From_int(static_cast< int >(wxLIGHT)));
56029 SWIG_Python_SetConstant(d, "BOLD",SWIG_From_int(static_cast< int >(wxBOLD)));
56030 SWIG_Python_SetConstant(d, "ITALIC",SWIG_From_int(static_cast< int >(wxITALIC)));
56031 SWIG_Python_SetConstant(d, "SLANT",SWIG_From_int(static_cast< int >(wxSLANT)));
56032 SWIG_Python_SetConstant(d, "SOLID",SWIG_From_int(static_cast< int >(wxSOLID)));
56033 SWIG_Python_SetConstant(d, "DOT",SWIG_From_int(static_cast< int >(wxDOT)));
56034 SWIG_Python_SetConstant(d, "LONG_DASH",SWIG_From_int(static_cast< int >(wxLONG_DASH)));
56035 SWIG_Python_SetConstant(d, "SHORT_DASH",SWIG_From_int(static_cast< int >(wxSHORT_DASH)));
56036 SWIG_Python_SetConstant(d, "DOT_DASH",SWIG_From_int(static_cast< int >(wxDOT_DASH)));
56037 SWIG_Python_SetConstant(d, "USER_DASH",SWIG_From_int(static_cast< int >(wxUSER_DASH)));
56038 SWIG_Python_SetConstant(d, "TRANSPARENT",SWIG_From_int(static_cast< int >(wxTRANSPARENT)));
56039 SWIG_Python_SetConstant(d, "STIPPLE",SWIG_From_int(static_cast< int >(wxSTIPPLE)));
56040 SWIG_Python_SetConstant(d, "STIPPLE_MASK",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK)));
56041 SWIG_Python_SetConstant(d, "STIPPLE_MASK_OPAQUE",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK_OPAQUE)));
56042 SWIG_Python_SetConstant(d, "BDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxBDIAGONAL_HATCH)));
56043 SWIG_Python_SetConstant(d, "CROSSDIAG_HATCH",SWIG_From_int(static_cast< int >(wxCROSSDIAG_HATCH)));
56044 SWIG_Python_SetConstant(d, "FDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxFDIAGONAL_HATCH)));
56045 SWIG_Python_SetConstant(d, "CROSS_HATCH",SWIG_From_int(static_cast< int >(wxCROSS_HATCH)));
56046 SWIG_Python_SetConstant(d, "HORIZONTAL_HATCH",SWIG_From_int(static_cast< int >(wxHORIZONTAL_HATCH)));
56047 SWIG_Python_SetConstant(d, "VERTICAL_HATCH",SWIG_From_int(static_cast< int >(wxVERTICAL_HATCH)));
56048 SWIG_Python_SetConstant(d, "JOIN_BEVEL",SWIG_From_int(static_cast< int >(wxJOIN_BEVEL)));
56049 SWIG_Python_SetConstant(d, "JOIN_MITER",SWIG_From_int(static_cast< int >(wxJOIN_MITER)));
56050 SWIG_Python_SetConstant(d, "JOIN_ROUND",SWIG_From_int(static_cast< int >(wxJOIN_ROUND)));
56051 SWIG_Python_SetConstant(d, "CAP_ROUND",SWIG_From_int(static_cast< int >(wxCAP_ROUND)));
56052 SWIG_Python_SetConstant(d, "CAP_PROJECTING",SWIG_From_int(static_cast< int >(wxCAP_PROJECTING)));
56053 SWIG_Python_SetConstant(d, "CAP_BUTT",SWIG_From_int(static_cast< int >(wxCAP_BUTT)));
56054 SWIG_Python_SetConstant(d, "CLEAR",SWIG_From_int(static_cast< int >(wxCLEAR)));
56055 SWIG_Python_SetConstant(d, "XOR",SWIG_From_int(static_cast< int >(wxXOR)));
56056 SWIG_Python_SetConstant(d, "INVERT",SWIG_From_int(static_cast< int >(wxINVERT)));
56057 SWIG_Python_SetConstant(d, "OR_REVERSE",SWIG_From_int(static_cast< int >(wxOR_REVERSE)));
56058 SWIG_Python_SetConstant(d, "AND_REVERSE",SWIG_From_int(static_cast< int >(wxAND_REVERSE)));
56059 SWIG_Python_SetConstant(d, "COPY",SWIG_From_int(static_cast< int >(wxCOPY)));
56060 SWIG_Python_SetConstant(d, "AND",SWIG_From_int(static_cast< int >(wxAND)));
56061 SWIG_Python_SetConstant(d, "AND_INVERT",SWIG_From_int(static_cast< int >(wxAND_INVERT)));
56062 SWIG_Python_SetConstant(d, "NO_OP",SWIG_From_int(static_cast< int >(wxNO_OP)));
56063 SWIG_Python_SetConstant(d, "NOR",SWIG_From_int(static_cast< int >(wxNOR)));
56064 SWIG_Python_SetConstant(d, "EQUIV",SWIG_From_int(static_cast< int >(wxEQUIV)));
56065 SWIG_Python_SetConstant(d, "SRC_INVERT",SWIG_From_int(static_cast< int >(wxSRC_INVERT)));
56066 SWIG_Python_SetConstant(d, "OR_INVERT",SWIG_From_int(static_cast< int >(wxOR_INVERT)));
56067 SWIG_Python_SetConstant(d, "NAND",SWIG_From_int(static_cast< int >(wxNAND)));
56068 SWIG_Python_SetConstant(d, "OR",SWIG_From_int(static_cast< int >(wxOR)));
56069 SWIG_Python_SetConstant(d, "SET",SWIG_From_int(static_cast< int >(wxSET)));
56070 SWIG_Python_SetConstant(d, "WXK_BACK",SWIG_From_int(static_cast< int >(WXK_BACK)));
56071 SWIG_Python_SetConstant(d, "WXK_TAB",SWIG_From_int(static_cast< int >(WXK_TAB)));
56072 SWIG_Python_SetConstant(d, "WXK_RETURN",SWIG_From_int(static_cast< int >(WXK_RETURN)));
56073 SWIG_Python_SetConstant(d, "WXK_ESCAPE",SWIG_From_int(static_cast< int >(WXK_ESCAPE)));
56074 SWIG_Python_SetConstant(d, "WXK_SPACE",SWIG_From_int(static_cast< int >(WXK_SPACE)));
56075 SWIG_Python_SetConstant(d, "WXK_DELETE",SWIG_From_int(static_cast< int >(WXK_DELETE)));
56076 SWIG_Python_SetConstant(d, "WXK_START",SWIG_From_int(static_cast< int >(WXK_START)));
56077 SWIG_Python_SetConstant(d, "WXK_LBUTTON",SWIG_From_int(static_cast< int >(WXK_LBUTTON)));
56078 SWIG_Python_SetConstant(d, "WXK_RBUTTON",SWIG_From_int(static_cast< int >(WXK_RBUTTON)));
56079 SWIG_Python_SetConstant(d, "WXK_CANCEL",SWIG_From_int(static_cast< int >(WXK_CANCEL)));
56080 SWIG_Python_SetConstant(d, "WXK_MBUTTON",SWIG_From_int(static_cast< int >(WXK_MBUTTON)));
56081 SWIG_Python_SetConstant(d, "WXK_CLEAR",SWIG_From_int(static_cast< int >(WXK_CLEAR)));
56082 SWIG_Python_SetConstant(d, "WXK_SHIFT",SWIG_From_int(static_cast< int >(WXK_SHIFT)));
56083 SWIG_Python_SetConstant(d, "WXK_ALT",SWIG_From_int(static_cast< int >(WXK_ALT)));
56084 SWIG_Python_SetConstant(d, "WXK_CONTROL",SWIG_From_int(static_cast< int >(WXK_CONTROL)));
56085 SWIG_Python_SetConstant(d, "WXK_MENU",SWIG_From_int(static_cast< int >(WXK_MENU)));
56086 SWIG_Python_SetConstant(d, "WXK_PAUSE",SWIG_From_int(static_cast< int >(WXK_PAUSE)));
56087 SWIG_Python_SetConstant(d, "WXK_CAPITAL",SWIG_From_int(static_cast< int >(WXK_CAPITAL)));
56088 SWIG_Python_SetConstant(d, "WXK_PRIOR",SWIG_From_int(static_cast< int >(WXK_PRIOR)));
56089 SWIG_Python_SetConstant(d, "WXK_NEXT",SWIG_From_int(static_cast< int >(WXK_NEXT)));
56090 SWIG_Python_SetConstant(d, "WXK_END",SWIG_From_int(static_cast< int >(WXK_END)));
56091 SWIG_Python_SetConstant(d, "WXK_HOME",SWIG_From_int(static_cast< int >(WXK_HOME)));
56092 SWIG_Python_SetConstant(d, "WXK_LEFT",SWIG_From_int(static_cast< int >(WXK_LEFT)));
56093 SWIG_Python_SetConstant(d, "WXK_UP",SWIG_From_int(static_cast< int >(WXK_UP)));
56094 SWIG_Python_SetConstant(d, "WXK_RIGHT",SWIG_From_int(static_cast< int >(WXK_RIGHT)));
56095 SWIG_Python_SetConstant(d, "WXK_DOWN",SWIG_From_int(static_cast< int >(WXK_DOWN)));
56096 SWIG_Python_SetConstant(d, "WXK_SELECT",SWIG_From_int(static_cast< int >(WXK_SELECT)));
56097 SWIG_Python_SetConstant(d, "WXK_PRINT",SWIG_From_int(static_cast< int >(WXK_PRINT)));
56098 SWIG_Python_SetConstant(d, "WXK_EXECUTE",SWIG_From_int(static_cast< int >(WXK_EXECUTE)));
56099 SWIG_Python_SetConstant(d, "WXK_SNAPSHOT",SWIG_From_int(static_cast< int >(WXK_SNAPSHOT)));
56100 SWIG_Python_SetConstant(d, "WXK_INSERT",SWIG_From_int(static_cast< int >(WXK_INSERT)));
56101 SWIG_Python_SetConstant(d, "WXK_HELP",SWIG_From_int(static_cast< int >(WXK_HELP)));
56102 SWIG_Python_SetConstant(d, "WXK_NUMPAD0",SWIG_From_int(static_cast< int >(WXK_NUMPAD0)));
56103 SWIG_Python_SetConstant(d, "WXK_NUMPAD1",SWIG_From_int(static_cast< int >(WXK_NUMPAD1)));
56104 SWIG_Python_SetConstant(d, "WXK_NUMPAD2",SWIG_From_int(static_cast< int >(WXK_NUMPAD2)));
56105 SWIG_Python_SetConstant(d, "WXK_NUMPAD3",SWIG_From_int(static_cast< int >(WXK_NUMPAD3)));
56106 SWIG_Python_SetConstant(d, "WXK_NUMPAD4",SWIG_From_int(static_cast< int >(WXK_NUMPAD4)));
56107 SWIG_Python_SetConstant(d, "WXK_NUMPAD5",SWIG_From_int(static_cast< int >(WXK_NUMPAD5)));
56108 SWIG_Python_SetConstant(d, "WXK_NUMPAD6",SWIG_From_int(static_cast< int >(WXK_NUMPAD6)));
56109 SWIG_Python_SetConstant(d, "WXK_NUMPAD7",SWIG_From_int(static_cast< int >(WXK_NUMPAD7)));
56110 SWIG_Python_SetConstant(d, "WXK_NUMPAD8",SWIG_From_int(static_cast< int >(WXK_NUMPAD8)));
56111 SWIG_Python_SetConstant(d, "WXK_NUMPAD9",SWIG_From_int(static_cast< int >(WXK_NUMPAD9)));
56112 SWIG_Python_SetConstant(d, "WXK_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_MULTIPLY)));
56113 SWIG_Python_SetConstant(d, "WXK_ADD",SWIG_From_int(static_cast< int >(WXK_ADD)));
56114 SWIG_Python_SetConstant(d, "WXK_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_SEPARATOR)));
56115 SWIG_Python_SetConstant(d, "WXK_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_SUBTRACT)));
56116 SWIG_Python_SetConstant(d, "WXK_DECIMAL",SWIG_From_int(static_cast< int >(WXK_DECIMAL)));
56117 SWIG_Python_SetConstant(d, "WXK_DIVIDE",SWIG_From_int(static_cast< int >(WXK_DIVIDE)));
56118 SWIG_Python_SetConstant(d, "WXK_F1",SWIG_From_int(static_cast< int >(WXK_F1)));
56119 SWIG_Python_SetConstant(d, "WXK_F2",SWIG_From_int(static_cast< int >(WXK_F2)));
56120 SWIG_Python_SetConstant(d, "WXK_F3",SWIG_From_int(static_cast< int >(WXK_F3)));
56121 SWIG_Python_SetConstant(d, "WXK_F4",SWIG_From_int(static_cast< int >(WXK_F4)));
56122 SWIG_Python_SetConstant(d, "WXK_F5",SWIG_From_int(static_cast< int >(WXK_F5)));
56123 SWIG_Python_SetConstant(d, "WXK_F6",SWIG_From_int(static_cast< int >(WXK_F6)));
56124 SWIG_Python_SetConstant(d, "WXK_F7",SWIG_From_int(static_cast< int >(WXK_F7)));
56125 SWIG_Python_SetConstant(d, "WXK_F8",SWIG_From_int(static_cast< int >(WXK_F8)));
56126 SWIG_Python_SetConstant(d, "WXK_F9",SWIG_From_int(static_cast< int >(WXK_F9)));
56127 SWIG_Python_SetConstant(d, "WXK_F10",SWIG_From_int(static_cast< int >(WXK_F10)));
56128 SWIG_Python_SetConstant(d, "WXK_F11",SWIG_From_int(static_cast< int >(WXK_F11)));
56129 SWIG_Python_SetConstant(d, "WXK_F12",SWIG_From_int(static_cast< int >(WXK_F12)));
56130 SWIG_Python_SetConstant(d, "WXK_F13",SWIG_From_int(static_cast< int >(WXK_F13)));
56131 SWIG_Python_SetConstant(d, "WXK_F14",SWIG_From_int(static_cast< int >(WXK_F14)));
56132 SWIG_Python_SetConstant(d, "WXK_F15",SWIG_From_int(static_cast< int >(WXK_F15)));
56133 SWIG_Python_SetConstant(d, "WXK_F16",SWIG_From_int(static_cast< int >(WXK_F16)));
56134 SWIG_Python_SetConstant(d, "WXK_F17",SWIG_From_int(static_cast< int >(WXK_F17)));
56135 SWIG_Python_SetConstant(d, "WXK_F18",SWIG_From_int(static_cast< int >(WXK_F18)));
56136 SWIG_Python_SetConstant(d, "WXK_F19",SWIG_From_int(static_cast< int >(WXK_F19)));
56137 SWIG_Python_SetConstant(d, "WXK_F20",SWIG_From_int(static_cast< int >(WXK_F20)));
56138 SWIG_Python_SetConstant(d, "WXK_F21",SWIG_From_int(static_cast< int >(WXK_F21)));
56139 SWIG_Python_SetConstant(d, "WXK_F22",SWIG_From_int(static_cast< int >(WXK_F22)));
56140 SWIG_Python_SetConstant(d, "WXK_F23",SWIG_From_int(static_cast< int >(WXK_F23)));
56141 SWIG_Python_SetConstant(d, "WXK_F24",SWIG_From_int(static_cast< int >(WXK_F24)));
56142 SWIG_Python_SetConstant(d, "WXK_NUMLOCK",SWIG_From_int(static_cast< int >(WXK_NUMLOCK)));
56143 SWIG_Python_SetConstant(d, "WXK_SCROLL",SWIG_From_int(static_cast< int >(WXK_SCROLL)));
56144 SWIG_Python_SetConstant(d, "WXK_PAGEUP",SWIG_From_int(static_cast< int >(WXK_PAGEUP)));
56145 SWIG_Python_SetConstant(d, "WXK_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_PAGEDOWN)));
56146 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SPACE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SPACE)));
56147 SWIG_Python_SetConstant(d, "WXK_NUMPAD_TAB",SWIG_From_int(static_cast< int >(WXK_NUMPAD_TAB)));
56148 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ENTER",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ENTER)));
56149 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F1",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F1)));
56150 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F2",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F2)));
56151 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F3",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F3)));
56152 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F4",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F4)));
56153 SWIG_Python_SetConstant(d, "WXK_NUMPAD_HOME",SWIG_From_int(static_cast< int >(WXK_NUMPAD_HOME)));
56154 SWIG_Python_SetConstant(d, "WXK_NUMPAD_LEFT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_LEFT)));
56155 SWIG_Python_SetConstant(d, "WXK_NUMPAD_UP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_UP)));
56156 SWIG_Python_SetConstant(d, "WXK_NUMPAD_RIGHT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_RIGHT)));
56157 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DOWN)));
56158 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PRIOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PRIOR)));
56159 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEUP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEUP)));
56160 SWIG_Python_SetConstant(d, "WXK_NUMPAD_NEXT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_NEXT)));
56161 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEDOWN)));
56162 SWIG_Python_SetConstant(d, "WXK_NUMPAD_END",SWIG_From_int(static_cast< int >(WXK_NUMPAD_END)));
56163 SWIG_Python_SetConstant(d, "WXK_NUMPAD_BEGIN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_BEGIN)));
56164 SWIG_Python_SetConstant(d, "WXK_NUMPAD_INSERT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_INSERT)));
56165 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DELETE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DELETE)));
56166 SWIG_Python_SetConstant(d, "WXK_NUMPAD_EQUAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_EQUAL)));
56167 SWIG_Python_SetConstant(d, "WXK_NUMPAD_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_NUMPAD_MULTIPLY)));
56168 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ADD",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ADD)));
56169 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SEPARATOR)));
56170 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SUBTRACT)));
56171 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DECIMAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DECIMAL)));
56172 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DIVIDE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DIVIDE)));
56173 SWIG_Python_SetConstant(d, "WXK_WINDOWS_LEFT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_LEFT)));
56174 SWIG_Python_SetConstant(d, "WXK_WINDOWS_RIGHT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_RIGHT)));
56175 SWIG_Python_SetConstant(d, "WXK_WINDOWS_MENU",SWIG_From_int(static_cast< int >(WXK_WINDOWS_MENU)));
56176 SWIG_Python_SetConstant(d, "WXK_COMMAND",SWIG_From_int(static_cast< int >(WXK_COMMAND)));
56177 SWIG_Python_SetConstant(d, "WXK_SPECIAL1",SWIG_From_int(static_cast< int >(WXK_SPECIAL1)));
56178 SWIG_Python_SetConstant(d, "WXK_SPECIAL2",SWIG_From_int(static_cast< int >(WXK_SPECIAL2)));
56179 SWIG_Python_SetConstant(d, "WXK_SPECIAL3",SWIG_From_int(static_cast< int >(WXK_SPECIAL3)));
56180 SWIG_Python_SetConstant(d, "WXK_SPECIAL4",SWIG_From_int(static_cast< int >(WXK_SPECIAL4)));
56181 SWIG_Python_SetConstant(d, "WXK_SPECIAL5",SWIG_From_int(static_cast< int >(WXK_SPECIAL5)));
56182 SWIG_Python_SetConstant(d, "WXK_SPECIAL6",SWIG_From_int(static_cast< int >(WXK_SPECIAL6)));
56183 SWIG_Python_SetConstant(d, "WXK_SPECIAL7",SWIG_From_int(static_cast< int >(WXK_SPECIAL7)));
56184 SWIG_Python_SetConstant(d, "WXK_SPECIAL8",SWIG_From_int(static_cast< int >(WXK_SPECIAL8)));
56185 SWIG_Python_SetConstant(d, "WXK_SPECIAL9",SWIG_From_int(static_cast< int >(WXK_SPECIAL9)));
56186 SWIG_Python_SetConstant(d, "WXK_SPECIAL10",SWIG_From_int(static_cast< int >(WXK_SPECIAL10)));
56187 SWIG_Python_SetConstant(d, "WXK_SPECIAL11",SWIG_From_int(static_cast< int >(WXK_SPECIAL11)));
56188 SWIG_Python_SetConstant(d, "WXK_SPECIAL12",SWIG_From_int(static_cast< int >(WXK_SPECIAL12)));
56189 SWIG_Python_SetConstant(d, "WXK_SPECIAL13",SWIG_From_int(static_cast< int >(WXK_SPECIAL13)));
56190 SWIG_Python_SetConstant(d, "WXK_SPECIAL14",SWIG_From_int(static_cast< int >(WXK_SPECIAL14)));
56191 SWIG_Python_SetConstant(d, "WXK_SPECIAL15",SWIG_From_int(static_cast< int >(WXK_SPECIAL15)));
56192 SWIG_Python_SetConstant(d, "WXK_SPECIAL16",SWIG_From_int(static_cast< int >(WXK_SPECIAL16)));
56193 SWIG_Python_SetConstant(d, "WXK_SPECIAL17",SWIG_From_int(static_cast< int >(WXK_SPECIAL17)));
56194 SWIG_Python_SetConstant(d, "WXK_SPECIAL18",SWIG_From_int(static_cast< int >(WXK_SPECIAL18)));
56195 SWIG_Python_SetConstant(d, "WXK_SPECIAL19",SWIG_From_int(static_cast< int >(WXK_SPECIAL19)));
56196 SWIG_Python_SetConstant(d, "WXK_SPECIAL20",SWIG_From_int(static_cast< int >(WXK_SPECIAL20)));
56197 SWIG_Python_SetConstant(d, "PAPER_NONE",SWIG_From_int(static_cast< int >(wxPAPER_NONE)));
56198 SWIG_Python_SetConstant(d, "PAPER_LETTER",SWIG_From_int(static_cast< int >(wxPAPER_LETTER)));
56199 SWIG_Python_SetConstant(d, "PAPER_LEGAL",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL)));
56200 SWIG_Python_SetConstant(d, "PAPER_A4",SWIG_From_int(static_cast< int >(wxPAPER_A4)));
56201 SWIG_Python_SetConstant(d, "PAPER_CSHEET",SWIG_From_int(static_cast< int >(wxPAPER_CSHEET)));
56202 SWIG_Python_SetConstant(d, "PAPER_DSHEET",SWIG_From_int(static_cast< int >(wxPAPER_DSHEET)));
56203 SWIG_Python_SetConstant(d, "PAPER_ESHEET",SWIG_From_int(static_cast< int >(wxPAPER_ESHEET)));
56204 SWIG_Python_SetConstant(d, "PAPER_LETTERSMALL",SWIG_From_int(static_cast< int >(wxPAPER_LETTERSMALL)));
56205 SWIG_Python_SetConstant(d, "PAPER_TABLOID",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID)));
56206 SWIG_Python_SetConstant(d, "PAPER_LEDGER",SWIG_From_int(static_cast< int >(wxPAPER_LEDGER)));
56207 SWIG_Python_SetConstant(d, "PAPER_STATEMENT",SWIG_From_int(static_cast< int >(wxPAPER_STATEMENT)));
56208 SWIG_Python_SetConstant(d, "PAPER_EXECUTIVE",SWIG_From_int(static_cast< int >(wxPAPER_EXECUTIVE)));
56209 SWIG_Python_SetConstant(d, "PAPER_A3",SWIG_From_int(static_cast< int >(wxPAPER_A3)));
56210 SWIG_Python_SetConstant(d, "PAPER_A4SMALL",SWIG_From_int(static_cast< int >(wxPAPER_A4SMALL)));
56211 SWIG_Python_SetConstant(d, "PAPER_A5",SWIG_From_int(static_cast< int >(wxPAPER_A5)));
56212 SWIG_Python_SetConstant(d, "PAPER_B4",SWIG_From_int(static_cast< int >(wxPAPER_B4)));
56213 SWIG_Python_SetConstant(d, "PAPER_B5",SWIG_From_int(static_cast< int >(wxPAPER_B5)));
56214 SWIG_Python_SetConstant(d, "PAPER_FOLIO",SWIG_From_int(static_cast< int >(wxPAPER_FOLIO)));
56215 SWIG_Python_SetConstant(d, "PAPER_QUARTO",SWIG_From_int(static_cast< int >(wxPAPER_QUARTO)));
56216 SWIG_Python_SetConstant(d, "PAPER_10X14",SWIG_From_int(static_cast< int >(wxPAPER_10X14)));
56217 SWIG_Python_SetConstant(d, "PAPER_11X17",SWIG_From_int(static_cast< int >(wxPAPER_11X17)));
56218 SWIG_Python_SetConstant(d, "PAPER_NOTE",SWIG_From_int(static_cast< int >(wxPAPER_NOTE)));
56219 SWIG_Python_SetConstant(d, "PAPER_ENV_9",SWIG_From_int(static_cast< int >(wxPAPER_ENV_9)));
56220 SWIG_Python_SetConstant(d, "PAPER_ENV_10",SWIG_From_int(static_cast< int >(wxPAPER_ENV_10)));
56221 SWIG_Python_SetConstant(d, "PAPER_ENV_11",SWIG_From_int(static_cast< int >(wxPAPER_ENV_11)));
56222 SWIG_Python_SetConstant(d, "PAPER_ENV_12",SWIG_From_int(static_cast< int >(wxPAPER_ENV_12)));
56223 SWIG_Python_SetConstant(d, "PAPER_ENV_14",SWIG_From_int(static_cast< int >(wxPAPER_ENV_14)));
56224 SWIG_Python_SetConstant(d, "PAPER_ENV_DL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_DL)));
56225 SWIG_Python_SetConstant(d, "PAPER_ENV_C5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C5)));
56226 SWIG_Python_SetConstant(d, "PAPER_ENV_C3",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C3)));
56227 SWIG_Python_SetConstant(d, "PAPER_ENV_C4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C4)));
56228 SWIG_Python_SetConstant(d, "PAPER_ENV_C6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C6)));
56229 SWIG_Python_SetConstant(d, "PAPER_ENV_C65",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C65)));
56230 SWIG_Python_SetConstant(d, "PAPER_ENV_B4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B4)));
56231 SWIG_Python_SetConstant(d, "PAPER_ENV_B5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B5)));
56232 SWIG_Python_SetConstant(d, "PAPER_ENV_B6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B6)));
56233 SWIG_Python_SetConstant(d, "PAPER_ENV_ITALY",SWIG_From_int(static_cast< int >(wxPAPER_ENV_ITALY)));
56234 SWIG_Python_SetConstant(d, "PAPER_ENV_MONARCH",SWIG_From_int(static_cast< int >(wxPAPER_ENV_MONARCH)));
56235 SWIG_Python_SetConstant(d, "PAPER_ENV_PERSONAL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_PERSONAL)));
56236 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_US",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_US)));
56237 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_STD_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_STD_GERMAN)));
56238 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_LGL_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_LGL_GERMAN)));
56239 SWIG_Python_SetConstant(d, "PAPER_ISO_B4",SWIG_From_int(static_cast< int >(wxPAPER_ISO_B4)));
56240 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD)));
56241 SWIG_Python_SetConstant(d, "PAPER_9X11",SWIG_From_int(static_cast< int >(wxPAPER_9X11)));
56242 SWIG_Python_SetConstant(d, "PAPER_10X11",SWIG_From_int(static_cast< int >(wxPAPER_10X11)));
56243 SWIG_Python_SetConstant(d, "PAPER_15X11",SWIG_From_int(static_cast< int >(wxPAPER_15X11)));
56244 SWIG_Python_SetConstant(d, "PAPER_ENV_INVITE",SWIG_From_int(static_cast< int >(wxPAPER_ENV_INVITE)));
56245 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA)));
56246 SWIG_Python_SetConstant(d, "PAPER_LEGAL_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL_EXTRA)));
56247 SWIG_Python_SetConstant(d, "PAPER_TABLOID_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID_EXTRA)));
56248 SWIG_Python_SetConstant(d, "PAPER_A4_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A4_EXTRA)));
56249 SWIG_Python_SetConstant(d, "PAPER_LETTER_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_TRANSVERSE)));
56250 SWIG_Python_SetConstant(d, "PAPER_A4_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A4_TRANSVERSE)));
56251 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
56252 SWIG_Python_SetConstant(d, "PAPER_A_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A_PLUS)));
56253 SWIG_Python_SetConstant(d, "PAPER_B_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_B_PLUS)));
56254 SWIG_Python_SetConstant(d, "PAPER_LETTER_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_PLUS)));
56255 SWIG_Python_SetConstant(d, "PAPER_A4_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A4_PLUS)));
56256 SWIG_Python_SetConstant(d, "PAPER_A5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A5_TRANSVERSE)));
56257 SWIG_Python_SetConstant(d, "PAPER_B5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_B5_TRANSVERSE)));
56258 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA)));
56259 SWIG_Python_SetConstant(d, "PAPER_A5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A5_EXTRA)));
56260 SWIG_Python_SetConstant(d, "PAPER_B5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_B5_EXTRA)));
56261 SWIG_Python_SetConstant(d, "PAPER_A2",SWIG_From_int(static_cast< int >(wxPAPER_A2)));
56262 SWIG_Python_SetConstant(d, "PAPER_A3_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_TRANSVERSE)));
56263 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA_TRANSVERSE)));
56264 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD)));
56265 SWIG_Python_SetConstant(d, "PAPER_A6",SWIG_From_int(static_cast< int >(wxPAPER_A6)));
56266 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2)));
56267 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3)));
56268 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3)));
56269 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4)));
56270 SWIG_Python_SetConstant(d, "PAPER_LETTER_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_ROTATED)));
56271 SWIG_Python_SetConstant(d, "PAPER_A3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A3_ROTATED)));
56272 SWIG_Python_SetConstant(d, "PAPER_A4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A4_ROTATED)));
56273 SWIG_Python_SetConstant(d, "PAPER_A5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A5_ROTATED)));
56274 SWIG_Python_SetConstant(d, "PAPER_B4_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B4_JIS_ROTATED)));
56275 SWIG_Python_SetConstant(d, "PAPER_B5_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B5_JIS_ROTATED)));
56276 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
56277 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
56278 SWIG_Python_SetConstant(d, "PAPER_A6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A6_ROTATED)));
56279 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2_ROTATED)));
56280 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3_ROTATED)));
56281 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3_ROTATED)));
56282 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4_ROTATED)));
56283 SWIG_Python_SetConstant(d, "PAPER_B6_JIS",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS)));
56284 SWIG_Python_SetConstant(d, "PAPER_B6_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS_ROTATED)));
56285 SWIG_Python_SetConstant(d, "PAPER_12X11",SWIG_From_int(static_cast< int >(wxPAPER_12X11)));
56286 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4)));
56287 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4_ROTATED)));
56288 SWIG_Python_SetConstant(d, "PAPER_P16K",SWIG_From_int(static_cast< int >(wxPAPER_P16K)));
56289 SWIG_Python_SetConstant(d, "PAPER_P32K",SWIG_From_int(static_cast< int >(wxPAPER_P32K)));
56290 SWIG_Python_SetConstant(d, "PAPER_P32KBIG",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG)));
56291 SWIG_Python_SetConstant(d, "PAPER_PENV_1",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1)));
56292 SWIG_Python_SetConstant(d, "PAPER_PENV_2",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2)));
56293 SWIG_Python_SetConstant(d, "PAPER_PENV_3",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3)));
56294 SWIG_Python_SetConstant(d, "PAPER_PENV_4",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4)));
56295 SWIG_Python_SetConstant(d, "PAPER_PENV_5",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5)));
56296 SWIG_Python_SetConstant(d, "PAPER_PENV_6",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6)));
56297 SWIG_Python_SetConstant(d, "PAPER_PENV_7",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7)));
56298 SWIG_Python_SetConstant(d, "PAPER_PENV_8",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8)));
56299 SWIG_Python_SetConstant(d, "PAPER_PENV_9",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9)));
56300 SWIG_Python_SetConstant(d, "PAPER_PENV_10",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10)));
56301 SWIG_Python_SetConstant(d, "PAPER_P16K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P16K_ROTATED)));
56302 SWIG_Python_SetConstant(d, "PAPER_P32K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32K_ROTATED)));
56303 SWIG_Python_SetConstant(d, "PAPER_P32KBIG_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG_ROTATED)));
56304 SWIG_Python_SetConstant(d, "PAPER_PENV_1_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1_ROTATED)));
56305 SWIG_Python_SetConstant(d, "PAPER_PENV_2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2_ROTATED)));
56306 SWIG_Python_SetConstant(d, "PAPER_PENV_3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3_ROTATED)));
56307 SWIG_Python_SetConstant(d, "PAPER_PENV_4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4_ROTATED)));
56308 SWIG_Python_SetConstant(d, "PAPER_PENV_5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5_ROTATED)));
56309 SWIG_Python_SetConstant(d, "PAPER_PENV_6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6_ROTATED)));
56310 SWIG_Python_SetConstant(d, "PAPER_PENV_7_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7_ROTATED)));
56311 SWIG_Python_SetConstant(d, "PAPER_PENV_8_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8_ROTATED)));
56312 SWIG_Python_SetConstant(d, "PAPER_PENV_9_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9_ROTATED)));
56313 SWIG_Python_SetConstant(d, "PAPER_PENV_10_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10_ROTATED)));
56314 SWIG_Python_SetConstant(d, "DUPLEX_SIMPLEX",SWIG_From_int(static_cast< int >(wxDUPLEX_SIMPLEX)));
56315 SWIG_Python_SetConstant(d, "DUPLEX_HORIZONTAL",SWIG_From_int(static_cast< int >(wxDUPLEX_HORIZONTAL)));
56316 SWIG_Python_SetConstant(d, "DUPLEX_VERTICAL",SWIG_From_int(static_cast< int >(wxDUPLEX_VERTICAL)));
56317 SWIG_Python_SetConstant(d, "ITEM_SEPARATOR",SWIG_From_int(static_cast< int >(wxITEM_SEPARATOR)));
56318 SWIG_Python_SetConstant(d, "ITEM_NORMAL",SWIG_From_int(static_cast< int >(wxITEM_NORMAL)));
56319 SWIG_Python_SetConstant(d, "ITEM_CHECK",SWIG_From_int(static_cast< int >(wxITEM_CHECK)));
56320 SWIG_Python_SetConstant(d, "ITEM_RADIO",SWIG_From_int(static_cast< int >(wxITEM_RADIO)));
56321 SWIG_Python_SetConstant(d, "ITEM_MAX",SWIG_From_int(static_cast< int >(wxITEM_MAX)));
56322 SWIG_Python_SetConstant(d, "HT_NOWHERE",SWIG_From_int(static_cast< int >(wxHT_NOWHERE)));
56323 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_FIRST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_FIRST)));
56324 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_1)));
56325 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_2)));
56326 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_1)));
56327 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_2)));
56328 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_THUMB",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_THUMB)));
56329 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_1)));
56330 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_2)));
56331 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_LAST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_LAST)));
56332 SWIG_Python_SetConstant(d, "HT_WINDOW_OUTSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_OUTSIDE)));
56333 SWIG_Python_SetConstant(d, "HT_WINDOW_INSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_INSIDE)));
56334 SWIG_Python_SetConstant(d, "HT_WINDOW_VERT_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_VERT_SCROLLBAR)));
56335 SWIG_Python_SetConstant(d, "HT_WINDOW_HORZ_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_HORZ_SCROLLBAR)));
56336 SWIG_Python_SetConstant(d, "HT_WINDOW_CORNER",SWIG_From_int(static_cast< int >(wxHT_WINDOW_CORNER)));
56337 SWIG_Python_SetConstant(d, "HT_MAX",SWIG_From_int(static_cast< int >(wxHT_MAX)));
56338 SWIG_Python_SetConstant(d, "MOD_NONE",SWIG_From_int(static_cast< int >(wxMOD_NONE)));
56339 SWIG_Python_SetConstant(d, "MOD_ALT",SWIG_From_int(static_cast< int >(wxMOD_ALT)));
56340 SWIG_Python_SetConstant(d, "MOD_CONTROL",SWIG_From_int(static_cast< int >(wxMOD_CONTROL)));
56341 SWIG_Python_SetConstant(d, "MOD_ALTGR",SWIG_From_int(static_cast< int >(wxMOD_ALTGR)));
56342 SWIG_Python_SetConstant(d, "MOD_SHIFT",SWIG_From_int(static_cast< int >(wxMOD_SHIFT)));
56343 SWIG_Python_SetConstant(d, "MOD_META",SWIG_From_int(static_cast< int >(wxMOD_META)));
56344 SWIG_Python_SetConstant(d, "MOD_WIN",SWIG_From_int(static_cast< int >(wxMOD_WIN)));
56345 SWIG_Python_SetConstant(d, "MOD_CMD",SWIG_From_int(static_cast< int >(wxMOD_CMD)));
56346 SWIG_Python_SetConstant(d, "MOD_ALL",SWIG_From_int(static_cast< int >(wxMOD_ALL)));
56347 SWIG_Python_SetConstant(d, "UPDATE_UI_NONE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_NONE)));
56348 SWIG_Python_SetConstant(d, "UPDATE_UI_RECURSE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_RECURSE)));
56349 SWIG_Python_SetConstant(d, "UPDATE_UI_FROMIDLE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_FROMIDLE)));
56350 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
56351 SWIG_addvarlink(SWIG_globals(),(char*)"EmptyString",EmptyString_get, EmptyString_set);
56352 SWIG_Python_SetConstant(d, "BITMAP_TYPE_INVALID",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_INVALID)));
56353 SWIG_Python_SetConstant(d, "BITMAP_TYPE_BMP",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_BMP)));
56354 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICO",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICO)));
56355 SWIG_Python_SetConstant(d, "BITMAP_TYPE_CUR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_CUR)));
56356 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM)));
56357 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM_DATA)));
56358 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM)));
56359 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM_DATA)));
56360 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TIF)));
56361 SWIG_Python_SetConstant(d, "BITMAP_TYPE_GIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_GIF)));
56362 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNG)));
56363 SWIG_Python_SetConstant(d, "BITMAP_TYPE_JPEG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_JPEG)));
56364 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNM)));
56365 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PCX",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PCX)));
56366 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PICT",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PICT)));
56367 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICON",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICON)));
56368 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANI",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANI)));
56369 SWIG_Python_SetConstant(d, "BITMAP_TYPE_IFF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_IFF)));
56370 SWIG_Python_SetConstant(d, "BITMAP_TYPE_MACCURSOR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_MACCURSOR)));
56371 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANY",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANY)));
56372 SWIG_Python_SetConstant(d, "CURSOR_NONE",SWIG_From_int(static_cast< int >(wxCURSOR_NONE)));
56373 SWIG_Python_SetConstant(d, "CURSOR_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_ARROW)));
56374 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_ARROW)));
56375 SWIG_Python_SetConstant(d, "CURSOR_BULLSEYE",SWIG_From_int(static_cast< int >(wxCURSOR_BULLSEYE)));
56376 SWIG_Python_SetConstant(d, "CURSOR_CHAR",SWIG_From_int(static_cast< int >(wxCURSOR_CHAR)));
56377 SWIG_Python_SetConstant(d, "CURSOR_CROSS",SWIG_From_int(static_cast< int >(wxCURSOR_CROSS)));
56378 SWIG_Python_SetConstant(d, "CURSOR_HAND",SWIG_From_int(static_cast< int >(wxCURSOR_HAND)));
56379 SWIG_Python_SetConstant(d, "CURSOR_IBEAM",SWIG_From_int(static_cast< int >(wxCURSOR_IBEAM)));
56380 SWIG_Python_SetConstant(d, "CURSOR_LEFT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_LEFT_BUTTON)));
56381 SWIG_Python_SetConstant(d, "CURSOR_MAGNIFIER",SWIG_From_int(static_cast< int >(wxCURSOR_MAGNIFIER)));
56382 SWIG_Python_SetConstant(d, "CURSOR_MIDDLE_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_MIDDLE_BUTTON)));
56383 SWIG_Python_SetConstant(d, "CURSOR_NO_ENTRY",SWIG_From_int(static_cast< int >(wxCURSOR_NO_ENTRY)));
56384 SWIG_Python_SetConstant(d, "CURSOR_PAINT_BRUSH",SWIG_From_int(static_cast< int >(wxCURSOR_PAINT_BRUSH)));
56385 SWIG_Python_SetConstant(d, "CURSOR_PENCIL",SWIG_From_int(static_cast< int >(wxCURSOR_PENCIL)));
56386 SWIG_Python_SetConstant(d, "CURSOR_POINT_LEFT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_LEFT)));
56387 SWIG_Python_SetConstant(d, "CURSOR_POINT_RIGHT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_RIGHT)));
56388 SWIG_Python_SetConstant(d, "CURSOR_QUESTION_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_QUESTION_ARROW)));
56389 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_BUTTON)));
56390 SWIG_Python_SetConstant(d, "CURSOR_SIZENESW",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENESW)));
56391 SWIG_Python_SetConstant(d, "CURSOR_SIZENS",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENS)));
56392 SWIG_Python_SetConstant(d, "CURSOR_SIZENWSE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENWSE)));
56393 SWIG_Python_SetConstant(d, "CURSOR_SIZEWE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZEWE)));
56394 SWIG_Python_SetConstant(d, "CURSOR_SIZING",SWIG_From_int(static_cast< int >(wxCURSOR_SIZING)));
56395 SWIG_Python_SetConstant(d, "CURSOR_SPRAYCAN",SWIG_From_int(static_cast< int >(wxCURSOR_SPRAYCAN)));
56396 SWIG_Python_SetConstant(d, "CURSOR_WAIT",SWIG_From_int(static_cast< int >(wxCURSOR_WAIT)));
56397 SWIG_Python_SetConstant(d, "CURSOR_WATCH",SWIG_From_int(static_cast< int >(wxCURSOR_WATCH)));
56398 SWIG_Python_SetConstant(d, "CURSOR_BLANK",SWIG_From_int(static_cast< int >(wxCURSOR_BLANK)));
56399 SWIG_Python_SetConstant(d, "CURSOR_DEFAULT",SWIG_From_int(static_cast< int >(wxCURSOR_DEFAULT)));
56400 SWIG_Python_SetConstant(d, "CURSOR_COPY_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_COPY_ARROW)));
56401 SWIG_Python_SetConstant(d, "CURSOR_ARROWWAIT",SWIG_From_int(static_cast< int >(wxCURSOR_ARROWWAIT)));
56402 SWIG_Python_SetConstant(d, "CURSOR_MAX",SWIG_From_int(static_cast< int >(wxCURSOR_MAX)));
56403 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultPosition",DefaultPosition_get, DefaultPosition_set);
56404 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSize",DefaultSize_get, DefaultSize_set);
56405 SWIG_Python_SetConstant(d, "FromStart",SWIG_From_int(static_cast< int >(wxFromStart)));
56406 SWIG_Python_SetConstant(d, "FromCurrent",SWIG_From_int(static_cast< int >(wxFromCurrent)));
56407 SWIG_Python_SetConstant(d, "FromEnd",SWIG_From_int(static_cast< int >(wxFromEnd)));
56408
56409 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
56410
56411
56412 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
56413
56414 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_TRANSPARENT",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_TRANSPARENT)));
56415 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_THRESHOLD",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_THRESHOLD)));
56416 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_OPAQUE",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_OPAQUE)));
56417 SWIG_addvarlink(SWIG_globals(),(char*)"NullImage",NullImage_get, NullImage_set);
56418 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_FILENAME",IMAGE_OPTION_FILENAME_get, IMAGE_OPTION_FILENAME_set);
56419 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BMP_FORMAT",IMAGE_OPTION_BMP_FORMAT_get, IMAGE_OPTION_BMP_FORMAT_set);
56420 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",IMAGE_OPTION_CUR_HOTSPOT_X_get, IMAGE_OPTION_CUR_HOTSPOT_X_set);
56421 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",IMAGE_OPTION_CUR_HOTSPOT_Y_get, IMAGE_OPTION_CUR_HOTSPOT_Y_set);
56422 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTION",IMAGE_OPTION_RESOLUTION_get, IMAGE_OPTION_RESOLUTION_set);
56423 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONX",IMAGE_OPTION_RESOLUTIONX_get, IMAGE_OPTION_RESOLUTIONX_set);
56424 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONY",IMAGE_OPTION_RESOLUTIONY_get, IMAGE_OPTION_RESOLUTIONY_set);
56425 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONUNIT",IMAGE_OPTION_RESOLUTIONUNIT_get, IMAGE_OPTION_RESOLUTIONUNIT_set);
56426 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_QUALITY",IMAGE_OPTION_QUALITY_get, IMAGE_OPTION_QUALITY_set);
56427 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_INCHES",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_INCHES)));
56428 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_CM",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_CM)));
56429 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BITSPERSAMPLE",IMAGE_OPTION_BITSPERSAMPLE_get, IMAGE_OPTION_BITSPERSAMPLE_set);
56430 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",IMAGE_OPTION_SAMPLESPERPIXEL_get, IMAGE_OPTION_SAMPLESPERPIXEL_set);
56431 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_COMPRESSION",IMAGE_OPTION_COMPRESSION_get, IMAGE_OPTION_COMPRESSION_set);
56432 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",IMAGE_OPTION_IMAGEDESCRIPTOR_get, IMAGE_OPTION_IMAGEDESCRIPTOR_set);
56433 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_FORMAT",IMAGE_OPTION_PNG_FORMAT_get, IMAGE_OPTION_PNG_FORMAT_set);
56434 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_BITDEPTH",IMAGE_OPTION_PNG_BITDEPTH_get, IMAGE_OPTION_PNG_BITDEPTH_set);
56435 SWIG_Python_SetConstant(d, "PNG_TYPE_COLOUR",SWIG_From_int(static_cast< int >(wxPNG_TYPE_COLOUR)));
56436 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY)));
56437 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY_RED",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY_RED)));
56438 SWIG_Python_SetConstant(d, "BMP_24BPP",SWIG_From_int(static_cast< int >(wxBMP_24BPP)));
56439 SWIG_Python_SetConstant(d, "BMP_8BPP",SWIG_From_int(static_cast< int >(wxBMP_8BPP)));
56440 SWIG_Python_SetConstant(d, "BMP_8BPP_GREY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GREY)));
56441 SWIG_Python_SetConstant(d, "BMP_8BPP_GRAY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GRAY)));
56442 SWIG_Python_SetConstant(d, "BMP_8BPP_RED",SWIG_From_int(static_cast< int >(wxBMP_8BPP_RED)));
56443 SWIG_Python_SetConstant(d, "BMP_8BPP_PALETTE",SWIG_From_int(static_cast< int >(wxBMP_8BPP_PALETTE)));
56444 SWIG_Python_SetConstant(d, "BMP_4BPP",SWIG_From_int(static_cast< int >(wxBMP_4BPP)));
56445 SWIG_Python_SetConstant(d, "BMP_1BPP",SWIG_From_int(static_cast< int >(wxBMP_1BPP)));
56446 SWIG_Python_SetConstant(d, "BMP_1BPP_BW",SWIG_From_int(static_cast< int >(wxBMP_1BPP_BW)));
56447 SWIG_Python_SetConstant(d, "QUANTIZE_INCLUDE_WINDOWS_COLOURS",SWIG_From_int(static_cast< int >(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
56448 SWIG_Python_SetConstant(d, "QUANTIZE_FILL_DESTINATION_IMAGE",SWIG_From_int(static_cast< int >(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
56449 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_NONE",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_NONE)));
56450 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_MAX",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_MAX)));
56451 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
56452 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
56453 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
56454 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
56455 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
56456 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
56457 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
56458 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
56459 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
56460 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
56461 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
56462 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
56463 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
56464 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
56465 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
56466 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
56467 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
56468 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
56469 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
56470 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
56471 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
56472 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
56473 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
56474 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
56475 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
56476 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
56477 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
56478 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
56479 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
56480 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
56481 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
56482 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
56483 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
56484 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
56485 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
56486 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
56487 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
56488 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
56489 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
56490 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
56491 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
56492 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
56493 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
56494 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
56495 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
56496 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
56497 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
56498 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
56499 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
56500 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
56501 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
56502 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
56503 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
56504 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
56505 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
56506 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
56507 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
56508 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
56509 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
56510 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
56511 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
56512 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
56513 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
56514 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
56515 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
56516 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
56517 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
56518 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
56519 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
56520 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
56521 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
56522 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
56523 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
56524 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
56525 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
56526 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
56527 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
56528 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
56529 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
56530 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
56531 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
56532 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
56533 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
56534 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
56535 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
56536 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
56537 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
56538 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
56539 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
56540 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
56541 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
56542 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
56543 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
56544 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
56545 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
56546 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
56547 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
56548 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
56549 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
56550 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
56551 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
56552 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
56553 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
56554 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
56555 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
56556 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
56557 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
56558 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_COPY", PyInt_FromLong(wxEVT_COMMAND_TEXT_COPY));
56559 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_CUT", PyInt_FromLong(wxEVT_COMMAND_TEXT_CUT));
56560 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_PASTE", PyInt_FromLong(wxEVT_COMMAND_TEXT_PASTE));
56561 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
56562 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
56563 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
56564 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
56565 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
56566 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
56567 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
56568 SWIG_Python_SetConstant(d, "MOUSE_BTN_ANY",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_ANY)));
56569 SWIG_Python_SetConstant(d, "MOUSE_BTN_NONE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_NONE)));
56570 SWIG_Python_SetConstant(d, "MOUSE_BTN_LEFT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_LEFT)));
56571 SWIG_Python_SetConstant(d, "MOUSE_BTN_MIDDLE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_MIDDLE)));
56572 SWIG_Python_SetConstant(d, "MOUSE_BTN_RIGHT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_RIGHT)));
56573 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_ALL)));
56574 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_SPECIFIED)));
56575 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsBackward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsBackward)));
56576 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsForward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsForward)));
56577 SWIG_Python_SetConstant(d, "NavigationKeyEvent_WinChange",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::WinChange)));
56578 SWIG_Python_SetConstant(d, "NavigationKeyEvent_FromTab",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::FromTab)));
56579 SWIG_Python_SetConstant(d, "IDLE_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_ALL)));
56580 SWIG_Python_SetConstant(d, "IDLE_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_SPECIFIED)));
56581 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
56582 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_SUPPRESS",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_SUPPRESS)));
56583 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_EXCEPTION",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_EXCEPTION)));
56584 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_DIALOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_DIALOG)));
56585 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_LOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_LOG)));
56586 SWIG_Python_SetConstant(d, "PRINT_WINDOWS",SWIG_From_int(static_cast< int >(wxPRINT_WINDOWS)));
56587 SWIG_Python_SetConstant(d, "PRINT_POSTSCRIPT",SWIG_From_int(static_cast< int >(wxPRINT_POSTSCRIPT)));
56588 SWIG_addvarlink(SWIG_globals(),(char*)"NullAcceleratorTable",NullAcceleratorTable_get, NullAcceleratorTable_set);
56589 SWIG_addvarlink(SWIG_globals(),(char*)"PanelNameStr",PanelNameStr_get, PanelNameStr_set);
56590 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_NORMAL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_NORMAL)));
56591 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_SMALL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_SMALL)));
56592 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MINI",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MINI)));
56593 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_LARGE",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_LARGE)));
56594 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MAX",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MAX)));
56595 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultValidator",DefaultValidator_get, DefaultValidator_set);
56596 SWIG_addvarlink(SWIG_globals(),(char*)"ControlNameStr",ControlNameStr_get, ControlNameStr_set);
56597 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_NONE",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_NONE)));
56598 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_SPECIFIED",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_SPECIFIED)));
56599 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_ALL",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_ALL)));
56600 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSpan",DefaultSpan_get, DefaultSpan_set);
56601 SWIG_Python_SetConstant(d, "Left",SWIG_From_int(static_cast< int >(wxLeft)));
56602 SWIG_Python_SetConstant(d, "Top",SWIG_From_int(static_cast< int >(wxTop)));
56603 SWIG_Python_SetConstant(d, "Right",SWIG_From_int(static_cast< int >(wxRight)));
56604 SWIG_Python_SetConstant(d, "Bottom",SWIG_From_int(static_cast< int >(wxBottom)));
56605 SWIG_Python_SetConstant(d, "Width",SWIG_From_int(static_cast< int >(wxWidth)));
56606 SWIG_Python_SetConstant(d, "Height",SWIG_From_int(static_cast< int >(wxHeight)));
56607 SWIG_Python_SetConstant(d, "Centre",SWIG_From_int(static_cast< int >(wxCentre)));
56608 SWIG_Python_SetConstant(d, "Center",SWIG_From_int(static_cast< int >(wxCenter)));
56609 SWIG_Python_SetConstant(d, "CentreX",SWIG_From_int(static_cast< int >(wxCentreX)));
56610 SWIG_Python_SetConstant(d, "CentreY",SWIG_From_int(static_cast< int >(wxCentreY)));
56611 SWIG_Python_SetConstant(d, "Unconstrained",SWIG_From_int(static_cast< int >(wxUnconstrained)));
56612 SWIG_Python_SetConstant(d, "AsIs",SWIG_From_int(static_cast< int >(wxAsIs)));
56613 SWIG_Python_SetConstant(d, "PercentOf",SWIG_From_int(static_cast< int >(wxPercentOf)));
56614 SWIG_Python_SetConstant(d, "Above",SWIG_From_int(static_cast< int >(wxAbove)));
56615 SWIG_Python_SetConstant(d, "Below",SWIG_From_int(static_cast< int >(wxBelow)));
56616 SWIG_Python_SetConstant(d, "LeftOf",SWIG_From_int(static_cast< int >(wxLeftOf)));
56617 SWIG_Python_SetConstant(d, "RightOf",SWIG_From_int(static_cast< int >(wxRightOf)));
56618 SWIG_Python_SetConstant(d, "SameAs",SWIG_From_int(static_cast< int >(wxSameAs)));
56619 SWIG_Python_SetConstant(d, "Absolute",SWIG_From_int(static_cast< int >(wxAbsolute)));
56620
56621 // Initialize threading, some globals and such
56622 __wxPyPreStart(d);
56623
56624
56625 // Although these are defined in __version__ they need to be here too so
56626 // that an assert can be done to ensure that the wxPython and the wxWindows
56627 // versions match.
56628 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
56629 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
56630 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
56631
56632 }
56633
wxWidgets (Impactor)